Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering

Mutation testing is a technique that deliberately introduces small changes to your source code to see if your test suite catches them. In this episode, Lucas and Luna break down how mutation testing exposes weaknesses in test coverage that traditional metrics miss. Lucas explains the concept with a concrete example: a simple tax calculation function and a test suite that passes line coverage but f...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into a classic testing nightmare: tests that pass in staging but fail in production, or worse, fail in staging but pass in production. They explore the root cause — environment drift — and focus on a specific case: how a major e-commerce platform lost $340,000 in revenue during a Black Friday sale because their staging database...

In this episode, Lucas and Luna explore how test data entropy — the randomness and variety in test inputs — can reveal bugs that structured test data misses. They walk through a real case from a payment processing startup that caught a rounding error costing $0.01 per transaction only after introducing high-entropy test data. Lucas explains the concept of entropy in testing, how to measure it with...

Lucas and Luna explore a real-world case from a major e-commerce platform that discovered a 300-millisecond latency bottleneck in its checkout microservice during Black Friday load testing. They explain how the team used distributed tracing to pinpoint the issue, why traditional end-to-end tests missed it, and why every team should run performance tests with production-like traffic patterns. This...

In this milestone 100th episode, Lucas and Luna dive into the hidden costs of non-deterministic tests in CI pipelines. They explore how flaky tests — tests that pass or fail randomly — waste developer time, erode trust in test suites, and mask real bugs. Using real-world examples from large-scale engineering teams, they discuss detection strategies like rerun budgets, flakiness dashboards, and qua...

Episode 99 of Software Testing with Fexingo dives into a silent killer of test suites: semantic versioning itself. Lucas and Luna explore how a library bump from 2.1.4 to 2.2.0 can cascade into hundreds of red tests, not because your code broke, but because the version contract is ambiguous. They dissect a real-world case—a major e-commerce platform’s CI pipeline that failed after a minor upgrade...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into the hidden cost of non-deterministic tests—tests that pass or fail randomly due to race conditions, timing issues, or flaky dependencies. Lucas explains how a single flaky test at a mid-size SaaS company caused a 45-minute CI delay, wasting $12,000 per month in engineer hours. Luna challenges the common fix of simply re-run...

Episode 97 of Software Testing with Fexingo dives into fuzz testing — but not the usual kind. Lucas and Luna explore how to test the fuzz generators themselves, using a real example from Google's OSS-Fuzz pipeline. They walk through how corrupted seed inputs, missing dictionary entries, and generator logic bugs can silently shrink coverage, and share a specific technique: mutation coverage of the...

Lucas and Luna explore property-based testing, a technique that finds bugs example-based tests miss. They walk through a real case: a payment system where a property-based test uncovered an edge case with currency rounding that cost users fractions of cents—and how the team fixed it before those fractions added up to thousands of dollars. They explain the core idea: instead of writing individual t...

In this episode, Lucas and Luna dive into contract testing — a testing approach that catches API integration failures before they reach production. They walk through a real example from a fintech startup that used Pact to test payment API contracts between their Node.js frontend and Java backend, cutting integration bugs by 70% in one quarter. The hosts explain why traditional end-to-end testing m...

Lucas and Luna dive into a common pitfall in software testing: relying on line coverage as a quality gate in CI pipelines. They explore a real case where a team at a mid-sized SaaS company proudly hit 90% coverage yet missed a critical production bug because their tests never exercised the right paths. The episode breaks down the difference between coverage quantity and test effectiveness, explain...

Lucas and Luna explore why testing with realistic synthetic user behavior—not just scripted inputs—uncovers performance bottlenecks that standard load testing misses. They dive into how companies like Netflix simulate thousands of virtual users with real-world browsing patterns to catch issues before they hit production. The episode breaks down the difference between synchronous request testing an...

Episode 92 of Software Testing with Fexingo tackles a subtle but costly problem: test environment configuration drift. Lucas explains how small differences between staging and production configs — like a database connection pool size or a TLS version — can cause tests to pass in staging but fail in production, or vice versa. He walks through a real example from a mid-size SaaS company where drift...

In this episode, Lucas and Luna explore a specific failure mode that haunts engineering teams: the database cascade. They dissect a real-world example from a mid-2025 incident at a major payments processor, where a routine schema migration triggered a chain reaction that took down three dependent services. Lucas explains why traditional load testing misses these failures, and Luna shares a lightwe...

In Episode 90 of Software Testing with Fexingo, Lucas and Luna dive into chaos engineering as a proactive testing discipline. They explain how intentionally injecting failures like server crashes, high latency, or resource exhaustion into production-like environments reveals weaknesses before real users are affected. Using concrete examples from Netflix's Chaos Monkey and a hypothetical e-commerce...

Episode 89 of Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering. Lucas and Luna dive into test flakiness as a leading indicator of CI pipeline health. They examine a real-world case from a mid-size e-commerce company where a 3% flaky-test rate masked a deeper infrastructure issue costing the team 40 minutes per developer per day. Lucas explains why tracking flaky tes...

Lucas and Luna unpack the dangerous gap between line coverage and bug detection. Using a real-world case from a payments startup that hit 95% coverage yet still suffered a catastrophic production failure, they explain why coverage percentages can mislead teams into false confidence. They explore the difference between coverage of code paths versus coverage of behaviors, introduce the concept of mu...

Episode 87 of Software Testing with Fexingo dives into visual regression testing—why pixel-perfect UI checks catch bugs that traditional assertions miss. Lucas and Luna walk through a real-world case: a major e-commerce app that broke its checkout button in a routine CSS update. Automated snapshot diffs caught the issue before any customer hit a broken flow. They contrast tools like Playwright scr...

Episode 86 of Software Testing with Fexingo: Lucas and Luna dive into a powerful technique that goes beyond traditional pass/fail assertions: using anomaly detection on test metrics to predict production incidents before they happen. They explore a real-world case where a mid-size e-commerce company used this approach to catch a silent memory leak that standard unit tests missed for weeks. Lucas e...

In this episode of Software Testing with Fexingo, Lucas and Luna explore test prioritization—a technique that reorders your regression suite to catch the most critical bugs first. They dive into a real-world case study: how a mid-sized fintech company cut their regression run from 45 minutes to under 12 minutes by prioritizing tests based on code change risk and historical failure data. Lucas expl...

Most test suites assume the testing infrastructure itself is reliable. But what happens when your CI runner misconfigures a Python interpreter, your test database driver silently drops connections, or your test framework skips tests due to a false positive? In this episode, Lucas and Luna explore the concept of testing your test infrastructure — from validating CI pipeline steps with synthetic tes...

Most teams treat their test suite as a source of truth. But what if the tests themselves are misleading you? In episode 83 of Software Testing with Fexingo, Lucas and Luna explore the concept of 'testing your tests' through A-B-style experimentation. They walk through a real case from a mid-size fintech that ran a controlled experiment: one team relied on their existing 12,000-test suite, while th...

Most teams run passing test suites with false confidence. This episode dives into mutation testing: a technique that introduces small changes (mutations) into your code to see if your tests actually catch them. Lucas and Luna break down how tools like Stryker, Pitest, and mutmut work, what a mutation score tells you versus code coverage, and why a high mutation score can save production incidents....

Lucas and Luna explore synthetic test data, a technique that generates realistic-but-fake data for software testing without exposing real user information. They break down how tools like Tonic.ai and Gretel.ai create structurally accurate datasets, why companies like Uber and Stripe use synthetic data to speed up testing, and the limitations around edge cases and statistical bias. A practical look...

In episode 80 of Software Testing with Fexingo, Lucas and Luna explore mutation testing—a technique that surgically introduces bugs into your source code to see if your tests catch them. They walk through a real example using a banking application's withdrawal function, showing how mutation testing exposes tests that pass even when they should fail. Lucas explains the concept of a 'killed mutant'...