Go vs Rust for backend services at scale: what real teams chose

Published 2026-10-19 · Built only from first-party engineering write-ups in our database. Every number below comes from the linked source.

The best-known direct comparison is Discord's 2020 post: it rewrote its Read States service from Go to Rust to get rid of garbage-collection latency spikes in a large in-memory cache. Elsewhere in our database the two languages coexist: Dropbox lists both Rust and Go for Magic Pocket, Datadog built Husky in Go and redid timeseries indexing in Rust, and Cloudflare uses Go for Quicksilver and its HTTP analytics pipeline and Rust for Pingora.

Go vs Rust: side by side

GoRust
Stories in our database915
CompaniesCloudflare, Datadog, Discord, Dropbox, Grab, OpenAI and SlackAxiom, Cloudflare, Datadog, Discord, Dropbox, Figma, Netflix and OpenAI
Published2017–2026 (1 undated)2018–2026 (2 undated)
Techniques alongside itcolumnar storage (2), multi-tenancy (2), agent framework (1), aggregation (1)rewrite (6), indexing (2), AI agents (1), caching (1)
Scale numbers stated in sources500+ services on the internal agent framework (Grab); 900 million+ weekly active users (OpenAI); 14 million HTTP requests/sec (network peak) (Cloudflare)nearly a petabyte of Git data/day (OpenAI); 1B+ users across 40 regions (OpenAI); ~65M concurrent streams (Paul vs. Tyson, Nov 2024) (Netflix)
Direct comparison storyDiscord: Why Discord is switching from Go to Rust(same story)

Verdict

In these stories, Rust shows up where teams hit GC pauses or wanted lower latency and memory (Discord, Figma, Cloudflare's Pingora). Go shows up in plenty of systems that scaled fine. Neither is a default winner.

Counts are stories in How They Scaled tagged with each side, see the Go and Rust pages. They describe what these teams wrote about, not market share or benchmark results.

The direct comparison

Discord · 2020

Why Discord is switching from Go to Rust

Discord rewrote its Read States service from Go to Rust to get rid of garbage-collection latency spikes in a large in-memory cache.

rewritecachinglatency reductionRustGo

Go in other scaling stories

Grab · 2026

Agent platform (Part 1): How we help Grab build and run AI agents at scale

Grab's internal AI agent work started as a Tech Infra support bot and grew into a company-wide platform: more than 500 services run on its agent framework (LLM-Kit), over 50 Model Context Protocol servers are registered on its remote MCP framework, and a single LLM gateway fronts every model call across the company, handling billions of tokens each month for production agents used daily by millions of merchants, drivers, and consumers. Part 1 covers how the original Go bot's reasoning plane and tool plane became reusable framework building blocks, and how problems that appeared around 500 agents—shared model control, safe tool reuse across teams, and evals after prompt changes—pushed the team toward the GrabGPT Gateway, remote MCP, and an evals platform covered in later parts.

500+ services on the internal agent framework50+ remote MCP serversagent frameworkLLM gatewayremote MCPLLM-KitGrabGPT GatewayModel Context Protocol
OpenAI · 2026

How OpenAI delivers low-latency voice AI at scale

OpenAI rebuilt its WebRTC stack for ChatGPT voice and the Realtime API after one-port-per-session media termination collided with Kubernetes: large public UDP ranges, sticky ICE/DTLS ownership, and global first-hop latency. A lightweight Go relay exposes a small fixed UDP surface, reads ICE ufrag routing hints from the first STUN packet, and forwards opaque media to the transceiver that owns ICE, DTLS, and SRTP state (with Redis-backed recovery). Cloudflare geo and proximity steering place signaling near users while Global Relay shortens the first media hop, preserving standard WebRTC for clients without making inference backends WebRTC peers.

900 million+ weekly active usersWebRTC relay + transceiverICE ufrag routinggeo-steered signalingWebRTCPionGo
Datadog · 2023

Husky: Exactly-once ingestion and multi-tenancy at scale

A deep dive on how Husky routes, shards and ingests events exactly once across tenants.

exactly-once ingestionshardingmulti-tenancyGoKafkaFoundationDB
Datadog · 2022

Introducing Husky, Datadog's third-generation event store

Datadog's Husky is a distributed, schemaless column store that keeps event data on object storage.

columnar storagestorage/compute separationmulti-tenancyGoObject storage
Cloudflare · 2020

Introducing Quicksilver: Configuration Distribution at Internet Scale

Quicksilver replicates Cloudflare's config key-value store to every edge server in seconds, built on LMDB.

14 million HTTP requests/sec (network peak)replicationconfig distributionLMDBGo
Cloudflare · 2018

HTTP Analytics for 6M requests per second using ClickHouse

Cloudflare rebuilt its HTTP analytics pipeline on ClickHouse, replacing a Postgres/Citus setup.

6M requests/seccolumnar storageaggregationpipeline redesignClickHouseKafkaGo
Slack · 2017

Flannel: An Application-Level Edge Cache to Make Slack Scale

Slack added Flannel, an edge cache that serves user and channel data lazily so huge teams no longer need giant boot payloads.

edge cachinglazy loadingGoWebSockets
Dropbox · n.d.

Scaling to exabytes and beyond

Dropbox built Magic Pocket, its own exabyte-class block store, and moved user data off third-party cloud storage.

500 PBcustom storagemigration off clouderasure codingCustom storageRustGo

Rust in other scaling stories

OpenAI · 2026

Scaling Git at OpenAI

OpenAI built Pando, a Git-compatible backend for its monorepo after Codex pushed concurrent branches, merges and fetches past the old system (reliability sometimes below 90%). Pando stores each push as an immutable pack in blob storage and records per-branch ref versions in a horizontally scalable metadata store, giving serializability per ref and causal consistency across the repo so unrelated branches do not contend. Instead of building unique packs per client, it reuses stored packs and serves them via packfile-uri through regional Express caches (over 99% hit rate), with LSM-style background compaction so fetches plan in logarithmic time. Deployed first as a read/write-through proxy, then cut over with a Git CLI wrapper; it now powers all monorepo development, cut median push latency by nearly 5x, and can deliver nearly a petabyte of Git data per day (57+ TB in a single hour).

nearly a petabyte of Git data/daymedian push latency cut nearly 5x (~80%)per-ref causal consistencyreusable packfilesstorage/compute separationGitPandoRust
OpenAI · 2026

Rapidly scaling online storage to serve over 1 billion ChatGPT users (Part II)

OpenAI's Habitat storage platform went from one shared Azure Cosmos DB container, to dedicated single-tenant containers that pushed capacity planning onto every product team, and back to a shared container by default once Azure added hot-key throttling, request-priority QoS and a new serverless mode where each physical partition scales to 10K RU/s and splits on RU usage. After failover and failback outages in late 2024, OpenAI and Azure now co-own testing and monitoring. Replicating small latency-critical datasets widely, a Valkey lookaside cache invalidated through the Cosmos DB change feed, and a Rust rewrite of the proxy cut global read p50 from about 120 ms to about 10 ms.

1B+ users across 40 regions500+ PB served by Habitatmulti-tenancyhot key throttlingCDC cache invalidationAzure Cosmos DBValkeyKafka
Netflix · 2026

Ontology-Driven Observability: Building an End-to-End Knowledge Graph at Netflix Scale

Netflix found a typical regression investigation took about four hours, mostly spent reconstructing relationships between systems like Atlas, Radar, Spinnaker, PagerDuty, incident.io and Slack that each named the same thing differently. It built an Observability Ontology on the W3C stack (RDF, OWL, SHACL, SPARQL), stored as a knowledge graph in QuipuDB, its homegrown distributed quad store built on the Rust key-value store redb. Enrichers, some LLM-based, turn noisy inputs into typed triples, every application is validated against a catalog of about 49,000 entries, and dependency edges are capped. A correlation engine scores chains across 13 signal types within a ten-minute window, discarding anything under 0.6 confidence, and an agentic AutoRCA system reads the graph to hand engineers ranked, evidence-backed hypotheses.

~65M concurrent streams (Paul vs. Tyson, Nov 2024)2B+ requests/dayknowledge graphsobservabilityroot cause analysisRDFOWLSHACL
OpenAI · 2026

Rapidly scaling online storage to serve over 1 billion ChatGPT users

OpenAI's Habitat storage platform grew from a Python client library over Cosmos DB into a central service handling 70M+ requests per second. The team ran many low-concurrency Python processes to keep asyncio delay down, switched aiohttp connection reuse from LIFO to FIFO to stop a metastable failure, used Envoy for connection fan-in, kept a deliberately simple NoSQL API, then rewrote the service in Rust.

70 million+ requests/sec1 billion+ weekly usersconnection poolingload balancingrate limitingPythonRustCosmos DB
Discord · 2026

How Discord Automates ScyllaDB Clusters at Scale

Discord's 7-person persistence team replaced fragile Python and bash scripts with the Scylla Control Plane, a Rust framework of idempotent tasks with declared preconditions, composed into YAML workflows. Jobs batch nodes by availability zone with concurrency limits to protect quorum, store their state in SQLite so they resume after interruptions, and send a webhook alert on unrecoverable errors. Operations like standing up shadow clusters and rolling upgrades went from a day and a half of babysitting to under two hours.

dozens of clusters, hundreds of database nodes7-person persistence teamdatabase operations automationidempotent taskszone-aware rolloutsScyllaDBRustYAML
Axiom · 2025

Haydex: From Zero to 178,600,000,000 rows a second in 30 days

Axiom turned a failed filter-index prototype into a production system for its event store, letting queries skip data and scan 178.6B rows per second.

178.6 billion rows/secindexingfiltersquery optimizationRustObject storage
Datadog · 2025

Evolving our real-time timeseries storage again: Built in Rust for performance at scale

Datadog rebuilt its real-time timeseries database (RTDB) storage engine in Rust as Monocle after outgrowing Cassandra, Redis, MDBM, and a Go B+ tree plus a separate RocksDB path for DDSketch distributions. The design shards the keyspace early with a shard-per-core model (for example, 24 storage shards on a 32-core machine), ingesting from Kafka partitions over MPSC channels into per-shard LSM trees on single-threaded Tokio schedulers, with tiered compaction, a unified series cache, and permit- and cost-based query throttlers (including CoDel). At peak scale the rewrite delivered a 60x increase in ingestion performance and 5x faster queries, turning extreme outliers that used to take minutes into results that return in seconds.

60x increase in ingestion performance5x faster queries at peak scaleshard-per-coreLSM treetiered compactionRustTokioLSM tree
Datadog · 2025

Achieving relentless Kafka reliability at scale with the Streaming Platform

Datadog treats Kafka as commodity hardware behind a Streaming Platform control layer. Streams span multiple Kafka clusters, AZs, and Kubernetes clusters so producers and consumers talk to stable identifiers while the control plane redirects traffic to healthier topics in seconds—for incidents, rebalancing, decommissioning, or repartitioning—without app redeploys. A custom Assigner replaces Kafka's group coordinator for multi-cluster rebalancing in seconds; Stream lanes isolate QoS and park poison pills in a DLQ; an enriched commit log tracks multiple offset ranges plus timestamps so consumers can process live traffic while replaying backlogs and the control plane can compute wall-clock lag across millions of partitions. After zstd "bombs" crashed stock clients, Datadog wrote libstreaming in Rust (with Java/Go/Python bindings) for unified, high-throughput access without a proxy in the TB/s data path.

hundreds of trillions of observability events/dayhundreds of Kafka clusters, thousands of topics, millions of partitionsmulti-cluster failovercustom coordinatorcommit log enrichmentApache KafkaKubernetesRust
Datadog · 2024

Timeseries indexing at scale

Datadog redesigned its timeseries indexing to handle a large jump in ingested data.

indexingrewriteRustRocksDB
Discord · 2023

How Discord Stores Trillions of Messages

Discord moved its message store from Cassandra to ScyllaDB and put Rust data services in front of it to coalesce hot-partition requests.

trillions of messagesdatabase migrationrequest coalescingdata services layerScyllaDBCassandraRust
Cloudflare · 2022

How we built Pingora, the proxy that connects Cloudflare to the Internet

Cloudflare replaced Nginx with Pingora, a Rust proxy that reuses connections better and needs less CPU and memory.

1 trillion requests/dayrewriteconnection reuseRustNginx
Figma · 2018

How Mozilla's Rust dramatically improved our server-side performance

Figma rewrote its multiplayer server in Rust to cut latency and memory use as documents and users grew.

rewriteperformanceRustTypeScript
Dropbox · n.d.

Rewriting the heart of our sync engine

Dropbox rewrote its desktop sync engine in Rust with a new data model built for correctness and testability.

rewritetestingRustPython

FAQ

Why did Discord switch from Go to Rust?

To remove garbage-collection latency spikes in the Read States service, which keeps a large in-memory cache (Discord, 2020).

Which companies use Rust for backend services?

In our database: Discord, Figma, Dropbox, Datadog, Cloudflare, Axiom and OpenAI, whose Habitat storage service was rewritten in Rust.

Is Go still used at scale?

Yes. Go appears in Slack's Flannel edge cache, Cloudflare's Quicksilver and HTTP analytics, Datadog's Husky and Dropbox's Magic Pocket in the write-ups we track.

The best scaling write-ups, weekly

One email a week. No spam.

Open subscribe page

More comparisons

Cassandra vs ScyllaDB at scaleMongoDB vs Cassandra at scaleEnvoy vs Nginx at scaleRedis vs MySQL at scaleClickHouse vs Postgres for analytics at scalePostgreSQL vs MySQL at scaleetcd vs SQLite for a control planeAurora vs RDS PostgresSharding vs partitioningRead replicas vs sharding

All comparisons →