Your Team Isn’t Ready for Rust’s Borrow Checker

By Geekery Team · · 4 min read

Rust in production: why your team isn't ready for the borrow checker is usually an ownership problem, not a syntax problem. If your engineers cannot explain references, lifetimes and shared-state boundaries under pressure, adding Rust will amplify those gaps rather than remove them.

A rewrite does not create engineering capacity. It creates a second language, a second toolchain and a six-month argument over whether every service needs async traits, unsafe abstractions and a custom allocator.

The borrow checker is an organisational constraint

Rust rejects broad mutation while allowing low-level systems access. That bargain is excellent for a payment ledger at Monzo or an imaging pipeline somewhere behind NHS Digital. It is awkward for a team whose delivery model depends on mutable module-level state, tangled shared objects and business rules spread across services.

The compiler will force those dependencies into the open. That is useful, but only if the team has enough Rust experience to redesign the code without turning a compile error into weeks of Arc<Mutex<T>> noise. Borrowing problems are often design problems. Cloning everything may satisfy the checker, but it can quietly trade compile-time confidence for runtime copying and a false sense of safety.

Run the readiness test before choosing Rust

Do not assess readiness with a quiz about Option<T>. Give a small, representative slice of your real workload to engineers who already know your production constraints: tracing, database cancellation, retries, feature flags and observability. Include a build pipeline, because cargo test running locally means little if CI cannot cache crates or your dependencies need private registries.

use std::sync::mpsc;
use std::thread;

fn main() {
    let (jobs_tx, jobs_rx) = mpsc::channel();
    let (results_tx, results_rx) = mpsc::channel();

    let worker_rx = jobs_rx;
    let worker_results = results_tx.clone();

    thread::spawn(move || {
        for job in worker_rx {
            let doubled = job * 2;
            worker_results.send(doubled).unwrap();
        }
    });

    for job in 1..=3 {
        jobs_tx.send(job).unwrap();
    }
    drop(jobs_tx);

    let mut results: Vec<i32> = results_rx.iter().collect();
    results.sort_unstable();
    assert_eq!(results, vec![2, 4, 6]);
}

This is not an impressive benchmark. That is the point. It tests channel ownership, move, joining, error propagation and test design without pretending a toy benchmark predicts production throughput. If the team starts reaching for unwrap() everywhere or cannot say which thread owns which channel, you have found the real readiness issue.

Measure feedback loops, not toy throughput

Rust is fast. Your users do not benefit unless the faster component is on a measured critical path. Benchmark parsing, serialisation or database work with Criterion or criterion.rs, then compare p95 and p99 latency against the existing implementation. Use tracing, OpenTelemetry and your normal load generator as well as microbenchmarks; the borrow checker cannot optimise a queue sitting in HMRC’s network path.

Warning signs that Rust is being adopted cosmetically

A team is not ready when “memory safety” replaces a written performance requirement. Ask whether Rust removes a demonstrated class of defects, improves tail latency, reduces infrastructure cost or unlocks deployment on constrained hardware. If nobody can name the target, Rust is a technology preference dressed as a production strategy.

  • The team cannot maintain Linux builds, cross-compilation or reproducible dependency pinning.
  • Every concurrency problem gets wrapped in a global Arc<Mutex<_>> with no measurement behind it.
  • Engineers write unsafe blocks but lack a documented invariant and fuzzing plan.
  • The service has three external interfaces, five internal abstractions and no clear domain boundary.

The opposite is stronger: incremental adoption around one isolated component, explicit acceptance criteria and a rollback path. Start with a parsing library, a CLI used by deployment tooling or a latency-sensitive worker. Keep the network boundary conventional until ownership and cancellation semantics are understood.

Make the team pay the learning cost

Rust’s borrow checker is valuable because it makes invalid lifetimes and data races hard to express. It is not valuable because developers become better systems engineers automatically. Budget pairing, code review and production onboarding. Use cargo clippy --all-targets --all-features -- -D warnings in CI, run cargo deny for dependency policy, and keep a small set of reviewed crates rather than permitting unchecked dependency sprawl.

For regulated UK work, also decide where evidence lands. A memory-safety language does not remove audit logs, access controls, incident response or data-retention duties around GOV.UK services. Rust reduces one set of bugs; it does not reduce the full compliance burden. Review generated documentation, SBOMs and model updates as part of release engineering, not as a clever follow-up ticket.

If the team is still struggling with basic ownership after a bounded pilot, delay production migration. The cheapest Rust project is the one that proves its operational and organisational value before becoming critical infrastructure.

The decision rule

Choose Rust when safety, predictable performance or deployment constraints justify a deliberate capability investment. Stay with Go, Java, .NET or another stack when the existing service works and the team would spend most of the project translating organisational debt into compiler arguments.

That is the uncomfortable point: the borrow checker can tell you that your design is fragile, but it cannot tell you who will maintain it during an on-call incident at 03:00. Test the team on real code, measure the outcome and let evidence decide.

Is Rust too difficult for an experienced backend team?

It can be initially unfamiliar, especially with lifetimes, ownership and async cancellation. An experienced systems team can learn it, but production readiness requires supervised practice on real code, not one weekend of syntax.

Does Rust eliminate memory-safety bugs?

Safe Rust prevents many use-after-free, double-free and data-race defects. Unsafe code, FFI boundaries and flawed business logic still require review, testing, fuzzing and operational discipline.

Should a UK engineering team migrate an existing service to Rust?

Usually not as a speculative rewrite. Migrate a measured component only when Rust addresses a documented latency, safety or deployment problem and the team can fund the learning, tooling and maintenance cost.