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

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...

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 velocity high without burning out their best talent. We look at specific practices from companies like St...

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 that turned complex financial plumbing into a seamless experience for millions of developers. Discover...

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 tooling that scaled with millions of lines of code, and why developer experience became their most def...

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 tracing and synthetic transactions. Drawing on lessons from high-traffic platforms that manage millions...

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 rollbacks and a dramatic drop in merge conflicts that used to stall sprints. We unpack the specific frictio...

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 architecture of automated remediation, the role of observability in triggering fixes, and why this approach red...

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 hiring signal. This episode explores the hidden costs of AI-assisted coding, including increased technic...

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 documentation, the failure of video-heavy onboarding, and why code reviews have replaced casual desk-side chat...

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 resilience but for developer confidence, and why they stopped measuring code churn in favor of deployment...

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 synchronous meetings to asynchronous written decisions, using concrete examples of how Amazon's narrativ...

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 architectural landscape. Lucas and Luna break down the specific shift in developer behavior, the rise of AI-assis...

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 the primary mechanism for decoupling deployment from release. We break down the operational discipline r...

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, the role of automated testing in enabling safe commits, and why this approach is becoming essential for t...

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 team leads redefined success using deployment stability and customer retention rates instead, and what...

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 incentives, how Microsoft shifted to outcome-based metrics like deployment frequency and lead time, and what ot...

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 the development lifecycle, using examples from high-velocity tech companies that treat internal wikis...

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 later Gremlin, shifted the focus from reactive firefighting to proactive resilience. We look at the specif...

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 time-to-first-commit by forty percent. We look at the specific metrics they tracked, why traditional shadowing fa...

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 review times in half, and deploy multiple times a day without sacrificing stability. We look at the specif...

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 code. They discuss practical strategies for protecting deep work blocks, managing Slack notifications, an...