Episodes
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 how to audit their test suites for assertion drift and why treating every test as a hypothesis is…
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 structural testing for your business logic without slowing down development velocity.…
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 consistency rather than just syntax, featuring insights from recent production incidents where models…
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 #ProductionSafety #CodeValidation #FexingoBusiness #BusinessPodcast #TechnologyNews #EngineeringLeadership…
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 suites that survive refactoring without constant maintenance. This is not about writing more tests; it…
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 attack, and how modern cloud-native architectures require a different mindset than traditional…
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 causes of nondeterministic behavior, from race conditions to shared state, and discuss practical…
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 mirrored to new code paths while the original path handles actual users, allowing engineers to…
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 pixel-matching tools. Lucas breaks down the architecture of stable locators, while Luna challenges the…
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 should watch for during a canary phase, including how to handle database schema changes safely when…
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 practical look at moving fast without breaking things in today's high-stakes cloud environment.…
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 analysis to catch bugs before they manifest as errors. Using examples from high-traffic financial…
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 calculation, where a naive test might miss a negative price bug that property-based testing catches…
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 integration bugs, how to measure test suite 'fitness' beyond coverage, and why the pyramid shape itself…
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 the difference between examples and properties, how to think in invariants, and why this approach…
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 path, model the state machine explicitly and test each transition in isolation. Lucas explains how…
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-driven contracts, walk through a real-world example using a popular open-source tool, and discuss…
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 from 40 to 800 tests in eighteen months, and the team's journey to classify, quarantine, and…
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 supply-chain attack that exploited non-reproducible builds, they discuss practical techniques like…
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 explain the concept of data diversity and offer practical strategies for improving your test data sets.…
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 own implementation, and why deterministic key exchange makes tests flaky. They also cover the…
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-sized SaaS company that lost a day of customer data because they'd never tested a restore, they…
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 shipped a broken feature because their tests only covered one configuration, and they share practical…
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 before they go live. From config-as-code and schema validation to canary releases and configuration…
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 saved a fintech's customer service rollout, the metrics that actually matter (think intent accuracy…
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 OWASP ZAP for automated scans. They also discuss why security testing is a mindset, not a tool, and how…
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 had already influenced client reports. From there, they break down why traditional testing approaches…
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 accessibility is not just a compliance checkbox but a core quality attribute, and how to make it a…
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 touch on the importance of load testing against a copy of production data. Tune in to learn a…
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 coverage, why mutation testing can reveal blind spots, and how focusing on risk-based testing rather…
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 — starting small, defining a steady state, using blast radius limits, and automating rollbacks — and…
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 details. They also share how to set realistic timeout thresholds and design retry logic that won't…
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. They break down how mutation testing works — introducing small changes, or 'mutations', into your…
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 injected client clock skew and burst patterns would have caught it. You'll learn the difference between…
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 without anyone noticing, they explain how to set realistic budgets, use synthetic monitoring, and…
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 how a combination of ThreadSanitizer, Go's race detector, and property-based testing caught it. The…
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 discuss practical fixes like data masking, synthetic data generation, and versioned seed data. If…
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 network variability — and dive into the 'device matrix' strategy that many teams adopt to balance cost…
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, and Luna shares a practical 'red team' trick she uses to review her own pull requests. They also…
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 Contract automate the checks, and why embedding these tests in your CI pipeline catches mismatches…
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 shouldn't have. Lucas explains how to design permission test matrices that cover both positive and…
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 from a fintech company where property-based testing caught a subtle bug in a currency conversion…
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 detection tooling, and why a simple snapshot-and-compare habit beats a complex platform. Listeners…
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 analysis with Checkov, policy-as-code with Open Policy Agent, integration testing with Terratest, and…
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 simulation. Using a real-world example of a social media platform's 2025 outage caused by a…
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 tools (like GraphWalker and Spec Explorer), practical setup steps, and why this approach is…
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 like simulating network partitions, gradually increasing load to find breaking points, and using tools…
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 flows. #DataPipelineTesting #SoftwareTesting #QA #DataQuality #DataEngineering #Fintech…
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 test your way out of that nightmare. #IdempotencyTesting #DistributedSystems #Microservices #API…
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 teams can detect model drift and data skew in production. Using a real-world credit scoring model…
Showing the latest 50 episodes. The full archive of 184 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.