Service · Software development

Setting up DevSecOps.

More code flows through than anyone can still read. A check that runs in the pipeline catches the category of errors that can be recognised mechanically, so your people's attention goes to the errors that can't. We set that up with agreements that stick.

SecretsDependenciesStatic analysisGate agreements

What we do here, and where the limit lies.

In practice, DevSecOps means something simple: the checks you would otherwise do at the end, or not at all, run at the moment code is written and delivered. It is not a separate security project alongside development, but a number of gates on the route the code already takes. The gain is not in finding issues as such, but in the timing: a flaw that surfaces while the code is being written is a short conversation; the same flaw after release is an incident.

There is a reason this is more urgent now than a few years ago. The pace at which code is produced has grown faster than the pace at which people can review it, and tools that generate code are optimised for working code, not secure code. That means more gets through, and more of it contains known patterns – precisely the category that a check in the pipeline catches and an overloaded reviewer does not.

We set up those checks, but most of the work lies in the agreements around them: what blocks, what warns, and how something gets through when it genuinely has to. This ties in directly with your component inventory and with vulnerability management. If your pipeline runs with an external party, we work together with whoever handles that management.

We set this up as a standalone engagement and as part of custom software development. For certification, it connects to ISO 27001-compliant development. Reports from outside the organisation go through our CVD policy.

Three kinds of engagements we get in this area.

Switching everything on at once in an existing project produces a mountain of alerts that nobody will tackle. That is why we work in this order, and only move on once the previous step has settled down.

First engagement · fixed sprint budget

Secrets and dependencies

We always start with secrets. It is the most common mistake, the easiest to catch, and the only one nobody can argue against: a key or password in code has no legitimate exception. Then the dependencies: outdated components with a known vulnerability, linked to your component inventory. Once that category is at zero and stays there, there is enough confidence to take on the next one.

Blocking secretsCleaning up historyDependenciesAutomatic updates
Mid-sized project · fixed sprint budget

Static analysis and containers

Analysis of the code itself for the patterns that can be recognised mechanically: input that ends up unfiltered in a query, unsafe functions, missing checks in the places where they belong. Alongside that, the container and infrastructure layer, where a large share of reported vulnerabilities sit and where a wrong setting leaves something open that should have been closed. We weigh alerts by where they sit, not just by their score.

Static analysisContainer layerInfrastructure as codeNoise suppression
Larger project · fixed sprint budget

Gate agreements and provenance of your build

Defining per category what blocks and what warns, with a clean exception route that records who signs off on what. Alongside that, securing the build pipeline itself: who may deploy what, where the building blocks come from, and whether you can demonstrate for an artefact which code it originated from. That last point is increasingly requested in procurement processes.

In a threat-led test, it is not only whether you find something that counts, but when you found it and what you did next. See the app for the detection and response timeline for that.

Gates per categoryException routeDeployment permissionsArtefact provenance

What you have at the end of an engagement.

Working checks in your own pipeline, plus the agreements that determine whether they are still switched on in six months.

  • Checks in your own pipelineRunning in the build pipeline you already use, with tooling that fits your languages – not a separate environment bolted on next to your process.
  • Gate agreements per categoryA written record of what blocks, what warns with a deadline, and what is information only, agreed with the people who work with it.
  • An exception route that worksA clean way to let something through once, with who signs it off and until when – because without that route the check gets switched off instead of letting that one case through.
  • A clean starting positionExisting findings in the categories you switch on are cleared or deliberately recorded, so the gate closes on a list that stands at zero.
  • Permissions and provenance around the build pipelineWho may deploy what, where building blocks come from, and the ability to trace an artefact back to the code it was built from.
  • Handover to your teamWorking sessions in which your developers assess and fix findings themselves, because a check that nobody can explain gets bypassed within a month.

When this applies to you.

Four situations where setting up checks in the pipeline delivers more than it costs. If you recognise one, there are probably quick wins to be had.

More code than review

More is coming through than anyone can read

The pace has gone up and code review has become the bottleneck, or has quietly become a formality. A mechanical check catches the category of errors that can be recognised automatically, so your people can focus on the rest.

Findings after the fact

The pentest keeps turning up the same kind of flaws

You test periodically and each time a list of known patterns comes back. That is expensive discovery of something the pipeline could have caught, and it makes the test less valuable for what it is actually good at.

Demonstrating to customers

Procurement questionnaires ask for it

Customers ask in their questionnaires whether you have security checks in your development process and whether you can demonstrate it. Reporting that shows the checks have run and what came out of them is exactly what is being asked for.

Earlier attempt stalled

It is switched on but nobody looks at it

A scanner was switched on at some point, hundreds of warnings are open and the channel has been muted. That is not a tooling problem but an agreements problem, and that is exactly where we start.

How a project works.

1

Introduction and baseline assessment

Which build pipeline is running, which languages, what is already switched on, and what came out of the latest test or audit. We also look at the people: who reviews findings now, and what happens when something has to go live urgently. That last point determines whether gates hold up.

2

Clearing up before anything closes

We switch on the first category in warning mode and clear what comes out, together with your team. Blocking on a pile of open findings is guaranteed to end in switching it off. Only when the list stands at zero does the gate close.

3

Making agreements with the people who work with it

For each category we decide what blocks, what warns and what is information, and what the exception route looks like. We do this with the developers themselves and not only with whoever makes the decision; that is the difference between a process that runs and one that stalls after a month.

4

Expanding in sprints

Category by category, in sprints, always in the same order: warning mode on, clear up, make agreements, close the gate. Secrets first, then dependencies, then static analysis, then the container and infrastructure layer.

5

Reporting and handover

A report you can include in a procurement process, a handover to your team, and an agreement on who manages the gates. If you would like us to keep reviewing periodically afterwards, that is possible, but it is not a condition.

Frequently asked questions about DevSecOps.

What development teams, CTOs and security officers ask us before they get started.

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.

Talk to us about your development pipeline.

A no-obligation introductory call of half an hour. Tell us what is currently in place and what came out of your latest test, and we will tell you where we would start and what can wait – even if we end up not working together.

Edit content