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

In episode 79 of Software Testing with Fexingo, Lucas and Luna dive into a topic that trips up even mature engineering teams: testing API rate limits before they break in production. They walk through a real example from a fintech startup that hit a 429 avalanche during a Black Friday sale in 2025, costing them $2 million in lost transactions and three days of firefighting. Lucas explains the diff...

Most teams save their end-to-end tests for staging environments, but that means they miss the quirks of real user data, network conditions, and browser configurations. In this episode, Lucas and Luna explore the emerging practice of running E2E tests directly in production — not on live user traffic, but on shadow traffic, synthetic user flows, and canary releases. They break down the risks (data...

In Episode 77 of Software Testing with Fexingo, Lucas and Luna dive into the hidden problem of UI drift—small, cumulative visual changes that break user experience over time. They explore how snapshot regression testing catches these pixel-level shifts before they reach production, using tools like Percy and Chromatic. The hosts discuss the difference between visual and functional testing, how to...

Lucas and Luna dive into why ephemeral environments are transforming software testing. Using a case study from a mid-size SaaS company that cut its test environment costs by 60% while catching bugs 40% faster, they explore how spinning up short-lived, disposable infrastructure on demand eliminates configuration drift, reduces flakiness, and gives QA teams true parity with production. They break do...

In episode 75 of Software Testing with Fexingo, Lucas and Luna dig into a blind spot many teams overlook: testing the continuous integration pipeline itself. They break down a recent case where a major fintech company's CI pipeline silently skipped tests for six weeks due to a misconfigured Docker layer cache — costing them three undetected production bugs. Lucas explains why 'pipeline as code' ne...

In this episode, Lucas and Luna dive into property-based testing, a technique where you define invariants about your code and let a framework generate thousands of test cases automatically. They contrast it with traditional example-based testing, using a concrete case: a flawed sorting function in Python that passes 50 examples but fails on a specific edge case found by property-based testing. The...

In this episode, Lucas and Luna dive into contract testing—a strategy that catches integration bugs before they hit production. Using the real-world example of Netflix and its shift to microservices, they explain how consumer-driven contract tests (CDCs) act as a safety net for API changes. Lucas breaks down the difference between provider and consumer contracts, shares a concrete case where a mis...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into fuzz testing — a technique that bombards your software with unexpected, malformed, or random inputs to uncover security and stability bugs that traditional test cases miss. They break down how fuzzing works, why it's essential for input validation, and how a real-world example — a 2014 vulnerability in the Bash shell called...

Lucas and Luna explore property-based testing, a technique where you define system invariants and let a tool generate thousands of random inputs to find edge cases hand-written tests overlook. They break down a real example from a financial transaction system where property-based tests caught a rounding bug that had survived for months. The episode covers the shift from example-based to property-b...

In this episode of Software Testing with Fexingo, Lucas and Luna explore test impact analysis (TIA), a technique that uses code dependency mapping to determine exactly which tests need to run after a code change. They walk through how Google's CI system cut test execution time by 40% using TIA, and why most teams run far more tests than necessary. Lucas explains the difference between static and d...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into log-based testing—a technique that uses your application's own logs to generate realistic test scenarios and catch silent failures. They explore a real case: how a major e-commerce platform discovered a catastrophic data corruption bug by replaying logs from a single user session. The discussion covers log parsing, anomaly...

Lucas and Luna dive into chaos engineering for APIs, exploring how Netflix's Chaos Monkey inspired a new wave of resilience testing for microservices. They break down a real case from a fintech startup that injected faults into their payment API to uncover hidden race conditions, saving them from a potential production outage during peak traffic. Learn how chaos testing differs from traditional st...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into the hidden cost of flaky tests — tests that pass and fail without code changes. They break down a real-world case from a mid-size fintech company where flaky tests consumed 20% of developer time in a single quarter. They explore common causes like race conditions, async timeouts, and shared mutable state, then discuss pract...

Lucas and Luna explore why pixel-perfect visual regression testing often fails to catch meaningful UI bugs, while perceptual diffing (like SSIM and DSSIM) catches the ones users actually see. They walk through a real case: an e-commerce checkout button whose hue shifted 3% — pixel tests flagged a false positive, then blind-spotted a real contrast failure. Engineers at a mid-size SaaS company reduc...

Episode 65 of Software Testing with Fexingo explores differential testing (a.k.a. metamorphic or diff testing) as a way to catch regressions when no oracle exists. Lucas explains how the technique works by comparing outputs of two program versions on the same input, using real-world examples like JPEG encoders. Luna pushes back on the cost of generating valid inputs and the challenge of flaky diff...

Episode 64 explores why paid crowdsourced testing platforms like uTest and Bugcrowd are finding defects that internal QA teams routinely overlook. Lucas and Luna break down a 2025 case study where a fintech app running on 15,000 real devices across 90 countries uncovered 47 unique edge-case bugs in two days — including a currency-format crash that only appeared on a Chinese Android build. They com...

Flaky tests — tests that pass or fail without code changes — are one of the most insidious productivity killers in modern software engineering. Lucas and Luna dig into a 2025 study from Google that found flaky tests cost their teams roughly 16 developer-years per quarter in reruns and debugging. They unpack the three main causes: order-dependent tests, race conditions, and brittle assertions. Then...

Lucas and Luna dive into session replay technology — a tool that records user interactions to uncover bugs that slip past traditional testing. They explore how companies like FullStory and Hotjar capture real user sessions, the privacy and ethical considerations of recording user behavior, and why session replay catches issues like broken flows and rage clicks that automated tests miss. This episo...

Lucas and Luna explore how visual regression testing has evolved from pixel-by-pixel diffs to AI-powered semantic comparison. They break down why traditional tools miss context-aware bugs like subtle layout shifts or color changes that don't affect usability, and how modern AI models can distinguish meaningful visual differences from noise. Using the example of a retail checkout flow, they show ho...

Lucas and Luna explore mutation testing, a technique that goes beyond code coverage by introducing small changes—mutations—into your source code to see if your test suite catches them. The episode drills into a real-world case: a UK fintech called Kaluza that used mutation testing to find a critical bug in its energy-balancing algorithm, despite 95 percent line coverage. Lucas explains why coverag...

In episode 59 of Software Testing with Fexingo, Lucas and Luna dive into the rising practice of synthetic test data generation. They explain why scraping production data for testing introduces compliance risks and stale edge cases, and how tools like Tonic.ai and generated data pipelines solve both problems. Lucas walks through a real example from a fintech startup that cut test data preparation t...

Episode 58 of Software Testing with Fexingo digs into session replay tools — video-like recordings of real user interactions — and why they catch bugs that no test or log ever will. Lucas and Luna walk through a concrete case: a mid-size e-commerce SaaS that lost $400,000 in cart abandonment before a replay showed a checkout button occasionally shifting 2 pixels on mobile Safari. They discuss the...

Lucas and Luna dive into data contracts—formal agreements between data producers and consumers that prevent silent corruption upstream from breaking test suites downstream. They walk through how Uber's Data Quality Platform (DQP) enforced schema and freshness guarantees across thousands of data pipelines, reducing data incidents by 70% in six months. They explore why a test suite's reliability dep...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into the deceptive world of code coverage metrics. They explore how a team at a mid-sized fintech company hit 95% line coverage yet still suffered a production outage from an untested edge case. The hosts contrast line coverage with branch and condition coverage, then go further to discuss mutation testing as a more honest signa...

In this episode of Software Testing with Fexingo, Lucas and Luna explore why accessibility testing should be a core part of your QA strategy, not an afterthought. They walk through a real-world example from a major e-commerce platform that discovered 40 percent of its checkout flow was unusable by screen readers after a routine redesign. The hosts discuss how automated accessibility checks catch o...