Join our Newsletter — 33% off our NHI Course
Home› Guides› DevOps vs DevSecOps: What Changes When Security Joins…
Guide Application Security

DevOps vs DevSecOps: What Changes When Security Joins the Pipeline

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 14 November 2026 15 min read
On this page

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.

DimensionDevOpsDevSecOps
GoalFast, reliable deliveryFast, reliable and secure delivery, with evidence
Security ownershipSeparate security team reviews, often lateDelivery team owns security defects; security owns policy, guardrails and assurance
Where security decisions happenChange advisory, pen tests, release sign-offIn code review, pipeline policy and admission control, automatically
View of the pipelineProductivity toolingPrivileged, attackable infrastructure inside the supply chain
Pipeline credentialsStatic secrets stored in the CI toolShort-lived federated tokens, scoped per job and environment
Release evidenceBuild logs and ticketsSigned provenance, SBOMs, recorded gate results
MetricsDORA delivery metricsDORA metrics plus remediation, exposure and integrity metrics
Failure modeSecurity 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.

ActivityDelivery teamPlatform teamSecurity team
Fix vulnerabilities in service code and dependenciesResponsible, accountableInformedConsulted on severity and exceptions
Define gate thresholds and policy as codeConsultedResponsible for implementationAccountable
Maintain shared pipeline templates and runnersInformedResponsible, accountableConsulted
Govern pipeline identities and secretsResponsible for their service's usageResponsible for the federation and secrets platformAccountable for policy and review
Approve risk exceptionsRequests, with justificationInformedAccountable, time-bound approval
Threat modelling of new servicesResponsibleConsulted on platform controlsConsulted, 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.

StageTypical DevOps stateDevSecOps additionThreat addressed
SourceBranch protection for main, optional reviewMandatory second reviewer for every change, signed commits where supported, secret scanning on pushSingle compromised account pushing malicious code
Pipeline definitionWorkflow files editable by any contributorPipeline definitions protected and reviewed like code, untrusted pull requests run without secretsPoisoned pipeline execution (ATT&CK T1677)
DependenciesPulled from public registries as neededSoftware composition analysis, pinned versions, internal proxy registry, SBOM generationDependency chain abuse, compromised packages (T1195.002)
BuildShared, long-lived runnersEphemeral, isolated runners; provenance generated and signed by the build platformCross-build tampering, persistence on runners
TestUnit and integration testsSAST, IaC scanning, container image scanning with agreed blocking thresholdsKnown vulnerability classes and misconfigurations reaching production
DeployDeploy with a stored cloud keyFederated short-lived credentials per environment; admission policy verifies signatures and provenanceStolen deploy credentials, unsigned or tampered artefacts
OperateAvailability monitoringRuntime detection, audit logging of who committed, reviewed and deployedUndetected 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, environment and repository against 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.

MetricModelWhat it tells you
Change lead time, deployment frequencyDevOps (DORA)Throughput; watch for drops when new gates land
Change fail rate, deployment rework rate, failed deployment recovery timeDevOps (DORA)Instability; security fixes should ship through the same fast path
Median time to remediate critical and high findings, by teamDevSecOpsWhether ownership is real
Gate outcomes: blocks, overrides and exceptions per monthDevSecOpsWhether thresholds are accepted or routinely bypassed
Secrets detected in commits, and time to revokeDevSecOpsCredential hygiene in the pipeline
Share of pipelines deploying with federated short-lived credentialsDevSecOpsProgress on pipeline identity
Share of production artefacts with verified signed provenanceDevSecOpsSupply 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

  1. Agree ownership first. Write the RACI, name champions, and define how exceptions are approved and expire.
  2. Inventory pipeline identities and secrets. List every credential the CI/CD estate holds, its scope, owner and last use.
  3. Replace the highest-privilege stored secrets with federation. Start with production deploy credentials.
  4. Protect the pipeline itself. Mandatory review, protected pipeline definitions, ephemeral runners, audit logging.
  5. 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.
  6. Add integrity evidence. SBOM generation, signed provenance, then admission verification.
  7. Move it into the platform. Package the controls as the golden path and track adoption.
  8. 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

FrameworkRelevant itemsDevSecOps relevance
NIST CSF 2.0PR.PS-06, GV.RR-02Secure development practices integrated and monitored; security roles and authorities defined
NIST SP 800-53 Rev 5SA-8, SA-10, SA-11, SA-15, CM-3, SR-4, SR-11Engineering principles, developer configuration management, developer testing, development process and tools, change control, provenance, component authenticity
NIST SP 800-218 (SSDF) v1.1Practice groups Prepare the Organization, Protect the Software, Produce Well-Secured Software, Respond to VulnerabilitiesEvidence framework for secure development
NIST SP 800-204DSoftware supply chain security in CI/CDPipeline stages as supply chain, attestations and provenance
MITRE ATT&CK v20T1677, T1195.002, T1552.001, T1528Poisoned 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

Related NHI Mgmt Group resources: DevSecOps Guide · Secure SDLC vs DevSecOps · CI/CD Pipeline Identity Security Guide · Platform Engineering Security

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 14 November 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.