Episodes
How Wikipedia Survives With Almost No Tech Debt
Wikipedia is one of the largest websites on Earth, yet its engineering team is famously small and its codebase famously pragmatic. In this episode, Lucas and Luna dig into how Wikipedia keeps its technical debt low despite running on MediaWiki, a codebase older than most of its contributors. They explore the decisions that keep the platform maintainable: the strict policy on backward compatibility, the use of feature flags to manage risk, the practice of eating your own dog food by running beta…
How HashiCorp Cut Cloud Spend with FinOps
In this episode of The CTO Podcast, Lucas and Luna dive into how HashiCorp, the company behind Terraform and Vault, implemented a FinOps practice that cut their cloud spend by 30 percent. They explore the cultural shift from 'infrastructure as code' to 'cost as code', the role of platform engineering in embedding financial accountability, and the specific practices—like tagging, showback, and automated rightsizing—that made it work. You'll hear about the challenges of getting engineers to care…
How Airbnb Cut Search Latency by 70 Percent with a Custom Cache
In this episode of The CTO Podcast, Lucas and Luna dive into how Airbnb slashed search latency by 70 percent by building a custom caching layer on top of their existing search infrastructure. They explore the technical decisions, the trade-offs, and the surprising role of machine learning in cache invalidation. If you're a technical leader or engineer wrestling with scalability, this deep dive offers concrete lessons on when to build versus buy, and how to design for performance without…
How Nubank Cut Cloud Costs While Scaling to 80 Million Customers
In this episode, Lucas and Luna dive into how Nubank, the Brazilian digital bank, managed to cut cloud costs by 30 percent while scaling to 80 million customers. They break down the specific architectural decisions—like moving to a multi-cloud strategy, optimizing Kubernetes clusters, and rethinking data storage—that made this possible. You'll learn how Nubank's engineering team balanced cost efficiency with the need for rapid growth, and what lessons any tech leader can apply to their own…
How DoorDash Cut Its Machine Learning Model Latency by 70 Percent
In this episode of The CTO Podcast, Lucas and Luna dive into how DoorDash's engineering team cut the latency of its machine learning model inference by 70 percent. They explore the specific techniques used—model distillation, quantization, and edge deployment—and how DoorDash's teams balanced speed with accuracy while scaling to millions of deliveries each day. The conversation touches on the trade-offs of running models on mobile devices versus cloud, the importance of measuring end-to-end…
How Nubank Cut Cloud Costs While Scaling to 80 Million Customers
Episode 154 of The CTO Podcast dives into how Nubank, the Brazilian digital bank, balances hyper-growth with cost discipline. Lucas and Luna explore the specific engineering choices — from a monolithic core to a multi-cloud strategy — that let Nubank scale to over 80 million customers while keeping cloud costs in check. They break down the numbers: a cost-per-active-customer metric that's half of traditional banks, a 25 percent reduction in cloud spend per transaction, and the migration of 90…
How Figma Cut Prototype Latency by 60 Percent
In this episode of The CTO Podcast, Lucas and Luna explore how Figma re-engineered its multiplayer engine to slash prototype latency by 60 percent. They break down the architectural shift from a centralized model to a hybrid local-first approach, the role of CRDTs, and the tough trade-offs the team made to keep real-time collaboration seamless. Along the way, they discuss how Figma measured success, the cultural pushback from engineers, and what this means for other teams building…
How Monzo Scaled Its Core Banking Platform
Monzo went from a prepaid card to a fully licensed UK bank with millions of customers. In this episode, Lucas and Luna dig into the engineering decisions that made that leap possible. They unpack Monzo's early bet on a microservices architecture before it was fashionable, and how the team handled the messy reality of splitting a monolith under regulatory pressure. They also explore the 'banking as a platform' move, where Monzo opened its APIs to third-party developers, and the operational costs…
How Cloudflare Cut DNS Query Costs by 60 Percent
In this episode of The CTO Podcast, Lucas and Luna dig into how Cloudflare, the content delivery network giant, slashed the cost of handling trillions of DNS queries by 60 percent without sacrificing an ounce of performance. They unpack the architecture behind the win—a move from general-purpose CPUs to custom, in-house silicon, paired with a radical simplification of the network stack. The conversation covers the engineering trade-offs, the surprising role of power efficiency, and how the…
How GitHub Cut Merge Conflicts by Half with Stacked PRs
For episode 150, Lucas and Luna dig into a quiet but transformative engineering practice: stacked pull requests. They use GitHub's own migration to stacked PRs as the case study, explaining how the team cut merge conflicts by half and shrank review latency from days to hours. Along the way they unpack the mechanics of stacked diffs, why they break the traditional PR workflow, and what it means for senior engineers, tech leads, and anyone who's ever waited on a review. Expect concrete numbers, a…
How Stripe Migrated to a Custom Database
In this episode of The CTO Podcast, Lucas and Luna dive into Stripe's bold decision to build Vitess, a custom database layer, to handle massive transaction volume. They explore why a company would choose to build its own database infrastructure instead of relying on off-the-shelf solutions, the engineering trade-offs involved, and the lessons for CTOs considering similar paths. With insights from the Vitess project and Stripe's engineering culture, this episode offers a concrete look at…
How npm Cut Package Publish Failures by 80 Percent
In this episode of The CTO Podcast, Lucas and Luna dive into how npm, the JavaScript package registry, rebuilt its publish pipeline to reduce failures by 80 percent. Covering the shift from a monolithic database to a distributed event-driven architecture, they explore the challenges of handling millions of packages and billions of downloads daily. With insights on sharding strategies, consistency trade-offs, and the importance of observability, this episode offers practical lessons for…
Inside the Migration That Cut Uber's Data Costs in Half
Uber's real-time data platform processes trillions of events daily, but by 2024 the cost of that infrastructure was ballooning. This episode dissects the migration that slashed their data storage and compute spend by 50 percent—moving from a monolithic streaming architecture to a tiered, disaggregated model built on Apache Pinot and an in-house engine called Speedy. Lucas and Luna break down the trade-offs: why they chose Pinot over Druid, how they rethought data lifecycle with hot, warm, and…
How Stack Overflow Cut Cloud Spend by 40 Percent
Stack Overflow runs one of the web's largest Q&A platforms, yet in 2025 its cloud bill was spiraling. In this episode, Lucas and Luna unpack how the engineering team turned a cost crisis into a 40 percent cloud-spend reduction, using a mix of workload re-platforming, smarter caching, and a hard look at reserved instances. They break down the specific moves: moving read-heavy traffic to a Postgres replica farm, cutting cold-start waste with pre-warmed Lambda functions, and negotiating a private…
How Airbnb Rebuilt Its Trust and Safety Team for 150 Million Guests
In this episode of The CTO Podcast, Lucas and Luna dive into Airbnb's 2024 trust and safety overhaul, a project that redefined how the platform verifies hosts and guests at scale. With 150 million users and 8 million listings, Airbnb faced a surge in fraudulent accounts and fake reviews. The team rebuilt their verification pipeline using a mix of machine learning models and human review, cutting fraudulent bookings by 40 percent in six months. We break down the technical architecture: a graph…
How Spotify Cut Streaming Costs by 30 Percent with a Smarter Codec
In this episode of The CTO Podcast, Lucas and Luna dig into Spotify's quiet but massive engineering win: cutting streaming costs by 30 percent by switching to a smarter audio codec. They explore the technical trade-offs behind the move, from compression efficiency to device compatibility, and what it means for the economics of streaming music at massive scale. With Spotify serving over 500 million users, even a small percentage point in cost savings translates to hundreds of millions of dollars…
How Postgres Tamed the Cloud Database Chaos
Cloud databases have fragmented into a dozen specialised services. But in the last few years, something shifted: Postgres became the default. In this episode, Lucas and Luna unpack how the open-source database quietly ate the cloud market — from Amazon Aurora to Neon's serverless branching — and what it means for architects who want fewer moving parts. They look at the concrete numbers: the 300-plus extensions, the 40 percent of new database workloads that now run on Postgres, and the companies…
How Airbnb Rebuilt Its Search for 100 Million Listings
In this episode of The CTO Podcast, Lucas and Luna explore how Airbnb transformed its search and ranking system to handle over 100 million listings and match travelers with the perfect stay in real time. They break down the shift from a monolithic ranking approach to a modular, machine-learning-driven architecture that balances multiple objectives like location, price, and availability. The conversation covers the practical engineering decisions behind Airbnb's move to a two-tower neural…
Netflix Cut Deploy Failures 90 Percent with Canary Deployments
Netflix deploys thousands of times daily, but a few years ago, deploy-related incidents were too common. Their solution? A sophisticated canary deployment system built on their internal tool Spinnaker and the open-source Kayenta project. In this episode, Lucas and Luna break down how Netflix uses automated canary analysis to detect rollouts that degrade performance or reliability before they affect many users. They walk through the architecture: how Spinnaker manages multi-cluster deployments…
How Lyft Rebuilt Its Ride Matching Algorithm
In this episode, we dive into Lyft's 2024 overhaul of its ride-matching dispatch algorithm. Facing growing city complexity and demand spikes, the operations research approach wasn't cutting it. Lyft rebuilt the core assignment system using graph neural networks and a new real-time data pipeline. The result: 15% lower passenger wait times and 10% better driver utilization. We walk through the architecture decisions, from the move away from linear programming to the design of a stateful model…
How the New York Times Rebuilt Its Digital Platform for 10 Million Subscribers
In episode 139 of The CTO Podcast, Lucas and Luna unpack the architectural transformation behind the New York Times' digital paywall and content delivery system. With over 10 million subscribers pushing a decade-old Java monolith to its limits, the engineering team made bold bets on microservices, a custom CDN, and a real-time personalization engine. We dive into the key decisions: why they chose to build a new content API instead of patching the old one, how they handled the paywall at the…
How Etsy Slashed Deploy Time 80 Percent with Feature Flags
Etsy's deployment pipeline used to take three hours, making Friday deploys a nightmare. Then their engineering team built a feature flag system that decoupled deployment from release, slashing deploy time by 80 percent and enabling canary launches for every change. In this episode, Lucas and Luna break down the architectural decisions behind Etsy's feature flag platform, how it reduced rollback risk, and why it became a cultural cornerstone for continuous delivery. Learn how the CTO championed…
How Segment Rebuilt Its Event Pipeline for 100 Billion Events
When Segment's event ingestion pipeline hit 100 billion events per month, their Ruby on Rails monolith started to buckle. In this episode, we dive into how the engineering team used a strangler pattern to extract a Go-based ingestion layer, introduced Kafka for buffering, and designed a custom load-shedding algorithm to handle spikes. We explore the trade-offs between a ground-up rebuild and incremental migration, the operational challenges of maintaining two systems in parallel, and the key…
How Datadog Slashed Incident Response Time by 40 Percent
In July 2024, a cascading failure in Datadog's own monitoring pipeline took down their dashboard for 47 minutes. That event triggered a top-to-bottom redesign of their incident command system. In this episode, we break down the three key changes: the new Incident Commander role, mandatory game-day drills, and a post-incident review process that cut mean time to resolve by 40 percent. We also explore what Datadog's CTO learned about balancing feature velocity with reliability, and how these…
The CTO Decision Tree for AI Generated Code
AI code assistants are writing more production code every day, but CTOs face a tough decision: when can you trust it? In this episode, Lucas and Luna break down a practical five-question framework used by a major payments company to evaluate whether to ship AI-generated code. From code review readiness to test coverage and failure blast radius, learn how engineering leaders are balancing speed and safety. Plus, why the decision tree itself is evolving as models improve. If you're an engineering…
How Postmortems at Google Cut Downtime 50 Percent
This episode of The CTO Podcast dives into Google's incident postmortem culture. Lucas and Luna explore how the tech giant's blameless postmortems, systematic root cause analysis, and actionable follow-ups have cut repeat incidents by 50 percent. They discuss the cultural shift needed to move from blame to learning, the role of leadership in modeling transparency, and how small engineering teams can adopt similar practices. Drawing on internal studies and decades of incident data, the hosts…
How Slack Rebuilt Its Platform for Ten Thousand Integrations
In this episode, we explore how Slack evolved its API and platform architecture from a monolithic system to a modular, event-driven ecosystem capable of supporting over 8,000 integrated apps. We dive into the specific engineering decisions—adopting GraphQL, building a sandboxed runtime, implementing per-app rate limiting—that allowed Slack to scale from a handful of early bots to a marketplace processing billions of API calls per month. Along the way, we discuss the trade-offs between…
How Discord Rebuilt Its Voice Engine for 150 Million Users
In 2022, Discord's voice engineering team faced a critical challenge: latency had doubled for users on slow networks, threatening the real-time feel that made the platform popular. This episode explores how the team rebuilt the voice stack from the ground up, moving from a single-threaded audio pipeline to a parallel, SIMD-optimized architecture. We break down the decision to replace the Opus encoder with a custom hybrid codec for high-packet-loss conditions, the introduction of a jitter buffer…
How Architecture Decision Records Shaped Spotify's Engineering Culture
In 2018, Spotify's playlist team faced mounting coordination costs across three backend services. Instead of a costly rewrite, they wrote an Architecture Decision Record (ADR) that sparked a cultural shift. This episode traces the impact of ADR #42—the decision to adopt event-driven architecture for playlist updates—which reduced latency by 40% and cut cross-team meetings in half. We explore how Spotify turned decision-making into a scalable artifact, the templating process they used, and why…
How Splunk Rebuilt Its Observability Platform for 10 Petabytes Daily
In this episode, Lucas and Luna dig into how Splunk — the data platform that ingests massive machine data — rebuilt its observability engine to handle 10 petabytes of new data every single day. They walk through the architectural pivot from a monolithic indexing layer to a microservices-based streaming ingest pipeline, the tough trade-offs between search speed and storage cost, and how the engineering team managed backward compatibility for thousands of enterprise customers who rely on Splunk…
How Shopify Rebuilt Its Checkout for One-Click Conversions
Episode 129 of The CTO Podcast digs into Shopify's massive checkout overhaul. Lucas and Luna unpack the architectural decisions behind migrating from a legacy Rails monolith to a composable, low-latency checkout system capable of handling 10 million requests per second during peak traffic. They explore the tradeoffs between consistency and speed, the role of edge computing and local storage, and why Shopify chose to build its own payment form encryption layer rather than rely on third-party…
How Wix Rebuilt Its Website Builder for 200 Million Users
In this episode, Lucas and Luna dive into Wix's massive architectural overhaul of its website builder platform to support 200 million users. They explore the decision to migrate from a monolithic PHP system to a microservices-based architecture, the challenges of maintaining backward compatibility while introducing a new drag-and-drop editor, and how Wix managed to reduce page load times by 40 percent without disrupting existing sites. The discussion touches on the trade-offs between…
How Netflix Rebuilt Its Recommendation Engine for 250 Million Profiles
Episode 127 of The CTO Podcast dives deep into the technical architecture behind Netflix's recommendation engine. Lucas and Luna break down how Netflix rebuilt its personalization stack to handle 250 million active profiles, moving from batch matrix factorization to a real-time deep learning pipeline. They explore the shift from Apache Spark to Ray for distributed training, the deployment of neural collaborative filtering at scale, and the tricky engineering problem of cold-start…
How Stripe Rebuilt Its API for Idempotency at Scale
Stripe processes hundreds of billions in payments annually. Every one of those API calls must be idempotent — meaning retries don't double-charge. In this episode, Lucas and Luna unpack how Stripe rebuilt its core API to guarantee exactly-once semantics without sacrificing latency. They walk through the architectural choices: idempotency keys, optimistic locking, and a custom transaction log that handles 50,000 requests per second. They also discuss the hard trade-offs — like when to fail fast…
How Figma Rebuilt Its Plugin Platform for 1000 Extensions
Lucas and Luna dive into Figma's architectural overhaul of its plugin platform, which now supports over 1000 community extensions. They explore the technical trade-offs between sandboxing and performance, how Figma migrated from a monolithic plugin runtime to an isolate-based architecture, and the surprising bottleneck that nearly broke the design tool's real-time collaboration. Along the way, Lucas shares a concrete example: how the new plugin API reduced latency for a popular color palette…
How Cloudflare Built Its Global Edge Network for 100 Million Requests per Second
Lucas and Luna dive into the architecture behind Cloudflare's global edge network, which handles over 100 million HTTP requests per second across 300+ cities. They explore how Cloudflare moved from a reverse-proxy model to a hyper-optimized, anycast-based infrastructure using custom-built servers, a proprietary operating system called Kernel by User (KbU), and a distributed key-value store called Quicksilver. The discussion covers how Cloudflare manages SSL termination at scale, mitigates DDoS…
How Duolingo Rebuilt Its AI Tutor for 100 Million Learners
In this episode, Lucas and Luna explore how Duolingo rebuilt its AI-powered language tutor, Birdbrain, to personalize learning for over 100 million monthly active users. They dive into the technical challenges of scaling real-time adaptive lesson generation, the decision to move from rule-based systems to transformer models, and how the team balanced engagement with educational efficacy. Specific numbers include a 40% increase in user retention and a 15% improvement in learning outcomes after…
How Notion Rebuilt Its Sync Engine for 100 Million Blocks
In this episode, Lucas and Luna dive into how Notion's engineering team rebuilt its real-time sync engine to handle over 100 million blocks of content without breaking. They explore the specific architectural decisions—switching from a monolithic sync to a delta-based CRDT system—and the performance gains that followed, including a 40% reduction in sync latency. Lucas compares it to how Google Docs handles collaborative editing, and Luna questions whether the trade-offs were worth it for a…
How Cloudflare Rebuilt Its DNS for 100 Million Queries per Second
In episode 121 of The CTO Podcast, hosts Lucas and Luna explore how Cloudflare redesigned its DNS infrastructure to handle 100 million queries per second during peak DDoS attacks. They dive into the architectural shift from a monolithic bind-based system to a custom, modular resolver called RRDNS, the challenges of maintaining 100 percent uptime during migration, and how the team used Rust to achieve memory safety without sacrificing performance. The episode also covers the operational lessons…
How MongoDB Rebuilt Its Query Engine for Real-Time Analytics
In this episode of The CTO Podcast, Lucas and Luna dive into MongoDB's architectural overhaul of its query engine to support real-time analytics alongside traditional transactional workloads. They explore the technical challenges of blending operational and analytical processing in a single database, including how MongoDB introduced native time-series collections, columnar storage indexes, and a new query optimizer that reduces latency from seconds to milliseconds. The discussion covers…
How Ethereum Switched to Proof of Stake Without Breaking
In September 2022, Ethereum completed the Merge — the most consequential single upgrade in blockchain history, moving from proof of work to proof of stake. Lucas and Luna dive into the technical architecture behind the transition: how client teams coordinated the Bellatrix upgrade, the Paris execution layer trigger, and the post-Merge validator economics. They discuss why the Beacon Chain ran in parallel for 18 months, how node operators prepared, and what the shift means for Ethereum's energy…
How Uber Rebuilt Its Dispatch Engine for 30 Million Trips
In this episode of The CTO Podcast, Lucas and Luna dive into Uber's massive architecture overhaul of its dispatch engine. Initially built for 10 million trips a day, the system hit a ceiling as demand tripled. The team had to re-architect from a monolithic matching service to a distributed event-driven system using Apache Kafka and custom state machines. Lucas walks through the concrete changes: how they partitioned city-level data, implemented geohash-based load balancing, and reduced matching…
How Figma Rebuilt Its Multiplayer Sync Engine
In this episode, Lucas and Luna dive into how Figma reengineered its real-time multiplayer sync engine to support over 500,000 simultaneous editors on a single file. They explore the shift from operational transformation to a custom conflict-free replicated data type (CRDT) approach, the decision to move from WebSocket to a custom UDP-like protocol for lower latency, and how the engineering team handled cursor synchronization, undo history, and cross-replica consistency at scale. Along the way…
How Pinterest Rebuilt Its Image Search at 5 Billion Pins
In this episode, Lucas and Luna dive into Pinterest's recent rebuild of its image search backend, handling 5 billion pins and 200 million monthly users. They walk through the shift from a monolithic search index to a distributed vector-based retrieval system, the decision to move from GPUs to custom TPUs for embedding inference, and how the engineering team tackled cold-start problems for new pins. The conversation covers real-world trade-offs in similarity search, the role of approximate…
How GitHub Migrated 100 Million Repos to a New Storage Layer
GitHub recently completed a years-long migration of its storage infrastructure, moving over 100 million repositories from a legacy git-based system to a new object-storage layer designed for scale and reliability. In this episode, Lucas and Luna break down the technical challenges: how GitHub avoided downtime during the migration, the trade-offs between consistency and availability, and the surprising lesson about git's internal data model that forced a rethink of their architecture. They walk…
How NASA Rebuilt Mission Control for Artemis Lunar Ops
Episode 114 of The CTO Podcast explores the architectural overhaul behind NASA's mission control for the Artemis program. Lucas and Luna break down how the Johnson Space Center replaced its legacy Apollo-era command-and-control systems with a modern, cloud-native stack capable of supporting sustained lunar operations. They walk through the technical challenges of migrating from a monolithic telemetry system handling 30 spacecraft to a distributed architecture ingesting data from 10,000…
How Tesla Reengineered Its Autopilot Stack for Pure Vision
In Episode 113 of The CTO Podcast, Lucas and Luna explore how Tesla rebuilt its Autopilot hardware and software stack to rely exclusively on camera-based vision, phasing out radar and ultrasonic sensors. They walk through the key architectural decision: switching from a sensor-fusion approach with radar as a primary input to a pure vision system that processes eight camera feeds through a single neural network. Lucas explains how the transition affected the neural network design, training data…
How Netflix Rebuilt Its CDN for 4K Streaming
In this episode of The CTO Podcast, hosts Lucas and Luna dive into the technical architecture behind Netflix's Open Connect CDN. They explore how Netflix moved from third-party CDNs to building its own globally distributed appliance network to handle 4K HDR streaming at scale. Lucas breaks down the key design decisions: storing entire catalogs on SSDs at ISP edge locations, using predictive algorithms to pre-populate content, and the custom FreeBSD-based server hardware that achieves 90 Gbps…
How Adobe Rebuilt Its Cloud Storage for 100 Petabytes
In this episode, Lucas and Luna dive into Adobe’s massive infrastructure project to unify its cloud storage layer for Creative Cloud, Document Cloud, and Experience Cloud. The team consolidated over a dozen legacy storage backends into a single multi-region object store handling 100 petabytes of assets and 2 billion daily API requests. Lucas breaks down the key architectural decisions: using erasure coding instead of triple replication to cut storage costs by 40 percent, building a distributed…
How Apple Rebuilt Its Maps Backend for 10 Billion Directions Requests
In this episode, Lucas and Luna dive deep into the technical rebuild of Apple Maps, focusing on the ground-up redesign of its routing engine to handle 10 billion direction requests per day. They explore the shift from third-party data to Apple's own cartography, the move to vector tiles, and the introduction of offline routing. Lucas explains how the team tackled the challenge of real-time traffic integration and the new architectural patterns that reduced map load times by 30 percent. Luna…
Showing the latest 50 episodes. The full archive of 159 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.