How teams scaled Rust: 15 real case studies
15 of the 91 engineering write-ups in our database mention Rust in their stack. They come from 8 companies (Datadog, Discord, OpenAI, Dropbox, Axiom and 3 more) and were published between 2018 and 2026 (2 undated). Techniques that show up most often alongside Rust: rewrite (6) and indexing (2). It's often paired with Python (3), Go (2), Kafka (2) and ScyllaDB (2). 11 of the 15 state concrete scale numbers, for example "nearly a petabyte of Git data/day" (OpenAI). Each card below links to our short summary and the original post.
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).
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.
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.
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.
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.
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.
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.
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.
Timeseries indexing at scale
Datadog redesigned its timeseries indexing to handle a large jump in ingested data.
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.
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.
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.
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.
Scaling to exabytes and beyond
Dropbox built Magic Pocket, its own exabyte-class block store, and moved user data off third-party cloud storage.
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.