Pratik Agarwal does not believe in theoretical debates about programming languages. The software engineer at Figma has spent his career building systems that need to move fast under pressure. This November, QCon San Francisco chose Pratik to host the track on high-performance languages in modern development because he had lived the consequences of choosing a programming language when building infrastructure for tech’s biggest names.
Agarwal is responsible for Figma’s storage and compute infrastructure, systems that millions of designers and developers rely on. For him, speed and efficiency aren’t abstract goals—they are non-negotiable. At Figma, Momento, and AWS, he consistently wrestled with the same challenge: how to get the best performance from existing hardware while maintaining system stability.
The practical answer usually comes down to selecting the right language and using it smartly.
Efficiency as a Business Driver
The QCon track Agarwal hosted focused on this problem, featuring five speakers. The core issue is simple: modern applications are running up against rising cloud costs and user demands for instant responses. The potential of modern hardware is often wasted by inefficient code.
“Engineers often just grab the tools they know without thinking about performance,” Agarwal notes. “We have to ask if our language and framework choices actually fit the job we’re trying to do.”
The track cut the academic fluff. The talks covered practical, in-production performance gains from integrating Rust and optimizing Python, as well as deep dives into database internals.
A Roadmap for High-Speed Systems
One talk offered a fresh perspective on Rust performance. Another showed how to implement observability tools without killing speed through excessive instrumentation. A third demonstrated how Valkey redesigned its hashtable to work better with modern CPUs.
Two talks directly tackled the headache of adoption. One laid out a playbook for integrating Rust into a codebase piece by piece, avoiding risky full-system rewrites. The other showed how financial services firms found a performance edge by using Python with Numba for algorithm-intensive tasks.
Agarwal’s own background is the proof. At Momento, his focus on performance directly boosted company growth and revenue. Better performance meant lower operational costs, leading to stronger margins, a necessity for survival.
At AWS, he optimized DynamoDB and led the re-engineering of the AWS Marketplace processing pipeline. Moving from slow batch processing to a fast event-driven architecture required a deep, practical understanding of performance tradeoffs. Language choice, data structure design, and hardware mapping all played a role.
“Hardware has changed,” Agarwal points out. “New processors have capabilities that old programming habits ignore. We have to update our approach.”
He applies this thinking at Figma, where the database must handle anything from simple mockups to massive collaborative files efficiently. He understands the full backend stack, from client software to storage, and how a decision in one area affects performance across the stack.
The QCon track mirrored this pragmatic, holistic view. High-performance languages are useful only in context. Engineers need to understand their specific workload and hardware to know when to optimize and when to settle for “good enough.”
“Why High-Performance Languages Matter in Modern Development” from QCon 2025
“Building infrastructure is about giving engineers the confidence to move fast,” Agarwal says. It’s about achieving speed and reliability, performance, and maintainability. These are the practical tensions of modern systems work.
The talks provided tangible examples. The Valkey presentation showed that aligning a basic data structure with CPU cache behavior led to speedups with no loss of correctness. The Rust talk offered a roadmap for teams to find the worst bottlenecks (“hot paths”) and rewrite only those segments. The instrumentation talk addressed the need for metrics without the crippling overhead. And the Numba talk proved that, with smart design and JIT compilation, Python could be a serious tool for intensive work.
Performance’s Connection to Growth
Agarwal and many of the speakers see these problems as connected. As systems get more complex, high-performance languages give us the tools to manage that complexity without slowing down.” His experience, from scaling DynamoDB for billions of operations to building Momento’s microsecond-latency caching platform to supporting real-time collaboration at Figma, confirms this. Performance has always been the bottom line.
The QCon track was for engineers facing the same challenges: rising cloud costs, impatient users, and intensifying competition. High-performance languages offer a practical way forward for those who learn how to implement them effectively.
“Engineers need actionable strategies,” Agarwal concludes. “They don’t need benchmarks proving Rust is faster than Python. They need to know how to fit these tools into their existing systems, how to train their teams, and how to measure the results.”
The presentations delivered exactly that—code, metrics, migration paths, and honest discussions about tradeoffs.
Agarwal’s work at Figma is a living example. The company needs infrastructure that supports rapid innovation while keeping the platform fast and reliable for designers and developers. This requires choosing the right tool for the job, with the main goal of making an informed decision based on the actual requirements and constraints.
Modern development demands this nuanced thinking. Applications are more complex, users are less patient, and resources are more expensive. High-performance languages are a direct answer to these business pressures. Agarwal understands this from experience: performance gains translated directly to customer acquisition at Momento, efficiency improvements affected millions at AWS, and infrastructure performance enables the whole Figma platform.
Ultimately, the QCon track offered engineers a toolbox, not a manifesto. Agarwal’s takeaway is simple: performance is a practical business driver, not a theoretical debate. By focusing on incremental adoption, hardware awareness, and making informed language choices based on real-world constraints, teams can start turning faster code into lower cloud bills and happier users today.
