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

Episode 54 of Software Testing with Fexingo dives into risk-based test prioritization—a smarter way to decide which tests to run first when time is tight. Lucas and Luna break down how the approach works using a real-world example from a payments startup that cut regression run time by 70% while catching three critical bugs before release. They cover how to weigh failure impact and likelihood, how...

Lucas and Luna explore how static analysis — automated code review that catches bugs before tests even run — can uncover issues that unit tests, integration tests, and even property-based tests miss. They walk through a real example from a payment-service codebase where a static analyzer flagged a race condition that had evaded three layers of testing. The hosts discuss why most teams treat static...

Episode 52 of Software Testing with Fexingo dives into test data hygiene as a critical security practice. Lucas and Luna examine real-world cases where exposed test databases leaked sensitive customer information—including a 2024 incident at a major retailer that exposed 50 million records through a QA environment. They walk through the three pillars of test data security: anonymization, access co...

In this episode of Software Testing with Fexingo, Lucas and Luna explore shift-left testing—moving quality checks earlier in the development lifecycle. They focus on a real-world case: how a mid-sized e-commerce team reduced their bug-fix cycle by 40 percent by catching defects during design and code review, rather than after deployment. Lucas explains the three concrete practices they adopted: li...

Chasing 99.999% uptime through endless regression tests? This episode argues that for most SaaS products, the cost of five-nines testing far outweighs the benefit. Lucas and Luna break down a real-world case from a mid-market CRM provider that cut its QA budget by 40% after adopting error budgets and shifting from exhaustive pre-release testing to targeted chaos experiments. They walk through the...

In this episode of Software Testing with Fexingo, Lucas and Luna explore property-based testing, a technique that generates thousands of random inputs to find edge cases you'd never think to write as unit tests. They use a concrete example: a CSV parser that silently dropped rows with trailing spaces. With a Python library called Hypothesis, the team caught the bug in minutes after weeks of manual...

Lucas and Luna explain why test coverage percentages, especially line and branch coverage, give teams a false sense of security. They dive into the concept of mutation testing — where small changes are injected into code to see whether tests detect them. Using real examples from a FinTech startup that discovered critical gaps despite '100% coverage', they show how mutation score reveals the true e...

Lucas and Luna explore record-and-replay testing, a technique that captures real user interactions and replays them against your code to catch heisenbugs—intermittent failures that vanish under debuggers. Lucas explains how tools like Replay.io and rr (Mozilla's reverse debugger) let developers step backward through execution, revealing race conditions and state corruption that unit tests never tr...

In Episode 46 of Software Testing with Fexingo, Lucas and Luna explore chaos engineering: deliberately injecting failures into production-like systems to uncover weaknesses before they cause real outages. Lucas walks through the Netflix case study, where the Chaos Monkey tool was first developed in 2011 after a crippling AWS outage. He explains the difference between chaos experiments and traditio...

Lucas and Luna dive into contract testing—the practice of defining and verifying the interfaces between microservices before they break in production. Using a real-world example from a major European e-commerce platform, they explain how consumer-driven contracts (CDC) catch integration failures during CI, not after deploy. Lucas walks through the difference between provider and consumer contracts...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into the hidden cost of test debt — the accumulation of brittle, duplicated, and hard-to-maintain test code that slows down every release. Using a concrete case from a mid-sized fintech startup that rewrote 12,000 lines of test setup into 600 lines of reusable Pytest fixtures, they explain why fixture-based test architecture isn...

In this episode, Lucas and Luna dig into a subtle but devastating class of bugs—state transitions. Most test automation scripts assume the application is in a known state when they start, but real users jump between screens, reload mid-flow, or leave a session open overnight. Lucas explains how a single missing state check caused a major retailer to discount products by 90 percent during a holiday...

In this episode of Software Testing with Fexingo, Lucas and Luna explain how the Cost of Delay framework can help QA teams decide which tests to automate first. Lucas walks through a concrete example: a fintech app with a login flow, a payment flow, and a reporting dashboard. Using Cost of Delay — calculated as value per unit time — they show why a slow payment test costs $50,000 per week while a...

Lucas and Luna explore why smoke testing — a lightweight automated check that runs before full regression — is the most underrated safety net in modern CI/CD. Lucas breaks down how one fintech startup cut its rollback rate by 40 percent simply by running a five-minute smoke suite on every deploy candidate. They discuss the difference between smoke tests and sanity tests, the ideal smoke-test ratio...

Lucas and Luna dive into visual regression testing — a technique that compares screenshots of your app before and after code changes to catch unintended layout shifts, misaligned buttons, and broken responsive designs. Lucas explains how Twitter (now X) used Percy to catch a critical checkout button misalignment that would have cost millions in lost revenue, and why pixel-perfect testing matters m...

Most teams waste hours debugging failures that only happen in stale test environments. In this episode, Lucas and Luna unpack why ephemeral environments — spun up per branch, destroyed after merge — are becoming the standard for reliable CI/CD. They walk through how Spotify saved 40 percent of its QA engineers' troubleshooting time by moving to ephemeral Kubernetes namespaces, and why Airbnb's 'on...

Flaky tests — those that pass and fail without any code change — waste developer time and erode trust in CI pipelines. In this episode, Lucas and Luna explore why treating flaky tests as purely a code bug misses the real problem: team culture, test ownership, and prioritization. They walk through a typical scenario at a mid-size SaaS company where a flaky API mock causes intermittent failures. Luc...

Mutation testing is one of the most underused techniques in software quality, and it directly answers the question: 'If my code has a bug, will my tests catch it?' In this episode, Lucas and Luna explore how mutation testing works by deliberately introducing small faults—mutations—into your code and checking whether your test suite detects them. They walk through a concrete example with a simple f...

Episode 36 of Software Testing with Fexingo explores why state management is often the biggest source of elusive UI bugs. Lucas and Luna break down a real-world case: a fintech app that crashed under load because its Redux store wasn't tested for race conditions. They explain how dedicated state management testing differs from traditional unit or component tests, with concrete techniques like acti...

Lucas and Luna explore fuzz testing — why throwing random inputs at your code finds bugs that hand-written test cases never will. They trace the technique from its origins in the 1988 'finger' vulnerability through Google's OSS-Fuzz, which has found over 30,000 bugs in critical open-source projects. They discuss how a single fuzzing harness at Microsoft caught a decade-old bug in their Windows TCP...

Lucas and Luna dive into the quiet crisis of flaky test failures caused by unversioned test data. They break down how a single team at Shopify reduced CI retries by 40 percent by treating test fixtures like source code — with Git LFS, checksums, and data snapshots. Along the way, they discuss why randomized data generation is a trap, how database seeding scripts rot, and the one tool (Keploy) that...

Lucas and Luna dig into a specific case from May 2026: a major fintech app's checkout flow broke for screen-reader users after a seemingly harmless CSS update. They walk through how the bug slipped past unit and visual regression tests, why the team missed it, and what they changed to catch it next time. Luna brings data from WebAIM's 2025 screen-reader survey showing 67% of users encounter access...

In this episode, Lucas and Luna dive into test prioritization — a smarter way to run test suites that cuts CI pipeline time without sacrificing quality. Lucas explains how techniques like risk-based sorting, historical failure data, and machine learning models can reduce test execution by 40 percent or more. They discuss real-world examples from Google's test automation research and how teams at c...

Episode 31 of Software Testing with Fexingo dives into load testing as a diagnostic tool for uncovering performance bugs that unit and integration tests miss. Lucas and Luna discuss how a simulated surge of 10,000 concurrent users on a fintech API exposed a memory leak that had been lurking for months, causing response times to degrade from 200ms to 8 seconds under peak load. They explain key conc...

In episode 30 of Software Testing with Fexingo, Lucas and Luna explore how A/B testing can serve as a powerful bug-finding tool — catching issues in production before they impact all users. They walk through a real-world case from a major e-commerce platform that used controlled experiments to uncover a subtle regression in checkout flow, saving millions in lost revenue. The conversation covers se...