Most engineering teams know the pain of a system that has outgrown its original design. The instinct is often to plan a full rewrite, to imagine that the problems stem from the wrong language or the wrong architecture, and that starting over will fix everything. Lily Mara's presentation offers a more practical path forward. She demonstrates how teams can replace Python bottlenecks with Rust through incremental FFI refactoring, using PyO3 to target specific functions rather than entire services. This approach avoids the high-risk, high-cost gamble of a rewrite while still delivering dramatic speedups where it matters most.
The timing here is worth noting. Many organizations are feeling pressure to modernize, but they often confuse modernization with replacement. Mara's method is a reminder that performance gains do not have to come from a complete overhaul. By focusing on function-level optimization, teams can keep their existing infrastructure intact, maintain integration testing, and see meaningful infrastructure cost savings without adding the operational complexity of microservices. This is not about being conservative for its own sake. It is about being strategic with engineering resources. If you can isolate a bottleneck and solve it with a small, well-tested Rust module, why would you risk destabilizing an entire codebase to achieve the same result? That is a question every team should ask before committing to a rewrite.
This philosophy aligns with what we have seen elsewhere in the industry. For example, Perplexity Transforms Search with CobbleDB, Achieving 5x Faster Queries shows how a targeted infrastructure change can yield outsized performance improvements. Similarly, Unlock Python's Potential: Advanced Techniques for Smarter Coding suggests that leveling up often means learning what a language already offers rather than reaching for something new. Mara's work sits right at the intersection of those ideas: it is about understanding the tools you have, recognizing their limits, and making surgical improvements that respect the existing system.
What stands out most is the emphasis on testing. A common fear with FFI is that it introduces a new class of bugs, but Mara shows how to integrate testing into the workflow so that the boundary between Python and Rust does not become a source of fragility. That is a concrete, practical takeaway: you can have speed and safety, but only if you treat the integration layer as a first-class citizen. For teams considering this approach, the question is not whether to adopt Rust, but where the bottlenecks actually are. Start there. Measure. Then decide if a function-level rewrite is worth the investment. That is the kind of advice that saves engineering teams from costly mistakes, and it is exactly what we would tell a reader who asked us whether incremental integration is worth the effort. The answer is yes, but only if you are honest about what you are optimizing for.