Fexingo
The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices
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 se...
Be sure to visit the podcast's website and support the creator: www.fexingo.com
Where to listen?
Podcasts in the app Replaio Radio Coming soonPodcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts
Episodes
How One Engineer Migrated 50 Million Users Without Downtime 18.07.2026 8:48
In this episode of The Software Engineering Podcast, Lucas and Luna dive into the story of a senior engineer at a major social platform who orchestrated a database migration of 50 million user accounts from a legacy sharded MySQL setup to a distributed NewSQL system — all while maintaining 99.99 percent uptime. The migration, code-named 'Project Sequoia,' took 18 months of planning, involved a cus...
How One Engineer Reduced a 12-Hour Batch Job to 15 Minutes with Streaming 17.07.2026 11:06
In this episode of The Software Engineering Podcast, Lucas and Luna explore how a senior engineer at a fintech company slashed a 12-hour nightly batch reconciliation job down to just 15 minutes by switching from a batch processing model to a streaming architecture using Apache Kafka and Flink. The episode walks through the original problem — a bottlenecked PostgreSQL pipeline that processed 50 mil...
How One Engineer Eliminated Flaky Tests Without Code Changes 17.07.2026 7:02
In episode 116 of The Software Engineering Podcast, Lucas and Luna dig into a real production nightmare: a 12,000-test CI suite that was failing 15% of the time with no code changes. They walk through how one engineer at a mid-size SaaS company traced the flakiness to a hidden dependency conflict in test environment provisioning, then solved it without touching a single test file. The fix: a deter...
How One Engineer Visualised Dependency Graphs to Fix Inefficient Microservices 16.07.2026 12:23
In this episode of The Software Engineering Podcast, Lucas and Luna explore how a single engineer at a mid-sized fintech company used dependency graph visualisation to untangle a microservices architecture that had become a tangled ball of circular dependencies, hidden cross-service calls, and unpredictable latency spikes. By mapping every inter-service interaction into a directed acyclic graph, t...
How One Engineer Debugged a Race Condition That Only Happened at 3 AM 16.07.2026 9:32
In this episode of The Software Engineering Podcast, Lucas and Luna investigate a notorious breed of production bug: the race condition that triggers exclusively during low-traffic hours. They walk through a real incident at a mid-size payments startup where a database read-after-write inconsistency caused silent duplicate charges—only between 2:30 AM and 4:00 AM. The fix involved a surprisingly s...
How One Engineer Debugged a Heisenbug That Only Reproduces in Production 15.07.2026 8:51
Episode 113 of The Software Engineering Podcast with Fexingo. Lucas and Luna dig into a maddening class of bug: the heisenbug that vanishes the moment you try to inspect it. They walk through a real case from a mid-size fintech startup where a payment-settlement job corrupted data only under production load, and only when observability tools were turned off. The engineer spent three weeks chasing...
How One Engineer Parallelized a Batch Job from 4 Hours to 3 Minutes 15.07.2026 11:16
In this episode, Lucas and Luna explore how a single engineer at a mid-sized fintech company transformed a legacy batch-processing pipeline that ran for four hours every night into a parallelized system that finishes in under three minutes. They walk through the specific technical decisions: partitioning the input data into 80 independent shards, using a fan-out pattern with AWS Lambda and SQS, ha...
How One Engineer Reduced Kubernetes Costs by 70 Percent 14.07.2026 8:35
In Episode 111 of The Software Engineering Podcast, Lucas and Luna dive into a real case from a mid-sized fintech startup where a single engineer—Sarah Chen—slashed their Kubernetes cluster costs by 70 percent without sacrificing performance. They break down the specific strategies she used: right-sizing node instances with custom scheduling policies, eliminating idle resources through vertical po...
How One Engineer Used Session Replay to Fix a Checkout Bug 14.07.2026 6:39
In this episode, Lucas and Luna dive into how a single engineer at an online retailer used session replay tools to diagnose and fix a checkout bug that cost $200,000 per week. They explore why traditional logs failed, how session replay revealed a race condition in an A/B test framework, and what engineering teams can learn about debugging user-facing issues. The conversation covers the trade-offs...
How a Single Mistyped Environment Variable Broke a Deployment Pipeline 13.07.2026 9:25
Episode 109 of The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices. Lucas and Luna dig into a surprisingly common failure mode: a single mistyped environment variable that silently broke a deployment pipeline for a mid-size SaaS company. They walk through how a typo in a config file caused partial outages, delayed rollouts, and hours of debugging befor...
How One Engineer Cut CI Build Times by 80 Percent 13.07.2026 6:49
Episode 108 of The Software Engineering Podcast with Fexingo dives into the story of senior engineer Priya Nair at a fast-growing fintech startup, who slashed continuous integration build times from 45 minutes to under 9 minutes. Lucas and Luna walk through the three-phase strategy she used: dependency caching, parallel job decomposition, and a targeted monorepo migration. They break down the exac...
How One Engineer Eliminated a Memory Leak in Production 12.07.2026 8:01
In this episode, Lucas and Luna dive into a real-world production memory leak that plagued a mid-sized SaaS company for weeks. They walk through how one engineer used heap dumps, allocation profiling, and a single suspicious class to trace the leak to an unclosed InputStream in a popular HTTP library. Lucas explains the debugging methodology step by step: capturing heap dumps at the right moment,...
How One Engineer Refactored a Monolith Without Stopping the Business 12.07.2026 10:06
In this episode of The Software Engineering Podcast, Lucas and Luna dive into a real-world monolith-to-microservices migration that took 18 months and never interrupted customer-facing operations. They examine the technique of strangler fig pattern applied at a payments company processing $12 billion annually, how the engineering team used feature flags and parallel runways to ship incremental sli...
How a Single CDN Misconfiguration Took Down 15000 Sites 11.07.2026 5:57
In June 2026, a single configuration change at a major CDN provider caused widespread outages for thousands of websites. Lucas and Luna dive into the technical root cause: a caching-layer bug that turned a routine config push into a catastrophic cascade. They break down how content delivery networks actually route traffic, why a seemingly harmless origin-shield setting can trigger a global meltdow...
How One Engineer Reduced Database Deadlocks by 95 Percent 11.07.2026 9:05
In this episode, Lucas and Luna dive into the story of a senior backend engineer at a mid-sized fintech company who systematically reduced database deadlocks by 95 percent. They break down the root cause—a combination of implicit table locks and poorly ordered transactions—and walk through the specific fix: introducing explicit row-level locking, reordering SQL statements to follow a consistent lo...
How One Engineer Automated Code Review with AI Agents 10.07.2026 10:01
Episode 103 of The Software Engineering Podcast explores how one engineer built an AI-powered code review agent that automates 70 percent of repetitive comments, freeing senior developers for higher-level architectural decisions. Lucas and Luna discuss the practical implementation — using a fine-tuned LLM on a private codebase, integrating with GitHub's API, and handling false positives with a con...
How One Engineer Used Structured Logging to Debug a Serverless Disaster 10.07.2026 8:55
In this episode, Lucas and Luna dive into the story of a serverless application that went haywire due to a hidden bug in a Lambda function's cold start logic. They explore how structured logging—with JSON-formatted logs and correlation IDs—allowed a single engineer to trace the issue across distributed systems in minutes. The episode covers the specific logging libraries and practices that turned...
How One Engineer Isolates Microservice Failures with Circuit Breakers 09.07.2026 7:03
In this episode, Lucas and Luna dive into a practical engineering story: how one engineer at a mid-size fintech company prevented a cascading failure by implementing circuit breakers between microservices. The discussion walks through the specific scenario—a downstream payment API latency spike that would have taken down the entire checkout flow—and how a simple Hystrix-style circuit breaker patte...
How a Single Database Connection Pool Caused a Production Meltdown 09.07.2026 6:51
In this episode, Lucas and Luna dive into a real-world production outage caused by a single misconfigured database connection pool. They walk through how a popular e-commerce site went down for 45 minutes because of a connection pool set too low, spilling over into cascading failures across their microservices. They explain what connection pooling is, how to tune it, and the monitoring signals tha...
How a Single Unicode Character Crashed a Payment Gateway 08.07.2026 9:21
In this episode of The Software Engineering Podcast, Lucas and Luna dive into a bizarre production outage caused by a single Unicode character. They dissect how a zero-width space sneaked into a payment gateway's input validation, bypassing all regex checks and causing silent transaction failures. Lucas breaks down the technical specifics—how UTF-8 encoding works, why most sanitizers miss non-prin...
How a Single Misconfigured DNS Entry Caused a Multi-Region Outage 08.07.2026 6:38
In Episode 98 of The Software Engineering Podcast, Lucas and Luna dive into a real-world incident where a single misconfigured DNS entry took down a multi-region e-commerce platform for 47 minutes. They walk through the architecture—how DNS resolution works, the difference between round-robin and geo-location routing, and the cascading failure that happened when a stale 'glue record' pointed to a...
How One Engineer Cut Database Query Time 90 Percent With Indexes 07.07.2026 8:44
Lucas and Luna dive into the story of how a single database index saved a startup's user-facing dashboard. When a page load hit 12 seconds during peak traffic, one engineer found the culprit: a full table scan on a 40-million-row table. The fix wasn't a $10,000 database upgrade or a caching layer — it was a composite index on three columns. Lucas walks through the query plan, the index structure,...
How One Engineer Reduced Lambda Cold Starts by 60 Percent 07.07.2026 7:17
In this episode, Lucas and Luna dive into a specific engineer's battle against AWS Lambda cold starts. They break down how a serverless backend handling real-time analytics was suffering from three-second cold starts during traffic spikes, and how a combination of provisioned concurrency, VPC endpoint optimization, and a custom runtime in Rust cut latency by 60 percent. The discussion walks throug...
How TypeScript Type Errors Caused a Three Hour Production Outage 06.07.2026 9:20
In this episode of The Software Engineering Podcast, Lucas and Luna dive into a 2025 incident where a seemingly harmless TypeScript type definition change cascaded into a three-hour production outage at a mid-size fintech company. They trace the root cause: an interface that was too permissive combined with a generic that silently widened the return type. The bug passed code review, passed CI, and...
How a Single Misconfigured Load Balancer Took Down a Billion Dollar Site 06.07.2026 6:34
Lucas and Luna dissect a real-world outage caused by a single misconfigured load balancer that took down a major e-commerce site for over an hour during a flash sale. They walk through the engineering details: how a health-check timeout setting caused the balancer to mark all backends as unhealthy, how the team debugged it, and what monitoring changes they made to prevent recurrence. Plus, they di...
Similar podcasts
Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.