
Episodes
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 debugging to proactive structural resilience. The conversation covers practical steps for mapping your own codebase risks and avoiding the domino effect that took down one of the world’s most popular…
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 it caused within engineering teams, and the measurable impact on vulnerability response times. They examine why treating external researchers as partners rather than adversaries yields higher quality…
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 outages. Lucas and Luna examine the specific engineering decisions that turned a simple checkout button into a global financial backbone. We look at why most fintech startups fail at this layer and what…
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 #SoftwareTesting #AICoding #GitHubCopilot #QualityAssurance #Automation #DeveloperProductivity #TechTrends #EngineeringCulture #CodeReview #BugPrevention #AIHallucinations #DevOps #ContinuousIntegration…
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 than raw numbers. With insights into how a tech giant handles vulnerability reports from thousands of contributors, this conversation offers a practical look at modern software security engineering.…
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 discuss the metrics that reveal test decay, the cultural pressure to ship fast versus test thoroughly, and practical steps to audit your suite without halting development. This is not about writing 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 outputs and examine real-world cases where companies missed critical safety guardrails. The conversation drills into prompt injection risks, output validation strategies, and how to measure reliability…
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 confidence. The conversation drills into specific metrics like mean time to recovery and the opportunity cost of false positives in CI pipelines. #SoftwareTesting #QualityAssurance…
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…
Showing the latest 50 episodes. The full archive of 192 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.