I’m fairly new to Rust. I’m not a software engineer, a coder, and I don’t claim to be one. But I’ve been close enough to engineering teams for long enough to notice when something shifts from interesting to important.

So you may have seen Ferris the Crab, but what is Rust?

Rust is a modern programming language designed for building fast, reliable software, especially in areas where mistakes are expensive.

My colleague Ross Townsend is a bit of a celebrity among Rustaceans, and his passion for Rust is hard to ignore. Listening to how he talks about the technology and seeing how connected the community is behind it has been cool to witness, and it’s what inspired me to look further at where and how this is being adopted.

It’s not often you come across a technology that can support a CISO, CFO, CIO, and CTO all at once, improving performance, strengthening security, enabling scale, and keeping cloud and infrastructure costs under control. That felt worth exploring.

Language choice is architecture choice

When you’re designing a system, choosing a language is choosing an architecture.

Some languages make it easier to move quickly and change direction.
Others make it easier to build something stable that lots of people can maintain over time.
And some are chosen because performance and reliability simply cannot be optional.

Rust fits into that last category.

It’s the kind of language you reach for when you want strong foundations, fewer hidden risks, and software that stays dependable as it grows. Yes, it asks more from you upfront, but it gives a lot back if you’re building the kind of software where correctness, performance, and long term maintainability matter.

It’s built around a few very specific promises:

• Fewer failures

• Fewer security issues

• Fewer nasty surprises in production

Who wouldn’t want that?

Why the biggest companies are adopting it quietly

Teams at Meta, Amazon, SAP, and Google are already using Rust for performance sensitive and safety critical components.

Mark Russinovich, CTO of Microsoft Azure, famously declared:

“It’s time to halt starting any new projects in C/C++ and use Rust for those scenarios where a non GC language is required. For the sake of security and reliability, the industry should declare those languages as deprecated.”

Since that statement, Microsoft has continued to invest heavily in Rust, including moving specific parts of its operating system in that direction as it looks to build more secure foundations across the OS.

There are some very clear benefits to adopting Rust, which I’ll come onto later. Rust solves real problems, but it also introduces a few new challenges, and understanding that balance is what leads to smarter adoption decisions.

As I dug deeper into the technology, I wanted to go beyond the hype to get clear on where Rust falls short and where it simply might not be the right fit.

Where Rust adoption gets hard

Rust’s biggest adoption hurdles aren’t usually technical. The language is brilliant, but it asks for a different approach and mindset, and as a modern language, the pool of talent is limited, but growing.

The learning curve is real
Rust takes time to get comfortable with. Even experienced engineers can feel slowed down early on, simply because it forces you to think differently.

Delivery speed can drop at the start
Most teams feel slower when they first adopt Rust. That’s normal, but it becomes a problem if the business expects immediate results and isn’t willing to invest through the learning phase.

It can feel less flexible
Rust is designed to prevent mistakes, but that also means it can feel less forgiving when you’re trying to move fast, experiment, or change direction quickly.

Building the skillset takes effort
Rust hiring is improving, but it’s still not as common as other languages. Even with good people, teams need time and support to build confidence and consistency.

It’s not always clear where to begin
Rust adoption works best when it starts small. Without a clear first use case, it can stay as “something we want to try” instead of something that delivers real value.

Rust is not for everything

Rust is not always the right choice. If your priority is rapid prototyping, constant iteration, or getting something into users’ hands quickly, Rust may be too heavy early on. In those environments, speed of change often matters more than perfect correctness.

It’s not all or nothing

Rust doesn’t need to replace your stack.

Many of the most successful adoption stories are built around targeted deployment in the critical parts of a system, where performance, security, and reliability matter most, while existing languages stay in place everywhere else.

It’s not about rewriting everything. It’s about strengthening the foundations that carry the most risk.

With attack surfaces expanding rapidly across IT, IoT, and OT environments, Rust’s lack of a garbage collector becomes a real security advantage. It gives you precise control over when memory is cleared and sensitive data is erased, rather than leaving it sitting around waiting for automatic clean up on someone else’s schedule.

Don’t take my word for it…

This isn’t just a passionate community talking itself into a new favourite language. There are real examples of organisations using Rust in production and seeing measurable outcomes:

• Dropbox rewrote parts of its file sync engine in Rust and reported around a 50% reduction in CPU usage

• Discord moved a core service from Go to Rust and reported a 40% reduction in memory usage, alongside more consistent performance under load

• Solana chose Rust for a system where throughput and speed are non negotiable, with the network often cited as targeting 65,000+ transactions per second

And it’s not just companies adopting Rust, developers are choosing it too.

In the 2025 Stack Overflow Developer Survey, Rust continued to stand out as one of the most admired programming languages, meaning developers who use it are highly likely to want to keep using it. While it’s not yet as widely used as languages like JavaScript, Python, or Java, it consistently ranks near the top for satisfaction and desire to learn, a strong signal that adoption is being driven by genuine developer experience rather than hype.

Start small and prove it

If you’re curious about Rust, the best approach is not a rewrite. It’s a small, deliberate experiment that proves value in a place where the outcome is measurable.

Start by looking for parts of your system where performance, reliability, and security really matter. Hot code paths, performance bottlenecks, edge services, data parsing and ingestion, or anything that sits on a trust boundary are typically good places to start.

Small improvements in these areas can create an outsized impact.

And the pay off isn’t just performance. It’s fewer incidents, fewer security issues, and less operational noise for teams. More time building, less time recovering. That’s what keeps engineering teams engaged and productive.

A focused pilot in one of these areas can validate both the performance gains and cost savings before you commit to broader adoption. Choose something you can test properly where you can compare outcomes, not opinions. Measure latency, throughput, error rates, CPU and memory usage, and the security related signals you care about. Run an A/B test, keep the scope tight, and make the decision based on evidence.

If the Rust version performs better and is easier to trust, you have your answer. If it doesn’t, you still win, because you’ve learned where Rust fits in your environment without taking on risk or disruption.

A simple rule of thumb

Rust is worth exploring if you’re building something long lived, performance sensitive, or security exposed.

If you’re building something uncertain, short lived, or purely experimental, it might not be the best first move.

You don’t have to bet everything to find out. The organisations seeing real results didn’t rewrite their entire stack. They identified a specific problem, ran a focused experiment, and let the evidence guide the decision.

The learning curve is real, and the talent pool is still growing. But the fundamentals that make Rust compelling aren’t going away, better performance, stronger security, fewer production surprises.

If you’re looking at parts of your system where reliability and security can’t be optional, where performance directly impacts cost, or where failures have real consequences, Rust deserves a look. Start small, measure properly, and see if it delivers. The best time to explore isn’t when you have no other choice. It’s when you have the space to experiment and prove the value.

Want to explore where Rust could fit in your organisation?

If you’re thinking about where Rust might make sense in your platform, product, or infrastructure, and want to understand what the market looks like for Rust engineers, teams, or leadership, it’s worth speaking to someone who lives in this space.

Get in touch with Scott Cook (s.cook@wearexps.com) to have a practical conversation about Rust talent, adoption patterns, and how organisations are building teams around performance and security critical systems.