Why Teams Are Migrating from Go to Rust (It's Not About Speed)

Key Takeaways

• Go-to-Rust migrations are driven by correctness guarantees and runtime tradeoffs, not just performance gains
• 78.5% of organizations officially report Rust migrations were worth the cost
• Grab reduced infrastructure costs by 70% and cut peak CPU from 20 cores to 4.5 after migrating a high-load service

Matthias Endler has helped dozens of teams migrate backend services between languages. But when companies move from Go to Rust, the conversation looks different. They're not asking about speed benchmarks or type systems. Go already handles those reasonably well.

"Out of all the migrations I help teams with, Go to Rust is a bit of an outlier," Endler wrote in a new migration guide published this week. "It's not a question of 'is Rust faster?' or 'does Rust have types?', Go already gets you most of the way there. The discussion is mostly about correctness guarantees, runtime tradeoffs, and developer ergonomics."

Endler runs Corrode Rust Consulting and has written extensively about both languages, including a 2017 piece titled "Go vs Rust? Choose Go." His new guide targets backend developers specifically, the territory where Go is strongest with its small static binaries and networking-focused standard library.

The Real Migration Drivers

Teams considering Rust aren't chasing marginal performance wins. They're trying to eliminate entire categories of bugs at compile time. Go's nil pointers and garbage collector pauses create real problems in latency-sensitive systems. Rust's borrow checker catches null pointer dereferences and data races before code ever runs.

This matters more than benchmarks for teams running high-load services. Grab, the Southeast Asian ride-hailing company, reduced infrastructure costs by 70% after migrating a specific high-load service from Go to Rust. Peak CPU load dropped from 20 cores to 4.5. These aren't synthetic benchmarks. They're production numbers from a company processing millions of transactions.

AWS found similar gains. A service implemented in Rust showed 10x performance improvement in transactions per second compared to a tuned Kotlin version. The pattern repeats: teams migrate not because Go is slow, but because Rust eliminates runtime surprises.

What You Actually Gain from the Borrow Checker

Go's error handling depends on discipline. Developers must check every error return value. Nothing in the language stops you from ignoring one. Rust makes these checks mandatory through its type system.

The same applies to null values. Go's nil can appear anywhere, leading to runtime panics that only surface under specific conditions. Rust's Option type forces explicit handling of absent values. You can't accidentally dereference something that might not exist.

“Rust shifts the complexity to the left to development. ... You'll need to unlearn bad habits and learn new concepts. Chances are, you will fight with the borrow checker a lot when you start out.”

— Matthias Endler, Founder of Corrode Rust Consulting

Endler is direct about the tradeoff: Rust front-loads complexity. The compiler catches bugs that Go would let slip into production, but you pay for that with a steeper learning curve. For teams where production stability matters more than initial development speed, that tradeoff makes sense.

Where Go Still Wins

Endler doesn't recommend Rust for everything. Go remains a practical choice for many backend services, especially when teams prioritize fast iteration over absolute correctness.

Go's compilation speed matters in large codebases. Rust's compile times can slow down development loops significantly. For standard CRUD applications where latency spikes don't matter and bugs can be fixed in production, Go's simplicity wins.

The hiring pool also favors Go. JetBrains Developer Ecosystem Survey shows Go hovering around 17-19% of working developers. Rust is growing steadily but remains a smaller slice. Finding Go developers is easier.

Incremental Migration Strategy

Endler's guide covers incremental migration, a critical point for production systems. Teams don't need to rewrite everything at once. Services can coexist, with Rust handling latency-critical paths while Go continues serving stable workloads.

The guide maps Go patterns to their Rust equivalents, helping developers translate familiar concepts rather than learning Rust from scratch. This pragmatic approach acknowledges that most migrations happen in working systems with real deadlines.

Endler acknowledges his bias openly: he runs a Rust consultancy, so more Rust adoption benefits his business. But he's also shipped Go services to production. The guide's value comes from that practical experience rather than language advocacy.

Community Response

Hacker News discussions reflect the split in the broader community. Rust advocates point to the borrow checker and type system as genuine advances. Go developers counter that Rust's learning curve and compilation times negate productivity gains for most applications.

The consensus among senior engineers tends toward context-dependent answers. Rust makes sense for specific architectural challenges: high-load services where latency spikes cause real problems, systems where correctness bugs are expensive, teams that can absorb the learning curve.

For the rest, Go's simplicity and ecosystem still deliver. As Endler puts it, referencing a deliberately opposite take: "Holding both views in your head at once is more useful than either one alone."

Frequently Asked Questions

Is Rust faster than Go for backend services?

Yes, but speed isn't the main reason teams migrate. Rust eliminates garbage collector pauses and provides stronger correctness guarantees. Grab saw 70% infrastructure cost reduction and peak CPU drop from 20 cores to 4.5 after migrating a high-load service.

How long does it take to learn Rust coming from Go?

Expect significant time fighting the borrow checker initially. Endler notes developers need to unlearn habits from Go and other languages. Most teams report the learning curve pays off in reduced production bugs, but initial productivity drops.

Should I migrate my Go service to Rust?

It depends on your constraints. Rust makes sense for latency-sensitive services where garbage collector pauses cause problems, or systems where correctness bugs are expensive. For standard CRUD applications, Go's simplicity often wins.

Can I migrate from Go to Rust incrementally?

Yes. Endler's guide covers incremental migration strategies. Services can coexist, with Rust handling critical paths while Go serves stable workloads. You don't need to rewrite everything at once.

What percentage of Rust migrations succeed?

78.5% of organizations officially report their Rust migration was 'worth the cost.' Success correlates with clear architectural reasons for migrating rather than following trends.

Source: Hacker News: Best / Corrode Rust Consulting