Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering
This podcast treats software testing as a strategic engineering discipline rather than a box-ticking exercise. Hosts Lucas and Luna devote each episode to a specific practice, covering unit test coverage metrics, integration test design patterns, the economics of test automation ROI, and the psychology of flaky test triage. They work through real-world case studies such as contract testing at Stripe, the trade-offs between Selenium and Cypress for e-commerce checkouts, and Google's small/medium/large test size taxonomy. The show also digs into mutation testing scores, the diminishing returns of 100% code coverage, shift-left versus shift-right approaches, risk-based prioritization, and the role of AI in generating test oracles. Listeners come away with concrete frameworks and heuristics for judging a test suite's health, deciding when to kill a test, and building a QA career path that keeps growing.
Episodes
How Software Teams Fix Bugs Without Blaming Developers
Most engineering teams treat bugs as individual failures, leading to blame games and hidden costs. This episode examines the 'no-blame postmortem' model pioneered by Netflix and adopted by high-performing teams like Datadog. We look at how shifting from punitive measures to systemic analysis reduces repeat errors by up to forty percent. Lucas and Luna break down the specific metrics that matter—li
How Teams Stop Testing From Becoming The Bottleneck
Most engineering teams treat testing as a gatekeeper rather than an enabler, creating delays that slow down deployment cycles and frustrate developers. In this episode of Software Testing with Fexingo, Lucas and Luna explore how leading organizations are shifting from manual QA bottlenecks to integrated quality ownership. We look at the specific operational friction caused by traditional test envi
How Chaos Engineering Prevents Silent Failures
We talk about how chaos engineering moves beyond simple uptime checks to test the resilience of distributed systems under stress. We examine how Netflix pioneered this approach and why modern teams need to inject failure into their infrastructure before users do. We explore the hidden costs of silent failures, the role of game days, and the psychological shift required to embrace controlled destru
How GitHub Copilot Changed Developer Quality
We examine the unexpected rise of AI-assisted code quality in modern engineering teams, focusing on how tools like GitHub Copilot are shifting QA responsibilities. By looking at specific data from October 2026, we explore why automated test generation is becoming the new bottleneck for software reliability and what it means for your career.
#SoftwareTesting #AIAssistedCoding #GitHubCopilot #Quali
How CI Pipelines Became The New Production Environment
Most engineering teams treat continuous integration pipelines as a gatekeeping mechanism, a necessary evil to check code before it hits production. But what if the pipeline itself is the primary environment where software quality is actually determined? We explore how leading tech organizations are shifting from validation-focused testing to simulation-driven development within their CI/CD workflo
Why Most Software Tests Are Just Expensive Noise
Lucas and Luna dig into the hidden cost of slow, brittle test suites that stall deployment pipelines. They examine how a mid-sized fintech startup reduced its build time from forty-five minutes to under five by killing redundant integration tests and embracing contract testing between services. The conversation covers why teams cling to flaky end-to-end tests for comfort rather than speed, the spe
How Figma Prevented UI Collapse
This week we look at how design-to-code handoffs break when engineering teams treat visual prototypes as final specifications. We examine a specific case where a major e-commerce platform nearly lost mobile conversion rates because their QA team tested the interface against static screenshots instead of the live component library. You will learn why shadow testing in production is the only way to
Why Your Best Testers Are The Weakest Link
We explore the paradox of manual testing in modern software engineering, using a specific case from a mid-sized fintech startup that lost eighteen months to human error. Lucas and Luna break down why automation alone cannot fix process failures, and how leading teams are redesigning their QA workflows to account for cognitive load, fatigue, and the hidden costs of context switching. This episode o
How Data Contracts Prevent Integration Breakdowns
This week we look at how modern data pipelines fail not because of bad code, but because of broken assumptions about what the data actually looks like. We explore the rise of data contracts as a formal agreement between producers and consumers, using a specific case study of a major fintech company that avoided a six-hour outage by enforcing schema validation early. Lucas breaks down why tradition
How Stripe Uses Shadow Testing To Prevent Outages
We look at how Stripe employs shadow testing to validate code changes against real traffic without risking customer transactions. This episode breaks down the mechanics of mirroring requests, comparing outputs, and using these insights to reduce deployment anxiety. We discuss why traditional regression tests are insufficient for complex payment infrastructure and how shadowing provides a safety ne
How Netflix Built Chaos Engineering
In October 2026, reliability engineering has moved beyond static checklists into active disruption. This episode examines how Netflix pioneered Chaos Engineering to test system resilience before customers ever notice a failure. We look at the specific metrics teams use to define a successful chaos experiment, why shadow testing alone isn't enough for critical infrastructure, and how modern softwar
Why Your Software Tests Fail When Humans Break Rules
Most testing frameworks assume users behave rationally. They don't. We look at how leading engineering teams are shifting from rigid validation to chaos engineering principles that anticipate human error, using real-world examples of how unpredictable user behavior breaks even the most robust codebases.
#SoftwareTesting #ChaosEngineering #HumanError #QAStrategy #TechEngineering #UserBehavior #Fex
The Hidden Cost of Slow Tests in Software Teams
Most engineering leaders think their CI pipeline is fast enough, but a ten-minute build time can silently kill developer velocity and morale. This episode dissects how slow test suites create hidden bottlenecks, using the example of a mid-sized fintech firm that cut its feedback loop from forty minutes to three by parallelizing infrastructure. We explore why speed matters more than coverage in ear
How Microsoft Fixed Its Bug Bounty Program
Lucas and Luna dig into why Microsoft rewrote its entire bug bounty rules in 2024, shifting from rigid scope lists to dynamic risk-based payouts. They break down how this change reduced false positives by thirty percent and increased high-severity submissions from independent researchers. The conversation explores the operational cost of managing thousands of daily reports and why treating securit
How Stripe Prevented a Catastrophic UI Collapse
We look at the specific architecture decision Stripe made in early twenty twenty four to solve the 'UI collapse' problem, where backend stability masked frontend fragility. By implementing strict data contracts and real-time validation layers before rendering, they reduced customer support tickets by thirty-two percent. This episode breaks down how that technical shift changed their engineering cu
How Stripe Prevented a Catastrophic UI Collapse
In September 2026, Stripe engineers faced a quiet crisis: their automated testing suite was passing one hundred percent while customers reported broken checkout flows. This episode explores how they abandoned brittle visual regression tests in favor of behavioral contract testing and synthetic user journeys. We break down the specific architecture shift that caught a critical payment API mismatch
Why Most Software Tests Are Just Expensive Noise
In this episode, Lucas and Luna dissect the growing crisis of 'test noise' in modern software engineering. They examine why teams spend millions maintaining test suites that report more false positives than actual bugs, using a deep dive into how leading fintech firms are shifting from broad coverage metrics to precise failure signal analysis. The hosts explore the specific mechanics of flaky test
Why Software Testing Fails When Engineers Ignore Human Error
We examine the recent critical failure at CloudScale, a mid-sized SaaS provider, where automated tests passed but production collapsed due to untested human workflows. The incident reveals a blind spot in modern QA: we automate everything except the people who click buttons. We break down how manual intervention protocols are becoming the new regression testing ground, and why relying solely on CI
Why Software Teams Ignore Legacy Code Until It Breaks
Most engineering leaders treat legacy code as a sunk cost, ignoring it until a critical failure forces a rewrite. This episode examines how Microsoft’s internal strategy for refactoring decades-old infrastructure changed their approach to technical debt. We look at the specific decision points that separate successful modernization from costly failures, using real examples from enterprise software
How Figma Prevented a Catastrophic UI Collapse
In this episode, we examine the hidden engineering crisis behind modern design-to-code workflows. While previous episodes covered testing AI and shadow mode, today we drill into a specific case study of how a major SaaS platform discovered that their automated UI regression suite was fundamentally broken by dynamic component libraries. We explore the concept of visual diffing versus structural val
How Data Contracts Prevent Integration Breakdowns
We examine the rise of data contracts as a preventive measure for modern software architecture. By treating data schemas like legal agreements between services, teams can catch mismatches before code ships. We look at how companies are using automated validation to stop integration failures and reduce debugging time in complex distributed systems.
#SoftwareEngineering #DataContracts #APIIntegrati
Why Shadow Testing Beats Feature Flags
Most teams use feature flags to toggle new code on and off in production. But what if you could test that same code without ever changing the user experience? In this episode, we dive into shadow testing—a technique where traffic is mirrored to a parallel system for validation without affecting the live path. We look at how major infrastructure teams use this approach to catch regressions before t
How Figma Prevented a Catastrophic UI Collapse
Lucas and Luna break down the specific engineering decisions behind Figma’s 2021 outage, focusing on how their dependency graph architecture created a single point of failure. They explore why visualizing software dependencies is critical for modern tech teams and discuss the shift from reactive debugging to proactive structural resilience. The conversation covers practical steps for mapping your
How Microsoft Fixed Its Bug Bounty Program
Microsoft's shift from a closed, invite-only security program to an open, global bug bounty platform fundamentally changed how enterprise software is secured. In this episode of Software Testing with Fexingo, Lucas and Luna explore the specific mechanics of that transition, the cultural friction it caused within engineering teams, and the measurable impact on vulnerability response times. They exa
How Stripe Built Resilient Payment Infrastructure
We break down how Stripe engineered its payment gateway to handle millions of transactions per second without dropping a single dollar. It is not just about speed, it is about the invisible architecture of idempotency keys and distributed tracing that prevents duplicate charges during network outages. Lucas and Luna examine the specific engineering decisions that turned a simple checkout button in
How GitHub Copilot Changed Software Engineering
We examine how GitHub Copilot reshaped daily coding workflows in 2026. Lucas and Luna discuss the shift from manual testing to AI-assisted validation, using concrete examples of how teams handle hallucinated code and maintain quality without breaking production.
#FexingoBusiness #BusinessPodcast #SoftwareTesting #AICoding #GitHubCopilot #QualityAssurance #Automation #DeveloperProductivity #TechTr
How Microsoft Fixed Its Bug Bounty Program
In this episode, Lucas and Luna dissect how Microsoft transformed its security posture by overhauling the Microsoft Bug Bounty program. They explore the specific mechanics of responsible disclosure, the financial incentives that drive ethical hackers, and why transparent bug tracking matters more than raw numbers. With insights into how a tech giant handles vulnerability reports from thousands of
The Hidden Cost of Test Debt in Software Teams
We break down the concept of test debt — the accumulated shortcuts and brittle tests that silently slow down engineering velocity. Using a hypothetical mid-sized fintech team as our anchor, Lucas and Luna explore how ignoring small testing compromises leads to major production failures. We discuss the metrics that reveal test decay, the cultural pressure to ship fast versus test thoroughly, and pr
How to Test AI Without Breaking Trust
Most teams treat AI model testing like traditional QA, but hallucinations and drift require a different playbook. Lucas and Luna explore the specific challenge of validating large language models in production environments. They discuss why standard unit tests fail when dealing with probabilistic outputs and examine real-world cases where companies missed critical safety guardrails. The conversati
Why Your Software Testing Strategy Is Broken
Lucas and Luna dissect the 'Testing Tax' — the hidden operational drag caused by maintaining test suites that grow faster than the codebase. They explore how Microsoft’s approach to flaky test quarantine and Netflix’s chaos engineering reveal a structural flaw: we are optimizing for coverage, not confidence. The conversation drills into specific metrics like mean time to recovery and the opportuni
Why Your Regression Tests Are Lying To You
Lucas and Luna dissect the silent killer of modern software quality: false positive test results. Using a hypothetical fintech scaling scenario, they explore how brittle assertions in regression suites mask real defects until production fails. The episode argues that confidence scores are replacing binary pass/fail metrics as the new standard for reliable deployment pipelines. Listeners will learn
Testing the Invisible Layers of Modern Software
We look at the hidden cost of invisible software failures, focusing on how dependency injection and interface contracts create brittle systems when left untested. Lucas and Luna break down a specific case where a payment gateway's abstract layer failed silently, costing a fintech startup millions in reconciliation errors. We discuss why mocking frameworks can hide real bugs and how to implement st
Testing AI Models for Hallucinations in Production
Most teams treat large language model outputs like static code, but hallucinations are probabilistic, not deterministic. We break down why traditional unit tests fail against generative AI and introduce the concept of semantic drift evaluation using embedding vectors to catch subtle factual errors before they hit users. This episode explores how to build a guardrail system that measures consistenc
Testing Shadow Mode Without Breaking Production
Shadow testing lets you run new code against live traffic without affecting users. We explore how Netflix uses this technique to validate changes in real time, the infrastructure overhead involved, and why it is safer than canary deployments for high-risk updates. Learn how to implement shadow mode safely.
#SoftwareTesting #ShadowTesting #Netflix #LiveTraffic #QAEngineering #TechStrategy #Product
Why Your Software Testing Strategy Is Broken
We explore the hidden cost of 'brittle automation' in modern software engineering. Using a specific case from a major fintech rollout, we dissect why over-reliance on visual regression and rigid UI tests creates fragility. Lucas and Luna discuss how to shift from brittle interface testing to resilient contract testing and semantic verification, offering a concrete framework for building test suite
How Chaos Engineering Reveals Hidden Software Weaknesses
We talk about how chaos engineering moves beyond simple uptime checks to proactively break systems. We look at the specific case of Netflix’s Chaos Monkey and why deliberately injecting failure into production environments is now a standard practice for high-availability teams. We explore the psychology behind breaking things on purpose, the metrics that matter when your infrastructure is under at
The Hidden Cost of Flaky Tests in CI Pipelines
Flaky tests are eroding developer velocity and trust in continuous integration pipelines across the industry. This episode examines how intermittent failures mask real bugs and waste engineering hours, using a concrete case study from a mid-sized fintech company that reduced their flakiness rate by forty percent through isolation strategies and test data management. We explore the structural cause
How to Test Production Without Breaking It
Most engineering teams treat production as a forbidden zone for testing, but that approach leaves critical blind spots in complex distributed systems. This episode explores how leading tech organizations use canary releases and feature flags to validate software behavior in live environments without risking user experience. We examine the specific mechanics of shadow traffic, where requests are mi
How to Test User Interfaces Without Manual Clicking
Most teams treat UI testing as a manual chore, but the real cost isn't time—it's brittleness. This episode explores how shifting from visual regression checks to behavioral assertions can save engineering hours and reduce production defects. We examine a specific case study of a fintech startup that reduced their QA cycle by forty percent after adopting a selector-based assertion strategy over pix
How to Test Production Traffic Safely with Canary Deployments
Canary deployments let you ship code to a tiny slice of users before rolling it out globally, but testing in production is risky. We examine how Stripe uses canary releases to validate new payment routing logic without disrupting merchants, and why monitoring error rates and latency percentiles matters more than raw traffic volume. Lucas and Luna break down the specific signals engineering teams s
How to Ship Code Without Breaking Production
We talk about how one fintech company reduced deployment failures by ninety percent using canary releases and automated rollback triggers. Lucas explains the mechanics of gradual rollouts while Luna challenges whether most teams actually have the observability to support them. We dig into specific metrics like error budgets, latency percentiles, and the human cost of bad deployments. This is a pra
How to Test Your Code Without Writing Tests
Most engineers think testing means writing unit tests, but the most robust systems often rely on chaos, contract verification, and property-based logic. In this episode, Lucas and Luna explore a different angle: how to ensure software reliability by testing the absence of failure. They dive into the concept of 'testing for silence'—using observability, synthetic transactions, and structural analys
How Property-Based Testing Catches the Bugs You Miss
In episode 172, Lucas and Luna dive into property-based testing, the technique that flips the script on traditional example-based testing. Instead of writing one test with one input, you define properties your code should always hold, and let a tool generate hundreds of random inputs to hunt for violations. They break down the core concepts with a concrete example: a shopping cart's total price ca
Testing Your Test Pyramid When It Collapses
In this episode, Lucas and Luna talk about the test pyramid and what happens when your suite grows so large the pyramid's base—your unit tests—turns to sand. We look at a real case: a fintech company whose unit tests take 40 minutes to run and how they rebuilt trust in their fast feedback loop using structural fault injection and slow-test budgets. We also get into why test doubles can mask integr
Testing Your Test Data with Property-Based Testing
In this episode of Software Testing with Fexingo, Lucas and Luna break down property-based testing—a technique that flips traditional testing on its head by generating thousands of edge-case inputs automatically. They explore how it catches bugs that hand-written examples miss, using the classic example of a sorting function and a real-world case involving a payment system's date validation. Learn
How to Test State Machines Without Getting Lost in Transitions
In episode 169 of Software Testing with Fexingo, Lucas and Luna explore a practical approach to testing state machines—those invisible logic engines behind everything from e-commerce checkouts to IoT devices. They start with a real-world example: a payment gateway that mysteriously failed only when a user cancelled a subscription during a trial. The key insight: instead of testing every possible p
Why Your Test Suite Needs Contract Testing
In this episode, Lucas and Luna explore contract testing — a powerful technique that keeps microservices in sync without brittle end-to-end tests. They break down how a simple JSON contract between a payments service and its consumers caught a breaking change before it hit production, saving a fintech team from a weekend outage. The hosts explain the difference between consumer-driven and provider
How to Test Your CI Pipeline for Flaky Test Fatigue
In this episode, Lucas and Luna tackle the silent productivity killer in modern software teams: flaky test fatigue. They explore how a test suite with an 87% pass rate on a normal day can still ship code that breaks in production, and why the urge to rerun failed tests until they pass is a dangerous habit. The conversation centers on the story of a mid-sized payments company whose CI pipeline grew
How to Test Your Build System's Reproducibility
In this episode of Software Testing with Fexingo, Lucas and Luna explore the often-overlooked challenge of testing whether your build system is truly reproducible. They dive into the concept of reproducible builds—where the same source code produces byte-for-byte identical artifacts every time—and why it matters for security, debugging, and trust in your software. Using a concrete example of a sup
Why Test Data Diversity Beats Volume
In this episode, Lucas and Luna discuss a common but often overlooked problem in software testing: test data that is too clean. They explore how a lack of data diversity can lead to tests passing in staging but failing in production, and why adding realistic, messy data can uncover more bugs. Using the example of a fintech startup that faced a major outage due to unrealistic test data, they explai
How to Test End-to-End Encryption Without Breaking Privacy
End-to-end encryption is the backbone of modern messaging, but testing it is a nightmare: the whole point is that nobody in the middle — including your testers — can read the data. So how do you verify it actually works? Lucas and Luna drill into the E2EE testing problem, from the cryptographic basics to the practical traps. They break down test vectors, the classic mistake of testing against your
How to Test Your Database Backups Before You Need Them
In this episode, Lucas and Luna dig into a deceptively simple question: when's the last time you actually restored a database from a backup? They walk through the 'backup vs. restore' gap, why most teams only discover their backups are broken when it's too late, and how a simple restore drill every quarter can save your company from a catastrophic data loss. Using a real-world example of a mid-siz
How to Test Feature Flags Without Breaking Production
Feature flags are everywhere in modern software, but they can quietly break your test suite and your production environment if you don't approach them carefully. In this episode, Lucas and Luna talk through the hidden dangers of feature flag testing—from stale flags that linger for years to the perils of testing both branches of a conditional. They walk through a real example of a company that shi
How to Test Configuration Changes Without Breaking Production
In this episode of Software Testing with Fexingo, Lucas and Luna dive into the hidden dangers of configuration changes — those tiny edits to feature flags, environment variables, and service settings that can silently break production. They explore real-world examples like the 2023 AWS S3 outage and the Knight Capital trading disaster, and discuss practical strategies for testing config changes be
How to Test AI Chatbots Without Losing Your Mind
In this episode, Lucas and Luna tackle a question every QA team is facing in 2026: how do you test AI chatbots when the output is never the same twice? They move past the hype and get into the practical weeds — from probing a GPT-4-powered support bot with borderline prompts to automating evaluation with LLM-as-judge and golden sets. You'll hear about the 'human-in-the-loop' escape hatch that save
How to Test Security Vulnerabilities Without a Red Team
Episode 159 of Software Testing with Fexingo digs into security testing for everyday QA teams. Lucas and Luna explore how a small fintech startup caught a critical authorization flaw using simple fuzzing and threat modeling — no dedicated security engineers needed. They walk through concrete techniques: mapping attack surfaces, fuzzing JSON inputs, testing for broken access control, and using OWAS
How to Test Data Pipelines Without Trusting the Output
In this episode of Software Testing with Fexingo, Lucas and Luna tackle one of the most frustrating problems in modern data engineering: knowing whether your data pipeline is actually producing correct results. They open with a real-world story about a financial services firm that discovered a silent currency-conversion bug in its reporting pipeline — a bug that had been live for six months and ha
How to Test Accessibility Without a Dedicated QA Team
In this episode of Software Testing with Fexingo, Lucas and Luna explore how small teams can integrate accessibility testing into their existing QA workflows without a dedicated specialist. They break down the WCAG 2.2 criteria, the surprising cost of ignoring accessibility in both legal and user terms, and practical tools like axe-core and Lighthouse that catch issues before release. Learn why ac
How to Test Database Migrations Without Downtime
Database migrations are one of the riskiest operations in software—a botched schema change can take down a service or corrupt data. In this episode, Lucas and Luna discuss the concept of expand-and-contract migrations, using the example of splitting a users table. They explain how to test migrations in a staging environment, the role of feature flags, and why rollback strategies matter. They also
Why Test Coverage Percentages Mislead You
In this episode of Software Testing with Fexingo, Lucas and Luna explore why a high test coverage percentage can give teams a false sense of security. They dissect a real-world case where a financial services company boasted 90 percent line coverage but still shipped a critical bug in a rarely used error-handling branch. The conversation digs into the difference between line coverage and branch co
How to Test Chaos Engineering Experiments Without Breaking Production
Chaos engineering has a reputation for being scary — Netflix famously breaks things on purpose. But the point isn't to cause outages; it's to learn how your system fails before users notice. In this episode, Lucas and Luna explain how teams can run chaos experiments safely, using a real-world example: a payment service that survived a simulated database failure. They cover the key principles — sta
How to Test Timeouts and Retries Without Flaky Tests
In this episode of Software Testing with Fexingo, Lucas and Luna dive into a tricky corner of reliability engineering: testing timeouts and retries. Using a real-world example of a payment service that flakes under load, they explain why naive timeout tests fail, how to build deterministic tests with virtual clocks and fault injection, and how to avoid common pitfalls like testing implementation d
How Mutation Testing Reveals Blind Spots in Your Test Suite
Most teams think a high code coverage percentage means their tests are solid. In this episode, Lucas and Luna explain why that confidence can be misplaced, and how mutation testing exposes the gaps. They walk through a real example: a simple utility function with 100 percent line and branch coverage that still lets a subtle bug slip through because the tests never actually check the return value.
How to Test API Rate Limiting Without Angering Users
Rate limiting is a silent killer of user experience when done wrong. In this episode, Lucas and Luna dig into why most API rate-limit tests only check the 429 status code and miss the real problems: retry storms, jitter, and Redis failover. They walk through a real incident at a rideshare company where a naive rate limiter turned a surge in demand into a five-hour outage, and how testing with inje
How to Test Performance Regressions Before Users Notice
On episode 150 of Software Testing with Fexingo, Lucas and Luna dig into performance regression testing—the discipline of catching slowdowns before they hit users. They explore why unit tests miss performance issues, how load testing and profiling fit into CI, and the surprising cost of a single millisecond of latency. Using a real-world example of a payments API that degraded by 30 percent withou
How to Test Race Conditions in Concurrent Code
Concurrency bugs are among the hardest to catch—they hide in the space between threads, appearing only under specific timing. In this episode, Lucas and Luna explore how teams can systematically test race conditions using deterministic scheduling, stress testing, and static analysis. They dig into a real-world example: a fintech app that lost $40,000 to a race condition in a balance update, and ho
Why Test Data Quality Is the Hidden Cost in CI Pipelines
Test data is often treated as an afterthought, but poor test data quality quietly drives flakiness, false confidence, and wasted developer hours. In this episode, Lucas and Luna explore how a mid-sized fintech cut its CI failure rate by 40 percent just by auditing its test databases. They walk through concrete problems: stale schemas, PII contamination, and the 'golden dataset' trap. They also dis
Why Testing Mobile Apps on Real Devices Still Matters
In Episode 147, Lucas and Luna explore the surprising pitfalls of relying solely on emulators and simulators for mobile app testing. They break down a real-world case from a fintech startup where a critical bug slipped past emulator tests and hit production, costing the company time, money, and user trust. They discuss why emulators can't replicate real device behavior — from battery drain to netw
How to Test Your Own Code Without Breaking It
In this episode, Lucas and Luna dive into the tricky art of self-testing — how developers can test their own code effectively without falling into the trap of confirmation bias. They break down a real case: a fintech startup that caught a critical bug in their payment logic only after implementing a structured self-review checklist. Lucas explains the psychology behind why we miss our own mistakes
How Contract Testing Prevents Microservices Meltdowns
In this episode, Lucas and Luna explore how contract testing keeps microservices from breaking each other in production. They walk through a real-world example: a payment service that went down because a team changed an API response field without updating the contract. They explain the difference between consumer-driven contracts and provider-side testing, how tools like Pact and Spring Cloud Cont
How to Test User Permissions Without Breaking Access
In this episode, Lucas and Luna dive into the surprisingly tricky world of permission testing: making sure users can only see and do what they're allowed to, without accidentally locking out legit users or opening the door to unauthorized access. They use a real-world example of a healthcare app where a misconfigured role-based access control test let a junior nurse see patient records they should
How Property-Based Testing Exposes Hidden Bugs
Property-based testing is one of the most powerful techniques in a QA engineer's toolkit, yet it's often misunderstood and underused. In this episode, Lucas and Luna dive into what property-based testing actually is, how it differs from traditional example-based testing, and why it's so effective at uncovering edge cases that human testers routinely miss. They walk through a real-world case study
Why Test Environments Drift and How to Stop It
In this episode, Lucas and Luna dig into the hidden costs of test environment drift — the quiet mismatch between where you test and where you run. They trace a concrete incident from a mid-sized FinTech that lost a full release day because a staging database had a schema one migration behind production. They talk about why drift happens, how to detect it early with configuration checks and drift d
How to Test Infrastructure as Code Before It Breaks Production
A misconfigured Terraform template caused a major cloud provider outage in June 2026 — passing every unit test but failing in production. In this episode, Lucas and Luna examine why traditional QA fails for Infrastructure as Code and how teams can catch configuration drift, security misconfigurations, and state corruption before they reach live systems. They discuss practical tools like static ana
How to Test Feature Flags for Safe Software Rollouts
Feature flags are powerful tools for incremental rollouts and A/B testing, but if not tested properly, they can cause catastrophic outages. In this episode, Lucas and Luna explore the hidden risks of feature flags, from fallback behavior and targeting logic to lifecycle management and performance. They discuss techniques like flag toggling tests, environment validation, and flag service outage sim
How Model-Based Testing Catches Edge Cases Manual Scripts Miss
In this episode, Lucas and Luna explore model-based testing, a technique where you build a formal model of your system's expected behavior and automatically generate test cases from it. They use a concrete example: testing a simple vending machine state machine. Lucas explains how model-based testing uncovered ordering edge cases that standard manual test scripts overlooked. The discussion covers
How to Test WebSocket Connections for Real-Time Reliability
When a trading platform outage last month left millions unable to trade for 45 minutes, the culprit was a WebSocket reconnection bug. In this episode, Lucas and Luna dive into the unique challenges of testing real-time WebSocket connections: from handshake verification and message ordering to reconnection logic and load testing with thousands of concurrent users. They share concrete strategies lik
How Testing Data Pipelines Prevents Costly Data Errors
In this episode, Lucas and Luna explore why data pipeline testing is often overlooked and how it can prevent multimillion-dollar errors. They discuss a case where a fintech company lost $2 million due to a pipeline bug that double-counted refunds, and share practical strategies like contract testing, schema evolution handling, and data quality assertions. Learn how to build confidence in your data
How Idempotency Testing Prevents Double Payments
Duplicate payments are the bane of e-commerce and fintech. In this episode, Lucas and Luna dive into idempotency — the property that makes retries safe. They explain how Stripe uses idempotency keys, how to test that your API endpoints are idempotent, and common gotchas like caching and asynchronous processing. If you've ever accidentally charged a customer twice, this episode will show you how to
When Traditional QA Fails for Machine Learning
In this episode, Lucas and Luna dive into why conventional software testing approaches break down for machine learning models. They explore a 2024 Google study revealing that 70% of ML production failures stem from data issues, not code bugs. The conversation covers the differences between deterministic and probabilistic testing, the critical role of data validation and schema enforcement, and how
Recommended
Dark Night Tales with Brian King
Fantasy Flex
زن بودن
Medicine with Meaning
Yours Truly Johnny Dollar Collection
Take Back Your Health®
CBS Radio Mystery Theater | Old Time Radio
Solved Murders - True Crime Stories
紐約鳥｜New York Aperture
The Swerve Podcast: Obscure Topics | Conspiracy Theories
The Bread and Banter Podcast
The Church of What's Happening Now: The New Testament
