PODCAST · business
The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices
by Fexingo
Lucas and Luna sit down at side-by-side laptops to talk about the craft of building software. Each episode picks a single engineering challenge — optimizing a database query for latency, designing a fault-tolerant microservice boundary, refactoring a legacy monolith without breaking production — and walks through the trade-offs with real code examples and benchmark numbers. They debate testing strategies (integration vs. end-to-end, when to mock), revisit classic papers on distributed systems and data structures, and trace how architectural decisions cascade into operational costs. The show serves senior developers, staff engineers, and technical leads who want to hear reasoned, specific conversations about trade-offs and rigor — not hype about the latest framework. Lucas brings the journalist's habit of asking why a team chose one pattern over another; Luna pushes back with real-world failure stories from her own career. Together, they treat software engineering as a discipline of exp
Episodes
-
How Stripe Killed Developer Debt With Internal Tooling
Stripe has long been the gold standard for developer experience, but in recent years they’ve shifted from building external APIs to mastering their own internal infrastructure. This episode explores how engineering leaders at Stripe moved away from measuring code churn or simple velocity metrics,...
-
How Engineers Ship Faster Without Writing Code
Engineers are spending less time typing and more time orchestrating. We look at how internal developer platforms and AI agents are shifting the core value of software engineering from code creation to system design. Using Stripe’s approach to platform teams as a benchmark, we explore why reducing...
-
How Engineers Stop Writing Code To Ship Faster
In this episode, we explore the counterintuitive strategy of 'code reduction' adopted by high-performing engineering teams at companies like Stripe and GitHub. Instead of measuring velocity by lines of code added, leaders are now incentivizing developers to delete legacy systems, merge duplicate...
-
How GitHub Copilot Quietly Rewrote Developer Workflows
We explore the hidden shift in engineering culture since AI coding assistants became mainstream. Instead of just speeding up syntax, these tools are changing how teams review code, handle technical debt, and manage knowledge transfer. We look at specific data on adoption rates, the rise of…
more -
How Stripe Fixed Developer Experience
We explore how Stripe transformed its internal engineering culture by treating developers as customers. The conversation focuses on the shift from fragmented tooling to a unified internal developer platform, specifically looking at how they reduced cognitive load and standardized APIs across...
-
How Stripe Killed Developer Debt With Internal Tooling
In this episode, Lucas and Luna dive into the specific engineering philosophy behind Stripe's developer experience. We explore how they transformed internal tooling from a maintenance burden into a product advantage, focusing on their 'internal API' strategy that treats every engineer as a...
-
How Stripe Mastered Developer Experience
Stripe has long been the gold standard for developer experience, but maintaining that edge in a world of AI copilots and fragmented tooling is harder than ever. In this episode, we dig into how engineering teams are rethinking documentation, API design, and internal developer platforms to keep...
-
How Stripe Fixed Developer Experience
Stripe built its developer-first infrastructure by treating API documentation as a product, not an afterthought. This episode explores how they reduced onboarding friction from days to minutes using interactive code examples and real-time validation. We examine the specific engineering decisions...
-
How Stripe Built Its Developer-First Infrastructure
Stripe didn't become a fintech giant by accident. In this episode, Lucas and Luna explore how Stripe’s decision to treat developers as its primary customers fundamentally reshaped its engineering culture. We dive into the specific architectural choices that made integration seamless, the internal...
-
How Engineers Mastered The Art Of System Observability
In this episode of The Software Engineering Podcast, Lucas and Luna dissect the often-overlooked discipline of system observability versus traditional monitoring. We look at how leading engineering teams moved beyond simple uptime checks to understand the 'why' behind failures using distributed...
-
How Engineering Teams Ship Faster With Trunk-Based Development
Trunk-based development sounds simple but it breaks decades of Git habit. We look at how one mid-size platform team cut their integration cycle from two weeks to two days by forcing every feature into the main branch within twenty-four hours. The result was not just faster shipping but fewer...
-
How Engineers Build Self Healing Systems
We look at how modern engineering teams are moving beyond manual incident response toward self healing infrastructure. Using examples from major cloud providers and fintech platforms, we explore the shift from reactive firefighting to automated recovery loops. The conversation covers the...
-
How GitHub Copilot Changed Developer Habits
We look at the real shift in engineering workflows after one year of AI pair programming. Lucas and Luna break down how teams are moving from autocomplete to full-function generation, the metrics that actually matter like context window usage, and why documentation quality has become a critical...
-
How Netflix Killed The Remote Onboarding Trap
Remote work promised flexibility but delivered a silent productivity tax. In this episode, Lucas and Luna examine how engineering leaders at companies like GitHub and Microsoft are redesigning the first ninety days for distributed teams. They explore the specific mechanics of asynchronous...
-
How Netflix Scaled Developer Velocity
This episode explores the specific architectural decisions that allowed Netflix to scale its engineering organization without collapsing under its own complexity. We look at how they replaced rigid microservice boundaries with fluid domain ownership, implemented chaos engineering not just for...
-
How Engineering Teams Mastered Async Documentation
Most engineering teams treat documentation as a post-shipping chore, resulting in rotting wikis and tribal knowledge silos. This episode explores how top-tier organizations flip that model by treating design docs as living contracts rather than static records. We look at the specific shift from...
-
How GitHub Copilot Changed Developer Habits
In September 2026, the conversation around AI coding assistants has shifted from novelty to infrastructure. We look at how major engineering teams have stopped treating tools like GitHub Copilot as mere productivity hacks and started viewing them as critical parts of their security and...
-
How Engineering Teams Ship Faster With Trunk-Based Development
Trunk-based development has become the standard for high-velocity software teams, but implementing it correctly requires more than just merging early. This episode examines how modern engineering organizations handle the friction of frequent integration, specifically looking at feature flags as…
more -
How Engineers Ship Faster With Trunk-Based Development
In this milestone episode, Lucas and Luna dissect how leading engineering organizations have moved away from long-lived feature branches toward trunk-based development to reduce merge conflicts and accelerate delivery. They explore the cultural shift required to support continuous integration…
more -
How Microsoft Stopped Measuring Code Churn
Episode 199 dives into the controversial shift in engineering metrics at Microsoft, where leadership moved away from counting lines of code and commit frequency toward measuring actual business value delivered. We explore why 'code churn' became a vanity metric that masked inefficiency, how Azure...
-
How Microsoft Stopped Measuring Code Churn
Microsoft Engineering VP Scott Guthrie revealed that the company stopped tracking lines of code and pull request counts years ago, finding they incentivized the wrong behaviors. In this episode, Lucas and Luna explore why measuring developer productivity by output volume creates perverse...
-
Why Your Company Is Hoarding Knowledge Instead of Building It
Most engineering teams treat documentation as a compliance checkbox rather than a product. This episode examines how organizations fail to capture tribal knowledge, leading to the bus factor risk and repeated reinvention of solutions. We look at specific practices for embedding documentation into...
-
How Netflix Prevented Developer Burnout With Chaos Engineering
We explore how Netflix transformed its engineering culture by embracing failure as a feature. Instead of trying to eliminate outages, the team at BUCKS (Build and Configuration System) started injecting chaos into production environments intentionally. This approach, known as Chaos Monkey and…
more -
How Netflix Killed The Remote Onboarding Trap
Most engineering teams treat remote onboarding as a documentation problem, but Netflix discovered it was actually a context and latency issue. This episode breaks down how Netflix Engineering shifted from passive wiki-reading to active 'pair-programming sprints' for new hires, reducing...
-
How Engineering Teams Ship Faster With Trunk-Based Development
Most engineering leaders think shipping code requires long-lived feature branches, but that mental model is causing more bottlenecks than it solves. This episode breaks down how high-velocity teams at companies like Google and Netflix use trunk-based development to reduce merge conflicts, cut...
-
How Engineers Mastered Context Switching
In this episode, Lucas and Luna explore the hidden cost of context switching in software engineering teams. Using a case study from a mid-sized fintech company that reduced deployment errors by forty percent, they break down how minimizing interruptions leads to deeper focus and higher quality...
-
How Engineering Teams Ship Faster With Trunk-Based Development
Most engineering teams still cling to long-lived feature branches, creating merge hell and slowing down deployment cycles. This episode explores how leading companies like Google and Meta have shifted to trunk-based development, where code is merged into the main branch daily or even multiple…
more -
How Engineers Mastered The Art Of Context Switching
Most engineering teams treat deep work and shallow tasks as interchangeable, but the cognitive cost of context switching is silently eroding productivity. In this episode, Lucas and Luna explore how top-tier organizations structure their days to protect focused coding blocks. We look at specific...
-
How Microsoft Rebuilt Its Engineering Culture
In 2014, Satya Nadella took over Microsoft and faced a company paralyzed by internal competition and siloed engineering teams. He didn't just change the mission statement; he changed how engineers collaborated. This episode explores the shift from 'know-it-all' to 'learn-it-all', the adoption of...
-
How Engineering Teams Kill Technical Debt Without Stopping Feature Work
Most engineering leaders treat technical debt like a fire to be extinguished, forcing a halt to new features until the code is refactored. This approach stalls product velocity and often leads to incomplete fixes. In this episode, Lucas and Luna explore the 'Boy Scout Rule' of software…
more -
How Stripe Mastered Observability At Scale
Stripe has grown into a financial infrastructure giant, processing billions of dollars in transactions daily. But how do you debug a system when you cannot see the flow? This episode explores Stripe's journey to building its own internal observability platform, OpenTelemetry adoption, and the...
-
How Engineers Mastered Context Switching
We dig into the hidden cost of context switching in software engineering teams. Using data from a mid-sized fintech company that reduced meeting load by half, we explore how to protect deep work blocks, structure asynchronous communication, and redesign pull request workflows to keep developers…
more -
How Engineers Mastered Context Switching
In this episode, we examine the cognitive cost of context switching for software engineers. We explore how even brief interruptions can degrade deep work and reduce code quality. The discussion covers practical strategies to protect focus time, including batching notifications, using status...
-
How Stripe Built a Universal Error Format
In this episode, we explore how Stripe engineered a universal error format to solve distributed tracing overhead and turn errors into revenue. We break down the specific architectural decision behind their standardization strategy, examining how consistent error codes reduced latency by ninety...
-
How Stripe Turned Errors Into Revenue
Stripe didn't just build a payment gateway; they built a universal error language that became a product feature. This episode explores how treating API errors as first-class citizens allowed the company to reduce support costs, improve developer experience, and ultimately turn debugging friction...
-
How Stripe Fixed Distributed Tracing Overhead
Stripe’s engineering team faced a classic scalability trap: their distributed tracing infrastructure was consuming more compute resources than the application logic it was monitoring. In this episode, Lucas and Luna break down how they redesigned their sampling strategy and implemented…
more -
How Stripe Solved Distributed Tracing Overhead
Stripe engineers faced a brutal trade-off: full distributed tracing offered perfect observability but crushed latency and bloat the network. In this episode, Lucas and Luna dissect how one team replaced heavy JSON payloads with a binary protocol that cut trace overhead by half while preserving...
-
How GitHub Copilot Changes Code Review
We dig into the counterintuitive reality of AI-assisted development: when code generation speeds up writing, it often slows down reviewing. We examine how one major platform team flipped their process by treating generated code as first-class contributors rather than disposable drafts. You will...
-
How Stripe Built a Universal Error Format
Stripe transformed developer experience by standardizing error responses across its entire API suite. In this episode, we explore how the company moved from chaotic, inconsistent error codes to a unified structure that reduced support tickets and accelerated integration times. Lucas and Luna…
more -
How Stripe Eliminated Technical Debt With Feature Flags
Stripe’s engineering team faced a classic dilemma: how to ship new payment features without breaking existing flows or waiting months for massive releases. They adopted a feature flag architecture that allowed them to decouple deployment from release, turning what used to be high-risk code merges...
-
How One Team Eliminated Technical Debt With Feature Flags
We look at how a mid-sized SaaS company used feature flags to isolate risky deployments, cut rollback rates by eighty percent, and finally tackle their legacy codebase without halting product velocity. This episode explores the specific architecture of their flag management system, the cultural...
-
How Stripe Reduced Server Costs by 90 Percent
Stripe didn't just optimize code; they rewired their entire compute strategy. In this episode, we dive into how the payments giant shifted from a monolithic architecture to a serverless-first model, cutting infrastructure costs by ninety percent while improving latency. We explore the specific...
-
How GitHub Copilot Changed Developer Output
We look at the real-world impact of AI coding assistants on engineering velocity and code quality. Using data from a mid-size SaaS company that adopted GitHub Copilot across three teams, we examine whether the tool actually saves time or just shifts where engineers spend their hours. The...
-
How Git Bisect Saved a Production Release
Episodes one hundred seventy-three and one hundred seventy-four both covered the mechanics of Git Bisect, so this episode pivots to a related but distinct debugging strategy: using randomized testing and mutation analysis to find bugs before they reach production. Lucas and Luna explore how teams...
-
How Git Bisect Saved a Production Release
Episodes often cover cost cuts or latency fixes, but today we tackle the most dangerous time in software engineering: the moment you don't know why something broke. We explore how one senior engineer at a mid-sized fintech firm used binary search through their commit history to find a single line...
-
How Git Bisect Saved a Production Release
When a subtle memory leak in a Python service caused random crashes during peak traffic, one engineering team faced a debugging nightmare. Instead of rolling back to a previous stable version and losing days of work, they used git bisect to isolate the exact commit responsible. This episode...
-
How One Team Cut Error Tracking Noise by 90 Percent
In this episode, Lucas and Luna dive into a fresh angle in software engineering: reducing alert fatigue and error tracking noise. They explore how one team at a mid-sized SaaS company cut their error tracking noise by 90 percent by implementing a structured triage process and custom issue…
more -
How a Side Project Became a $2K Monthly SaaS
In this episode, Lucas and Luna explore the journey of a solo developer who turned a simple internal tool into a profitable SaaS product generating $2,000 a month in recurring revenue. They break down the technical decisions—like choosing a boring stack (Node.js, Postgres, and a vanilla SPA) over...
-
How a Monte Carlo Simulation Cut Deployment Risk
In episode 170 of The Software Engineering Podcast, Lucas and Luna explore how one team used a Monte Carlo simulation to predict deployment risk and cut failed releases by 40 percent. They walk through the specific model: simulating a hundred thousand rollouts, using historical failure rates and...
-
How One Engineer Cut Database Load by 90 Percent with Read Replicas
In this episode of The Software Engineering Podcast, Lucas and Luna dive into a real-world case where a simple architectural change—adding read replicas—cut database load by 90 percent. They break down the decision-making process, the trade-offs, and the engineering mindset behind scaling reads...
We're indexing this podcast's transcripts for the first time — this can take a minute or two. We'll show results as soon as they're ready.
No matches for "" in this podcast's transcripts.
No topics indexed yet for this podcast.
Loading reviews...
ABOUT THIS SHOW
Lucas and Luna sit down at side-by-side laptops to talk about the craft of building software. Each episode picks a single engineering challenge — optimizing a database query for latency, designing a fault-tolerant microservice boundary, refactoring a legacy monolith without breaking production — and walks through the trade-offs with real code examples and benchmark numbers. They debate testing strategies (integration vs. end-to-end, when to mock), revisit classic papers on distributed systems and data structures, and trace how architectural decisions cascade into operational costs. The show serves senior developers, staff engineers, and technical leads who want to hear reasoned, specific conversations about trade-offs and rigor — not hype about the latest framework. Lucas brings the journalist's habit of asking why a team chose one pattern over another; Luna pushes back with real-world failure stories from her own career. Together, they treat software engineering as a discipline of exp
HOSTED BY
Fexingo
CATEGORIES
Loading similar podcasts...
Frequently Asked Questions
How many episodes does The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices have?
The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices currently has 183 episodes available on PodParley. New episodes are automatically indexed when they're published to the podcast feed.
What is The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices about?
Lucas and Luna sit down at side-by-side laptops to talk about the craft of building software. Each episode picks a single engineering challenge — optimizing a database query for latency, designing a fault-tolerant microservice boundary, refactoring a legacy monolith without breaking production —...
How often does The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices release new episodes?
The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices publishes regularly with 183 episodes available. Check the episode list for the typical release schedule.
Where can I listen to The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices?
You can listen to The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices on PodParley by clicking any episode. We provide an embedded audio player for direct listening, and you can also subscribe via your preferred podcast app using the RSS feed.
Who hosts The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices?
The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices is created and hosted by Fexingo.
URL copied to clipboard!