Rust at the edge: when it pays, when it doesn't

Rust is a serious investment. The compile times, the borrow-checker ramp-up, the smaller library ecosystem in some domains. Spending that investment in the wrong place is one of the more expensive mistakes a team can make. We have shipped enough Rust now to have a real opinion on where it earns its place and where it absolutely does not.

Three workloads where Rust wins outright

Edge runtimes are the first. Cloudflare Workers, Fastly Compute, Deno Deploy with native modules. When the workload is parse-and-route at sub-millisecond budgets, Rust gives you a latency floor that V8 cannot match. We have a Rust service in front of one client's API that strips three to five milliseconds from every request, which compounds into real money at their volume.

The second is data pipelines that need stream processing without GC pauses. Arrow, Polars, custom binary formats. Anything where a 200ms GC pause ruins the streaming guarantee. Rust gives you predictable allocation behavior the way Go and Node cannot.

The third is anything that touches FFI heavily: native bindings to a C/C++ library, system-level integrations, codecs. The Rust binding ecosystem is now mature enough that this is often cleaner than the equivalent Node or Python wrapper.

Where Rust is the wrong call

• CRUD APIs. The performance ceiling does not matter; the developer-velocity ceiling does. Use TypeScript on Node, Go, or even Python.
• Anything where the team will not retain a maintainer who can read Rust. The borrow checker is not a code smell, but a Rust codebase that lapses out of active care becomes harder to onboard onto than the JS equivalent.
• Frontend. WASM for hot loops, sure. Replacing your component framework with Yew or Leptos for no specific reason: no.
• Glue work. Stitching three SaaS APIs together, writing a webhook handler, building an admin tool. The investment is wasted on these shapes.

How we structure a Rust beachhead

When Rust is justified, we keep it small and isolated. A single binary or service with a narrow contract, an HTTP endpoint, a Kafka consumer, a CLI, written in Rust, talking to the rest of the system through a normal protocol (JSON over HTTP, Protobuf, well-defined CSV). The surface area is a contract, not a library boundary. The rest of the system stays in whatever language is already there.

This shape lets a TypeScript-fluent engineer touch the Rust service rarely and survive. They read the contract, not the borrow checker. The Rust expertise sits with one or two engineers who carry it; the rest of the team operates on the contract.