Tech Stacks - Migrations
Key Macro Trends
Examining industry-wide tech stack migrations over the last decade reveals several defining architectural waves:
1. The Great Migration to Rust
- From C/C++ in Core Systems: Driven by memory safety mandates from government bodies (CISA, NSA) and major tech firms, organizations are rewriting vulnerability-prone C/C++ codebases in Rust (e.g., Linux kernel, Android 13, Windows kernel, Chromium, Cloudflare Pingora).
- From Scripted Tooling to Native Performance: The frontend and Python ecosystems are replacing JavaScript/Python-based CLI tools with ultra-fast Rust binaries (
uv, Ruff, Biome, Turbopack, Rolldown, SWC). - From Manual Memory Languages: Even performance-first projects with manual memory management (such as Bun migrating from Zig to Rust) transitioned to Rust to eliminate use-after-free and double-free edge bugs at garbage collector boundaries.
2. Native Compiled Developer Toolchains
Developer tooling has largely abandoned interpreted runtimes (Node.js, Python, Ruby) for core compiler and packaging passes. Compilers, linters, formatters, and bundlers are now standardly written in Go or Rust, delivering 10x–100x speedups and zero-dependency single-binary distributions.
3. Native In-Tree Consensus (Retiring External ZooKeeper)
Distributed infrastructure projects have progressively deprecated external coordination layers (primarily Apache ZooKeeper) in favor of embedded, in-tree Raft consensus (Kafka KRaft, ClickHouse Keeper). This eliminates separate cluster operations and drastically improves failover latency.
4. License Shifts & Foundation-Backed Open Forks
As venture-backed open-core companies moved away from permissive licenses (BSD/MIT/Apache 2.0) toward restrictive business licenses (SSPL, BSL, RSAL), the open-source community, major cloud providers, and the Linux Foundation repeatedly responded by creating sustainable, open-governance forks:
- Elasticsearch OpenSearch
- Terraform OpenTofu
- Redis Valkey
5. Architectural Pragmatism: Monoliths & "Cloud Exit"
After the initial hyper-enthusiasm for microservices and complex serverless step machines, organizations experiencing runaway cloud bills and distributed debugging complexity began selectively consolidating back into modular monoliths and self-hosted bare-metal infrastructure (37signals, Amazon Prime Video, Segment).
2026
Python Toolchain: pip / virtualenv / poetry => uv (Rust)
Astral's uv (written in Rust) became the dominant unified package and project manager across the Python ecosystem, replacing disparate tools (pip, pip-tools, virtualenv, poetry, pyenv, pipx) with 10-100x faster package installation and dependency resolution.
JavaScript Bundling: Webpack & Rollup => Rolldown & Turbopack
The web ecosystem accelerated its convergence toward native compiled tooling:
- Vite transitioned its production bundler from Rollup to Rolldown (a high-performance Rust port of Rollup).
- Next.js transitioned default build and development pipelines from Webpack to Turbopack.
Bun: Zig => Rust
Bun officially completed a full migration of its 500,000+ line codebase from Zig to Rust.
- Why: While Zig provided raw performance, manual memory management coupled with JavaScriptCore's garbage collector resulted in hard-to-diagnose memory bugs (use-after-free, double-free, leaks) in edge runtime conditions. Rust's strict borrow checker and ownership model provided compile-time memory safety.
- How: The rewrite was executed as a landmark AI-assisted engineering effort led by Jarred Sumner, utilizing autonomous multi-agent systems to translate and verify logic across 6,500+ commits.
- https://bun.com/blog/bun-v1.4
2025
Apache Kafka: ZooKeeper => KRaft (Kafka Raft)
Apache Kafka 4.0 completed the multi-year migration removing Apache ZooKeeper entirely. Kafka clusters now manage metadata using an internal event-driven Raft consensus quorum (KRaft), drastically improving partition scalability, simplifying operations, and speeding up controller failover recovery times.
In-Memory Datastores: Redis => Valkey
Following Redis Ltd.'s licensing change from BSD-3-Clause to non-open-source dual RSALv2/SSPL in 2024, major cloud providers (AWS, Google Cloud, Oracle, Heroku) and Linux distributions migrated production workloads and managed caching services to Valkey (the open-source fork hosted under the Linux Foundation).
Cloud Native & Systems: C/C++ => Rust in Infrastructure & Kernels
- Microsoft Windows Kernel & Azure: Replaced core C++ memory allocation and GDI components with Rust to systematically eliminate memory safety vulnerabilities.
- Android / Linux: Google reported memory-safety vulnerabilities in Android dropped from >70% of all vulnerabilities down to under 25% due to proactive new code development in Rust.
2024
Google ChromeOS: Migrating to the Android Tech Stack
Google announced and began an architectural transformation to rebuild the foundation of ChromeOS on top of the Android tech stack (including the Android Linux kernel, hardware abstraction layers, and Android system frameworks).
- Why: Accelerate deployment of on-device AI/Gemini features, unify driver development across Chromebooks and Android devices, and simplify engineering maintenance across mobile and desktop form factors.
- Outcome: Retains the familiar ChromeOS desktop UI, security model, and enterprise management while sharing a common kernel and runtime foundation with Android.
- https://blog.google/products/chrome-os/google-chromeos-optimizing-for-ai/
Cloudflare: NGINX => Pingora (Rust)
Cloudflare fully deprecated NGINX across its global proxy fleet and migrated to Pingora, an in-house asynchronous multithreaded proxy framework written in Rust.
- Why: NGINX's process-per-worker model suffered from poor connection reuse, high TLS connection overhead, and complex architecture for custom caching policies.
- Outcome: Pingora reduced CPU usage by 70% and memory usage by 67% across trillions of daily requests while eliminating memory safety issues.
- https://blog.cloudflare.com/pingora-open-source/
Kubernetes 1.31: SPDY => WebSockets
Kubernetes transitioned streaming API transport (kubectl exec, kubectl attach, kubectl port-forward) from the deprecated and non-standard SPDY/3.1 protocol to standard WebSockets (RFC 6455), resolving long-standing proxy, load balancer, and HTTP/2 middlebox incompatibility issues.
37signals (Basecamp / HEY): Public Cloud (AWS) => Bare Metal Monolith ("Cloud Exit")
37signals completed their high-profile "Cloud Exit", migrating all flagship applications (Basecamp, HEY) off AWS to self-hosted enterprise servers in colocated data centers using Kamal (open-source Docker container deployment tool).
- Why: Cloud infrastructure costs grew disproportionately for steady-state workloads.
- Outcome: Saved over $3 million over a 5-year period with superior server performance.
- https://world.hey.com/dhh/we-have-left-the-cloud-251760fb
Amazon Prime Video: Distributed Serverless (Step Functions + Lambda) => Monolith (ECS)
Amazon Prime Video's audio/video stream monitoring service restructured from microservices orchestrated by AWS Step Functions and AWS Lambda into a single monolithic application running on Amazon ECS.
- Why: High distributed state transitions and S3 bucket intermediate storage caused severe scaling bottlenecks and excessive infrastructure bills.
- Outcome: Cut infrastructure costs by 90% and increased scalability tenfold.
- https://www.primevideotech.com/video-streaming/scaling-up-the-prime-video-audio-video-monitoring-service-and-reducing-costs-by-90
Frontend Linting & Formatting: ESLint + Prettier => Biome
Web developers increasingly migrated from Node.js-based ESLint and Prettier setups to Biome (Rust-based successor to Rome), consolidating formatting and linting into a single sub-second tool.
2023
Lyft: Druid => ClickHouse
Lyft replaced Apache Druid with ClickHouse across its analytics and real-time computation workloads.
- Why: Steep learning curve and complex configuration maintenance for Druid ingestion specs; high infrastructure footprint.
- Outcome: Significantly reduced compute footprint and simplified query development for data and software engineers.
- https://eng.lyft.com/druid-deprecation-and-clickhouse-adoption-at-lyft-120af37651fd
At Lyft, our primary Druid customers were data engineers and software engineers. One of the main barriers we faced for onboarding new customers was the steep ramp-up for writing and maintaining their ingestion specifications, as well as understanding the different tuning mechanisms for each use case. ... for Lyft, as a Kubernetes Compute company, running ClickHouse over Druid would reduce our compute footprint by a large margin.
Google Chromium: Adding Rust to C++ Codebase
Google officially supported and integrated Rust into the Chromium browser engine source tree.
- Why: ~70% of high-severity security bugs in Chromium were memory-safety vulnerabilities stemming from C++. Rust allows interoperable, memory-safe code without performance degradation.
- https://security.googleblog.com/2023/01/supporting-use-of-rust-in-chromium.html
Infrastructure as Code: Terraform => OpenTofu
Following HashiCorp's transition of Terraform from the open-source MPLv2 license to the Business Source License (BSL), the open-source community, Gruntwork, Spacelift, and the Linux Foundation launched and migrated to OpenTofu as an open, community-driven fork.
Next.js: Pages Router (pages/) => App Router (app/ & React Server Components)
With the release of Next.js 13.4, Vercel declared the App Router stable, initiating a massive ecosystem-wide migration toward React Server Components (RSC), streaming HTML, nested layouts, and server actions over traditional client-side data fetching (getServerSideProps).
Netflix: Microservices Gateway => Federated GraphQL (DGS)
Netflix unified its backend architecture across hundreds of disparate microservice APIs by migrating to a federated GraphQL architecture powered by the Domain Graph Service (DGS) framework and Spring Boot.
2022
Android 13: C/C++ => Rust for Native Components
Google introduced Rust as a first-class language in the Android Open Source Project (AOSP). Android 13 was the first release where the majority of new native code was written in Rust.
- Outcome: The number of memory-safety vulnerabilities in Android dropped dramatically, from 223 per year down to 85, with zero memory-safety vulnerabilities found in new Rust code.
- https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html
DoorDash: Monolithic Python / Django => Kotlin & gRPC Microservices
DoorDash systematically decoupled its core monolithic Python/Django backend into modular microservices written in Kotlin with gRPC and Apache Kafka.
- Why: Python's dynamic typing and GIL (Global Interpreter Lock) created operational instability during peak delivery hours; poor type safety across large engineering teams.
- Outcome: Higher throughput, lower latencies, and compile-time type safety across inter-service communication.
- https://doordash.engineering/2022/02/08/how-doordash-migrated-its-monolith-to-microservices/
Shopify: Ruby on Rails Performance via YJIT (Rust)
Shopify migrated its multi-million-RPM production Rails core to run on YJIT (a Just-In-Time compiler for CRuby written in Rust, merged into Ruby 3.1).
- Outcome: Achieved a 15–25% reduction in request latency across global e-commerce traffic without changing application-level Ruby code.
- https://shopify.engineering/yjit-speeding-up-rubys-execution
Amazon Kindle UI: Web JavaScript => React Native
Amazon overhauled the user interface of the Kindle e-reader line, transitioning from custom web JavaScript views to React Native.
- Why: Required smoother page turns, lower battery consumption, and better native touch responsiveness on hardware-constrained E-ink displays.
- https://goodereader.com/blog/electronic-readers/amazon-kindle-ui-is-switching-from-javascript-to-react-native
SingleStore: Next.js => Clean Static Architecture
SingleStore migrated their customer-facing web presence away from Next.js server runtime complexity to a leaner static architecture to eliminate unnecessary server-side rendering latency and operational overhead.
Escape: Vue 2 => Svelte
Escape documented their migration from Vue 2 to Svelte, citing improved bundle sizes, reactive syntax simplicity, and elimination of virtual DOM overhead.
2021
React Official Documents: Gatsby -> Next
Next 12: Babel -> SWC
Next.js now uses Rust-based compiler SWC to compile JavaScript/TypeScript. This new compiler is up to 17x faster than Babel when compiling individual files and up to 5x faster Fast Refresh.
Uber: Fulfillment Platform Rearchitecture
https://eng.uber.com/fulfillment-platform-rearchitecture/
- The old service was written with Node.js and HTTP/JSON, while newer Uber services use Java with Protocol Buffers (Protobuf) for communication.
- use Spanner as db
Qt: qmake to cmake
https://www.qt.io/blog/qt-and-cmake-the-past-the-present-and-the-future
2020
AOSP: -> Bazel
https://blog.bazel.build/2020/11/12/aosp_migrating_to_bazel.html
Spring Boot: Maven -> Gradle
https://spring.io/blog/2020/06/08/migrating-spring-boot-s-build-to-gradle
Discord: Go -> Rust
https://blog.discordapp.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f
Rust does not have garbage collection; Go has latency spikes every 2 min.
2019
Dropbox: to gPRC
https://blogs.dropbox.com/tech/2019/01/courier-dropbox-migration-to-grpc/
Deliveroo: Ruby -> Rust
https://deliveroo.engineering/2019/02/14/moving-from-ruby-to-rust.html
Redhat: MongoDB -> PostgreSQL
https://www.redhat.com/en/blog/red-hat-satellite-standardize-postgresql-backend
GNU Health: MongoDB -> PostgreSQL
http://savannah.gnu.org/forum/forum.php?forum_id=9366
MongoDB Changed the license to Server Side Public License (SSPL) at the end of 2018. Previous versions are still on GPLv3, but MongoDB no longer maintain those old versions.
2018
Udacity: Deprecate React Native
Airbnb: Sunsetting React Native
https://medium.com/airbnb-engineering/sunsetting-react-native-1868ba28e30a
Depop: Heroku to AWS
https://engineering.depop.com/aws-migration-a-depop-story-1444e9aaad31
Facebook: InnoDB to MyRocks
https://code.facebook.com/posts/1478526992216557/migrating-a-database-from-innodb-to-myrocks/
Why: With pure Flash, UDB was space-bound. Even though we used InnoDB compression and there was excess CPU and random I/O capacity, it was unlikely that we could enhance InnoDB to use less space...This was one of the motivations for creating MyRocks – a RocksDB storage engine for MySQL...
Uber: Postgres to MySQL
https://eng.uber.com/mysql-migration/
Segment: Microservices back to Monolith
https://segment.com/blog/goodbye-microservices/
Redfin: Maven to Bazel
https://redfin.engineering/we-switched-from-maven-to-bazel-and-builds-got-10x-faster-b265a7845854
Steam: Python to Go
https://getstream.io/blog/switched-python-go/ https://lobste.rs/s/zsbrjy/why_we_switched_from_python_go#c_ea61kn
Scala to Go
https://movio.co/en/blog/migrate-Scala-to-Go/
2016
Spotify: on-prem to Google Cloud Platform
https://labs.spotify.com/2016/02/25/spotifys-event-delivery-the-road-to-the-cloud-part-i/
2015
Braintree: Gradle to Bazel
https://www.braintreepayments.com/blog/migrating-from-gradle-to-bazel/