Backend stack

Backend podcast

Ten long-form episodes per stack: people who shipped real Backend software for messy human problems—inventory, bookings, tours, money, and the spreadsheets that came before. Each page has details, show notes, timestamps, a YouTube link, and a full transcript.

Backend episodes

6 episodes

Real-World Backend Boundaries: Patterns for Testing and Maintainability

#1: Real-World Backend Boundaries: Patterns for Testing and Maintainability

Real-World Backend Boundaries: Patterns for Testing and Maintainability

In this episode, we dive deep into backend architecture patterns that truly withstand the realities of growing teams and shifting requirements. Our guest, a seasoned backend architect, shares practical insights on establishing effective boundaries between services and modules, ensuring that testing strategies scale, and keeping systems maintainable over time. Listeners will learn how to spot and avoid architecture pitfalls that don’t survive real-world pressures, the importance of clear domain boundaries, and how to write tests that provide lasting value instead of becoming blockers. We explore stories from the trenches: what happens when boundaries blur, how to refactor legacy code without breaking everything, and why maintainability demands more than just good intentions. Whether you’re scaling a startup or wrangling a legacy enterprise system, this episode offers actionable lessons you can apply right away.

View Episode
Backend Performance Unplugged: Profiling, Bottlenecks, and Optimization Wins

#2: Backend Performance Unplugged: Profiling, Bottlenecks, and Optimization Wins

Backend Performance Unplugged: Profiling, Bottlenecks, and Optimization Wins

Today's episode pulls back the curtain on backend performance: how to actually profile complex systems, identify real-world bottlenecks, and implement optimizations that make a measurable impact. Our guest, a veteran backend engineer and performance tuning specialist, shares hard-won lessons from production environments, including common mistakes teams make when chasing performance and how to avoid misinterpreting metrics. We’ll break down the tools and processes that turn vague 'slow' complaints into actionable insights, and explore the trade-offs that come with every optimization. Expect practical case studies, honest debates about prioritization, and actionable techniques you can bring to your own backend codebase. Whether you’re wrangling monoliths or microservices, you’ll walk away with a sharper eye for diagnosing and improving system performance.

View Episode
Building Resilient APIs: Idempotency, Rate Limits, and Surviving Real-World Failures

#3: Building Resilient APIs: Idempotency, Rate Limits, and Surviving Real-World Failures

Building Resilient APIs: Idempotency, Rate Limits, and Surviving Real-World Failures

What does it take to design APIs that hold up under unpredictable traffic, unreliable networks, and integration chaos? In this episode, we dig into the nuts and bolts of backend integrations, focusing on the real-world challenges of idempotency, rate limiting, and gracefully handling failures. Our guest shares hard-won lessons from working on critical internal and external APIs, exploring where theory meets practice, and the subtle pitfalls teams often miss. We’ll untangle the concepts behind safe retries, preventing duplicate operations, and setting fair but effective rate limits. You’ll hear concrete strategies for monitoring, alerting, and evolving your contracts as your backend grows. Whether you’re building APIs for customers or for other teams, this conversation will sharpen your approach and help you ship more robust, predictable systems.

View Episode
Backend Security Pitfalls: Auth, Secrets, Supply Chain, and the Power of Defaults

#4: Backend Security Pitfalls: Auth, Secrets, Supply Chain, and the Power of Defaults

Backend Security Pitfalls: Auth, Secrets, Supply Chain, and the Power of Defaults

In this episode, we unpack the often-overlooked security pitfalls lurking in modern backend systems. From subtle authentication missteps to the risky management of secrets and the hidden dangers of third-party dependencies, we explore how real-world backend teams stumble—and succeed—in hardening their systems. Our guest, a seasoned backend engineer and security advocate, shares practical stories and lessons about avoiding false confidence, building safer defaults, and catching issues that slip past code reviews. You’ll learn actionable strategies for reducing attack surface, managing sensitive data, and navigating the tangled web of supply chain vulnerabilities. Whether you're maintaining a legacy monolith or scaling out microservices, this conversation reveals how attackers really break in—and how to stop them. Tune in for war stories, red flags, and security patterns you can actually use.

View Episode
Backend Operational Excellence: Monitoring, Incident Response, and Deployment Discipline

#5: Backend Operational Excellence: Monitoring, Incident Response, and Deployment Discipline

Backend Operational Excellence: Monitoring, Incident Response, and Deployment Discipline

What separates a reliable backend from one constantly firefighting outages? In this episode, we unpack how modern engineering teams achieve operational excellence by treating monitoring, incident response, and deployment discipline as first-class citizens. Our guest shares real-world stories of transforming backend reliability—exploring how to build actionable observability, avoid alert fatigue, and create a culture where deployments are boring and incidents are learning opportunities. We’ll dig into practical patterns for robust monitoring, runbooks that actually work, and the subtle ways deployment habits make or break uptime. Whether you’re scaling a new service or wrangling legacy systems, you’ll walk away with actionable insights to level up your team’s operational game.

View Episode
Avoiding Backend Rewrites: Data Modeling, Migration Mistakes, and Future-Proofing Strategies

#6: Avoiding Backend Rewrites: Data Modeling, Migration Mistakes, and Future-Proofing Strategies

Avoiding Backend Rewrites: Data Modeling, Migration Mistakes, and Future-Proofing Strategies

Why do so many backend teams end up rewriting core parts of their systems when it’s time to evolve the data model? This episode deep-dives into the hidden traps and crucial decisions around data modeling and schema migrations in backend projects. Our guest shares field-tested tactics for designing flexible models, planning smooth migrations, and avoiding costly technical debt that leads to painful rewrites. Listeners will learn how to spot migration red flags early, communicate data model changes across teams, and choose the right tools and patterns for evolving systems. We explore real-life stories of backend migration gone wrong—and what actually worked to fix them. Whether you’re building from scratch or inheriting legacy, this is your survival guide to backend data evolution.

View Episode

More Episodes by Stack