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

Lucas and Luna explore why testing on real devices is critical for catching hardware-specific bugs that emulators miss. They break down a case where a fintech app crashed on 4% of Android devices due to a GPU driver issue, discuss how Apple's silicon transition exposed emulator blind spots, and explain practical strategies like cloud-based device farms and targeted device matrices. This episode gi...

In this episode of Software Testing with Fexingo, Lucas and Luna explore why many test automation efforts fail not because of bad tools, but because of missing feedback loops. They dive into a case study from a fintech startup that cut its bug-to-fix time by 70 percent by implementing a simple feedback mechanism: every failed test automatically created a structured bug report with logs, screenshot...

In this episode of Software Testing with Fexingo, Lucas and Luna explore why traditional end-to-end tests often miss critical failures—and how adding observability transforms them into powerful debugging tools. They walk through a real-world example: a major e-commerce checkout flow that passed all automated E2E tests but silently broke for users due to a third-party payment timeout. The hosts exp...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into the critical role of security testing in modern QA. While many teams focus on functional and performance testing, security testing often takes a back seat until a breach occurs. Lucas explains the key differences between penetration testing and automated vulnerability scanning, using the 2023 MOVEit Transfer vulnerability a...

Lucas and Luna explore why traditional test pass/fail results aren't enough. They break down how observability-driven testing — combining structured logs, distributed traces, and real-time metrics — helps teams pinpoint root causes in minutes instead of hours. Using a real example from a fintech startup that cut its average debug time from 90 minutes to 15, they show how instrumenting your test su...

Episode 24 of Software Testing with Fexingo dives into the overlooked power of logging. Lucas and Luna explore how structured logging, log levels, and observability pipelines can slash debugging time by up to 40 percent, using real-world examples like a production outage at a major e-commerce platform. They contrast logging with traditional debugging methods, discuss the ELK stack, and explain why...

In this episode, Lucas and Luna argue that accessibility testing is not just a compliance checkbox but a core software quality practice. Lucas cites a 2023 WebAIM study showing that 96.8 percent of the top one million homepages have detectable WCAG failures, and walks through the most common violations like missing alt text and low color contrast. They discuss how implementing automated tools like...

Lucas and Luna explore contract testing as a solution to microservices integration failures. They break down how companies like Netflix and Uber use consumer-driven contract tests to catch breaking API changes before deployment, using real-world examples like a payment service that broke a checkout flow. The episode explains the difference between provider and consumer contracts, the tools (Pact,...

Lucas and Luna explore why copying production data for testing is a security and compliance nightmare—and how synthetic test data generation solves it. They walk through a real-world case: a mid-sized fintech company that reduced PII exposure by 94 percent using generative AI to create realistic fake data, while also cutting test data provisioning time from two weeks to four hours. The hosts discu...

Episode 20 of Software Testing with Fexingo digs into chaos engineering — deliberately injecting failures into production systems to uncover weaknesses your test suite never hits. Lucas and Luna explore how Netflix pioneered the approach with Chaos Monkey, and why teams today are adopting controlled experiments like latency injection and instance termination to build resilience. They discuss where...

Unit tests verify individual functions, but they can't simulate real-world load or concurrency issues. In this episode, Lucas and Luna explore a real case: a fintech startup whose checkout service passed every unit test but collapsed under Black Friday traffic because of a subtle database connection-pool leak. They break down why performance testing—specifically load testing with tools like k6 and...

Episode 18 of Software Testing with Fexingo dives into property-based testing—a technique that shifts from writing individual test cases to defining general properties your code must satisfy. Lucas and Luna explore how companies like Stripe use property-based testing with tools like Hypothesis and QuickCheck to uncover edge cases that traditional example-based tests miss. They discuss the concrete...

In this episode of Software Testing with Fexingo, Lucas and Luna explore visual regression testing — a technique that catches layout and styling bugs that functional tests miss. They break down how a major e-commerce company lost millions because a CSS change broke the checkout button on mobile devices, and how visual regression testing could have caught it before release. The hosts discuss thresh...

In episode 16 of Software Testing with Fexingo, Lucas and Luna explore mutation testing—a technique that injects small faults into your code to see if your tests catch them. They break down how it works using a real-world example: a payment processing function that passes all unit tests but silently rounds pennies incorrectly. Lucas explains why traditional code coverage tells you what code ran, n...

In this episode, Lucas and Luna drill into a quiet productivity killer in software testing: unmanaged regression test suites. They walk through a real-world case: a mid-stage SaaS team that saw its sprint velocity drop 40 percent over 18 months, not because they shipped bad code, but because their regression suite ballooned from 400 tests to 7,200 without pruning. Lucas breaks down the math — each...

In this episode, Lucas and Luna explore how canary releases reduce risk in software deployment by rolling out changes to a small subset of users first. They walk through a real-world example: a payment processing company that avoided a catastrophic data corruption bug by catching it in a 2-percent canary. The hosts explain the mechanics—how traffic splitting, automated rollback triggers, and obser...

Lucas and Luna dig into test flakiness — tests that fail without any code change. They break down why flaky tests destroy developer trust, waste hours of CI pipeline time, and silently undermine entire QA strategies. Lucas cites real data: Microsoft's 2014 study found 14% of test failures are flaky, and a 2023 Google survey showed teams spend 10–30% of sprint time re-running and debugging false fa...

Episode 12 of Software Testing with Fexingo examines why the quality of test data often matters more than the volume of test cases. Lucas and Luna dive into the 70-30 rule—70 percent of test failures trace back to data issues, not code bugs—using the 2024 CrowdStrike outage as a real-world case study. They discuss how synthetic data generation, production-like datasets, and data versioning can pre...

In this episode of Software Testing with Fexingo, Lucas and Luna tackle a problem that derails even the best test suites: unreliable test environments. Lucas explains why environment drift is the silent killer of test validity, using a case study of a fintech startup where 40% of test failures were false alarms caused by configuration mismatches. They discuss practical strategies like infrastructu...

In episode 10 of Software Testing with Fexingo, Lucas and Luna dive into the concept of testability as a design principle, not an afterthought. They dissect how code written without testing in mind creates hidden costs—longer debug cycles, flaky suites, and fragile refactors. Lucas introduces the concrete example of a fintech startup whose QA velocity doubled after enforcing dependency injection a...

In this episode, Lucas and Luna dive into the overlooked practice of bug taxonomy — categorising software defects by root cause, severity, and occurrence pattern. They explain why most QA teams skip this step, and how a structured taxonomy at companies like Microsoft and Google has cut bug-fix time by up to 30 percent. Using real examples — from a null-pointer crash in a NASDAQ trading engine to a...

Lucas and Luna dive into the hidden failure of test coverage metrics. They unpack why hitting 90% line coverage can still let critical bugs slip into production, using a real example from a mid-size fintech company that shipped a payment-calculation error despite excellent coverage. The hosts explain the distinction between coverage as a vanity metric and coverage as a meaningful risk signal, disc...

Lucas and Luna explore why most test suites waste resources testing the wrong things. They anchor on a real example: a fintech company that reduced its regression suite by 60 percent after mapping test cases to business risk. The hosts walk through the concept of a risk matrix — plotting feature criticality against failure probability — and show how it changes test prioritization. They discuss tra...

Lucas and Luna dive into flaky tests—software tests that fail intermittently for no apparent code change. They explore why infrastructure instability, not your code, is often the culprit, using a real case from a mid-size fintech company where a failing test traced back to a memory-constrained CI runner. They discuss how to diagnose flaky infrastructure, the role of deterministic test environments...

In this episode of Software Testing with Fexingo, Lucas and Luna dive into shift-left testing—the practice of moving testing earlier in the software development lifecycle. Lucas breaks down the cost-benefit analysis using a real example from a major fintech company that saved $2.4 million by catching bugs in design phase instead of production. They discuss how traditional testing is like a 'rework...