Episodes
How Stripe Built Developer Trust Through Incident Transparency
In this episode of The CTO Podcast, Lucas and Luna examine how Stripe turned a catastrophic 2023 payment outage into a trust-building asset. By abandoning the traditional corporate habit of hiding behind vague status pages, Stripe adopted radical transparency, publishing detailed post-mortems in real time. We explore the specific mechanics of their 'incident command' model, the metrics they track to measure developer confidence, and why admitting failure faster than your competitors actually…
How GitHub Built a Culture of Psychological Safety
In this episode, Lucas and Luna explore how GitHub engineered psychological safety into its engineering culture, moving beyond buzzwords to implement concrete practices like blameless postmortems and structured vulnerability. They examine the specific mechanisms that allow teams to fail fast without fear of retribution, drawing on insights from leadership interviews and internal documentation. The conversation drills into the difference between perceived safety and actual safety, offering…
How GitHub Solved the Merge Conflict Crisis
GitHub’s engineering organization faced a silent crisis in early 2025: merge conflicts were not just slowing down deployments, they were eroding developer trust. Lucas and Luna explore how the platform moved from chaotic pull requests to a disciplined trunk-based development model with automated conflict resolution. We break down the specific tooling changes, the cultural shift required to stop treating merges as manual artistry, and the measurable impact on cycle time. If you’re leading an…
How Microsoft Scaled AI Agents Without Losing Control
As of October seventeenth two thousand twenty-six, the conversation around artificial intelligence has shifted from chatbots to autonomous agents. But autonomy without guardrails is a liability. This episode examines how Microsoft engineered its Copilot Studio to balance developer freedom with enterprise compliance. We look at specific architectural decisions like the policy engine that sits between agent actions and production data, and the telemetry required to audit non-deterministic…
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 they tracked, from deployment frequency to regression rates, and why treating code like a public…
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 chaos into clarity through strategic deprecation and unified standards. #FexingoBusiness…
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 into clarity, offering practical lessons for any tech leader managing high-velocity development…
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 on how they structured data permissions and trained their own large language models to surface…
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 architectural safeguards that made this risky transition possible, including mandatory code reviews for…
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 company's resurgence as a cloud leader. We dive into the specific mechanisms they used to break down…
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 down release cycles. #FexingoBusiness #BusinessPodcast #TechLeadership #SoftwareEngineering #DevOps…
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 developer mindset required to trust the server, and the specific architectural decisions that allowed…
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 standardizing tooling, and why reducing context switching became their most critical metric. Lucas…
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 technical debt is different from traditional software companies. This is not just about better…
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 CTOs can learn from their approach to managing technical debt in a complex enterprise ecosystem.…
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 specific engineering trade-offs between latency and truthfulness, and why maintaining a single source…
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 metrics they use to measure compliance, and why treating architecture as a legalistic framework…
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 rules that allow teams to deploy independently while maintaining system stability. The discussion…
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 engineering efficiency into competitive moats. #Stripe #DeveloperExperience #APIEconomics…
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 matters for any scaling tech company today. #Figma #EngineeringLeadership #MonorepoStrategy…
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 REST for legacy systems, and how they used 'internal developer platforms' to reduce time-to-market…
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 that failed, the cultural pushback from senior engineers, and the concrete playbook for any CTO who…
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 #DeveloperExperience #DevOpsCulture #PlatformEngineering #TechLeadership #SoftwareArchitecture…
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 episode explores how they reduced average review time by forty percent without adding headcount, what…
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, and the leadership decisions that made engineering teams embrace feedback rather than fear it. If…
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 strict data boundaries, and maintained user trust while rolling out features like AI-assisted…
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 prioritize work. Lucas and Luna examine the tension between speed and stability, using Atlassian’s public…
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 contracts, the introduction of automated policy gates that catch eighty percent of issues before a human…
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 still influencing tech hiring strategies, understanding this human-centric operational model is…
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 headcount, focusing on the shift from reactive alerting to proactive dependency mapping. Learn how…
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 on-call burnout. We break down the technical architecture behind this shift, the cultural…
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 tracking, and why this matters for any engineering team deploying LLMs in production today.…
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 break down the infrastructure trade-offs, the security protocols for handling sensitive context…
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 rushing code. If you are leading an engineering org, this is the playbook for scaling without burning…
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 codebase could, offering a blueprint for technical leaders facing similar burnout crises in September…
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 architectural changes to their pull request pipeline, the cultural shift toward async-first…
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 decisions. #Datadog #AIHallucination #LLMSafety #Observability #TechLeadership #EnterpriseAI #ModelOps…
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 inventory management with real-time user data, the supply chain decisions that saved margins, and what…
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 automated conflict resolution scripts. Lucas breaks down the technical mechanics of how they…
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 code; it was a fundamental rethinking of trust, security, and developer experience that saved the…
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 their CI/CD pipelines and team topology, moving from chaotic scaling to disciplined autonomy. The…
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 burning out their staff. This isn't just a story about hiring faster; it's a deep dive into the…
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 work where strict mandates fail, and what other engineering leaders can learn from their approach…
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 questions about whether strict contracts stifle innovation or enable scale. We look at the tradeoffs…
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 merge friction is critical for developer velocity in September 2026. #GitHub #MergeConflicts…
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 of draft pull requests, and the subtle cultural shifts that turned conflict from a bug into a…
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's early days to its use in everything from Square's terminal SDKs to open-source projects like…
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 state management. They also discuss the monitoring and chaos engineering practices that helped Zalando…
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 what this means for other AI teams trying to run large models economically. If you're building on…
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 consistency and speed, the role of WebSockets and gRPC, and how Robinhood handled the infamous GameStop…
Showing the latest 50 episodes. The full archive of 218 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.