The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices

We explore the paradox of modern software engineering: teams are shipping more features faster, yet writing significantly less source code. This episode dissects how platforms like Vercel and internal developer portals have shifted value from individual syntax to system orchestration. We examine the specific metrics that define this shift, including the drop in lines of code per feature and the ri...

We look at how GitHub Copilot changed developer output by shifting the focus from syntax to system design. Using recent data on code acceptance rates and a specific case study of a mid-sized fintech team, we explore whether AI is actually boosting productivity or just creating more complex technical debt. We break down the numbers behind the hype and ask if the real bottleneck in software engineer...

We look at how the engineering team at Datadog moved from a traditional monolithic architecture to an event-driven system that cut deployment times in half. We discuss the specific tradeoffs of internal developer platforms and why measuring code quality isn't just about test coverage. This episode explores the real cost of context switching for senior engineers and how they solved it. #SoftwareEng...

We look at how modern engineering organizations are tackling the hidden tax of context switching. When developers jump between tickets, meetings, and alerts, productivity doesn't just drop, it fractures. This episode examines the specific cognitive cost of task-switching in software teams and explores how some companies are redesigning their workflows to protect deep work. We discuss the data on l...

We explore the quiet crisis of monolithic architecture in modern engineering teams. Most companies started with a single codebase that grew too big to manage. We look at how Stripe and Shopify moved away from their original structures and what it actually costs when one bug takes down half your platform. This episode breaks down the trade-offs between speed and stability when your system is too ti...

Most engineering teams treat CI/CD as an afterthought, but the fastest ships optimize for build latency. We look at how one mid-sized platform team reduced their mean time to recover by cutting build times from twelve minutes to ninety seconds using containerized build environments and parallelization. This isn't about AI code generation or async decision making. It is about the gritty reality of...

We strip away the vanity metrics of code coverage and commit counts to examine what actually moves the needle in software engineering. This episode dissects the real friction points in modern development workflows, focusing on how high-performing teams balance velocity with stability. We look at specific case studies where engineering leaders shifted from quantity-based incentives to quality-centr...

In this episode of The Software Engineering Podcast, Lucas and Luna dismantle the myth that lines of code or bug counts equal quality. They examine how leading engineering teams at companies like Netflix and GitHub have shifted from vanity metrics to value-driven signals like deployment frequency, change failure rate, and mean time to recovery. The conversation explores why measuring developer vel...

We explore how modern engineering teams are bypassing traditional coding bottlenecks by adopting platform engineering and internal developer portals. Using a specific case of a mid-sized fintech company that reduced deployment time from weeks to hours, we examine the shift from individual contributor coding to systemic orchestration. This episode breaks down the concrete steps taken to build an in...

In this episode of The Software Engineering Podcast, Lucas and Luna explore the controversial shift away from mandatory code reviews. With engineering velocity hitting record highs in late October 2026, teams at companies like GitHub and Stripe are experimenting with AI-augmented, async-first review processes that prioritize speed over consensus. We dig into the data on how removing human bottlene...

In this episode of The Software Engineering Podcast with Fexingo, Lucas and Luna explore the counterintuitive rise of low-code and no-code platforms in enterprise software delivery. Rather than viewing these tools as a threat to professional developers, they examine how top engineering organizations are using them to offload routine internal workflows, freeing up high-value talent for complex syst...

Engineers lose up to twenty three minutes refocusing after every interruption. This episode dissects the cognitive cost of context switching in modern software development, using data from JetBrains and Microsoft studies to show why deep work is becoming a strategic asset. We explore how top engineering teams design their workflows to protect focus time, reduce meeting density, and build asynchron...

In this episode, we explore how engineering leaders at Spotify and Atlassian have transformed technical debt from a vague excuse into a measurable budget line item. We break down the specific framework used to quantify 'interest payments' on legacy code, the controversial decision to halt feature work for two weeks every quarter, and why treating refactoring like product development yields higher...

In this episode of The Software Engineering Podcast with Fexingo, Lucas and Luna explore the counterintuitive trend of engineers deliberately reducing their coding output to accelerate delivery. We examine how teams at companies like HashiCorp and early-stage startups are using declarative configuration, internal developer platforms, and automated scaffolding to eliminate boilerplate. Rather than...

In this episode, we explore the counterintuitive trend of engineers deliberately reducing their own coding output to accelerate delivery. We look at how major platforms are shifting from writing custom logic to leveraging internal developer platforms and low-code tools. Lucas and Luna break down the specific metrics that drive this change, the role of abstraction layers, and why less code often me...

Most engineering teams treat decisions like meetings — urgent, synchronous, and prone to groupthink. But the highest-velocity teams have shifted to asynchronous decision logs, where context is written down before any conversation happens. In this episode, we look at how a mid-sized fintech scaled its engineering org from fifty to two hundred engineers without adding a single manager, simply by cha...

Most engineering leaders rely on lines of code or commit frequency to gauge performance, but these metrics often drive bad behavior. We examine why Spotify’s DORA framework shifted the industry toward deployment frequency and lead time for changes. Lucas and Luna dissect how measuring output instead of outcomes creates technical debt, using specific examples from mid-size SaaS companies that succe...

In this episode, Lucas and Luna dissect the rising trend of internal developer platforms and low-code orchestration at scale. They examine how major engineering organizations are shifting from traditional software development to configuring pre-built modules, using specific examples from industry leaders like Stripe and Netflix. The discussion explores the trade-offs between velocity and technical...

In this episode, we dig into the specific architectural shift at Figma that transformed how engineering teams interact with design files. Before their platform overhaul, the handoff between designers and developers was a broken process reliant on manual exports and inconsistent specifications. We explore how embedding interactive prototypes directly into the codebase reduced miscommunication by ne...

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, focusing instead on reducing cognitive load and automating repetitive internal tasks. We examine the s...

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 lines of code is actually increasing velocity. If this tech conversation gave you something usable, co...

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 microservices, and embrace configuration over custom builds. We break down why reducing technical debt...

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 'prompt engineering' as a core skill, and why some top-tier engineering leaders are now measuring success by...

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 thousands of services. We examine the concrete metrics behind their success, including the reduction in dep...

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 customer. Learn why measuring developer velocity requires looking at time-to-first-commit rather than lines o...