The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org
Lucas and Luna explore the decisions that shape technical organizations in this podcast from Fexingo. Each episode examines a specific engineering leadership challenge, such as scaling microservices without creating a distributed monolith, managing cognitive load in a large engineering org, or choosing between monorepo and polyrepo based on team topology. The discussions use real-world cases, from Etsy's data pipeline restructuring after a 2019 outage to Stripe's API versioning policy and Basecamp's SQLite choice. Lucas brings journalistic rigor with commit histories, RFCs, and postmortems, while Luna pushes back with org dynamics, hiring constraints, and technical debt. The show avoids hot takes and vendor pitches, ending each episode with an unresolved tension for listeners.
Episodes
How Figma Killed Technical Debt With Architecture Contracts
Figma faced a classic scaling trap: too many teams building overlapping UI components, leading to visual inconsistency and bloated bundle sizes. In this episode, Lucas and Luna explore how the design tool giant introduced 'architecture contracts'—binding agreements between platform engineers and product teams that enforce interface stability and component reuse. We break down the specific metrics
How Microsoft Managed Platform Fatigue
In this episode of The CTO Podcast, Lucas and Luna explore how Microsoft combated internal platform fatigue by consolidating its fragmented developer ecosystem. We examine the specific metrics behind their service mesh unification, the cultural shift required to retire legacy internal tools, and the surprising ROI of reducing cognitive load for engineers. Discover how one major tech giant turned c
How Figma Solved the Merge Conflict Crisis
In this episode of The CTO Podcast, we explore how Figma’s engineering leadership tackled the hidden crisis of merge conflicts in their massive codebase. With a team scaling rapidly and hundreds of engineers contributing daily, simple version control issues were causing deployment delays and frustration. We dive into the specific architectural changes and workflow adjustments that turned chaos int
How Microsoft Solved the Silent Knowledge Crisis
Lucas and Luna explore how Microsoft combated the 'Silent Knowledge Crisis' by shifting from centralized wikis to AI-powered context retrieval. With over half a million employees, the tech giant realized that critical institutional knowledge was trapped in private chats and scattered emails, inaccessible to those who needed it most. This episode dissects their internal tooling strategy, focusing o
How GitHub Reduced Deployment Friction With Trunk-Based Development
In this episode of The CTO Podcast, we explore how GitHub fundamentally shifted its engineering culture by abandoning feature branches in favor of trunk-based development. We break down the specific metrics behind their deployment frequency increase and examine the cultural resistance they faced from senior engineers who relied on long-lived integration workflows. Lucas and Luna discuss the archit
How Microsoft Fixed Its Engineering Culture
In 2016, Microsoft was a company losing its way. Engineers were frustrated by bureaucracy, silos were rampant, and innovation felt stifled. Then Satya Nadella became CEO and made a radical shift: he changed the culture from one of know-it-alls to learn-it-alls. This episode explores how that cultural transformation directly impacted engineering productivity, collaboration, and ultimately, the comp
How GitHub Solved the Merge Conflict Crisis
In this episode, we look at how GitHub reduced merge conflicts by 40 percent through trunk-based development and automated branch protection. Lucas and Luna discuss the shift from long-lived feature branches to continuous integration, using specific metrics from GitHub's internal engineering reports. We explore how small teams can adopt these practices without sacrificing code quality or slowing d
How Figma Solved the Merge Conflict Crisis
Figma faced a unique engineering crisis as its collaborative canvas grew too large for traditional version control. In this episode, we explore how the company moved away from git-centric workflows toward a custom operational transformation system to handle simultaneous edits without corruption. Lucas and Luna break down the technical trade-offs of abandoning standard merge tools, the shift in dev
How Salesforce Fixed Its Engineering Culture
Salesforce has long been the poster child for hyper-growth engineering, but that scale came with a hidden tax: internal friction. In this episode, we look at how the company restructured its platform teams to reduce cognitive load and accelerate developer velocity. We explore the specific shift from feature-based squads to product-centric platforms, the role of the 'Platform Productivity' team in
How Figma Mastered Cross Team Collaboration
Figma’s internal collaboration tools have become a masterclass in breaking down silos between design and engineering. In this episode, we explore how the company built an internal protocol that turns abstract ideas into concrete code without the usual friction. We look at the specific metrics behind their developer experience strategy, the role of AI in bridging the gap, and why their approach to
How Salesforce Managed Technical Debt With Architecture Contracts
Salesforce faced a classic engineering crisis: rapid feature growth led to fragmented APIs and rising maintenance costs. This episode explores how they implemented Architecture Review Boards and strict API contracts to restore order without slowing innovation. We examine the specific governance models that allowed their platform to scale, the trade-offs between speed and stability, and what other
How Salesforce Solved the AI Hallucination Crisis
When Salesforce launched its Einstein AI capabilities, they faced a critical trust deficit: their models were generating plausible but incorrect data for enterprise clients. This episode examines how the company moved from simple accuracy checks to a rigorous 'grounding' architecture, implementing strict retrieval-augmented generation pipelines and human-in-the-loop validation. We look at the spec
How Salesforce Managed Technical Debt With Architecture Contracts
Technical debt is often treated as a moral failing, but at Salesforce it was managed through enforceable architecture contracts. This episode examines how the cloud giant shifted from reactive firefighting to proactive governance by requiring every major service change to pass a standardized review against core engineering principles. We break down the specific mechanics of these contracts, the me
How Atlassian Managed Technical Debt With Architecture Contracts
Atlassian has spent years building tools for developers, but its own engineering organization faced a classic paradox: how to move fast without breaking things. In this episode, Lucas and Luna explore the concept of 'architecture contracts'—a governance model that replaces rigid gatekeeping with clear boundaries. We look at how the company defined explicit API guarantees and backward compatibility
How Stripe Mastered Developer Experience Strategy
Episode 200 of The CTO Podcast explores the economics of developer experience at Stripe. Lucas and Luna break down why treating developers as internal customers drives revenue, not just satisfaction. They examine Stripe’s specific strategy of investing in documentation, SDKs, and API stability to reduce churn and accelerate integration. This is a deep dive into how technical leadership can turn en
How Figma Solved the Merge Conflict Crisis
This episode explores how Figma managed its complex monorepo migration without halting developer velocity. We look at the specific engineering decisions around atomic commits and internal tooling that allowed thousands of engineers to collaborate in real-time. Lucas and Luna discuss the trade-offs between consistency and speed, the role of their internal platform team, and why this architecture ma
How Stripe Mastered Developer Experience Strategy
Stripe did not become a fintech giant by accident. They became one by treating developer experience as their primary product feature, not just an afterthought. In this episode, we look at how Stripe built its internal platform engineering team to solve the specific problem of API sprawl and integration friction. We explore their decision to standardize on GraphQL for public APIs while maintaining
How Datadog Fixed Its Internal Developer Platform
Datadog spent years building an internal developer platform to speed up engineering, but the metrics showed it was actually slowing teams down. In this episode, Lucas and Luna break down how the company reversed course by killing their custom tooling and returning to a developer-centric model focused on friction reduction rather than centralization. We look at the specific architectural contracts
How Atlassian Built an Internal Developer Platform
Atlassian transformed its engineering experience by building a standardized Internal Developer Platform. This episode explores how they reduced boilerplate code, cut deployment times, and empowered teams to ship faster without sacrificing security or compliance. We break down the concrete decisions behind their platform strategy.
#InternalDeveloperPlatform #EngineeringProductivity #Atlassian #Dev
How GitHub Automated Its Own Code Review Bottlenecks
GitHub faced a growing crisis where pull requests were sitting in review for days, slowing down feature releases and frustrating developers. Instead of hiring more reviewers or enforcing stricter SLAs, the engineering leadership introduced a radical automation strategy: using AI to pre-screen code changes against internal style guides and security policies before human eyes ever saw them. This epi
How GitHub Built a Culture of Code Review
GitHub revolutionized software development by turning code review from a bureaucratic bottleneck into a core cultural value. This episode explores how they standardized pull requests, implemented mandatory peer reviews, and scaled this practice across millions of repositories without slowing down innovation. We dive into the specific metrics they tracked, the tools they built to enforce quality, a
How Figma Built a Secure AI Sandbox
Figma’s approach to integrating generative AI into its design workflow offers a masterclass in balancing innovation with security. Rather than exposing raw model weights or unfiltered data, the company built an internal sandbox architecture that isolates user interactions from core intellectual property. We break down how they structured their retrieval-augmented generation pipeline, enforced stri
How Atlassian Managed Technical Debt With Architecture Contracts
Technical debt is often treated as a moral failing, but at scale it becomes a structural inevitability. This episode explores how Atlassian used architecture contracts to manage decay without halting innovation. We break down the specific metrics they track, the cultural shift required to enforce them, and why treating code quality as a contractual obligation changes how engineering teams prioriti
How GitHub Prevented Code Review Bottlenecks
Code review is the single biggest bottleneck in modern software delivery, yet most engineering leaders treat it as a purely technical problem. In this episode, Lucas and Luna examine how GitHub restructured its internal pull request workflow to reduce review latency by forty percent without adding headcount. They explore the shift from synchronous peer reviews to asynchronous architectural contrac
How Datadog Solved the On-Call Burnout Crisis
In this episode of The CTO Podcast, Lucas and Luna examine how Datadog flipped its engineering culture by capping on-call hours at thirty per week. They explore the trade-offs between immediate incident response and long-term developer sustainability, analyzing the specific metrics that proved reduced pager fatigue led to faster mean-time-to-resolution. With September 18, 2026 market volatility st
How Datadog Tamed Chaos with Service Maps
Datadog transformed from a simple monitoring tool into an observability platform by solving the problem of distributed system complexity. This episode explores how their engineering team used service maps to visualize dependencies, reduce mean time to resolution, and prevent cascading failures in real-time. We dive into the specific architectural decisions that allowed them to scale without adding
How Datadog Tamed Chaos with Service Maps
In this episode of The CTO Podcast, we look at how Datadog transformed its own chaotic microservices landscape by implementing dynamic service maps. We explore the specific engineering decision to shift from static topology definitions to real-time, AI-driven dependency tracking. The result was a forty percent reduction in mean time to resolution for production incidents and a significant drop in
How Datadog Stabilized AI Observability
As enterprise AI adoption accelerates into late 2026, the infrastructure layer is struggling to keep pace. This week we examine how Datadog built a specialized observability framework for generative AI workloads, moving beyond traditional metrics to track semantic drift and token-level latency. We break down the specific architectural shift from request-response monitoring to trace-based context t
How Notion Built a Secure AI Sandbox
As AI integration accelerates across the tech sector, engineering leaders face a new architectural challenge: how to let developers experiment with generative models without exposing proprietary code or customer data to external APIs. This episode explores Notion's specific approach to building an internal, air-gapped inference environment that allows engineers to prototype AI features safely. We
How Stripe Prevented Engineering Burnout
In this episode of The CTO Podcast, we explore how Stripe shifted from reactive fire-fighting to proactive architectural health. We examine their decision to cap technical debt accumulation and implement a mandatory 'debt tax' on every new feature request. Lucas and Luna break down the specific metrics they track—like developer cycle time and incident frequency—to measure the invisible cost of rus
How Figma Prevented Engineering Burnout
In this episode, we examine how Figma’s engineering leadership shifted from heroic sprints to sustainable cadence after a critical platform outage. We explore the specific metrics they tracked, including engineer cycle time and deployment frequency, to prove that rest is a feature, not a bug. Lucas and Luna discuss why reducing meeting load by thirty percent saved more revenue than any new codebas
How GitHub Reduced Code Review Bottlenecks
GitHub faced a critical scaling problem in late 2024: as their platform grew, the time between code submission and approval skyrocketed, creating dangerous bottlenecks for engineering teams. In this episode, we examine how they implemented automated triage systems and restructured reviewer incentives to cut average review cycles by forty percent without adding headcount. We look at the specific ar
How Datadog Prevented AI Hallucinations in Production
Datadog faces a unique challenge as AI models generate code and configurations at scale. How does the observability giant prevent its own tools from hallucinating critical infrastructure changes? We explore their shift from static validation to continuous runtime monitoring, the specific cost of false positives, and why human-in-the-loop reviews remain non-negotiable for safety-critical AI decisio
How Netflix Solved The Last Mile Delivery Crisis
In 2026, the biggest threat to digital platforms isn't algorithmic bias or server downtime—it is physical logistics. This episode examines how Netflix pivoted from pure streaming to a hybrid model involving physical merchandise and interactive experiences, forcing them to solve the last mile delivery problem for millions of subscribers. We explore the engineering challenges of integrating inventor
How GitHub Solved the Merge Conflict Crisis
We drill into a specific, often-overlooked friction point in modern engineering: merge conflicts. While many teams focus on CI/CD pipelines or code review tools, few address the human and architectural reality of simultaneous changes. We examine how GitHub engineered their own workflow to reduce merge-related delays by forty-five percent using a combination of trunk-based development practices and
How Slack Survived the API Crisis
In 2017, Slack faced an existential threat when its third-party app ecosystem collapsed under its own weight. Apps were breaking constantly, permissions were a nightmare, and developers were fleeing to competitors like Microsoft Teams. We explore how Slack Engineering and Product teams pivoted from a chaotic, open-access model to a rigorous, curated platform strategy. This shift wasn't just about
How Datadog Scaled Engineering Without Burning Out
Datadog’s rise to a fifty billion dollar valuation wasn’t just about product-market fit. It was about surviving hyper-growth without collapsing under its own weight. In this episode, we look at how their engineering leadership tackled the invisible crisis of developer burnout and architectural drift during their fastest expansion phase. We break down the specific structural changes they made to th
How Slack Scaled Engineering Without Adding Headcount
In this episode of The CTO Podcast, Lucas and Luna dissect how Slack managed to double its active user base while keeping its engineering team size remarkably flat. We explore the specific architectural decisions around serverless adoption, automated testing pipelines, and the controversial but effective 'you build it, you run it' culture shift that allowed them to maintain velocity without burnin
How Atlassian Tamed Technical Debt With Architecture Contracts
Atlassian shifted from reactive firefighting to proactive governance by introducing architecture contracts — lightweight, enforceable agreements between product teams and platform engineers. This episode explores how the company standardized API boundaries, reduced cross-team friction, and cut integration errors by half over eighteen months. We break down the mechanics of these contracts, why they
How Atlassian Tamed Technical Debt With Architecture Contracts
Technical debt isn't just bad code, it's a coordination failure. We examine how Atlassian built an internal platform called the Architecture Contract to enforce consistency across thousands of engineers. This system shifted the burden from individual teams to centralized governance, reducing cross-service latency and deployment failures by over thirty percent in two years. The approach raises ques
How GitHub Tamed Merge Conflict Chaos
Episode 174 explores the engineering and cultural strategies behind GitHub's solution to merge conflict crises. Lucas and Luna examine how massive teams avoid codebase fragmentation, the specific tooling shifts from GitFlow to trunk-based development, and the psychological safety required for frequent integration. We look at real-world examples of automated conflict resolution and why reducing mer
How GitHub Solved the Merge Conflict Crisis
GitHub faced a structural crisis in developer productivity when merge conflicts became a daily bottleneck for engineering teams. This episode examines how they redesigned their pull request workflow to reduce friction, cut context-switching costs, and improve code review velocity without sacrificing security. We look at the specific architectural changes to their CI/CD pipeline, the introduction o
How Stripe Tamed Payout Latency with Idempotency Keys
In this episode, Lucas and Luna dig into a deceptively simple engineering decision that has quietly shaped the reliability of modern fintech: idempotency keys. Using Stripe's payout API as the central case, they unpack how a single HTTP header prevents duplicate charges, double refunds, and the kind of cascading failures that keep payments engineers up at night. They trace the pattern from Stripe'
How Zalando Cut Checkout Failures by 45 Percent
In this episode, Lucas and Luna dig into how Zalando, the European online fashion retailer, reduced checkout failures by 45 percent during peak traffic events. They walk through the architectural changes — moving from a monolithic checkout service to a set of purpose-built services, implementing a distributed saga pattern for order processing, and using a combination of Redis and Postgres for stat
How Anthropic Cut Inference Costs by 40 Percent
In this episode of The CTO Podcast, Lucas and Luna dig into how Anthropic, the company behind Claude, managed to cut inference costs by roughly 40 percent over the past year. They explore the technical levers: from optimizing transformer architectures and using speculative decoding to smarter batching and model distillation. They also discuss the trade-offs between cost, latency, and quality, and
How Robinhood Cut App Latency by 50 Percent
Robinhood's trading app is famous for speed, but behind the scenes, its engineers had to slash latency to keep up with retail trading surges. In this episode, Lucas and Luna dive into the specific architectural decisions that cut order placement latency by fifty percent, from moving to a custom in-memory matching engine to rewriting critical paths in Rust. They explore the tradeoffs between consis
How Notion Cut Notification Noise by 70 Percent
In this episode, Lucas and Luna explore how Notion slashed notification noise by 70 percent, a move that boosted user engagement and reduced churn. They break down the technical strategy, including a preference-based notification system and a machine learning model that predicts user preferences, and discuss the cultural shift needed to embrace a leaner notification philosophy. With real-world num
How Notion Cut Notification Noise by 70 Percent
In this episode of The CTO Podcast, Lucas and Luna dig into how Notion's engineering team reduced notification noise by 70 percent, a project that started with a simple question: why do users keep muting our alerts? They walk through the technical decisions, from consolidating event streams to building a relevance scoring model, and the surprising trade-offs that came with it. Along the way, they
How to Cut Database Costs Without Downtime
In this episode of The CTO Podcast, Lucas and Luna dive into the art of reducing database costs while maintaining performance and reliability. They explore real-world strategies like rightsizing instances, leveraging read replicas, and adopting serverless options, using examples from companies like Airbnb and Shopify. The conversation covers how to approach cost optimization as a proactive practic
How Datadog Built Observability at Massive Scale
In this episode, Lucas and Luna dive into the engineering decisions behind Datadog's observability platform, which processes trillions of data points daily. They explore how the company evolved from simple dashboards to a full-stack monitoring powerhouse, the trade-offs in balancing real-time ingestion with long-term storage, and the recent shift toward AI-powered anomaly detection. Learn how Data
How Shopify Cut Build Times with Remote Caching
In this episode, Lucas and Luna explore how Shopify slashed build times by up to 90 percent using remote caching. They break down the technical architecture behind the change, from build cache keys to distributed storage, and discuss the organizational shifts that made it possible. Along the way, they examine the trade-offs — like cache invalidation and security — and what other engineering teams
How Figma Cut Prototype Latency by 60 Percent
In this episode of The CTO Podcast, Lucas and Luna dive into the engineering decisions behind Figma's dramatic reduction in prototype latency. They explore the shift from a synchronous request-response model to an event-driven architecture, the adoption of WebAssembly for client-side computation, and the importance of caching at every layer. Along the way, they discuss the trade-offs of moving log
How Disposable Vapes Went from Boom to Bust
In this episode, Lucas and Luna dive into the meteoric rise and sudden fall of disposable vapes. They trace how a single device went from a California startup's novelty to a global phenomenon, and then to a regulatory casualty. With the FDA's market denial orders and a looming 2026 federal ban, the hosts examine the economics of the industry: the razor-thin margins, the supply chain race, and the
How Shopify Slashed Build Times with Remote Caching
In this episode of The CTO Podcast, Lucas and Luna dive into how Shopify cut build times from over an hour to under five minutes using Bazel, remote caching, and a carefully managed monorepo. They explore the engineering trade-offs, the cultural shift required, and the surprising win that came from treating developer tooling as a product. If you run an engineering org wrestling with slow builds, t
How Duolingo Cut Translation Costs by 40 Percent with a Custom MT Pipeline
Lucas and Luna dig into how Duolingo slashed translation costs by 40 percent by building a custom machine-translation pipeline for its course content. They walk through the tradeoffs between generic MT engines and a tailored model, how the team balanced quality with speed, and what lessons any engineering org can take when considering build-versus-buy for AI. Along the way, they touch on the surpr
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
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 auto
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 off
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 effi
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 trad
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
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 succes
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
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 conver
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
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
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
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 t
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
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 f
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
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-pl
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 conver
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 affec
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 archi
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
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 ri
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 incre
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 explo
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
