Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / Why Shift-Left Testing Saves Millions
Transcript
- Lucas: So we talk a lot about catching bugs before they hit production, but there's a whole philosophy that says you should find them even before you've written the code. It's called shift-left testing, and it's one of those ideas that sounds obvious in theory but gets really messy in practice. Luna: Shift-left — moving testing earlier in the development lifecycle. I've heard the term thrown around, but honestly, most teams I know are still struggling to get good test coverage on the code they already have. Lucas: Exactly. And that's the tension. Let me give you a concrete example. There's a fintech company — I won't name them, but they process billions in transactions — they did an internal study a couple years ago. They found that a bug caught during the design phase cost them roughly $100 to fix. That same bug, if it made it to production, cost them over $16,000. So the math is screaming at you to test earlier. Luna: Sixteen thousand dollars versus one hundred. That's a hundred-sixty times multiplier. But how do you test something that doesn't exist yet? You can't run a test case against a wireframe. Lucas: You're right, and that's where a lot of teams get hung up. Shift-left isn't just about automated test scripts. It's about activities like requirements review, static analysis of design documents, and model-based testing. The fintech company I mentioned — they started doing something called 'test design workshops' where testers sat in on the requirements meetings and wrote test scenarios before a single line of code was written. Luna: So the testers are essentially acting as a second set of eyes on the spec itself. That makes sense, because a lot of bugs are really just misunderstood requirements. Lucas: Bingo. A 2025 study from Tricentis — the test automation folks — looked at over a thousand software projects. They found that 44 percent of all bugs originated from flawed or incomplete requirements. If you catch those before development starts, you've eliminated nearly half the potential defects without writing a test script. Luna: That's a huge number. But I have to push back a little — doesn't this slow things down? In a sprint, developers want to start coding immediately. If you're spending two days in a test design workshop, that's two days where nothing is being built. Lucas: It's a valid concern, and the data actually addresses it. The same Tricentis study tracked the time spent on shift-left activities versus the time saved in debugging. They found that for every hour spent on shift-left testing, teams saved eight hours of debugging and rework later. So yes, you're front-loading the effort, but the net time saved is massive. Luna: Eight to one return on time investment. That's the kind of ratio that would make any project manager sit up and take notice. But I imagine the cultural shift is the hardest part. Developers are used to writing code first, testing later. Lucas: It's a huge cultural change. And it doesn't happen overnight. The fintech company I mentioned — they started small. They picked one critical payment processing module and ran a pilot. They paired a senior tester with the lead developer during the design phase. The tester would ask questions like 'What happens if the database connection times out during this transaction?' The developer would realize they hadn't considered that edge case. Luna: So it's almost like a code review before the code exists. I like that. But how do you scale that? You can't have a senior tester pair with every developer on every feature. Lucas: You're right, you need tooling to support it. Static analysis tools that run on your design documents, or even on your requirements written in a structured language. There are tools now that can take a Gherkin feature file — that's the 'given when then' format — and automatically generate test scenarios. So the tester writes the feature file, and the tool generates the test scripts. Luna: That's interesting. So the shift-left isn't just about process; it's about enabling the process with automation. But I still wonder about the cost of maintaining all these early tests. If the requirements change — and they always do — you've got a bunch of test scenarios that are now out of date. Lucas: That's the biggest criticism of shift-left, honestly. You invest in tests that might be invalidated by a requirement change. But the counterargument is that those requirement changes themselves are less likely to happen if you've already clarified them early. And when they do change, the test scenarios act as a living specification. You update the scenario, and now everyone knows what the new expected behavior is. Luna: So the test becomes the documentation. That's actually a powerful idea — instead of having a separate spec document that goes stale, your test cases are the source of truth. Lucas: Exactly. And that's where the term 'shift-left' gets really interesting. It's not just about catching bugs early; it's about changing how the entire team thinks about quality. In a traditional model, testing is a separate phase after development. In a shift-left model, quality is everyone's responsibility from the very beginning. Luna: Okay, so let's talk about concrete metrics. The fintech company saved $2.4 million over two years by shifting left. What were they measuring? Lucas: They tracked defect detection rate by phase. Before shift-left, about 70 percent of their bugs were found during system testing or later. After implementing shift-left practices — design reviews, static analysis, and automated unit tests written alongside code — that number flipped. Seventy percent of bugs were found before code was even committed to the repo. The downstream testing phases became more about validation than debugging. Luna: That's a complete inversion. And I imagine the morale of the testing team improved too, because they weren't just firefighting in production anymore. Lucas: Absolutely. One of the test leads there told me that before shift-left, their testers were burned out from constantly dealing with emergency patches. After, they felt like they were actually preventing problems instead of just cleaning up messes. It's a huge shift in job satisfaction. Luna: So for a team listening today who wants to start shifting left, what's the first thing they should do? Not the whole methodology, just the first step. Lucas: I'd say start with a static analysis tool on your codebase if you haven't already. That's the lowest-hanging fruit. Tools like SonarQube or ESLint can catch potential bugs, security vulnerabilities, and code smells before the code even gets reviewed. And they run automatically on every commit, so it's not a manual process. Luna: That's a good starting point. But doesn't static analysis generate a lot of false positives? I've seen teams get frustrated and start ignoring the warnings. Lucas: It can, yeah. The key is to configure the tool to your team's standards. Start with the most critical rules — things that could cause a crash or a security breach — and gradually add more. And make sure that when a warning is raised, someone actually reviews it. If you treat it as noise, it will become noise. Luna: Fair point. So step one: configure static analysis and actually pay attention to it. Step two? Lucas: Step two: start a test design workshop for your next major feature. Just one. Invite the developer, the product manager, and a tester. Spend two hours walking through the acceptance criteria and writing given when then scenarios. At the end of the workshop, you'll have a shared understanding and a set of test cases that can be automated later. Luna: I like that it's limited to one feature. That makes it feel manageable. And what about the rest of the team? How do you get buy-in from developers who are skeptical? Lucas: Data is your friend. Show them the $100 versus $16,000 number. Better yet, run a small pilot and track how many bugs are caught in the workshop versus found in testing. When they see that the workshop prevented three critical bugs that would have taken days to fix, they'll start to believe. Luna: It's a proof-by-experiment approach. I can see that working in a culture that values evidence. But I also think there's a generational shift happening. Newer developers coming out of bootcamps and CS programs are being taught test-driven development from day one. So shift-left might become the default in a few years. Lucas: I hope so. Because the cost of not doing it is just too high. And with ai assisted test generation becoming more common, shift-left is only going to get easier. Imagine an AI that can look at your requirements and automatically generate a set of test scenarios. That's already happening with tools like Testim and Mabl. Luna: So the future is: you write the spec, AI generates the tests, and the developer writes the code to pass those tests. That's a pretty tight feedback loop. Lucas: Exactly. And that's the ultimate shift-left — testing before the code exists, with AI as the enabler. But even without AI, the principle holds: the earlier you think about quality, the better the outcome. Luna: Alright, I'm convinced. But I have one last question: what about legacy systems? You can't exactly go back and do design workshops for code that's been running for ten years. Lucas: Good question. For legacy systems, you start with characterization testing — you run the system, capture its actual behavior, and turn that into a set of tests that document the current state. That's a form of shift-left because you're creating a safety net before you make changes. Then, for any new feature or refactor, you apply the shift-left practices. Luna: So you eat the elephant one bite at a time. That makes sense. I think the key takeaway for me is that shift-left isn't a binary thing — it's a spectrum. You can start small and gradually move more testing activities earlier. Lucas: Exactly. It's not all or nothing. Even just doing code reviews earlier — that's shift-left. The important thing is to start moving in that direction, because every bug you catch early is one that won't cost you sixteen thousand dollars later. Luna: Alright, Lucas. I think we've given our listeners a concrete roadmap. Next time someone says 'shift-left,' they'll know it's more than a buzzword — it's a cost-saving, quality-improving discipline. Lucas: And hopefully they'll have a few numbers to back it up at their next standup. For Software Testing with Fexingo, I'm Lucas. Luna: And I'm Luna. See you next time.