Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering
by Fexingo
Lucas and Luna examine the discipline of software testing as a strategic function, not a checkbox. Each episode focuses on a specific testing practice — from unit test coverage metrics and integration test design patterns to the economics of test automation ROI and the psychology of flaky test triage. They walk through real-world case studies: how Stripe reduced regression defects by 40% with contract testing, the trade-offs between Selenium and Cypress for e-commerce checkouts, and why Google's test size taxonomy (small/medium/large) forces better architectural decisions. Lucas explains the math behind mutation testing scores and the diminishing returns of 100% code coverage; Luna challenges him on how to sell testing budgets to skeptical product managers and when manual exploratory testing still outperforms automation. They also explore testing philosophies — shift-left vs. shift-right, risk-based testing prioritization, and the role of AI in generating test oracles. The listener lea
Episodes
-
Why Your Best Tests Miss The Real Risks
Most software teams treat testing as a gatekeeper, but the real danger lies in what they choose not to test. This episode explores the concept of risk-based testing prioritization using a specific case study from a major fintech platform that shifted its QA strategy. We examine how focusing on...
-
How GitHub Copilot Transformed Developer Quality
We examine how AI coding assistants have shifted software testing from a gatekeeping function to a continuous quality signal. By analyzing specific metrics from recent engineering reports, we explore how teams are integrating automated test generation into their daily workflows to reduce flaky...
-
How Netflix Prevented Its Recommendation Engine From Collapsing
In October 2026, we look at how Netflix engineered its recommendation system to handle unprecedented scale without breaking. This episode explores the specific architectural decisions that turned a fragile data pipeline into a resilient engine. We discuss the trade-offs between real-time...
-
How Microsoft Prevented Cloud Collapse
In October 2026, we look at how Microsoft shifted from traditional QA to a rigorous chaos engineering model within Azure. Lucas and Luna explore the specific incident that forced this change, the implementation of automated fault injection in production environments, and why testing for failure…
more -
How To Fix Flaky Tests Without Killing Velocity
Flaky tests — automated checks that pass sometimes and fail others — are a silent tax on engineering velocity, costing teams hours of wasted debugging time every week. In this episode, we examine how a major e-commerce platform reduced their flakiness rate from four percent to under one percent…
more -
How Airbnb Solved The Testing Paradox
Airbnb faced a unique dilemma in 2023. Their platform connected millions of hosts and guests, but their testing infrastructure was built for a simpler world. As they scaled globally, traditional QA methods began to break down under the weight of localization, regulatory complexity, and real-time...
-
How AI Reshapes Software Testing
As we navigate October 25, 2026, the software testing landscape is undergoing a seismic shift driven by generative AI. This episode explores how leading engineering teams are moving beyond traditional automation to embrace AI-driven test generation and intelligent defect prediction. We examine...
-
Why Code Reviews Are The Real QA
Most engineering teams treat code reviews as a quality gate, but they are actually the primary mechanism for risk mitigation and knowledge transfer. In this episode of Software Testing with Fexingo, we examine how top-tier organizations like Google and Atlassian structure their review processes…
more -
How Netflix Stabilized Its Chaos Engineering Culture
In this episode of Software Testing with Fexingo, we dive into the specific mechanics behind how Netflix transformed chaos engineering from a risky experimental protocol into a disciplined, team-owned reliability practice. We explore the evolution of their internal platform, the cultural shift...
-
How Feature Flags Prevent Deployment Disasters
Software teams are moving away from risky code freezes and toward feature flags as their primary safety net. This episode explores how major tech companies use toggle-based deployments to isolate failures, enable gradual rollouts, and maintain velocity without sacrificing stability. We look at…
more -
How Figma Stopped Testing From Killing Velocity
Figma faced a classic engineering paradox: their design tool was so complex that every code change risked breaking user workflows, yet they couldn't afford to slow down development. This episode explores how they moved beyond traditional regression suites by implementing property-based testing…
more -
How Spotify Fixed Its Testing Culture
Lucas and Luna explore how Spotify transformed its engineering quality by shifting from rigid QA gates to developer-owned testing. They examine the specific metrics behind this cultural change, why traditional test automation often slows delivery, and how teams can balance speed with reliability...
-
Why Your Best Tests Miss The Real Risks
We talk about how automated testing suites create a false sense of security by optimizing for code coverage rather than actual user risk. Lucas and Luna examine why teams that hit ninety-five percent test coverage still ship catastrophic bugs, focusing on the difference between verifying that…
more -
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...
-
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...
-
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...
-
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...
-
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…
more -
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.…
more -
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...
-
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...
-
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…
more -
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...
-
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…
more -
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...
-
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...
-
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...
-
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…
more -
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…
more -
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...
-
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...
-
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…
more -
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…
more -
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...
-
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…
more -
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...
-
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…
more -
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...
-
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...
-
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...
-
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…
more -
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...
-
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...
-
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…
more -
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...
-
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…
more -
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…
more -
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...
-
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...
-
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…
more
About this show
Lucas and Luna examine the discipline of software testing as a strategic function, not a checkbox. Each episode focuses on a specific testing practice — from unit test coverage metrics and integration test design patterns to the economics of test automation ROI and the psychology of flaky test triage. They walk through real-world case studies: how Stripe reduced regression defects by 40% with contract testing, the trade-offs between Selenium and Cypress for e-commerce checkouts, and why Google's test size taxonomy (small/medium/large) forces better architectural decisions. Lucas explains the math behind mutation testing scores and the diminishing returns of 100% code coverage; Luna challenges him on how to sell testing budgets to skeptical product managers and when manual exploratory testing still outperforms automation. They also explore testing philosophies — shift-left vs. shift-right, risk-based testing prioritization, and the role of AI in generating test oracles. The listener lea
Hosted by
Fexingo
Categories