Most organisations that started DevSecOps a few years ago followed a similar path: a pilot team, a few scanners in its pipeline, some quick wins. Then they tried to roll it out to every team and repository, and ran into a different set of problems:
- Finding overload: tens of thousands of findings across SAST, SCA, container and IaC scanners, most of them never fixed.
- Tool sprawl: overlapping tools with different severity scales and dashboards.
- Inconsistent adoption: some pipelines scan everything, others scan nothing.
- Unclear ownership: findings in shared libraries, platforms and orphaned services with no obvious owner.
Scaling DevSecOps is less about adding tools and more about standardising, prioritising and routing.
1. Deliver security through the platform
If every team builds its own pipeline, every team has to add and maintain security steps. At scale, security belongs in the platform:
- shared CI templates that include secrets scanning, SCA, SAST, IaC and image scanning by default,
- golden-path service templates with secure defaults (non-root containers, security headers, logging),
- central policy enforcement at deployment (signed images, no critical vulnerabilities with fixes available), and
- self-service exceptions with expiry dates, so teams are not blocked indefinitely.
# Teams include one shared template; the platform team maintains the security steps inside it.
include:
- project: platform/ci-templates
ref: v4.2.0
file: /pipelines/service.yml
variables:
SERVICE_TIER: "1" # tier drives blocking thresholds and SLAs
SECURITY_OWNER: "team-payments"When the platform team improves a scanner or a rule, every team benefits at once.
2. Aggregate findings into one view
Findings from different tools need to land in one place, de-duplicated and linked to the service, team and asset they affect. This category of tooling is increasingly called application security posture management (ASPM). Whether you buy a platform or build a pipeline into your existing ticketing and data tools, the goals are the same:
- one inventory of applications, owners and criticality,
- normalised severities across tools,
- de-duplication, since the same vulnerable library found by three scanners is one issue, and
- history, to see trends and time to fix.
3. Prioritise by real risk
Severity scores alone produce impossible backlogs. Combine several signals:
- Known exploitation: is the vulnerability on CISA's Known Exploited Vulnerabilities (KEV) catalogue?
- Exploit likelihood: the Exploit Prediction Scoring System (EPSS, updated to version 3 last year) estimates the probability of exploitation in the next 30 days.
- Reachability: is the vulnerable function actually called by your code? Reachability analysis in modern SCA tools can dramatically reduce noise.
- Exposure: is the service internet-facing? Does it handle sensitive data?
- Business criticality: a tier-1 payment service matters more than an internal prototype.
flowchart LR
F[Finding] --> K{On CISA KEV?}
K -->|yes| P1[P1: fix in days]
K -->|no| E{High EPSS and<br/>reachable?}
E -->|yes| X{Internet-facing or<br/>sensitive data?}
X -->|yes| P2[P2: fix this sprint]
X -->|no| P3[P3: fix within SLA]
E -->|no| P4[P4: backlog / accept with review]4. Route to owners, with SLAs
A finding without an owner will never be fixed. Maintain a service catalogue with owning teams, and route findings automatically into their backlog, not a security dashboard they never open. Agree remediation SLAs by priority and service tier, and report on them.
5. Scale people, not just tools
- Security champions in every team, with training, a community and time allocated to the role.
- Secure coding training targeted at the vulnerability types each team actually introduces, based on its findings.
- Threat modelling for new systems and major changes, supported by the security team.
- Clear escalation paths for difficult fixes and risk acceptance.
6. Measure outcomes
Useful metrics at scale:
- mean time to remediate, by priority and tier,
- percentage of findings within SLA,
- coverage: share of repositories using the standard pipeline,
- risk trend: exploitable, reachable, exposed issues over time, and
- escaped vulnerabilities: issues found in production or by pentests that pipeline checks should have caught.
Avoid vanity metrics such as the number of scans run or total findings detected.
Common anti-patterns
- Blocking builds on every high-severity finding in legacy code: teams will route around the checks.
- Security owning the backlog: findings must live with the teams who can fix them.
- One-size-fits-all rules: a prototype and a payment service need different thresholds.
- Buying more scanners before fixing prioritisation and routing.
The bottom line
At scale, DevSecOps succeeds or fails on operations, not detection. Deliver security through shared platforms, aggregate and de-duplicate findings, prioritise by exploitability and exposure, route to owners with clear SLAs, and measure how quickly real risk goes down.
Our vulnerability management and application security testing services help organisations build risk-based DevSecOps programmes across large application portfolios.