THE MIGRATION LINE

All systems · status board

Every metric
breaks eventually.

Real companies, real systems, real thresholds crossed. Each row is an engineering migration retold as the incident it actually was — what climbed, what broke, what they shipped instead. Facts traced to source, never altered.

105Migrations logged

205Tech categories

24yYears covered

Ruby sitar-agent on a Sparkey datastore⟶Java sitar-agent on a WAL-mode SQLite datastoreAirbnbAirbnb's config-delivery sidecar, sitar-agent, was fully rewritten from Ruby to Java in 2024 — and its local datastore moved off a Sparkey store that had to lock the whole file on every write.

StatsD + Veneur⟶OpenTelemetry + vmagent (Prometheus)AirbnbAirbnb migrated its high-volume metrics pipeline off StatsD and a proprietary Veneur fork onto OpenTelemetry and VictoriaMetrics' vmagent, scaling to over 100 million samples per second while solving a subtle undercounting bug that Prometheus's counter model introduced along the way.

ClickHouse with exclusive-locked query planning⟶ClickHouse with shared-lock, cached-copy query planningCloudflareCloudflare's billing jobs run on a petabyte-scale ClickHouse cluster. After a routine partitioning change, they started slowing down for no visible reason — I/O, memory, and rows scanned all looked clean. The real cause was a mutex.

Data center SFUs⟶Cloudflare edge voice (Rust)DiscordDiscord moved voice onto Cloudflare's 300+ city edge, then spent weeks hunting European ping spikes that turned out to start inside its own event loop.

Fragmented, per-market onboarding APIs⟶Unified modular workflow platform (DxO)DoorDashDoorDash rebuilt Dasher onboarding — three coexisting API versions, hard-coded per-country logic, and status scattered across multiple tables — into a single configurable workflow platform, then migrated every market onto it starting with the US, with zero user-facing regressions in any launch.

In-house ORM sharding + index database⟶Vitess vindexesEtsyEtsy's ~1,000-shard MySQL cluster routed every query through a single index database — a full-site outage waiting to happen. Five years later it runs on Vitess.

Hive Parquet, managed through the Hive Metastore⟶Apache Iceberg, rolled out highest-value tables firstGrabGrab's Hive Metastore had become a single point of failure whose query planning time scaled linearly with partition count, while some ML datasets fragmented into thousands of sub-1MB files per partition. Moving to Iceberg cut one navigation query from 70 seconds to 6 — but adopting a second table format meant Grab had to build its own way to hide that fact from everyone downstream.

Customer-owned data ingestion pipelines⟶A self-managed, hyperscale data warehouse ingestion serviceMetaMeta's data ingestion system scrapes several petabytes of social graph data out of MySQL every day. The legacy pipeline design worked at small scale and started to buckle as landing-time requirements got stricter — so Meta migrated tens of thousands of jobs to a new architecture without a cutover.

Compute Managed Batch (CMB), a homegrown batch queueing system⟶Kueue, on Kubernetes-native TitusNetflixNetflix built Compute Managed Batch in 2018 because nothing in the Kubernetes ecosystem did what it needed. Seven years later, the open-source Kueue project did all of that and the features CMB never shipped — so Netflix moved millions of batch jobs onto it in a four-week production migration.

React Native (Shop app)⟶Native Swift and KotlinShopifyShopify rebuilt its Shop app from React Native into fully native Swift and Kotlin, using AI coding agents to go from proof of concept to a published app store release in 12 weeks — cutting Android cold-start time by half and Android crash-adjacent instability by roughly 10x.

HDFS with Kerberos-based security⟶Google Cloud Storage via Storage Access ServiceUberUber moved 160+ petabytes of its on-prem Hadoop data lake to Google Cloud Storage while keeping its existing Kerberos-based security model intact, building an intermediary token-exchange service to bridge HDFS authentication and GCS IAM without any of the 150,000+ existing access policies needing to change.

Gradle⟶BazelAirbnbAirbnb's JVM monorepo held tens of millions of lines of Java, Kotlin, and Scala. Moving it off Gradle and onto Bazel took 4.5 years.

Mussel v1 (custom key-value store)⟶Mussel v2 (NewSQL backend on Kubernetes)AirbnbAirbnb replaced the storage backend of Mussel, its core key-value store for derived data, with a NewSQL backend on a Kubernetes-native control plane — migrating more than a petabyte across thousands of tables with zero downtime or data loss via a blue/green, dual-write rollout.

Standalone, high-end sharded database servers⟶An open-source distributed SQL database spread across three Kubernetes clustersAirbnbAirbnb runs an open-source distributed SQL database across three independent Kubernetes clusters, one per AWS availability zone, so a bad deploy only ever costs a third of the fleet.

Android Java codebase⟶KotlinLyftLyft spent seven years converting its Android apps from Java to Kotlin, then added a CI lint check so no one could add Java back.

Fully Kubernetes-based ML compute⟶AWS SageMaker (offline) + Kubernetes (serving) hybridLyftLyft moved LyftLearn's offline training and batch-processing workloads off a fully self-managed Kubernetes stack and onto AWS SageMaker, while deliberately keeping online model serving on Kubernetes — requiring zero changes to any team's actual ML code.

React Native Old Architecture⟶React Native New ArchitectureShopifyShopify moved Shopify Mobile and Point of Sale onto React Native's New Architecture while shipping weekly, and watched production reveal cracks its internal testing never did.

A single GraphQL monolith serving 70 clients⟶Microservices routed through a Smart OrchestratorAgodaAgoda's GraphQL API had backed every client app since 2016. To split it into microservices without breaking any of the 70 clients depending on it, they migrated the clients before they touched the backend.

Enzyme⟶React Testing Library (RTL)AirbnbAirbnb used an LLM-driven pipeline to migrate 3.5K React test files from Enzyme to RTL in 6 weeks instead of an estimated 1.5 years.

Scheduled worker services on MySQL (OLTP)⟶ELT pipeline on an OLAP warehouse (Snowflake)CanvaCanva counts billions of content usages a month to pay creators. Counting them one database round trip at a time on MySQL was O(N) and took over a day — so they moved the counting into an OLAP warehouse.

Elasticsearch, with a parallel HDFS write path⟶ClickHouse, split into dedicated Log and Trace clustersDidiDidi's logs lived in Elasticsearch, written twice — once to ES for search, once to HDFS for analysis — at petabyte scale. Moving both onto ClickHouse cut machine cost 30% and made queries 4 times faster.

Local MacBook Dev⟶Cloud Dev Environments (Coder)DiscordDiscord moved backend development for its entire engineering org off local MacBooks and into Coder cloud dev environments — and Apple's M1 set the deadline.

AWS Elastic Container Service (ECS)⟶Kubernetes (EKS)FigmaFigma's teams were burning engineering hours working around ECS, so the infrastructure team moved most core services to EKS in under 12 months by refusing to change anything else.

PostgreSQL 11 on GOV.UK PaaS⟶RDS PostgreSQL 15 on AWSGOV.UK NotifyGOV.UK Notify moved a 400GB, 1.3-billion-row PostgreSQL database off a retiring platform and onto its own AWS account — and cut over live traffic in 11 seconds.

Wide-column database (Counter Service storage)⟶AerospikeGrabGrab's Counter Service served a billion requests a day off a wide-column store. Moving to Aerospike with a map-based schema cut disk from ~3 TB to ~1 TB per node and p99 read latency by roughly half.

HBase⟶TiDB, with other workloads split to Druid/StarRocks, Goku, and KVStorePinterestAt its peak, Pinterest ran roughly 50 HBase clusters on 9,000 EC2 instances holding over 6 petabytes of data. By the end of 2021, the company decided to deprecate it entirely, splitting its workloads across four successor systems.

Static-analysis boundaries (Packwerk)⟶Running-code isolationShopifyFour years after shipping Packwerk, Shopify hit the wall: a package with zero Packwerk violations still crashed when run in isolation. The retrospective is an honest accounting of what static analysis missed.

A single Elasticsearch logging platform⟶ClickHouse, on multiple Kubernetes-managed clustersTrip.comTrip.com's 2012 Elasticsearch logging platform hit a wall at 4PB — request rejections, out-of-memory queries, and daily hot-to-cold migrations that degraded the whole cluster. ClickHouse took it from there to 40PB+.

Amazon Web Services⟶Own hardware37signalsAfter 15 years on the cloud, 37signals concluded the promised savings never came and the team never shrank — so they bought their own servers and left.

Single shared RDS instance⟶Separate service database via AWS DMSCanvaCanva's Creators Monetization team had to split over 1 TB of royalty-tracking data off a shared RDS instance without dropping a single usage event — because every dropped row is a mispaid creator.

Clustered search-system storage⟶Husky (decoupled compute + object storage)DatadogDatadog's event platform outgrew its clustered search-system storage. Husky is the third-generation rebuild — a columnar store that decouples compute from storage on commodity object storage — and this is the design that guarantees exactly-once ingestion into it.

Airflow⟶Dagster + dbtDiscordDiscord outgrew Derived, its five-year-old in-house orchestrator, and picked Dagster plus dbt against four hard criteria.

Single-writer PostgreSQL (store_items table)⟶CockroachDBDoorDashDoorDash's push into grocery and convenience multiplied menu items until a single-writer Postgres table hit its internal 500GB ceiling. They built a facade layer first, then swapped the store underneath it for CockroachDB.

Replication alone⟶Pocket Watch verificationDropboxMagic Pocket stores multiple exabytes across over half a million disks. Pocket Watch is the six-system verification layer that continuously proves the data is still there — and it runs more traffic than the customers do.

Subversion support (on a Git backend)⟶Git onlyGitHubGitHub spent fourteen years hosting Subversion so people could leave Subversion. By the end, under 0.02% of requests used it — so on January 8, 2024, it turned the bridge off.

Fragmented per-team data tools, including at least a dozen Airflow instances⟶A unified stack — dbt plus one Airflow deployment on Snowflake (project Ground Truth)InstacartEvery engineering pillar at Instacart had its own data tools, its own event framework, and its own Airflow. Ground Truth collapsed them into one stack in six months.

Eureka + Ribbon client-side load balancing⟶Envoy service mesh with on-demand cluster discoveryNetflixNetflix moved its decade-old Eureka-and-Ribbon IPC architecture onto an Envoy-based service mesh, co-developing a new Envoy feature with Kinvolk — On-Demand Cluster Discovery — specifically so services could migrate with zero configuration changes required.

Monolithic architecture⟶Cell-based architectureSlackOne flaky network link inside a single availability zone took Slack down twice in a day, so Slack spent 18 months building a button that drains an AZ.

Go⟶RustVercelHaving decided to move Turborepo from Go to Rust, Vercel's team rejected a ground-up rewrite. Instead they ran both languages at once, porting piece by piece behind a Rust entry point they call the Rust-Go-Rust sandwich -- and hit a segfaulting Alpine Linux binary along the way.

Legacy payments in the Rails monolith⟶Product-agnostic payment orchestration platformAirbnbAirbnb's payment logic was welded to stay reservations, so every new product — Experiences, Resolution Center — meant reimplementing payments. This is the rebuild into an idempotent, product-agnostic orchestration platform.

Manually orchestrated EC2 instances⟶Dynamically autoscaled Kubernetes clustersAirbnbAirbnb moved nearly all online services from hand-scaled EC2 machines onto thousands of Kubernetes nodes across a hundred-plus clusters, then had to teach the autoscaler Airbnb-specific business logic to keep it efficient.

Snapshot replication⟶CDC-based service-aligned data platformCanvaCanva was taking a full snapshot of every service database every 24 hours to feed a 5-petabyte Snowflake warehouse. When a snapshot started taking longer than 24 hours to extract, the whole schedule fell apart.

Nginx (NGINX/OpenResty + Lua)⟶Pingora (Rust)CloudflareCloudflare evaluated forking NGINX, adopting another proxy, or starting clean — and built Pingora in Rust, cutting CPU by 70% and memory by 67% at over a trillion requests a day.

Apache ZooKeeper (Kafka metadata)⟶KRaft (Kafka Raft)ConfluentKafka kept its metadata in a second distributed system, and that second system capped how many partitions Kafka could hold. KIP-500 moves the metadata into Kafka itself.

AWS SQS + Kinesis (data pipelines)⟶Apache Kafka + Apache FlinkDoorDashEvery one of DoorDash's data pipelines worked, yet data arrived late and cost too much. The culprit was the shape of the collection, not any single pipe.

Ruby pre-receive hooks (in the Rails monolith)⟶A dedicated Go serviceGitHubEvery git push to GitHub ran Ruby hooks that spent about 880 milliseconds loading dependencies before doing any work — so pushing nothing at all took over two seconds.

Voldemort and proprietary derived-data stores⟶VeniceLinkedInLinkedIn's batch and stream jobs needed somewhere fast to land online, and the answer was Voldemort Read-Only stores plus a scatter of proprietary systems. Venice replaced them with one platform, now open source.

Kafka Mirror Maker (KMM)⟶BrooklinLinkedInLinkedIn left Kafka Mirror Maker for Brooklin in 2018 and got stability — but its mirroring pipelines still blew their latency SLAs, and the reason was hiding in how partitions were counted.

google-breakpad (C++ minidump processor)⟶rust-minidump / minidump-stackwalk (Rust)MozillaMozilla spent about a year replacing google-breakpad's minidump processor with a pure-Rust rewrite, tested it against the old C++ system on real production crash reports, and shipped it — half the runtime, more reliable, and, by the article's own admission, still not done fighting the format's edge cases.

HBase⟶TiDBPinterestPinterest moved a 4 TB HBase table serving 14,000 reads and 400 writes per second onto TiDB with no downtime, verifying 99.999% consistency between the two systems before finally deprecating the HBase table.

Pinball (in-house workflow system)⟶Spinner (Apache Airflow, custom branch)PinterestPinterest built a transparent migration layer that translated legacy Pinball workflow definitions into native Airflow DAGs on the fly, moving more than 3,000 workflows to its new Spinner platform with no required user code changes.

On-prem HDFS (Hadoop)⟶Google Cloud / BigQueryTwitterTeam-by-team, Twitter's exabyte move to BigQuery crawled — two weeks per dataset and choking on a 77 Gbit/s proxy. An automated framework cut that to one hour.

Zookeeper cluster (Kafka)⟶New Zookeeper clusterAirbnbAirbnb's biggest Kafka cluster stored its metadata in a shared Zookeeper ensemble that nobody owned, so the team moved it to a dedicated one with no downtime and no data loss.

Apache HBase (on-premises)⟶Google Cloud BigtableBoxBox moved 600 TB of file metadata off three on-premises HBase clusters onto two Bigtable clusters with zero downtime, by writing to both databases synchronously until it trusted the new one.

Separate ZooKeeper dependency⟶KRaft (Kafka built-in consensus)ConfluentKafka kept its metadata in ZooKeeper, so every controller failover meant re-reading the whole cluster's metadata before it could act. Confluent moved that metadata into a Kafka log and replaced the single controller with a quorum.

Python monolith (Metaserver)⟶Managed microservices platform (Atlas)DropboxDropbox tried breaking its 3-million-line Python monolith into services, decided most teams shouldn't run services at all, and built a managed platform instead.

Python 2⟶GoKhan AcademyHow an end-of-life deadline turned into a full backend rewrite

Two forced migrations, Python 2 and App Engine⟶Go services + GraphQL, shipped one field at a timeKhan AcademyFacing Python 2's end of life, Khan Academy didn't just port the language — they priced a full rewrite against the cheaper fix, chose the bigger bet, and then spent the project proving that a rewrite doesn't have to be "big bang."

Hadoop-based event delivery⟶Google Dataflow + a stateless receiverSpotifySpotify rebuilt the pipeline that carries every event it collects — while it was carrying nearly 8 million events per second — and then spent the long tail waiting for 600+ legacy event types to catch up.

Per-system sync APIs⟶Kafka as the org-wide message busZerodhaDozens of Zerodha's internal systems stayed in sync by calling each other's APIs directly — a maze that grew for years. They cut the direct connections and let every system publish to, or read from, one shared Kafka bus instead.

JavaScript⟶TypeScriptAirbnbAirbnb converted a 6-million-line frontend monorepo to TypeScript by writing a tool that migrates a whole project in a day — and deliberately fills it with types that are wrong on purpose.

Single-tenant Confluence⟶Stateless multi-tenant on AWS (Project Vertigo)AtlassianConfluence Cloud's real ceiling wasn't CPU or memory — it was database connections, and one busy tenant could exhaust them for everyone. Vertigo rebuilt the architecture around that fact.

Polyrepo (many small repos)⟶Bazel monorepoCoinbaseCoinbase had nearly a thousand services in separate repos, where a fix to a shared library could take months to roll out. So they bet on a Bazel monorepo.

Python 2 monolith⟶Go microservicesDoorDashSplitting the monolith bought DoorDash developer velocity and independent deploys — and a new class of failure where one slow database took the app down for three hours.

Java (Android app)⟶KotlinDuolingoDuolingo's Android app spent its first five years as a Java codebase, then fully converted to Kotlin over two years — cutting converted files' line counts by around 30% on average and flattening a previously 46% year-over-year codebase growth rate.

2000+ on-premises servers⟶Google CloudEtsyEtsy moved more than 5.5 petabytes off 2,000-plus on-premises servers to Google Cloud in two years, and got back 15% of its engineering headcount.

Ruby 2.6⟶Ruby 2.7 (the step to Ruby 3)GitHubGitHub fixed over 11,000 deprecation warnings across 400,000 lines of code to reach Ruby 2.7 — because 2.7 was the only door to Ruby 3.

Custom Express-based frontend stack⟶Next.js (100+ microservices)LyftLyft's homegrown Express build system scaled to a hundred frontend microservices — and then upgrading it became a showstopper, so Lyft rebuilt the platform on Next.js.

3,000-line God Object (Shop model)⟶Strangler-Fig-extracted domainsShopifyShopify's Shop model had grown past 3,000 lines into a God Object. Instead of a risky big-bang rewrite, they grew a new system over the old one and let the legacy code get strangled away.

Native iOS + Android apps⟶React NativeShopifyAfter three app experiments showed 95-99% code sharing and a team that felt twice as productive, Shopify decided all new mobile apps would be built in React Native.

Mesos (PaaSTA) / Flink on AWS EMR⟶Kubernetes (PaaSTA) + Flink operatorYelpYelp's PaaSTA platform moved from Apache Mesos to Kubernetes so it could run stateful workloads. Flink was the first big tenant — and a custom Kubernetes operator cut cluster spin-up from around 30 minutes to under 2.

Resque/Redis job queue⟶Dynein (SQS + DynamoDB)AirbnbAirbnb's centralized Resque cluster was at-most-once and bounded by a single Redis instance, so the team built Dynein — a delayed job queue on SQS with a scheduler on DynamoDB.

Untyped Python⟶Static-typed Python (mypy)DropboxDropbox annotated roughly 4 million lines of Python with mypy, and had to build a daemon and a compiler to keep the type checker fast enough to use.

Delta sync (full document on every change)⟶Incremental syncFigmaFigma studied operational transforms and CRDTs, then built a simpler centralized model that syncs one property at a time instead of shipping document state around.

Manual code review and regex-based lint checks⟶LibCST-powered lint framework and Pyre-driven codemodsInstagramInstagram's Python server is several million lines, edited by hundreds of engineers shipping hundreds of commits a day. A single shared-state linter couldn't keep up, so they rebuilt static analysis as infrastructure.

Tax logic scattered across the monolith⟶A single tax componentShopifyTax code at Shopify was spread across components that knew too much about how tax worked. A change in Checkout could silently break Cart.

Custom JavaScript Workers sandbox⟶V8 Isolates (worker runtime)CloudflareCloudflare needed to run untrusted customer code in 155 data centers without containers, so it borrowed the isolation mechanism Chrome uses to keep browser tabs apart.

PostgreSQL + Citus⟶ClickHouseCloudflareCloudflare's HTTP analytics pipeline hit a wall at 15 queries per second on a Postgres/Citus cluster. They rebuilt it on ClickHouse, shut down 12 database nodes, and deleted tens of thousands of lines of Go, SQL, Bash and PHP.

Self-hosted GitHub Enterprise Server⟶GitHub Enterprise CloudGitHubEtsy stopped running its own GitHub Enterprise Server and moved repositories to GitHub Enterprise Cloud, trading infrastructure self-reliance for third-party service.

Monolith, then inconsistent microservices⟶Grab-Kit (standardized Go microservices)GrabGrab broke up its monolith and got a new problem — every team building services their own way, with logs in different formats and alerts nobody set up. Grab-Kit made the right way the fastest way.

Single Redis node (auth tokens)⟶AWS ElastiCache Redis clusterGrabGrab's authentication tokens lived on one Redis node, and it was about two months from choking. Here's how they moved to a 9-node ElastiCache cluster with zero downtime and no invalidated tokens.

Samza's low-level, callback-based API, where every job hand-built its own windows and joins⟶Samza 1.0 — a high-level API, Apache Beam portability, Samza SQL, and a standalone modeLinkedInSamza gave LinkedIn a stable, fast engine for stream processing since 2013, but building on it meant writing windows and joins by hand and wiring jobs together through raw Kafka topics. Samza 1.0 layered a high-level API, Beam portability, and a SQL interface on the same engine.

Manual region failover, provisioning capacity cold⟶Project Nimble, pre-warmed dark capacityNetflixFailing traffic out of a bad AWS region used to take Netflix close to 50 minutes, mostly waiting for new instances to boot. Project Nimble keeps fully booted, invisible standby capacity running at all times, so a failover becomes flipping a switch instead of provisioning from zero.

Emulated queues on custom objects⟶Platform Events — a Kafka-inspired time-ordered event logSalesforceWithout native eventing, Salesforce customers were emulating message queues with custom objects — fragile, slow, and billed as extra storage. No existing broker pattern could scale to hundreds of thousands of tenants, so Salesforce borrowed Kafka's log instead of a queue.

A single JSON blob column for all workspace preferences⟶An entity-attribute-value preferences tableSlackSlack's 165 workspace preferences all lived in one JSON blob column, north of 55 kB per workspace. Reading one setting meant paying for the whole blob — so Slack gave every preference its own row instead.

Mocha (test runner)⟶JestAirbnbAirbnb's Mocha suite took 12+ minutes in CI, 45 minutes locally, and flaked on 12% of builds. Jest cut it to 4m30s and ~1% flake — once they found the 480ms hiding in their spec helper.

Rails monolith⟶Service-oriented architecture (Thrift + Dropwizard)AirbnbAirbnb's Rails monolith had no strongly typed service contracts and shipped every payload as bulky JSON. This is how they standardized on Thrift IDLs and generated Java services so a new one could take production traffic in weeks.

Ruby on Rails monolith⟶Client-rendered React SPA on a v2 APIAirbnbSwapping one small template for a React component broke unrelated parts of Airbnb's search page — and even its API response. The hunt for why ended in a rearchitecture away from Rails-delivered pages.

OpenSSL (patched)⟶BoringSSLCloudflareCloudflare's edge ran a patched OpenSSL fork alongside a separate Go stack that existed only to handle TLS 1.3. It folded both into BoringSSL.

MongoDB⟶CassandraDiscordHow Discord rebuilt message storage before MongoDB's single replica set hit its limit

Go (performance-critical services)⟶RustDropboxDropbox rewrote Magic Pocket's storage engine in Rust and it worked so well that almost nobody learned it — and that turned out to be the problem.

Bare-metal Unicorn servers⟶KubernetesGitHubFor eight years GitHub's main Ruby app ran on Unicorn processes managed by God on Puppet-configured servers, deployed over SSH. This is how they moved github.com's web and API traffic onto Kubernetes.

InnoDB (MySQL storage engine)⟶MyRocks (RocksDB-backed)Meta (Facebook)UDB, the database behind Facebook's social graph, had run out of space rather than speed — so Meta swapped its storage engine and halved its storage usage.

Single-threaded C++ CSS engine (Gecko)⟶Quantum CSS / Stylo (Rust, parallel, ported from Servo)MozillaFirefox's CSS engine matched selectors and computed styles for every DOM node on a single core. Quantum CSS, ported wholesale from Mozilla's experimental Servo browser, splits that work across every core on the machine — safely, because Rust can prove at compile time that there's no data race to find.

Ad-hoc manual MongoDB migrations⟶An automated migration panelCoinbaseA Coinbase MongoDB migration meant finding one of a handful of engineers with production access to hand-run a script over tens of millions of records.

Sequential PHP API (logic built twice)⟶API-first v3 with cURL concurrencyEtsyEtsy built every feature twice — once for the website, once for the API — in a PHP world with no concurrency. So they rebuilt the API from scratch, and taught PHP to run requests in parallel.

Bare open-source Kafka, with topic setup left to producers/consumers and everything else routed through Kafka SREs⟶A purpose-built ecosystem of tools around Kafka (Nuage, LiKafka, Gobblin, an audit trail, Burrow)LinkedInLinkedIn's Kafka already let any team create a topic and start producing to it. What wasn't self-service — custom configs, topic metadata, access control — funneled through Kafka SREs, so LinkedIn built an entire tooling layer to close that gap at 1,400-broker scale.

The tracelet-based HHVM JIT compiler⟶A profile-guided, region-based HHVM JIT compilerMeta (Facebook)HHVM's original JIT compiled PHP and Hack one small, type-guessed fragment at a time, re-checking types at every boundary. A three-year profile-guided redesign cut CPU usage for running Facebook by about 15 percent.

Hand-written C++ MP4 metadata parser⟶Rust media parser (mp4parse-rust)MozillaFirefox 48 shipped Mozilla's first production Rust code: an MP4 metadata parser built by Ralph Giles and Matthew Gregan, replacing C++ on the exact code path that reads untrusted video files from strangers on the internet.

Oracle billing database, in Netflix data center⟶AWS — Cassandra for subscriber data, MySQL for paymentsNetflixOn January 4, 2016, right before Netflix expanded into 130 new countries, its billing infrastructure went 100% AWS cloud-native — splitting one Oracle database into Cassandra for subscribers and MySQL for payments, because payment processing needed ACID transactions.

Zuul 1, blocking one-thread-per-connection gateway⟶Zuul 2, asynchronous non-blocking gateway on NettyNetflixZuul is Netflix's front door for every user's traffic. The original ran one thread per connection; at 83 million members with multiple devices each, that thread cost was the whole problem.

PostgreSQL⟶MySQLUberUber traced write amplification, verbose replication, a corruption bug and painful upgrades back to one Postgres design choice — indexes pointing at physical disk locations — and moved to MySQL/InnoDB.

A single memcached instance⟶A globally distributed, multi-region memcache layerMeta (Facebook)Mark Zuckerberg downloaded memcached and installed it on Facebook's Apache web servers in August 2005 to stop page loads from crawling. By 2013, that same lineage of cache served billions of requests per second.

Solr HTTP replication⟶BitTorrent replicationEtsyEtsy's search index grew from 2 GB to over 28 GB, and Solr's HTTP replication couldn't feed the replicas fast enough. So they made the search servers seed to each other, like a torrent.

Obidos monolith⟶SOA (Service-Oriented Architecture)AmazonBy 2001 the Obidos monolith behind amazon.com had become a deployment bottleneck, and a famous internal mandate broke it into services owned by two-pizza teams.