← Back to blogs

Quality is a team sport. Not a gate.

QAqualityprocessesshift-left

It's Monday afternoon, you're just back from your holiday, you open Jira and the Ready for Test lane has grown to twelve tickets (or more) while you were away. And on the Retro board? A sticky about QA being a bottleneck.

Here's the thing though: a bottleneck is never a single person. If one shows up, it's the process that's broken, never a single person.

Loads of companies still run a model that sounds perfectly logical on paper but doesn't hold up in real life:

  • Developers build.
  • QA tests.
  • QA gives the final approval.
  • Release.

And look, in a smaller, slower environment that can work just fine. Not so much in faster or bigger teams, as the number of developers almost always grows quicker than the QA team, and quality doesn't magically scale along with it.

So the team grows (or QA is simply off for a week) and a queue starts forming. Then the ping pong begins. Context gets lost (honestly, do you remember what you did last week?), tickets bounce back and forth, merge conflicts get more and more common, and you find problems weeks after the decisions that caused them.

In this post I want to share how I see Shift Left, what I think the QA role should actually be, and why quality (especially scaling it) works so much better when the whole team is in on it.

What Shift Left actually means to me

"Shift Left" gets thrown around a lot, which doesn't help as it means completely different things to different people. Mostly caused by the fact that most people don't understand what it actually is for.

There's no single way to do it either. Every company, team and product has its own problems. For me it comes down to this: stopping problems from being created in the first place.

That means asking better questions earlier on, challenging assumptions and getting the right people in the room before decisions are already locked in. A question in refinement might cost you an extra fifteen minutes. Exactly the same question after development is done (and after everyone's lost the context...), or even after it's hit production, can cost days.

In practice it looks like:

  • Making sure we understand the problem before we build a solution.
  • Spotting risks before they turn into defects.
  • Involving the right people at the right moment.
  • Sharing ownership of quality instead of pushing it all onto one final step.

So no, Shift Left isn't just "do the QA stuff earlier on the timeline". In fact, most of it has nothing to do with testing at all. It's about making quality part of the decisions that happen all the way through development.

QA is not the same thing as testing

When people hear QA, they often only think about testing. Testing is a part of it, sure, but the role is much wider than running test cases (or automation for that matter).

Think about it: a developer isn't just someone who writes code, and a product manager isn't just someone who writes requirements. In the same way, QA isn't just someone who checks whether something works.

QA is about increasing confidence in what we build. That means understanding risks, questioning assumptions, helping the team work out what "ready" and "done" really mean, improving how we collaborate, and learning from problems instead of just fixing one bug at a time. Testing sits inside all of that.

This is also where I think the ISTQB certificate (still super common on QA CVs) can cause a bit of confusion. To be clear, there are loads of brilliant QA engineers with ISTQB certifications, and it teaches some useful stuff: testing techniques, coverage, test levels, the foundations. The problem is that the certification knowledge becomes the whole definition of QA, even amongst many QA.

A lot of traditional testing knowledge fits neatly into a verification model:

  • One team builds.
  • Another team checks.
  • QA gives confidence before release.

That model isn't wrong! It solves a real problem. But as teams and products grow, it gets harder to scale when all the quality decisions are squeezed into one stage of the process.

A QA engineer in a Shift Left environment still tests, still thinks about coverage and still builds automation. The difference is that they also help the team think about risk, impact and confidence much earlier.

The kind of questions they might ask:

  • Are we solving the right problem for the user?
  • What assumptions are we making?
  • What could go wrong?
  • How will we know this works?
  • How can we test this?
  • Who else needs to be involved?
  • What impact could this have on future changes?

Those conversations are often where QA can have the biggest influence. An extra benefit is that testing 'on the left' is much cheaper than the traditional method as well. Both in terms of money as well as resources and effort.

Everyone contributes to quality

Shift Left sometimes gets seen as "less QA involvement" or "developers are now responsible for everything". That's not how I see it at all.

Developers testing their own work is just part of good engineering. QA engineers still test and still build automation. That hasn't changed at all. What changes is where everyone puts their attention.

Not every change carries the same risk:

  • A small UI tweak and a change to authentication are not the same thing.
  • A copy update doesn't need the same validation as a payment flow.

This is where a risk-based approach really helps. The team looks at the impact of a change and decides together how much confidence they need.

So the conversation shouldn't be:

"QA doesn't need to look at this."

It should be:

"Given the risk and impact, what's the best way to validate this and who is most suited to do so?"

And finding a problem while you're still working on the feature is much easier than finding it weeks later. The context is still fresh, everyone still remembers why the decisions were made, and the people involved can sort it out together. That's a much faster feedback loop for everyone involved.

Moving towards Shift Left also means changing habits, and that's not always easy. People need to understand why the change is happening, what's expected of them and how it makes their work better. In my experience the best improvements come when a team gets the reason behind a change, not when someone just drops a new process on them. So focusing on the 'why' before the 'what'.

What this looks like in practice

I've worked on this with different teams and companies over the years, and the focus was always a bit different depending on where the team was at the time. Some of the things I've done:

  • Explaining what Shift Left means and why it can help.
  • Changing expectations around the QA role.
  • Helping teams understand who owns quality.
  • Running small experiments to compare different approaches.
  • Using data and examples to see where the process creates problems.
  • Helping developers get more comfortable with testing.
  • Answering questions and talking through concerns openly.
  • Bringing in improvements step by step, with the team.

Shift Left shouldn't happen because it's popular or because another company does it. The better question is:

"We have this problem. How can we improve the way we work?"

Metrics, examples and feedback make those conversations far more practical (and you will get a lot more support for the idea as well).

Final thoughts

I still love the technical side of QA: building frameworks, improving tooling, automating where it adds value and solving problems with code.

But after working with many different teams, I've realised that QA's biggest impact often comes from improving how teams think about quality. Sometimes the biggest win is simply a team asking better questions earlier, understanding risks before they become problems and working together more effectively.

Those changes are way less visible than shipping a shiny new framework or finding a pile of bugs. But over time they tend to make a much bigger difference.

Quality isn't something a team should check at the end, but something created throughout the process. It is a team sport, not a gate.


Alex Hovenkamp