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 Optimized Postgres Vacuum Without Downtime 02.08.2026

In this episode, Lucas and Luna dig into a real-world Postgres performance crisis: a table with 200 million rows where autovacuum couldn't keep up, causing bloat and query slowdowns. They walk through how one engineer diagnosed the issue using pg_stat_user_tables, tuned vacuum and autovacuum settings, and introduced a custom vacuuming schedule using pg_cron — all without a single minute of downtim...

How SQLite Powers Billions of Devices 01.08.2026

SQLite is the most widely deployed database engine on the planet, quietly running inside every smartphone, most web browsers, and countless embedded systems. In this episode, Lucas and Luna explore how a single small C library became the backbone of modern computing without most users ever knowing it exists. They break down SQLite's unique architecture, its conservative engineering philosophy, and...

How Contract Testing Prevented Microservices Breaking Changes 30.07.2026

When a fintech team with 15 microservices was spending 20 hours per week on regression testing just to avoid breaking downstream consumers, they turned to consumer-driven contract testing with Pact. In this episode, we break down how they shifted ownership of API contracts to the consumers, automated verification in CI, and reduced production incidents by 40 percent. We also explore the practical...

How OpenTelemetry Traced a Request Across 12 Microservices 30.07.2026

In this episode, we follow Priya, a senior engineer at a fintech startup, who used OpenTelemetry to instrument a distributed tracing system across 12 microservices. She identified a 400ms latency bottleneck caused by a misconfigured connection pool in a third-party payment API, reducing mean time to debug from hours to under five minutes. We break down how she set up trace propagation, sampled int...

How One Engineer Cut Test Suite Time by 90 Percent 29.07.2026

In this episode, Lucas and Luna dive into a common but painful problem: a test suite that takes 45 minutes to run, blocking CI and slowing developers to a crawl. They walk through how one engineer at a fintech startup, Finlytics, tackled this by implementing intelligent test splitting. The key idea was to use historical timing data for each test file and distribute them evenly across parallel CI r...

How One Engineers Post-Mortem Cut Incident Recurrence by 80 Percent 29.07.2026

In this episode of The Software Engineering Podcast, Lucas and Luna explore the anatomy of an effective post-mortem through a real-world example from a fintech company. They dissect a database replication lag incident that caused partial service degradation, walk through the five whys analysis, timeline reconstruction, and the action items that emerged. Lucas explains how the engineering team used...

How Property-Based Testing Caught Invisible Bugs 28.07.2026

Episode 137 of The Software Engineering Podcast dives into property-based testing — a technique that automatically generates thousands of edge-case inputs to find bugs that unit tests miss. Lucas and Luna examine a real-world case: an engineer at a fintech startup used the Hypothesis library to uncover a rounding error in a transaction system that would have cost customers pennies over millions of...

How One Engineer Automated Dependency Updates Without Breaking the Build 28.07.2026

In this episode, Lucas and Luna explore how a single engineer at a mid-sized SaaS company transformed a chaotic dependency update process into a streamlined, automated pipeline. Facing 150 pull requests per week from their bot, the engineer introduced grouping by update type, pre-merge testing, canary deployments, and automated conflict resolution. The result: just 15 PRs per week, zero production...

How One Team Reduced a 40 Percent Defect Rate Through Targeted Refactoring 27.07.2026

Technical debt can slowly cripple a codebase. In this episode, Lucas and Luna dive into a real-world case where a fintech company's legacy billing module had a staggering 40 percent defect rate. They explore how the team used defect clustering to identify the highest-impact refactoring targets, employed feature flags to roll out changes incrementally, and built a robust automated test suite that t...

How Chaos Engineering Prevented a Black Friday Meltdown 27.07.2026

In this episode, we dive into how one engineer at a major e-commerce company used chaos engineering to prevent a catastrophic Black Friday outage. By intentionally injecting failures into their payment processing service, they discovered a critical retry bug that would have caused a cascading failure under peak load. We walk through the specific experiments they ran, the circuit breaker pattern th...

Using Structured Logging to Slash Debug Time by Hours 26.07.2026

In this episode, Lucas and Luna break down how engineering teams can dramatically reduce incident response time by adopting structured logging. They recount a real-world incident at a major e-commerce platform where a single payment failure took four hours to debug because logs were scattered plain text. Then they walk through the fix: adding JSON-formatted logs, correlation IDs, and centralized a...

How One Engineer Used Feature Flags to Migrate a Core Service Without Downtime 26.07.2026

In early 2026, a major European payments platform needed to replace its aging authentication service — the single most critical path in its infrastructure, handling over 50 million requests daily. The lead engineer, Maya, designed a migration strategy built entirely around feature flags and automated canary analysis. She used a centrally managed flag to route a tiny fraction of live traffic to the...

How Stripe Masters API Versioning Without Breaking Clients 25.07.2026

In episode 131 of The Software Engineering Podcast, Lucas and Luna examine Stripe's developer-friendly approach to API versioning. They break down how the company uses dated API versions, a single `Stripe-Version` header, and a rigorous changelog to allow thousands of clients to upgrade at their own pace without breaking production. The conversation covers the engineering behind versioned middlewa...

How One Engineer Reduced a Pipeline from 6 Hours to 4 Minutes with Delta Lake 24.07.2026

In this episode, Lucas and Luna dive into a real-world data engineering case study: how one engineer at a mid-size e-commerce company slashed a daily ETL pipeline from six hours to just over four minutes. The secret was migrating from a legacy Parquet-on-S3 setup to Delta Lake with incremental processing and Z-ordering. Lucas breaks down the technical decisions—why vanilla Parquet caused a 40-minu...

How One Engineer Reduced a Docker Image from 2GB to 55MB 23.07.2026

In episode 129 of The Software Engineering Podcast, Lucas and Luna dive into a real-world Docker image optimization story. A backend team at a mid-sized fintech startup was pushing a 2GB container to production — causing five-minute deploy times and massive storage costs. One engineer, Sarah Chen, spent a week systematically shaving off layers: switching from Ubuntu to Alpine Linux, using multi-st...

How to Debug Slow Queries with Flame Graphs 23.07.2026

In this episode of The Software Engineering Podcast, Lucas and Luna dive into the practical use of flame graphs for diagnosing slow database queries. They walk through a real case where a Node.js service was timing out, and how a senior engineer used a flame graph to pinpoint the bottleneck—a missing index that caused a full table scan on a 10-million-row table. The conversation covers when to use...

How an Off-by-One Error Caused a Silent Data Corruption Bug 22.07.2026

Episode 127 of The Software Engineering Podcast dives into a notorious class of bugs: off-by-one errors. Lucas and Luna explore a real-world case where a single misplaced increment in a C++ memory allocator silently corrupted data for months before discovery. They trace how the bug passed code review, evaded unit tests, and ultimately required a formal verification tool to catch. Along the way, th...

How One Engineer Shrunk an AWS Bill by 40 Percent Using Spot Instances 22.07.2026

In this episode of The Software Engineering Podcast, Lucas and Luna break down a real-world engineering win: how a single engineer at a mid-size SaaS company used AWS spot instances and intelligent fallback logic to cut the company's cloud bill by 40 percent—saving over $200,000 a year—without sacrificing reliability. They walk through the technical architecture: how the engineer set up a spot-fle...

How One Engineer Optimized an API with Connection Pooling 21.07.2026

In this episode of The Software Engineering Podcast, hosts Lucas and Luna dive into a single, high-impact optimization: connection pooling. Lucas shares the story of an engineer at a mid-sized SaaS company who reduced API latency by 40 percent and cut database load by half just by tuning the connection pool settings. They break down what connection pooling is, the common misconfigurations that cau...

How One Team Fixed a GDPR Data Deletion That Took 72 Hours 21.07.2026

When a European user requested their data be deleted under GDPR, a fintech startup's automated pipeline triggered a 72-hour cleanup that accidentally removed records from shared analytics clusters, breaking dashboards for three teams. This episode follows engineer Amara Okonkwo as she traces the damage to a cascading delete trigger in a Postgres schema that didn't account for foreign-key relations...

How One Engineer Fixed a Quorum Read Slowdown in CockroachDB 20.07.2026

In this episode, Lucas and Luna dive into a real-world debugging story: a production CockroachDB cluster that suddenly slowed to a crawl during a minor version upgrade. The root cause was an unexpected quorum read pattern triggered by a changed default setting. Lucas explains how distributed database reads work, why quorum reads are usually fast, and how one engineer traced the slowdown to a singl...

How One Hotfix Caused a Production Outage and What We Learned 20.07.2026

In this episode, Lucas and Luna recount a real incident where a seemingly harmless one-line hotfix took down a critical microservice for 40 minutes. They walk through the chain of events: a developer rushing a fix for a non-critical bug, skipping the peer review process, and accidentally deploying a change that triggered a cascading failure in an upstream service. They discuss why hotfixes are so...

How One Engineer Migrated 10 Million Database Records Without Downtime 19.07.2026

In this episode, Lucas and Luna dive into a real-world case where a single engineer at a mid-sized e-commerce company migrated over 10 million database records from a legacy MySQL setup to a new PostgreSQL cluster without a second of downtime. The episode walks through the specific strategy used: a dual-write pattern with a backfill worker, careful consistency checks at each stage, and a gradual t...

How One Engineer Cut Storage Costs by 60 Percent Using Tiered Compression 19.07.2026

In episode 120, Lucas and Luna dive into a real-world storage optimization story: how a senior engineer at a mid-sized e-commerce company reduced S3 costs by 60% without sacrificing query performance. They unpack the specific trade-offs between compression algorithms (Zstandard vs. Gzip), the role of data temperature tiers, and the surprising lesson about hot data that didn't need to be hot. No th...

How One Engineer Fixed a Cascading Cache Stampede 18.07.2026

In episode 119 of The Software Engineering Podcast, Lucas and Luna dive into a specific production incident: a cascading cache stampede that took down a major e-commerce checkout flow. They walk through how a single senior engineer diagnosed the problem — thousands of concurrent cache misses hammering an origin database — and implemented a probabilistic early-expiration strategy using jitter. The...

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.