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 Automated 90 Percent of Code Reviews with a Custom Linter 23.06.2026 8:33
In this episode, Lucas and Luna break down the story of Sarah Chen, a senior engineer at a mid-size fintech company who wrote a custom linter that automated 90% of code review comments. They explain how she turned institutional knowledge into rule sets, what the team's adoption curve looked like, and why the biggest win wasn't speed but consistency. Plus, they debate where automated review stops a...
How One Engineer Debugged a Null Pointer in Production 22.06.2026 7:14
In this episode, Lucas and Luna dive into a production bug that brought down a payment processing system for 47 minutes. The root cause? A null pointer exception buried in code that had run flawlessly for over two years. We trace how a seemingly harmless code change triggered the failure, why the logs were misleading, and the specific debugging technique — binary search on git bisect — that isolat...
How a Single Linter Rule Prevented a Data Corruption Bug 22.06.2026 10:26
In this episode, Lucas and Luna dive into a real-world case where a seemingly harmless TypeScript function silently corrupted user data in a fintech application. The bug was never deployed to production because a custom ESLint rule caught it during code review — but only after the team spent three days tracing the root cause. They explore why type narrowing alone isn't enough, how lint rules can e...
How One Engineer Debugged a Race Condition in a Distributed Database 21.06.2026 6:55
In Episode 65 of The Software Engineering Podcast, Lucas and Luna dive into a real production nightmare: a race condition in a distributed SQL database that caused phantom reads and silently corrupted a financial reconciliation system. They walk through how one engineer at a fintech startup isolated the bug using deterministic simulation, applied a linearizability fix, and reduced incident respons...
How One Engineer Wrote a Single Git Hook That Saved 200 Hours a Week 21.06.2026 9:30
Most engineering teams spend hours each week catching trivial mistakes: trailing whitespace, debug code that shouldn’t be committed, credentials accidentally pushed to a public repo. In this episode, Lucas and Luna dig into the story of a single pre-commit Git hook written by an engineer at a mid-size SaaS company. The hook ran static analysis on every staged file — about 15 checks total — and pre...
How One Engineer Cut Latency 40 Percent with Tailwind CSS Purge 20.06.2026 9:47
In this episode, Lucas and Luna dive into the story of a front-end engineer at a mid-sized e-commerce company who discovered that their production CSS bundle had grown to over 900 kilobytes, causing measurable latency on mobile devices. By implementing Tailwind CSS's built-in purge and customizing the configuration to aggressively strip unused utility classes, the engineer reduced the bundle to un...
How One Engineer Cut CI Costs 80 Percent with Smart Caching 20.06.2026 6:53
Episode 62 of The Software Engineering Podcast. Lucas and Luna dissect a real-world case: a senior engineer at a mid-size SaaS company slashed their CI pipeline costs by 80 percent and cut build times from 45 minutes to 8 minutes — without rewriting tests or switching providers. They walk through the specific caching strategies used: Docker layer caching with buildkit, monorepo dependency graph ha...
How One Engineer Saved a Project from Vendor Lock-In with OpenTelemetry 19.06.2026 8:55
In this episode of The Software Engineering Podcast, Lucas and Luna break down how a single engineer at a mid-sized SaaS company saved their project from catastrophic vendor lock-in by building an observability layer with OpenTelemetry. They walk through the specific scenario: the team was deep into a migration from one cloud provider to another, only to discover that their monitoring and tracing...
How One Engineer Debugged a Timezone Bug That Cost a Trading Desk Millions 19.06.2026 9:29
In this episode, Lucas and Luna dive into one of software engineering's most insidious villains: the timezone bug. They focus on a real-world case from a trading desk where a subtle mismatch between UTC and local time in a cron job caused millions in losses over six months. Lucas explains why timezone bugs are uniquely hard to catch — they pass unit tests, work in staging, then fail in production...
How One Engineer Fixed a Serverless Cold Start Nightmare 18.06.2026 10:24
In this episode, Lucas and Luna dive into the hidden cost of serverless: cold starts. They break down a real case where a fintech startup saw API latency spike from 50ms to 2.5 seconds under load, all because of Lambda cold starts. They walk through the root cause—VPC cold starts and bloated deployment packages—and the fix: provisioned concurrency combined with a lightweight runtime written in Rus...
How One Engineer Shrank a Docker Image by 95 Percent 18.06.2026 8:01
Episode 58 of The Software Engineering Podcast explores how a single engineer at a mid-size SaaS company reduced their Docker image size from 1.2 GB to 60 MB, cutting deploy times from 12 minutes to under 90 seconds. Lucas and Luna walk through the exact techniques used: multi-stage builds, Alpine base images, distroless layers, and aggressive dependency pruning. They also discuss the surprising s...
How One Engineer Debugged a Year 2038 Bug in 2025 17.06.2026 9:40
In this episode, Lucas and Luna explore a real-world Y2038 bug that surfaced in 2025, years before the famous epoch overflow. They dissect how a legacy C++ trading system stored timestamps as 32-bit signed integers, causing a critical failure when a date field crossed the 2,147,483,647-second threshold. Lucas explains the root cause, the step-by-step debugging process using binary analysis, and th...
The $400k Bug That Only Happened in Production 17.06.2026 7:40
Lucas and Luna dive into a notorious production-only bug from a mid-size fintech company: a memory corruption issue that triggered random data loss in user transactions. The bug only manifested under real load and took three weeks to root-cause. They break down the debugging process, the tools used (GDB, address sanitizer, core dumps), and the engineering lesson about Heisenbugs and timing-depende...
How a Single Config Change Reduced AWS Costs by 90 Percent 16.06.2026 8:22
Episode 55 of The Software Engineering Podcast. Lucas and Luna dive into one of the most dramatic cost-saving stories in cloud engineering: how a team at a mid-sized fintech company reduced their monthly AWS bill from $80,000 to just $8,000 by changing a single configuration parameter. They explore the overlooked power of AWS Compute Optimizer, the difference between provisioned and on-demand capa...
How One Engineer Reduced Cloud Costs by 60 Percent with Spot Instances 16.06.2026 9:45
Episode 54 of The Software Engineering Podcast dives into a real-world cost optimization story. Lucas and Luna walk through how a senior engineer at a mid-size SaaS company cut their AWS bill by 60 percent by migrating stateless workloads to spot instances. They discuss the engineering trade-offs: designing for interruption tolerance, using checkpointing and auto-scaling groups, and the monitoring...
How One Engineer Debugged a Heisenbug That Only Happened in Production 15.06.2026 7:19
Episode 53 of The Software Engineering Podcast dives into the maddening world of heisenbugs — bugs that disappear the moment you try to inspect them. Lucas and Luna walk through a real case: a production service that crashed once every 72 hours, but only under load. The team spent two weeks instrumenting, tracing, and finally caught a race condition in a Go channel that only triggered when the CPU...
How One Engineer Fixed a Timezone Bug That Lost Millions 15.06.2026 8:39
Episode 52 of The Software Engineering Podcast with Fexingo tells the story of a single timezone handling bug at a travel-booking company that caused a cascading failure, losing over $2 million in revenue in a single weekend. Lucas and Luna break down how one engineer—Maya Chen—discovered the root cause was a misconfigured Olson database file, and the elegant fix she deployed using a small Go serv...
How One Engineer Eliminated Configuration Drift with a Single Declarative Tool 14.06.2026 9:09
Configuration drift is one of those slow, silent killers in infrastructure. You patch one server manually, push a hotfix to another, and six months later your production environment is a unique snowflake that nobody fully understands. In this episode, Lucas and Luna walk through the story of a senior platform engineer named Priya at a mid-sized fintech company. Her team was spending roughly 30 per...
How One Engineer Cut a 12-Hour Deploy to 11 Minutes with Sandboxed Previews 14.06.2026 11:36
In episode 50 of The Software Engineering Podcast, Lucas and Luna explore the story of a senior engineer at a mid-sized SaaS startup who reduced deployment time from 12 hours to 11 minutes by implementing an ephemeral sandbox preview system. They break down the technical architecture: how the engineer used Kubernetes namespaces, a custom ingress controller, and a GitHub Actions pipeline to spin up...
How One Engineer Cut Database Latency by 99 Percent with Connection Pooling 13.06.2026 7:48
In this episode of the Software Engineering Podcast, Lucas and Luna dive into a real-world case where a single engineer reduced database query latency by 99% by rethinking connection pooling. They explore the problem of connection storms, the trade-offs between pooling and direct connections, and how a simple configuration change transformed a struggling API into a high-throughput service. The epi...
How a Single Memory Leak Crashed a Trading Platform 13.06.2026 7:22
In this episode of The Software Engineering Podcast, Lucas and Luna dive into the anatomy of a memory leak that took down a major trading platform for 45 minutes during peak market hours. They break down how a missing free() call in a C++ order-book module caused heap exhaustion, why the leak evaded detection for months, and the engineering fix—arena allocation with bounded lifetimes—that eliminat...
How a Single Query Lock Brought Down Production at 3 AM 12.06.2026 7:01
Lucas and Luna dive into a real-world incident where a seemingly innocent database query caused a full production outage at a mid-size e-commerce company. They walk through the sequence of events: a developer ran an unindexed join on a table with 12 million rows, which escalated into a table-level lock, cascading connection pool exhaustion, and a 47-minute downtime. The hosts explain how the query...
How One Engineer Reduced Queue Latency by 80 Percent with Batching 12.06.2026 9:06
In this episode, Lucas and Luna explore a real-world case where a single engineer at a major e-commerce company slashed message queue latency by 80 percent. They walk through the original architecture — a RabbitMQ cluster handling 50,000 messages per second for order processing — and the bottleneck caused by per-message acknowledgments and database writes. The fix: a batching layer that collected...
How One Engineer Reduced Memory Use by 70 Percent with Arena Allocation 11.06.2026 9:46
Episode 45 tells the story of Sarah Chen, a backend engineer at a mid-size ad-tech company, who cut a high-throughput Go service's memory consumption by 70 percent by replacing the default garbage collector with arena-based allocation. The episode dives into Go's garbage collection behavior, the concept of memory arenas (inspired by C's malloc arenas and jemalloc), and how Sarah identified that he...
How One Engineer Used Genetic Algorithms to Optimize API Routing 11.06.2026 10:25
Episode 44 of The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices. Lucas and Luna explore the story of a senior backend engineer at a ride-sharing company who used a genetic algorithm to optimize API request routing across hundreds of microservices. The engineer faced a classic NP-hard problem: route requests through a complex dependency graph to minim...
Similar podcasts
Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.