Fexingo

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

Business EN ↓ 243 episodes

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

Author

Fexingo

Category

Business

Podcast website

www.fexingo.com

Latest episode

Nov 15, 2026

Where to listen?

Podcasts in the app Replaio Radio Coming soon

Podcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts

Get it on Google Play Install for free Android almost 10M downloads · 4.7+ rating iOS soon

Episodes

How a Single Null Byte Broke a Payment System 05.07.2026

In this episode, Lucas and Luna dissect a notorious production incident where a single null byte in a user input crashed a payment processing system handling thousands of transactions per minute. They trace the bug from a misconfigured web form to a C library's string handling, and explain how a tiny oversight in input sanitization cascaded into a full outage. Along the way, they discuss defensive...

How a Single Feature Flag Caused a Cascading Production Failure 05.07.2026

In this episode, Lucas and Luna dissect a real-world incident where a poorly managed feature flag caused a cascading failure that took down a major e-commerce platform for over two hours. They walk through the chain of events: a developer enables a flag for internal testing, the flag's default value is 'true', a deployment script fails to reset it, and the new code path triggers a database bottlen...

How a Single Race Condition Cost an E-Commerce Company Millions 04.07.2026

Lucas and Luna dive into a real-world debugging story: a race condition in an order-processing system that caused duplicate shipments and lost revenue for a mid-size e-commerce company. They explore how the bug evaded testing, the specific timing window that triggered it, and the fix that prevented it from recurring. Along the way, they discuss concurrency gotchas in distributed systems, the limit...

How a Single Config Change Halved Server Costs 04.07.2026

In this episode, Lucas and Luna dive into a real-world case where a top-tier SaaS company cut its infrastructure bill by over half — not by migrating clouds or rewriting code, but by tuning a single PostgreSQL configuration parameter. They walk through the default settings that silently waste memory, the specific 'shared_buffers' and 'effective_cache_size' adjustments that turned the tide, and the...

How a Single Regex Caused a Production Meltdown 03.07.2026

In this episode, Lucas and Luna dissect a real-world software engineering disaster: a single poorly written regular expression that brought a major e-commerce site to its knees during Black Friday. They walk through how a catastrophic backtracking bug turned a harmless input validation check into a CPU-eating monster, triggering cascading failures across microservices. Learn what catastrophic back...

How One Engineer Debogused a Kubernetes Outage Caused by a Single Misconfigured Pod 03.07.2026

In this episode of The Software Engineering Podcast, Lucas and Luna dive into a real-world Kubernetes nightmare: a single misconfigured pod that silently caused cascading failures across a whole cluster. They walk through how an engineer at a mid-size fintech company discovered the root cause — not through monitoring alerts, but by noticing a subtle anomaly in request latency distributions. The fi...

How One Engineer Reduced AWS Costs by 80 Percent With Reserved Instances 02.07.2026

Episode 87 of The Software Engineering Podcast digs into a real-world cost optimization story. Lucas and Luna walk through how a senior engineer at a mid-sized SaaS company slashed their AWS bill from $120,000 to $24,000 per month using a combination of Reserved Instances, Savings Plans, and right-sizing. They break down the math: 1-year vs 3-year commitments, partial upfront vs no upfront, and ho...

How One Engineer Cut CI Build Times by 80 Percent With Cache Warmers 02.07.2026

In episode 86 of The Software Engineering Podcast, Lucas and Luna explore how a senior engineer at a mid-sized SaaS company reduced continuous integration build times from 47 minutes to under 10. They break down the specific caching strategy — a combination of Docker layer caching, dependency pre-warming, and a custom GitHub Actions cache warmer — that eliminated redundant work across 150 develope...

How One Engineer Debugged a Production Outage Using Flame Graphs 01.07.2026

In episode 85 of The Software Engineering Podcast, Lucas and Luna dive into a real-world production debugging story where flame graphs turned chaos into clarity. They walk through how a single engineer traced a mysterious CPU spike that was causing intermittent timeouts across a microservices architecture — and how a visual profiling tool cut the investigation from days to hours. Along the way, th...

How One Engineer Debugged a Race Condition in a Redis Lock 01.07.2026

In this episode of The Software Engineering Podcast with Fexingo, Lucas and Luna dive into a single tricky bug: a distributed lock implemented with Redis that caused intermittent failures in a high-traffic checkout system. They walk through the engineer's discovery of a missing atomicity guarantee in the lock acquisition path, the specific race window that allowed two processes to acquire the same...

How a Single Log Line Saved a Startup from a Data Breach 30.06.2026

Episode 83 of The Software Engineering Podcast with Fexingo: Lucas and Luna dive into the story of a software engineer at a fintech startup who noticed a suspicious log line during routine monitoring. That single log entry revealed an attacker had been exfiltrating customer data for weeks via a compromised API key. The engineer's quick detection and response prevented a full-blown data breach that...

How One Engineer Recalled a Wrong Production Deploy in 8 Seconds 30.06.2026

In this episode, Lucas and Luna dive into the story of an engineer at a mid-size SaaS company who accidentally deployed a breaking change to production on a Friday afternoon. Instead of a panicked 20-minute scramble to revert via Git, she had already set up a one-line rollback script — a single shell command that restored the previous deployment image in under 10 seconds. The hosts break down how...

How an Engineer Reduced Docker Image Size by 95 Percent 29.06.2026

In episode 81 of The Software Engineering Podcast, Lucas and Luna explore how a senior DevOps engineer at a mid-sized SaaS company shrunk Docker images from 1.8 GB to under 90 MB — cutting deployment times by 70 percent and saving $12,000 a year in storage costs. They walk through the specific techniques used: multi-stage builds, Alpine base images, distroless runtimes, and layer optimisation. The...

How One Engineer Cut Logging Costs 90 Percent Without Losing Observability 29.06.2026

Episode 80 of The Software Engineering Podcast dives into a specific cost-optimization story: how a senior engineer at a mid-size fintech company reduced their cloud logging bill by 90 percent — from $80,000 per month to under $8,000 — without sacrificing the signal their on-call team relied on. Lucas and Luna walk through the technical decisions: switching from structured JSON logging to a custom...

How One Engineer Repaired a Corrupt Git Repository Without Losing History 28.06.2026

When a junior developer force-pushed over a shared branch and corrupted the entire git history, most teams would panic. In this episode, Lucas and Luna break down how one engineer rescued a 14-month-old codebase using git reflog, filter-repo, and careful cherry-picking. They walk through the specific commands, the decision tree for when to rewrite history versus when to accept it, and the single b...

How One Engineer Debugged a Kubernetes Pod Eviction That Wiped 5000 Jobs 28.06.2026

In this episode of The Software Engineering Podcast with Fexingo, Lucas and Luna dive into a production nightmare: a Kubernetes cluster that silently evicted over 5000 batch jobs over three weekends. They walk through how one engineer at a data processing startup traced the root cause to a subtle interaction between kubelet resource reservation defaults and a misconfigured eviction threshold. Lear...

How One Engineer Fixed a Sidekiq Memory Bloat That Crunched Servers Every 72 Hours 27.06.2026

Episode 77 of The Software Engineering Podcast digs into a deceptively simple bug: a Sidekiq worker that ballooned in memory every 72 hours, forcing the ops team to restart it manually. Lucas and Luna walk through how one engineer discovered the culprit—a cached ActiveRecord relation that never cleared—and how a single call to `.reload` cut memory usage by 80 percent. They discuss lazy evaluation...

How One Engineer Handled a Database Migration With Zero Downtime Using Flyway 27.06.2026

In episode 76 of The Software Engineering Podcast, Lucas and Luna dive into the story of a senior engineer at a mid-sized e-commerce company who migrated a critical PostgreSQL database from a single instance to a replicated cluster without any downtime. The migration involved 200 GB of data, 50 tables, and a tight deadline. The engineer used Flyway for schema versioning, pglogical for replication,...

How One Engineer Rewrote a Legacy Database Without Downtime 26.06.2026

Episode 75 of The Software Engineering Podcast tells the true story of a senior engineer at a mid-sized logistics firm who migrated a 15-year-old PostgreSQL monolith to a sharded, horizontally-scalable architecture without a single minute of planned downtime. The project touched 4.3 million lines of trigger code and 2,800 stored procedures. By combining logical replication, a write-ahead log chang...

How One Engineer Debugged a Floating Point Bug That Cost a Drone Company $2 Million 26.06.2026

In this episode of The Software Engineering Podcast with Fexingo, Lucas and Luna dive into a real-world debugging nightmare: a floating-point precision bug in a drone navigation system that caused erratic flight patterns and led to $2 million in lost contracts. They break down the core issue — why 0.1 + 0.2 does not equal 0.3 in IEEE 754 binary floating-point representation — and walk through the...

How a Single Index Cut Query Time from Minutes to Milliseconds 25.06.2026

In this episode, Lucas and Luna dive into the story of how one database index — just one — turned a query that took over two minutes into a response that came back in under twenty milliseconds. They walk through the specific scenario: a PostgreSQL database on AWS RDS, a SaaS startup seeing page load times spike to critical levels, and the engineer who found the problem by examining the query plan....

How One Engineer Debugged a Memory Leak That Crashed Production Every 47 Days 25.06.2026

Lucas and Luna dive into the story of a senior engineer at a mid-sized fintech company who tracked down a mysterious production crash that struck like clockwork every 47 days. After weeks of false leads — suspecting everything from a rogue cron job to a cloud provider glitch — the engineer finally traced the root cause to a single static HashMap in a Java service that was caching user session data...

How One Engineer Optimised an API with Branch Prediction 24.06.2026

Episode 71 of The Software Engineering Podcast tells the story of a senior engineer who discovered that a single branch misprediction in a hot loop was causing a 35 percent latency spike on a critical API endpoint. The engineer used perf stat to identify the bottleneck, rearranged conditional logic to match common data patterns, and cut p99 latency from 200ms to 130ms. Lucas and Luna break down wh...

How One Engineer Fixed a Cache Poisoning Nightmare 24.06.2026

In this episode, Lucas and Luna dig into a real-world cache poisoning bug that took down a major e-commerce site for six hours during Black Friday. They walk through how a single engineer—backed by a small team—traced the root cause to a misconfigured CDN caching rule, then deployed a fix that cut page-load times by 70 percent while preventing future incidents. Along the way, they discuss cache ke...

How One Engineer Turned a Monolith Into Microservices Without Downtime 23.06.2026

Episode 69 of The Software Engineering Podcast with Fexingo dives into one of the most daunting infrastructure projects an engineer can face: decomposing a monolithic application into microservices while keeping the system live and serving users. Lucas and Luna walk through the story of a senior platform engineer at a mid-sized e-commerce company who spent eighteen months splitting a six-million-l...

Listen to the The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices podcast in Replaio

Radio and podcasts in one app - free, with no sign-up. Install today and do not miss the launch

Get it on Google Play

Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.