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 One Engineer Cut Test Suite Runtime by 80 Percent with Property Based Testing 10.06.2026

Episode 43 of The Software Engineering Podcast explores how property-based testing can dramatically reduce test suite execution time while catching edge cases that traditional example-based tests miss. Lucas and Luna walk through a real case where a senior engineer at a fintech startup replaced thousands of brittle unit tests with a handful of property-based tests, cutting the CI pipeline from 45...

How One Engineer Reduced Incident Response with a Custom Chaos Engineering Tool 10.06.2026

In this episode of The Software Engineering Podcast, Lucas and Luna dive into chaos engineering — but not the abstract kind. They focus on a specific story: how a senior engineer at a mid-sized e-commerce company built a lightweight chaos simulation tool from scratch after existing solutions proved too heavy for their team. The tool intentionally injects latency into specific microservices during...

How One Engineer Transformed a Legacy Monolith into Microservices Without Downtime 09.06.2026

Luna and Lucas explore the story of how a single engineer at a mid-sized e-commerce company migrated a 15-year-old monolithic Java application to microservices over 18 months. The key? A strangler fig pattern that routed traffic incrementally, zero-downtime deploys using feature flags, and a custom gateway that handled the transition. They break down the specific techniques: how the engineer ident...

How One Engineer Reduced a Monorepo CI Pipeline to 8 Minutes 09.06.2026

Episode 40 of The Software Engineering Podcast dives into monorepo CI optimization. Lucas and Luna explore how a single engineer at a mid-sized tech company slashed continuous integration from 45 minutes to under 8 minutes by implementing incremental builds and dependency caching. They break down the specific techniques: Bazel-style action caching, remote caching with a shared Redis store, and a c...

How a Single Feature Flag Prevented a Five-Hour Outage 08.06.2026

In this episode, Lucas and Luna dive into the story of a fintech startup that avoided a catastrophic outage during a critical payment system migration — thanks to a single feature flag. They break down how the engineering team used a kill switch to gradually roll out a new database schema, caught a silent data corruption bug in the canary phase, and toggled back to the old system in under 90 secon...

How One Engineer Automated Code Review with a Custom Static Analysis Tool 08.06.2026

In this episode, Lucas and Luna explore how a single engineer at a mid-size SaaS company built a custom static analysis tool that automated 80% of code review comments. They break down the specific rules the tool enforced, how it was integrated into the CI pipeline, and the surprising cultural pushback the engineer faced. The episode includes a real-world example: a rule that caught unnecessary da...

How One Engineer Cut Incident Response from Hours to Seconds with a Runbook 07.06.2026

Episode 37 of The Software Engineering Podcast with Fexingo dives into a specific operational win: how a senior engineer at a mid-size fintech company automated incident response runbooks, slashing mean time to resolution from over two hours to under thirty seconds. Lucas and Luna walk through the before-and-after — the chaotic Slack threads, the manual playbook that lived in a Google Doc, and the...

How a Single Bit Flip Brought Down an Entire Data Center 07.06.2026

In episode 36 of The Software Engineering Podcast with Fexingo, Lucas and Luna dive into one of the most infamous hardware-induced software bugs in recent memory: the 2021 Facebook outage caused by a single bit flip. Lucas explains how a routine configuration change triggered a cascading failure that took down Facebook, Instagram, and WhatsApp for over six hours. He walks through the exact sequenc...

How One Engineer Slashed Build Times from 40 Minutes to 90 Seconds 06.06.2026

In this episode of The Software Engineering Podcast, Lucas and Luna dive into the story of a senior engineer at a mid-size SaaS company who cut their CI build pipeline from 40 minutes to 90 seconds. They walk through the specific bottlenecks: a monolithic Gradle build with unnecessary task dependencies, Docker layers being rebuilt on every commit, and a test suite that ran sequentially. The fix wa...

How One Engineer Cut Docker Image Size by 90 Percent 06.06.2026

Episode 34 of The Software Engineering Podcast with Fexingo dives into a practical optimization story: how one engineer at a mid-sized SaaS company shrank a bloated Docker image from 2.1 GB to just 210 MB. Lucas and Luna walk through the specific techniques used — from switching to Alpine base images to eliminating layer bloat with multi-stage builds and removing unnecessary packages. They discuss...

How One Engineer Refactored a 10 Year Old Codebase in Six Weeks 05.06.2026

Episode 33 of The Software Engineering Podcast with Fexingo. Lucas and Luna dive into the story of a senior engineer who inherited a monolithic ten-year-old codebase with zero tests and a single deployment causing multi-hour outages. Over six weeks, they systematically added integration tests, extracted domain modules, and built a CI pipeline that cut deployment failures by 90 percent. The episode...

How One Engineer Prevented a Deletion Cascade with a Soft Delete 05.06.2026

In this episode, Lucas and Luna dive into a near-disaster at a mid-sized SaaS company where a single engineer prevented a cascading data loss by implementing a soft delete pattern. They walk through the specific scenario: a misconfigured database trigger that would have wiped thousands of customer records during a routine cleanup. The engineer's decision to use a tombstone column and a scheduled p...

How a Single Consistent Hashing Change Prevented a Cascade Failure 04.06.2026

In this episode of The Software Engineering Podcast, Lucas and Luna dive into a real-world case of consistent hashing preventing a production cascade failure. They break down how one engineer at a major streaming platform rearchitected a cache layer to avoid the thundering herd problem, reducing p99 latency spikes from 12 seconds to under 200 milliseconds during a regional outage. The conversation...

How One Team Cut Cloud Costs by 60 Percent with a FinOps Strategy 04.06.2026

In this episode of The Software Engineering Podcast, Lucas and Luna dive into the practical world of FinOps — cloud financial operations. They explore how a mid-size SaaS company called DataNest slashed its AWS bill by 60 percent in just six months. Lucas breaks down the specific tactics: moving from on-demand to reserved instances, implementing automated right-sizing policies, and building cost-a...

How One Engineer Reduced AWS Costs by 70 Percent with Spot Instances 03.06.2026

In this episode, Lucas and Luna explore how a single engineer at a mid-sized fintech company slashed their AWS bill by 70 percent—over $2 million annually—by migrating stateless workloads to spot instances. They break down the technical strategy: designing for interruption tolerance using checkpointing and distributed queues, setting up a spot-fleet mix across instance types and availability zones...

How a Two-Character Typo Exposed 50 Million User Records 03.06.2026

In this episode, Lucas and Luna dissect a real-world data breach that stemmed from a simple two-character typo in an access control file. They walk through how a missing 'not' in an AWS S3 bucket policy left 50 million user records exposed for months. Lucas explains the technical details of the misconfiguration, how it was discovered by a security researcher, and the cascading consequences for the...

How One Engineer Turned a Flaky Test into a Daily Reliability Report 02.06.2026

Flaky tests are the bane of every CI pipeline — they waste developer time, erode trust in test suites, and can hide real regressions. In this episode, Lucas and Luna dive into the story of one engineer at a mid-size fintech company who got so fed up with a single notoriously flaky end-to-end test that she built a lightweight daily reliability report. They walk through the specific data she tracked...

How a Single Test Case Caught a Million-Dollar Bug 02.06.2026

In this episode, Lucas and Luna unpack a real-world story from a payments startup where one obscure test case — a $0 transaction — exposed a rounding error that would have lost the company over a million dollars annually. They discuss how the bug survived code review, unit tests, and staging, only to be caught by a junior engineer's curiosity during edge-case testing. The conversation covers test...

How One Engineer Used Regression Testing to Prevent a Production Outage 01.06.2026

In this episode, Lucas and Luna explore how one engineer at a mid-size SaaS company used regression testing to prevent a catastrophic production outage. The engineer, Sarah Chen, implemented a focused automated regression suite that caught a subtle bug in a payment processing module before it hit production. Lucas breaks down the specific techniques Sarah used: prioritizing high-risk test cases, i...

How One Engineer Cut Database Queries by 95 Percent with a Cache 01.06.2026

In this episode, Lucas and Luna explore a specific case where a single engineer reduced database query volume by 95 percent by implementing a carefully designed caching layer. They walk through the before-and-after: a SaaS platform serving 50,000 daily users was hitting its Postgres database over 1,000 times per second during peak hours, causing latency spikes and near-daily connection pool exhaus...

How to Say No as a Software Engineer 31.05.2026

Episode 23 of The Software Engineering Podcast. Lucas and Luna explore the underrated skill of saying 'no' in engineering culture. Drawing on a real case from a mid-size SaaS company where a lead engineer saved 400 engineering hours per quarter by pushing back on a misguided feature request, they discuss the psychology of agreement bias, how to frame rejections around business goals, and one concr...

How One Engineer Cut Average Incident Response Time with a ChatOps Bot 31.05.2026

In this episode, Lucas and Luna explore how a single engineer at a mid-sized fintech company built a ChatOps bot that cut average incident response time from 45 minutes to under 8. They walk through the specific architecture: a Slack bot listening on a dedicated channel, a simple runbook lookup using a vector database, and an automated escalation pipeline that pings the right on-call engineer base...

How an Intern Fixed a 3AM Production Database Deadlock 30.05.2026

In this episode, Lucas and Luna unpack a specific production incident: a PostgreSQL deadlock that brought down a mid-sized SaaS platform every night at 3 AM for three weeks. They trace the root cause—an overlooked index on a foreign key column—and walk through how a summer intern identified the problem using pg_locks and a custom logging script. Along the way, they discuss why database deadlocks a...

How One Engineer Cut CSS Bundle Size by 80 Percent 30.05.2026

In this episode, Lucas and Luna explore how one frontend engineer at a mid-size e-commerce company shrank their CSS bundle from 2.4 megabytes to under 500 kilobytes — without losing any design fidelity. They walk through the specific techniques used: auditing unused styles with PurgeCSS, extracting critical CSS inline, and switching to utility-first classes with Tailwind. The episode breaks down t...

How One Engineer Cut Tech Onboarding From Weeks to Days 29.05.2026

In this episode of The Software Engineering Podcast, Lucas and Luna explore how one senior engineer at a mid-size fintech company slashed new-hire onboarding time from three weeks to three days. They break down the specific tactics used: a self-service environment provisioning system, a curated 'day one' commit that walks through the full deploy pipeline, and a living runbook that evolves with eve...

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.