Plenty of organisations rename their DevOps team "DevSecOps", buy a scanner, and change nothing about who owns risk, what the pipeline is allowed to do, or how its own credentials are governed. DevOps is an operating model for delivering software quickly and reliably by joining development and operations around shared automation. DevSecOps keeps that model and makes security an engineering property of it: owned by the same teams, enforced by the same pipeline, measured with the same rigour. This guide sets out what actually differs between the two: ownership and decision rights, the controls the pipeline carries, how pipeline identities and secrets are treated, the metrics each model reports, and how platform engineering now absorbs much of the work. It is for engineering leaders, platform teams and security architects deciding how far to go. The toolchain and lifecycle detail is in the DevSecOps Guide, and the process comparison with a classic secure development lifecycle in Secure SDLC vs DevSecOps.
Key takeaways
- The difference is ownership, not tooling. In DevSecOps, delivery teams own the security outcome of what they ship and security sets policy and builds guardrails; adding scanners to a DevOps pipeline does not change that.
- The pipeline becomes a security boundary. DevOps treats CI/CD as a productivity system; DevSecOps treats it as privileged infrastructure with its own threat model, separation of duties and integrity evidence.
- Pipeline identities are the sharpest gap. Build agents, deploy tokens and integration credentials often hold more production reach than any engineer, and DevOps pipelines rarely govern them.
- Keep the DevOps metrics and add security ones. The DORA delivery metrics still matter; DevSecOps adds remediation time, gate outcomes, secret exposure and provenance coverage, read alongside them.
- Platform engineering is where DevSecOps scales. Golden paths with security built in let hundreds of teams inherit controls instead of each team implementing them.
The short answer
DevOps optimises the flow of change. Its common measures, the DORA software delivery metrics, are throughput (change lead time, deployment frequency, failed deployment recovery time) and instability (change fail rate, deployment rework rate). Nothing in that set measures whether the change was safe from a security point of view, and nothing in the model says who owns that question.
DevSecOps answers both. It moves security decisions into the same automated flow, gives delivery teams ownership of security defects in their services, and treats the delivery system itself as something to defend. NIST SP 800-204D, which sets out strategies for integrating software supply chain security into DevSecOps CI/CD pipelines, frames the pipeline stages from source through build, test, package and deploy as part of the software supply chain, which is the shift in a sentence: the pipeline is no longer only how you ship, it is part of what you ship.
| Dimension | DevOps | DevSecOps |
|---|---|---|
| Goal | Fast, reliable delivery | Fast, reliable and secure delivery, with evidence |
| Security ownership | Separate security team reviews, often late | Delivery team owns security defects; security owns policy, guardrails and assurance |
| Where security decisions happen | Change advisory, pen tests, release sign-off | In code review, pipeline policy and admission control, automatically |
| View of the pipeline | Productivity tooling | Privileged, attackable infrastructure inside the supply chain |
| Pipeline credentials | Static secrets stored in the CI tool | Short-lived federated tokens, scoped per job and environment |
| Release evidence | Build logs and tickets | Signed provenance, SBOMs, recorded gate results |
| Metrics | DORA delivery metrics | DORA metrics plus remediation, exposure and integrity metrics |
| Failure mode | Security becomes a late blocker or is bypassed | "DevSecOps" in name only: tools added, ownership unchanged |
Ownership: who decides and who fixes
The operating model change is about decision rights. In a DevOps organisation with a separate security function, security findings arrive as tickets from another team, prioritised against a backlog the security team does not control. In DevSecOps the team that owns the service owns its security defects, and security's job moves from reviewing to enabling: writing policy as code, maintaining shared pipeline components, setting risk thresholds and providing expert help on hard problems.
| Activity | Delivery team | Platform team | Security team |
|---|---|---|---|
| Fix vulnerabilities in service code and dependencies | Responsible, accountable | Informed | Consulted on severity and exceptions |
| Define gate thresholds and policy as code | Consulted | Responsible for implementation | Accountable |
| Maintain shared pipeline templates and runners | Informed | Responsible, accountable | Consulted |
| Govern pipeline identities and secrets | Responsible for their service's usage | Responsible for the federation and secrets platform | Accountable for policy and review |
| Approve risk exceptions | Requests, with justification | Informed | Accountable, time-bound approval |
| Threat modelling of new services | Responsible | Consulted on platform controls | Consulted, facilitates |
NIST CSF 2.0 GV.RR-02 asks that cybersecurity roles, responsibilities and authorities are established, communicated, understood and enforced. A DevSecOps claim should be testable against it: can each team say what security outcome it owns? Security champions in each team are a common bridge; see the DevSecOps Engineer Career Guide for the skills profile.
Pipeline controls: what the pipeline carries
A DevOps pipeline already builds, tests and deploys. DevSecOps adds controls in two directions: checks on what flows through the pipeline, and protection of the pipeline itself. The NSA and CISA guidance Defending Continuous Integration/Continuous Delivery (CI/CD) Environments (June 2023) is a useful baseline for the second direction.
| Stage | Typical DevOps state | DevSecOps addition | Threat addressed |
|---|---|---|---|
| Source | Branch protection for main, optional review | Mandatory second reviewer for every change, signed commits where supported, secret scanning on push | Single compromised account pushing malicious code |
| Pipeline definition | Workflow files editable by any contributor | Pipeline definitions protected and reviewed like code, untrusted pull requests run without secrets | Poisoned pipeline execution (ATT&CK T1677) |
| Dependencies | Pulled from public registries as needed | Software composition analysis, pinned versions, internal proxy registry, SBOM generation | Dependency chain abuse, compromised packages (T1195.002) |
| Build | Shared, long-lived runners | Ephemeral, isolated runners; provenance generated and signed by the build platform | Cross-build tampering, persistence on runners |
| Test | Unit and integration tests | SAST, IaC scanning, container image scanning with agreed blocking thresholds | Known vulnerability classes and misconfigurations reaching production |
| Deploy | Deploy with a stored cloud key | Federated short-lived credentials per environment; admission policy verifies signatures and provenance | Stolen deploy credentials, unsigned or tampered artefacts |
| Operate | Availability monitoring | Runtime detection, audit logging of who committed, reviewed and deployed | Undetected misuse, inability to reconstruct incidents |
Two principles from the NSA and CISA guidance shape the pipeline design: separation of duties, so that code authors do not control the build environment and build engineers do not have source write access, and signing of configuration and code with verification at each stage. Supply chain integrity can be sequenced with SLSA: its Build track moves from L1 (provenance exists) to L2 (a hosted build platform that signs provenance) to L3 (hardened builds that isolate runs and keep signing secrets away from user-defined steps). SLSA v1.0 is now marked retired in favour of v1.2, so check the current specification before setting targets. See the CI/CD Security Guide and Provenance Attestation vs SBOM.
Pipeline identities and secrets
This is where DevOps and DevSecOps diverge most in practice. A DevOps pipeline needs credentials to pull code, fetch packages, push images, sign artefacts and deploy to cloud, and the simplest way is to store long-lived secrets in the CI tool. Those secrets are often the most privileged identities in the estate: a deploy key that can change production infrastructure, a registry token that can overwrite any image, a signing key trusted by every customer.
- Federate instead of storing: GitHub's documentation describes OIDC tokens that are valid for a single job and then expire, with the cloud provider checking claims such as
sub,environmentandrepositoryagainst trust conditions on the cloud role. The NSA and CISA guidance likewise recommends temporary, ephemeral credentials wherever possible. See the GitHub Actions OIDC Federation Hardening Guide. - Scope per job and environment: expose a secret only to the step that needs it, and bind production credentials to a protected environment with required reviewers. See How to Audit CI/CD Secrets Scope.
- Separate build and deploy identities: the identity that compiles untrusted code should not be the identity that can change production.
- Inventory and own every pipeline identity: service connections, personal access tokens used by automation, integration apps and runner registration tokens, each with an owner and last-used date. See the CI/CD Pipeline Identity Security Guide.
- Protect signing keys separately: keep them in dedicated, hardware-backed or managed signing services, never in plain pipeline variables.
Two incidents show why this matters. In the Codecov breach, a tampered uploader script sent CI environment variables, which commonly hold cloud keys, tokens and signing keys, to an attacker for about two months; the credential used to modify the script was extracted through an error in Codecov's Docker image creation process. In the CircleCI breach, malware on an engineer's laptop stole a 2FA-backed SSO session, the attacker reached production stores, and customers were told to rotate every secret held on the platform. In both cases, per-job federated credentials would have left far less worth stealing. Relevant ATT&CK techniques are T1552.001 Credentials In Files and T1528 Steal Application Access Token.
Metrics: what each model reports
DevOps teams report delivery performance. DevSecOps keeps those numbers, because security controls that wreck lead time get bypassed, and adds measures that show security is working inside the flow.
| Metric | Model | What it tells you |
|---|---|---|
| Change lead time, deployment frequency | DevOps (DORA) | Throughput; watch for drops when new gates land |
| Change fail rate, deployment rework rate, failed deployment recovery time | DevOps (DORA) | Instability; security fixes should ship through the same fast path |
| Median time to remediate critical and high findings, by team | DevSecOps | Whether ownership is real |
| Gate outcomes: blocks, overrides and exceptions per month | DevSecOps | Whether thresholds are accepted or routinely bypassed |
| Secrets detected in commits, and time to revoke | DevSecOps | Credential hygiene in the pipeline |
| Share of pipelines deploying with federated short-lived credentials | DevSecOps | Progress on pipeline identity |
| Share of production artefacts with verified signed provenance | DevSecOps | Supply chain integrity coverage |
Report the two sets together. A programme where remediation time improves while lead time collapses has moved the bottleneck, not removed it.
How platform engineering absorbs DevSecOps
DevSecOps asks every team to own security, which does not scale if every team must also build its own scanners, federation and signing. Platform engineering resolves this. The CNCF Platforms white paper describes a platform as an integrated collection of capabilities presented according to the needs of its users, names security services (static analysis of code and artefacts, runtime analysis and policy enforcement) as one of its capability domains, lists secure by default as a platform attribute, and describes golden paths as a bundle of a reusable workflow, a project template and documentation.
- Golden path pipelines: the platform's standard pipeline template already includes secret scanning, SCA, image scanning, provenance generation and federated deploy credentials. A team that uses it inherits the controls.
- Paved, not mandated: make the secure path the easiest one, and measure adoption. Teams off the path carry the security work themselves and are reported separately.
- Policy as code at the platform layer: admission controllers and cloud guardrails enforce the rules regardless of which pipeline produced the change.
- Platform privilege is concentrated risk: the platform team's own identities and the shared runners become the highest-value targets, so they need the strongest controls. See Platform Engineering Security.
The practical result is that "DevSecOps team" increasingly means a capability spread across delivery teams (ownership), a platform team (paved road) and a security team (policy and assurance), rather than a separate group.
Decision guidance: how far to move
- Small teams with one pipeline: adopt the CI platform's built-in secret scanning and dependency alerts, switch deploys to OIDC federation, and require review on the main branch. That covers most of the gap without a dedicated function.
- Mid-sized organisations: build one shared pipeline template, name a security champion per team, and agree blocking thresholds for critical findings only at first.
- Large or regulated organisations: fund a platform team to own golden paths, put signed provenance and admission control in front of production, and report DORA and security metrics side by side. Map controls to NIST SP 800-218 (SSDF) version 1.1 for customer and regulator evidence.
- When to stay closer to classic gates: safety-critical or heavily certified software may still need formal release approval; keep it, but automate the evidence feeding it.
Worked scenario: one service, two models
DevOps: a payments service deploys twenty times a week through a shared pipeline. A stored cloud key in the CI tool can modify any production account. Dependency scans run nightly and email the security team, who raise tickets that sit for weeks. Release evidence is the build log.
DevSecOps: the same service uses the platform's golden path. Secret scanning blocks pushes containing credentials. SCA blocks only critical, reachable findings, and the team fixes them in the same sprint. The deploy job exchanges an OIDC token for a role limited to the payments account and the production environment, with a required reviewer. The build platform signs provenance, and the cluster admits only signed images. Lead time is unchanged; mean time to remediate critical findings falls; the stored cloud key no longer exists.
Implementing the move from DevOps to DevSecOps
- Agree ownership first. Write the RACI, name champions, and define how exceptions are approved and expire.
- Inventory pipeline identities and secrets. List every credential the CI/CD estate holds, its scope, owner and last use.
- Replace the highest-privilege stored secrets with federation. Start with production deploy credentials.
- Protect the pipeline itself. Mandatory review, protected pipeline definitions, ephemeral runners, audit logging.
- Add checks in warn mode. Run scanners and policy in report-only mode for a few weeks, tune false positives, then block on a narrow set of rules. Rollback is reverting the threshold to warn, not removing the check.
- Add integrity evidence. SBOM generation, signed provenance, then admission verification.
- Move it into the platform. Package the controls as the golden path and track adoption.
- Report delivery and security metrics together each quarter and adjust gates that harm flow without reducing risk.
Detection and measurement
Log and alert on changes to pipeline definitions and branch protection, creation of new pipeline credentials or service connections, use of deploy credentials outside their expected job or environment, runner registration, and overrides of blocking gates. The NSA and CISA guidance stresses audit logs that record who committed, reviewed and deployed each change, and when and where, so incidents can be reconstructed. See OWASP CI/CD Top 10 CICD-SEC-10 Insufficient Logging and Visibility Guide.
Common failure patterns
- Rename without re-org: the DevOps team becomes "DevSecOps", security findings still go to a separate team, and nothing about ownership changes.
- Scanner sprawl: many tools, no agreed thresholds, thousands of unprioritised findings, and teams learn to ignore the output.
- Blocking everything on day one: gates that fail builds on medium findings get bypassed or disabled within weeks.
- Ignoring the pipeline's own credentials: code is scanned carefully while stored deploy keys and broad tokens sit in the CI tool, as the Codecov breach showed.
- Trusting third-party scripts and actions by tag: unpinned actions and piped install scripts change under you. See How to Pin GitHub Actions to Commit SHAs.
- Platform team as a single point of failure: golden paths centralise control and also centralise privilege; the platform's own identities need the strongest protection.
Framework mapping
| Framework | Relevant items | DevSecOps relevance |
|---|---|---|
| NIST CSF 2.0 | PR.PS-06, GV.RR-02 | Secure development practices integrated and monitored; security roles and authorities defined |
| NIST SP 800-53 Rev 5 | SA-8, SA-10, SA-11, SA-15, CM-3, SR-4, SR-11 | Engineering principles, developer configuration management, developer testing, development process and tools, change control, provenance, component authenticity |
| NIST SP 800-218 (SSDF) v1.1 | Practice groups Prepare the Organization, Protect the Software, Produce Well-Secured Software, Respond to Vulnerabilities | Evidence framework for secure development |
| NIST SP 800-204D | Software supply chain security in CI/CD | Pipeline stages as supply chain, attestations and provenance |
| MITRE ATT&CK v20 | T1677, T1195.002, T1552.001, T1528 | Poisoned pipeline execution, software supply chain compromise, credentials in files, token theft |
Practitioner checklist
- Publish a RACI that gives delivery teams ownership of security defects and security ownership of policy and exceptions.
- Inventory every pipeline identity and secret with owner, scope and last use.
- Replace stored production deploy credentials with per-job federated tokens.
- Require a second reviewer for all changes and protect pipeline definitions.
- Use ephemeral, isolated runners for builds that handle untrusted code.
- Introduce scanners in warn mode, then block on a small agreed rule set.
- Generate SBOMs and signed provenance, and verify signatures at deploy.
- Ship the controls as the platform's golden path and track adoption.
- Report DORA metrics and security metrics in the same review.
Standards and references
- NIST: SP 800-204D Strategies for the Integration of Software Supply Chain Security in DevSecOps CI/CD Pipelines
- NIST: SP 800-218 Secure Software Development Framework (SSDF) Version 1.1
- NSA and CISA: Defending Continuous Integration/Continuous Delivery (CI/CD) Environments
- OpenSSF SLSA: Security Levels
- DORA: Software Delivery Performance Metrics
- CNCF TAG App Delivery: Platforms White Paper
- GitHub Docs: About Security Hardening with OpenID Connect
Related NHI Mgmt Group resources: DevSecOps Guide · Secure SDLC vs DevSecOps · CI/CD Pipeline Identity Security Guide · Platform Engineering Security