Fexingo
The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices
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
Where to listen?
Podcasts in the app Replaio Radio Coming soonPodcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts
Episodes
How One Engineer Cut CSS Bundle Size by 80 Percent 30.05.2026 10:49
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 10:12
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...
How a Simple Linter Rule Prevented a Million Dollar Outage 29.05.2026 10:50
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...
How One Engineer Debugged a Sleep Bug in Production 28.05.2026 6:45
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...
How One Engineer Shrank a 200GB Logging Bill to 20GB 28.05.2026 8:10
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...
How Spotify Unbundled the Monolith into Microservices 27.05.2026 9:36
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...
How One Engineer Cut Their On-Call Fatigue by 60 Percent 27.05.2026 8:21
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...
How One Engineer Cut Database Latency by 80 Percent 26.05.2026 6:45
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...
How a Simple Logline Prevented a Production Disaster 26.05.2026 8:43
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...
How Big Tech Standardized on Internal Developer Platforms 25.05.2026 14:00
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...
How a Feature Flag Almost Broke Black Friday 25.05.2026 8:49
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...
How One Enigneer's Monorepo Decision Saved Three Million Dollars 24.05.2026 10:48
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...
Why Your Logging Strategy Is Costing You Millions 24.05.2026 5:58
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...
The Hidden Cost of Tech Debt in Your Codebase 23.05.2026 8:29
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...
Why Your API Is Slower at 3 PM Than at 3 AM 23.05.2026 9:05
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 —...
How One Team Cut Their CI Pipeline From 45 Minutes to 4 22.05.2026 9:43
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...
How One Engineer Cut Cloud Costs by 90 Percent 22.05.2026 11:40
Episode 4 of The Software Engineering Podcast dives into a specific case: Sarah Chen, a senior infrastructure engineer at a mid-size SaaS company, reduced her team's monthly AWS bill from $47,000 to $4,700 over six months. Lucas and Luna unpack the concrete steps she took — right-sizing instances, switching to spot instances, implementing auto-scaling policies, and deleting orphaned resources. The...
How One Tech Lead Cut Incident Response Time by 70 Percent 21.05.2026 8:30
In this episode of The Software Engineering Podcast, Lucas and Luna dive into a single operational decision that transformed a team's incident response. They examine how a senior engineer at a mid-size e-commerce company introduced structured severity levels, a dedicated on-call escalation channel, and a lightweight postmortem culture. The result: mean time to acknowledge alerts dropped from 12 mi...
Why Your Code Review Is Slower Than It Should Be 21.05.2026 9:51
Lucas and Luna examine why code reviews take so long, drawing on a 2020 study of Google's internal review process that found a median first-response time of 4.5 hours. They break down the cognitive cost of context switching, the difference between synchronous and asynchronous review, and practical techniques like review slop and size limits that teams at companies like Shopify and Netflix use to c...
The One Hundred Million Dollar Bug 19.05.2026 8:44
Lucas and Luna launch their new podcast by dissecting a single infamous software bug — the 2018 Knight Capital trading glitch that cost $440 million in 45 minutes. They unpack how a missing line of code, a flawed deployment process, and a weak rollback plan turned a routine upgrade into one of the most expensive rollouts in history. Along the way, they explain what 'idempotency' means, why unit te...
Similar podcasts
Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.