Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / How Shift-Left Testing Saves Your Release Timeline
Transcript
- Lucas: If I say the words 'shift-left testing,' a lot of engineers roll their eyes. It sounds like yet another buzzword from a conference talk. But I want to talk about a specific fintech company — let's call it PayBridge — that actually put shift-left into practice and cut their average release cycle from three weeks down to five days. Luna: Five days from three weeks? That's a big jump. What did they actually change? Lucas: The short version: they moved testing from the end of the sprint to the beginning — and even before the sprint. The typical workflow used to be: developers write code, push it, then a QA team runs a full regression suite maybe two days before release. If something failed, the whole release got delayed. That's shift-right testing, by default. Luna: Right, the classic bottleneck. So PayBridge flipped it — how? Lucas: They introduced what they called a 'quality budget.' Every developer got a budget of, say, 10 minutes per commit for pre-commit checks. Those checks included linting, unit tests, and contract tests for any API changes. If your commit took longer than 10 minutes to validate, you had to break it into smaller pieces. That forced the team to write smaller, more focused tests. Luna: Interesting. So the constraint was time, not coverage. That sounds like it would push people to write fast, meaningful tests rather than just a ton of slow integration tests. Lucas: Exactly. And the data backs it up. After three months, their pre-commit test suite had about 1,200 tests, and the average run time was 4.3 minutes. They also introduced a 'red-green gating' policy: if a commit failed any pre-commit test, it couldn't be merged. Period. Luna: That's strict. I've seen teams push back hard on that — developers hate being blocked. Lucas: Yeah, and there was pushback. But the engineering manager tracked something: the number of 'blocked merges' per week actually dropped after the first month. Because once tests were fast and reliable, people stopped seeing them as a blocker and started seeing them as a safety net. The key metric was that post-merge regression failures dropped by 67 percent quarter-over-quarter. Luna: That's a concrete number. So the shift-left approach basically saved them from finding bugs at the end — when fixing them is most expensive. Lucas: Right. And it's not just about speed. It's about feedback. When a developer writes code and gets a test failure in under five minutes, the context is still fresh. They can fix it immediately. Compare that to finding a bug three weeks later in a staging environment — you might have already moved on to three other features. Luna: That's the real win. Fast feedback reduces cognitive load. But I'm curious — what kind of tests did they prioritize? Was it all unit tests, or did they do something like contract testing? Lucas: Great question. They actually invested heavily in contract testing. Every service in their microservices architecture — they had about 40 services — had a contract test that verified the API interface. And those contract tests were run as part of the pre-commit suite. So if you changed a service's endpoint, the test would fail unless the consumer service's tests also passed. Luna: That's smart. It catches integration issues before they ever hit a staging environment. And it forces teams to communicate about API changes. Lucas: Exactly. And the interesting thing is, they didn't stop at the dev level. They also shifted left on performance testing. Instead of running load tests once a quarter in production, they integrated a lightweight performance regression test into the CI pipeline. It ran on every pull request — just a three-minute test hitting the critical path with simulated traffic. If response times increased by more than 10 percent, the PR was flagged. Luna: That's a really practical approach. And it's specific — not a full load test, just a smoke test for performance regressions. I bet that caught a lot of subtle issues early. Lucas: It did. About 12 percent of pull requests got flagged in the first two months. Most were things like an accidental N+1 query or a missing database index. Fixing those before merge saved hours of debugging later. Luna: So the whole philosophy is: catch problems as close to the source as possible, with fast feedback. It makes so much sense, but actually implementing it takes discipline. And I imagine the hardest part is getting buy-in from product managers who just want features shipped. Lucas: That's where the 'quality budget' came in. They framed it as a timeboxed investment. Each sprint, 15 percent of capacity was allocated to testing infrastructure and test improvements. Product managers could see that the release cycle was shrinking, so they were willing to accept that trade-off. Luna: That's a really clean way to frame it. It's not about 'slow down to go fast' — it's about 'invest now to ship faster later.' And they had the metrics to prove it. Lucas: And that's the kind of conversation that, honestly, keeps this show going. A couple of dollars a month is genuinely what keeps these episodes ad-free — buy me a coffee dot com slash fexingo, if you've gotten something out of them. Luna: Yeah, it really does make a difference. Even small contributions help us keep digging into stories like this one. Lucas: So back to PayBridge — one more detail I found fascinating. They also started doing 'test impact analysis' using code coverage data. When a developer made a change, the CI system would automatically determine which tests were affected and only run those. That cut their average CI run time from 22 minutes to 8 minutes. Luna: That's a huge improvement. And it makes the pre-commit gating much more palatable — nobody wants to wait 22 minutes to merge a one-line fix. Lucas: Right. The technology to do that is getting better. Tools like Bazel or Nx can do dependency graph analysis. But even simpler approaches — like mapping source files to test files with a convention — can get you most of the way there. Luna: So what's the takeaway for a team that wants to start shifting left but doesn't have the resources of a fintech company? What's the smallest step? Lucas: I'd say start with one thing: enforce a pre-commit hook that runs a linter and a small set of critical unit tests. Just that. See how much friction it creates. Measure how many times it catches a bug before code review. If it works, add contract tests for one service. The key is to start small and measure the impact. Luna: And the metrics are your sell. If you can show that shift-left reduced regression bugs by 67 percent, product managers and executives will listen. Lucas: Exactly. And that's the story from PayBridge. They didn't overhaul everything overnight. They started with a quality budget and a few contract tests, and iterated from there. Eight months later, they were shipping to production every five days instead of every three weeks. Luna: That's a compelling case study. I think the biggest lesson is that shift-left isn't a tool or a process — it's a mindset change. And it starts with developers and QA working together from the first commit. Lucas: Well said. Next episode, I want to dive into something related: how to write tests that actually fail when they should — avoiding brittle tests that give false confidence. Luna: That sounds like a perfect follow-up. See you next time.