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

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

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

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

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

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

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

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

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

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

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

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

Episode 18 of The Software Engineering Podcast with Fexingo dives into the surprising power of a single linter rule. Lucas and Luna examine how a seemingly trivial ESLint configuration — no floating promises — caught a critical bug in a major e-commerce platform's checkout flow. They walk through the actual incident: how an unhandled promise rejection silently swallowed a payment confirmation call...

In this episode of The Software Engineering Podcast, Lucas and Luna dive into a notorious class of production bugs: concurrency issues that only surface under load. They explore a real-world case where a seemingly innocent sleep call caused intermittent failures in a high-throughput payment processing system. Lucas breaks down the root cause analysis, the debugging techniques that caught it, and t...

Lucas and Luna dig into a real-world case where a single engineer at a mid-size fintech company reduced their daily logging volume from 200 gigabytes to 20 gigabytes — slashing cloud storage costs by over 90% and cutting query times from minutes to seconds. They walk through the exact tactics used: structured logging with selective sampling, dropping DEBUG logs in production, removing duplicate fi...

When Spotify's engineering team hit a wall with their monolithic backend in 2014, they didn't just split it into microservices — they invented a new organizational model called squads, tribes, chapters, and guilds. In this episode, Lucas walks through how the music streaming giant used domain-driven bounded contexts to decouple their codebase, how they avoided the trap of distributed monoliths, an...

On-call burnout is a hidden crisis in software engineering. In this episode, Lucas and Luna explore how a senior engineer at a mid-sized SaaS company systematically reduced their team's on-call fatigue by 60 percent — without adding headcount or sacrificing reliability. They break down the specific changes: smarter alert routing, tiered escalation, a blame-free postmortem culture, and a simple das...

Episode 13 of The Software Engineering Podcast dives into a deceptively simple optimization: how a single engineer at a mid-size fintech company reduced their primary database's p99 latency from 200 milliseconds to under 40 milliseconds — without changing hardware, adding indexes, or touching application code. Lucas and Luna unpack the actual root cause: a misconfigured connection pool that was si...

Episode 12 of The Software Engineering Podcast explores the quiet power of structured logging. Lucas and Luna dissect a real incident at a mid-sized fintech company where a missing logline turned a routine database migration into a six-hour outage affecting 40,000 users. They explain why most teams treat logging as an afterthought, how the 'log-first, code-second' philosophy works in practice, and...

In episode 11 of the Software Engineering Podcast, hosts Lucas and Luna explore the rise of internal developer platforms, or IDPs. They break down why companies like Spotify, Uber, and Netflix built their own platforms to abstract away infrastructure complexity, and what that means for the rest of the industry. Lucas explains the 'paved road' concept, where a platform team provides golden paths fo...

Feature flags are everywhere in modern software — they let teams ship code incrementally, run A/B tests, and kill broken features instantly. But when a Black Friday traffic spike hit a major fintech company's checkout pipeline in 2025, a single misconfigured flag caused a 43-minute outage that cost two point three million dollars in lost transactions. Lucas and Luna break down exactly what happene...

In this episode of The Software Engineering Podcast, Lucas and Luna dive into the real cost of choosing a monorepo over a multirepo strategy. They break down a case study where one infrastructure engineer at a mid-sized SaaS company saved $3 million annually by consolidating 47 separate repositories into one monorepo. Lucas explains how the change reduced CI/CD overhead, eliminated dependency drif...

Lucas and Luna dive into the hidden cost of excessive logging in production systems. Using a real-world case of a fintech startup that accidentally burned $2.3 million per year on unnecessary log storage and processing, they break down the three types of log waste: noisy logs, oversized payloads, and retention overreach. They explain how structured logging with selective sampling, dynamic log leve...

In this episode of The Software Engineering Podcast, Lucas and Luna dig into the true cost of technical debt, using the real-world example of a mid-sized fintech company that let its codebase rot for three years. They break down how the company's decision to prioritize features over refactoring led to a 40% increase in development time for new features, a 60% rise in bug rates, and ultimately a fa...

Episode 6 of The Software Engineering Podcast digs into tail latency — the hidden performance problem that makes APIs unpredictably slow. Lucas and Luna walk through how a single backend team at a mid-size fintech discovered that 99th-percentile response times were spiking to 3 seconds every afternoon, even though p50 stayed under 100ms. They explain what causes tail latency at the system level —...

Lucas and Luna break down the case of a 12-engineer team at a mid-sized SaaS company that systematically shaved 91 percent off their continuous integration pipeline time. They walk through the three specific changes that made the biggest dent: parallelizing test suites by dependency graph, caching Docker layers at the right granularity, and replacing a brittle end-to-end test suite with contract t...