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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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