What does a check in the pipeline catch, and what does it not?
What it does catch: keys and passwords that end up in code, known unsafe functions, input that goes unfiltered into a query, outdated components with a known vulnerability, and settings that leave something open that should be closed. What it does not catch: flaws in the logic of your permissions. That user A can retrieve user B's data is not a pattern but a consequence of how your rules were written, and no scanner can see that. That is why a short manual review should sit alongside the automated check.
Won't this slow us down?
The checks themselves take minutes in the build, which is negligible. What slows you down is a badly tuned gate: blocking everything on a list of hundreds of open findings. That is precisely why we clean up first and only then start blocking, agreeing per category what stops a build. In practice it saves time overall, because fixing things afterwards costs more than correcting them as you write.
How do we stop the check from being switched off?
With a proper exception route. There will come a moment when something has to get through despite a finding: an outage, a deadline, a supplier that has nothing yet. If there is no route for that, the check gets switched off, and then you lose everything rather than just that one case. The route records who signs off and until when the exception applies, so there is something to come back to later.
Will we need extra people for this?
Rarely. The work lies in the setup and the agreements; after that it costs your team less time than the repairs it replaces. What you do need is an owner: someone who manages the gates and assesses the exceptions. That is usually half a day a month, and it is generally the same person who assesses the vulnerabilities, because it is the same trade-off.
We use AI tools when developing. Does that make a difference?
Yes, and it strengthens the case. More code comes through than a team can read, and tools that generate code optimise for working code, not secure code. That is no reason not to use them, but it does shift where the check needs to sit: from the reviewer to the pipeline. On top of that, there is a category that classic scanners do not cover, such as instructions that arrive from outside and are followed by an AI feature; that calls for a separate approach.
Does this also work on older software?
Yes, and the first round is the hardest there because the accumulated backlog becomes visible all at once. We tackle that by working strictly per category and only blocking what is clean. With very old systems, this often goes hand in hand with a conversation about
modernisation or about
technical debt, because some findings cannot be resolved without touching the structure.
Will this cost us new licences?
Not necessarily. For secrets, dependencies, containers and most static analysis, open-source tooling is available that fits into your existing build pipeline, and many platforms have basic functionality built in. Paid products mainly add an overview across many projects and better noise suppression. We start with what you already have and set out any recurring costs for you up front.
What do we do with the existing backlog?
We set it aside. New findings are blocked from day one or given a deadline; the existing list gets its own approach, prioritised by impact rather than by the published score. That separates the two conversations: the gate is about what comes in from now on, the backlog about what was already there. Without that separation, one blocks the other.
Can we demonstrate this to a client?
Yes, and that is one of the reasons for doing it. We set up the reporting so you can show which checks run, how often, and what the outcome was, including the exceptions and their justification. That is exactly what procurement questionnaires and audits ask for, and it is far more convincing than a policy document.
How does this compare with a pentest?
They find different things, and neither replaces the other. The pipeline catches known patterns, continuously and cheaply. A pentest finds what the pipeline misses: flaws in your permissions logic, chains of small issues that add up to something serious, assumptions that are only wrong in your context. What does change is that your pentest becomes more valuable, because the tester no longer spends their time reporting outdated components.
Who should lead this on our side?
Someone from the development team, not someone from outside it. Security controls imposed by a separate department are seen as an obstacle and disappear as soon as attention drifts. That is why we work with your developers and agree the rules with them. The security officer is the client and a reviewer, which works better than the other way round.