Add links to additional learning resources

Author: mre

content/learn/case-studies/hubstaff/index.md

@@ -180,3 +180,9 @@ and [Artur Jakubiec](https://www.linkedin.com/in/artur-jakubiec/), Technical Lea
 
 Want to learn more about Hubstaff? [Check out their website](https://hubstaff.com/).
 
+{% info(title="Thinking About a Similar Migration?", icon="crab") %}
+
+Hubstaff's story is not unique. Many teams hit the same scaling and reliability limits and find Rust to be the right answer.
+If you're evaluating a migration or want to understand whether Rust is the right fit for your stack, [let's talk](/services).
+
+{% end %}

content/learn/migration-guides/cpp-to-rust/index.md

@@ -514,3 +514,12 @@ __int128, intptr_t/ptrdiff_t</code></pre>
     </tr>
   </tbody>
 </table>
+
+{% info(title="Need Help Migrating from C++ to Rust?", icon="crab") %}
+
+Migrating a C++ codebase is one of the more involved transitions.
+The languages share many low-level concepts, but Rust's ownership model requires a shift in how you structure code (no mutable aliases, no self-referential structs, etc.). 
+I help engineering teams navigate that shift, from training and architecture reviews to hands-on migration support.
+[Get in touch to talk about your project](/services).
+
+{% end %}

content/learn/migration-guides/java-to-rust/index.md

@@ -208,7 +208,7 @@ Java makes everything mutable by default, which is arguably its single biggest i
 
 Rust does the opposite - everything stays immutable unless marked with `mut`. This simple change has profound effects on code quality. You think more carefully about what really needs to change, leading to fewer bugs and easier concurrent programming. **This also enables better compiler optimizations** since the compiler can make stronger assumptions about your data.
 
-Many developers find they write better code in all languages after working with Rust's immutability model.
+Many developers find they write better code in all languages after working with Rust's [immutability model](/blog/immutability/).
 
 ### Rethinking Null
 
@@ -256,7 +256,7 @@ Your team will not only learn Rust but also feel more confident working with it
 Migrating to Rust comes with some risks, but careful planning will minimize them. Here's how to ensure success:
 
 1. **Start Small**  
-Pick a small, non-critical part of your application for the first Rust implementation. This lets your team experiment and build confidence without affecting core systems. Expand gradually as you see results.
+Pick a small, non-critical part of your application for the [first Rust implementation](/blog/successful-rust-business-adoption-checklist/). This lets your team experiment and build confidence without affecting core systems. Expand gradually as you see results.
 
 2. **Prepare Your Team**  
 Don't just decide this for your developers—decide together. Get the team ready with training or external expertise, and focus on integration with your existing Java system. Rust will likely need new dependencies, so research the ecosystem and be ready to roll up your sleeves to contribute if necessary.
@@ -426,7 +426,7 @@ What are your hopes for Rust? What are the alternatives considered? What are you
 What is the skill level of your team, and how can you support them in learning Rust?
 It helps to put your thoughts into writing and share them with the team.
 
-On that note, hiring Rust developers can be challenging. It's a relatively new language, and most Rust developers 
+On that note, [hiring Rust developers](/blog/hiring-rust-engineers/) can be challenging. It's a relatively new language, and most Rust developers 
 don't have any production experience yet. Instead, consider upskilling your existing Java developers.
 They already know your systems and can learn Rust with the right training and support.
 

content/learn/migration-guides/python-to-rust/index.md

@@ -201,7 +201,7 @@ While Python excels at readability and rapid development, teams often hit scalin
 Python's Global Interpreter Lock (GIL) limits true parallelism, making it challenging to fully utilize modern multi-core processors.
 There is a version of Python without the GIL, but it [doesn't solve the performance issues](https://news.ycombinator.com/item?id=41677131). 
 
-While tools like asyncio help with I/O-bound tasks, CPU-intensive operations remain constrained. Teams often resort to complex workarounds involving multiple processes or C extensions.
+While tools like [asyncio](https://docs.python.org/3/library/asyncio.html) help with I/O-bound tasks, CPU-intensive operations remain constrained. Teams often resort to complex workarounds involving multiple processes or C extensions.
 
 ### Type Safety Concerns
 
@@ -376,7 +376,7 @@ A successful migration requires careful planning:
 
    - Choose non-critical components first
    - Focus on areas where Rust's benefits are most valuable
-   - Build team confidence through early wins
+   - Build team confidence through [early wins](/blog/successful-rust-business-adoption-checklist/)
 
 2. **Invest in Training**
 
@@ -469,7 +469,7 @@ They have Python bindings, so you get a lot of the benefits of Rust without havi
 
 Rust wasn't initially planned to be a strong contender in the web development space.
 This has changed in recent years with the rise of frameworks like [Axum](https://axum.rs/) and [Loco](https://loco.rs/).
-Now, Rust is a viable option for building high-performance APIs and web applications.
+Now, Rust is a viable option for building [high-performance APIs](/blog/why-rust/) and web applications.
 It is one key area the Rust team is investing in, and the ecosystem is maturing rapidly.
 
 In combination with [sqlx](https://github.com/launchbadge/sqlx) for database access and [serde](https://serde.rs/) for serialization, Rust is a very effective choice for web backends. 

content/learn/migration-guides/scala-to-rust/index.md

@@ -62,7 +62,7 @@ Rust's predictable resource usage and lack of garbage collection pauses make it
 The business case for Rust extends beyond technical merits.
 
 - **Infrastructure costs often decrease** due to better performance and resource utilization.
-- **Maintenance becomes more predictable** thanks to superior tooling and compile-time guarantees.
+- **[Maintenance becomes more predictable](/blog/long-term-rust-maintenance/)** thanks to superior tooling and compile-time guarantees.
 - **The risk of production issues decreases** due to Rust's strong type system and ownership model catching many common bugs at compile time.
 
 Scala and Clojure developers typically transition well to Rust because the languages share many fundamental concepts. The emphasis on strong type systems, functional programming patterns, and correctness creates a natural bridge. While Rust's ownership system presents a learning curve, developers coming from functional programming backgrounds often find they already think in ways that align well with Rust's model.
@@ -77,8 +77,7 @@ The key to successful migration is maintaining optionality. Rust's excellent int
 
 The transition to Rust does present challenges. The ownership and borrowing concepts take time to master, though the compiler's excellent error messages help guide developers through the learning process. The ecosystem, while growing rapidly, may not yet have direct equivalents for all specialized JVM libraries. Some internal tooling may need to be rebuilt or adapted.
 
-However, these challenges should be viewed in context. The learning curve, while steep, is finite — developers
-with a strong functional programming background typically become productive in Rust within a few months. The ecosystem limitations often push teams toward simpler, more maintainable solutions. And the need to rebuild tools can be an opportunity to improve and modernize development workflows.
+However, these challenges should be viewed in context. The [learning curve](/blog/flattening-rusts-learning-curve/), while steep, is finite. Developers with a strong functional programming background typically become productive in Rust within a few months. The ecosystem limitations often push teams toward simpler, more maintainable solutions. And the need to rebuild tools can be an opportunity to improve and modernize development workflows.
 
 ## Conclusion
 
@@ -88,7 +87,7 @@ The decision to migrate from Scala/Clojure to Rust should be driven by specific
 
 The transition requires investment, but Rust's growing ecosystem, excellent tooling, and strong industry adoption make it an increasingly attractive option for organizations looking to move beyond the JVM while maintaining the benefits of strong typing and functional programming paradigms.
 
-{% info(title="Is Your Team Considering a Migration to Rust?") %}
+{% info(title="Is Your Team Considering a Migration to Rust?", icon="crab") %}
 
 I can help you evaluate your current systems, design a migration strategy, and
 help you make an informed decision about moving to Rust. I offer consulting