The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org

Episode 54 of The CTO Podcast: Lucas and Luna explore how Datadog, the monitoring giant, uses its own tools to manage a sprawling infrastructure that ingests over 100 terabytes of data daily. They dive into the dogfooding strategy, the architectural choices that keep observability scalable, and the surprising insight that Datadog runs its entire backend on a single PostgreSQL fork — with custom sh...

Stripe's payment infrastructure processes billions of dollars annually, and their routing engine—the system that decides which bank or processor gets each transaction—is a marvel of distributed systems engineering. In this episode, Lucas and Luna explore how Stripe rebuilt its payment routing layer to achieve five-nines uptime, handling failures at the bank level in milliseconds without user impac...

In this episode, Lucas and Luna explore how Supabase, an open-source Firebase alternative, built a real-time layer on top of PostgreSQL that handles millions of concurrent WebSocket connections. They break down the architecture behind Supabase's Realtime server, which uses PostgreSQL's logical replication and Elixir's BEAM VM to stream database changes to client applications with sub-second latenc...

In this episode of The CTO Podcast, Lucas and Luna dive into how Discord achieved sub-50 millisecond voice latency across millions of concurrent users. They break down the specific architectural changes Discord made: switching from Opus to a custom codec called Siren, rewriting their audio processing pipeline in Rust, and deploying edge relays in over 300 locations worldwide. The discussion covers...

In this episode, Lucas and Luna dive into Airbnb's multi-year effort to rebuild its search infrastructure to handle 150 million nightly searches. They explore the shift from a monolithic PostgreSQL-backed system to a custom search service built on Elasticsearch, the trade-offs between relevance and latency, and the team's decision to implement a two-phase ranking system with lightweight machine le...

Lucas and Luna examine how PostgreSQL has quietly become the default database for modern cloud-native applications. They trace the journey from a 1996 open-source project to powering 40 percent of new database instances on AWS, Azure, and Google Cloud. The episode focuses on the architectural decisions that made Postgres scalable: its extension ecosystem, the rise of managed services like Aurora a...

In this episode of The CTO Podcast, Lucas and Luna dive into the operational and cultural mechanics behind GitLab's all-remote engineering organization. With over 2000 developers spread across 65 countries, GitLab has become a case study in asynchronous work, written documentation, and intentional culture-building. Lucas walks through GitLab's handbook-first approach, how they structure teams arou...

Lucas and Luna dive into how Monzo, the UK digital bank, replaced its legacy core banking system with a real-time event-driven architecture. They explore the technical bet on Apache Kafka as the source of truth, the migration from a batch-processing model to stream processing, and the engineering trade-offs involved in ensuring instant balance updates without breaking financial integrity. With spe...

LinkedIn's search team faced a massive technical challenge: how to serve relevant results to 950 million members across jobs, people, companies, and posts — all while respecting privacy and permissions. In this episode, Lucas and Luna dive into how the team rebuilt LinkedIn's search infrastructure using a real-time indexing pipeline and a custom retrieval engine called Galene. They discuss the tra...

In this episode, Lucas and Luna dive into HashiCorp's architectural overhaul of Terraform to handle multi-cloud deployments at massive scale. They explore the shift from a monolithic state management system to a modular, plugin-based architecture, the introduction of Terraform Cloud's real-time collaboration features, and the engineering decisions behind maintaining backward compatibility while sc...

Episode 44 of The CTO Podcast dives deep into how Cockroach Labs built a distributed SQL database that could survive not just server failures, but the competitive onslaught of AWS, Google, and Microsoft. Lucas walks through the key architectural decisions — the Raft consensus protocol, the geo-partitioning trick that made multi-region compliance possible, and the controversial move to make the pro...

Lucas and Luna dive into how Vercel redesigned its edge compute layer to achieve cold-start latencies under 50 milliseconds, even for complex serverless functions. They unpick the architecture behind Vercel's 'Edge Functions' — from isolate pooling and Wasm-based sandboxing to regional pre-warming. The hosts discuss the trade-offs between JavaScript and Rust runtimes, how Vercel collaborates with...

In this episode, Lucas and Luna dive into the technical decisions behind Slack's backend overhaul as it scaled from a small team tool to a platform serving 10 million daily active users. They explore how Slack moved from a monolithic Ruby on Rails architecture to a service-oriented model using Java and C++, the critical choice of building its own message queue instead of relying on Kafka or Rabbit...

Notion's real-time sync has become table stakes for any collaborative product, but building it was anything but straightforward. In this episode, Lucas and Luna break down how Notion's engineering team moved from a naive polling model to a custom CRDT-based sync engine that handles millions of concurrent edits across documents, databases, and wikis. They walk through the key design decisions: why...

Episode 40 of The CTO Podcast explores Linear — the project management tool built by a team of seven engineers using what they ship. Lucas and Luna walk through Linear's architecture: a single TypeScript codebase, a custom sync engine built on SQLite and CRDTs, and how they handle optimistic updates with zero conflict. The episode examines why the team chose not to adopt microservices, how they ke...

Lucas and Luna break down how Shopify prepares its infrastructure for the biggest shopping day of the year. They focus on a specific technique: using edge static caching to absorb 90 percent of read requests before they hit the application layer. The episode walks through Shopify's architecture for serving storefront pages from CDN nodes, how they invalidate caches when a merchant updates a produc...

In 2019, Amazon announced it would convert Prime shipping from two days to one day. Most people saw a marketing promise. Engineers saw a logistics nightmare. This episode unpacks how Amazon rebuilt its fulfillment network — restructuring inventory placement, rethinking sortation center algorithms, and launching its own air hub in Cincinnati — to make one-day delivery economically viable across mil...

In this episode, Lucas and Luna dive into how GitLab manages a fully remote engineering organization of over 2,000 developers. They explore the company's unique handbook-first culture, how they maintain code quality across time zones, and the specific tools they use for asynchronous communication. Lucas shares key metrics: GitLab ships 40 releases per year with a median merge request cycle time of...

Episode 36 of The CTO Podcast dives into how Figma built its real-time collaboration engine using Conflict-Free Replicated Data Types (CRDTs). Lucas and Luna unpack the architectural decision to move from Operational Transform to CRDTs, how Figma handles merge conflicts at scale, and the engineering tradeoffs behind its vector-based multi-user editing. They walk through the key design choices: why...

Netflix runs one of the largest Elasticsearch deployments in the world — over 150 clusters, thousands of nodes, processing tens of billions of documents. In this episode, Lucas and Luna unpack how Netflix uses Elasticsearch not just for log aggregation, but to power its internal search, real-time monitoring, and even the titles you see when you open the app. They walk through the architecture behi...

In this episode of The CTO Podcast, Lucas and Luna dive into Discord's architectural overhaul of its real-time voice system. They explore how the team reduced latency from hundreds of milliseconds to under 50 by switching from a traditional client-server model to a mesh-based WebRTC architecture. The discussion covers the trade-offs of running their own media servers versus outsourcing, the engine...

Amazon Web Services runs over 200 services, each with its own control plane. In this episode, Lucas and Luna break down how AWS's internal architecture team designed a unified control plane framework that handles millions of API requests per second across regions. They explore the concept of 'control plane as a platform' — a set of reusable primitives for authorization, rate limiting, and state ma...

Stripe processes hundreds of billions in payments annually. But behind the API is a reliability architecture that few people talk about. In this episode, Lucas and Luna dive into how Stripe achieves five-nines uptime across its payment infrastructure — the layers of redundancy, the careful rollout strategy, and the incident response playbook that keeps money moving. They explore Stripe's use of ci...

Episode 31 of The CTO Podcast digs into how Uber's engineering team rebuilt its mapping and routing stack from scratch between 2019 and 2022 to handle over 40 million daily rides across 10,000 cities. We look at the specific reason they abandoned the old pipeline — vendor lock-in with Google Maps and a 40 percent cost increase in a single quarter — and how they designed a modular routing engine ca...

In 2016, Spotify announced it was moving its entire infrastructure from its own data centers to Google Cloud Platform. The migration took four years and involved moving over 1,200 services, petabytes of data, and the machine learning pipelines powering Discover Weekly — all while keeping the music streaming without audible interruption. Lucas and Luna break down how Spotify's engineering team pull...