Implementing a 3-Gate Quality System: Moving from Reactive Chaos to Operational Readiness

by | Nov 16, 2026 | Uncategorised

The Cost of Catching Mistakes Late

Anyone who has worked in product or development knows the feeling. A feature, system or product goes live after months of hard work. Then the call comes at 5:30 on a Friday afternoon with the ever-helpful statement: “It’s broken.”

My heart drops, then kicks into overdrive. I jump on to find a solution or push a hotfix as quickly as I can, so the client has as little downtime as possible. The result is long hours and a lot of stress.

This is an ongoing battle for any software or development house, and it will still crop up from time to time. But we are always working to reduce how often it happens. That way, our team can focus on stability and building rather than jumping from one fire to the next, stuck in a permanent state of crisis management.

Why “More Testing” Isn’t the Answer

When something breaks, the default reaction is that it wasn’t tested properly, so the solution must be more testing. But is that really the answer? In our experience, no.

We’ve found it far more effective to bring our QA (quality assurance) team in much earlier. Rather than seeing a project for the first time just before release and scrambling to get up to speed, they’re part of the journey from day one. As a result, they share our understanding of how the project is evolving and what the stakeholders expect.

Delivery is always an iterative process, and a lot can shift along the way. Having product owners and QA in the conversation helps massively, and it has saved us a great deal of time on lengthy onboarding sessions.

So how do we do it? With what we fondly call “the 3-Gate system.”

Introducing the 3-Gate System

The 3-Gate system is our Scrum-based delivery process, with enforced human-in-the-loop checkpoints acting as guardrails. These checkpoints help us catch mistakes early, while they are still cheap to fix, and keep everyone’s expectations aligned.

Before the Gates: Clear User Stories — Build the Right Thing

Before development even begins, we set up every task so that the expectations and deliverables match what the client expects and the agreed scope of work.

We do this by writing user stories and refining their acceptance criteria (ACs). Together, these set out the requirements and define the boundaries of each task, so everyone knows what “done” looks like before we write any code.

Gate 1: Shift-Left Testing — Developers Test as They Build

This is where the key change happened. We used to write the code first and then hand it over to our testing team to check that everything worked as expected. Now testing starts with the developer.

As they write each section of code, the developer writes and runs the unit, feature and end-to-end tests alongside it. By the time they finish the code, the person who built it has already tested it, and the scripts are ready to go. The result is faster feedback and the confidence to refactor without worrying about breaking something.

Gate 2: QA Verification — Test Beyond the Happy Path

Once the developer has finished, our QA team takes over. Their first step is to rerun the main test criteria. At this point we fully expect everything to pass. This isn’t about catching the developer out; it’s about confirming the work independently.

From there, QA moves on to the edge cases and “sad paths.” It’s easy to test what happens when a user does everything right. It’s just as important to know what happens when they enter the wrong details, skip a step or do something nobody planned for.

Gate 2 is also a sanity check that everything tested in Gate 1 was actually committed. Code that worked on a developer’s machine but never made it into the build is a classic cause of release-day surprises, and this check catches it early.

Gate 3: The Release Gate — Prove It Works Before It Ships

By this point, our scripts are already written, and we have a solid understanding of the system being tested. That frees us to focus fully on regression runs and stress testing: actively trying to break the system so we can fix and secure any weak points before it ships.

This is also where we build our evidence bundles, which record any breaks or bugs that are found. This gives developers clear visibility when they go in to make fixes. They can quickly see where the break is occurring. This also gives us the data we need to share with the client and include in our audits before we submit for client sign-off.

Evidence bundles are a valuable record after release, too. If a similar issue appears later, we can check whether it’s something we have already fixed or a new bug.

The Human in the Loop

We’re in the age of AI and automation, and we use the tools available to us to streamline our process and speed up turnaround. Manual testing that might take a person three days can be run by an automated script in a couple of hours.

That doesn’t make people any less important. It is essential to have a human at every checkpoint to confirm that each script ran correctly, that the acceptance criteria were met, and that the outcomes are what we expected. As we’ve all seen, AI can do some weird and wonderful things, so it’s up to us to make sure it delivers what we need, and never to assume that it does.

A person reviews and marks every script, regression run and piece of evidence as passed or failed. If something fails, we amend the script as needed and run it again. Because the release is ultimately meant for people, people need to check that it actually makes sense and matches the original request.

This is a critical part of the process: no release goes out until the human in the loop has signed it off.

From Chaos to Operational Readiness: What Changes

Since adopting this system, we have seen a significant improvement in our release cycle.

Testing is far more efficient, saving what used to take days or even weeks. Because we work from scripts, expectations are set upfront, which makes delivery more predictable. Our release team can plan more effectively and share accurate timelines with our clients.

We’ve also had fewer production incidents. Releases go through easily and smoothly, and fewer bugs are reported once a release is in day-to-day use.

Most importantly, our teams are far less stressed. Instead of running from one last-minute crisis to the next, they can work within reasonable timelines and plan and prepare properly.

One System, Every Service

The 3-Gate system has worked so well for us that we have woven it through our business. Every development service we offer is built on the same three gates.

That means whichever development service you choose, you get the same quality guarantees: user stories verified before the build begins, tests written alongside the code, and evidence that the release works before it ships.

Would you like to find out more about our services and how they can work for you? Explore our services