What is DevSecOps? It is a way of building software where security checks run inside the pipeline that builds, tests and ships the code, on every change, instead of in a review at the end. Development, security and operations share the responsibility, and automation does the repetitive part. Below is the definition from official sources, and then the order in which I put it into practice in a company.
What is DevSecOps: the short answer
NIST describes DevSecOps in SP 800-204C as a paradigm built on CI/CD pipelines: workflows that take a developer's code through build, test, packaging, deployment and operations, "supported by automated tools with feedback mechanisms."
In practice it comes down to four habits:
- every change goes through a pipeline with automated security checks;
- secrets and permissions live in one managed place, with least privilege;
- dependencies and build artifacts have a traceable origin;
- infrastructure is described as code, so it can be reviewed and rebuilt.
DevSecOps vs DevOps
DevOps brought development and operations together: continuous integration, automated releases, monitoring. Security often stayed outside that loop, as a gate before release or an annual audit.
DevSecOps moves security into the same loop. NIST's Secure Software Development Framework (SP 800-218) notes that "few software development life cycle (SDLC) models explicitly address software security in detail" and offers a core set of practices you can add to any of them. CISA's Secure by Design initiative pushes the same idea from the vendor side: treat customer security as a core business requirement of the product.
| DevOps | DevSecOps | |
|---|---|---|
| Main goal | Ship small changes often and safely | Same, with security checked on every change |
| Security checks | Often manual, near the release | Automated in the pipeline, from the first commit |
| Who owns security | A separate team | Shared, with a security owner setting the rules |
Security testing in the pipeline
The pipeline is the place to start, because every change goes through it. The OWASP Top 10 CI/CD Security Risks puts "Insufficient Flow Control Mechanisms" first: the ability to push code to production without the reviews and approvals that should stop it.
So the first things I set up are flow controls:
- a protected main branch that only accepts reviewed changes;
- an explicit approval for production deployments;
- a small, known group of people who can edit the pipeline itself.
Then I add security testing one check at a time: secret scanning, dependency scanning for known vulnerabilities, static analysis, container image scanning. Each new check starts in warning mode and only blocks releases once its false positives are under control. A check that cries wolf on every build gets ignored.
Secrets and credentials
Passwords, API keys and tokens do not belong in code or in versioned config files. They live in a secrets manager (Vault, or your cloud provider's service), and the pipeline receives them at run time with permissions scoped to that job.
- one secret per environment and per service, never shared;
- rotation without a code change;
- access logged, so you can see who read what;
- a pipeline check that blocks a commit containing a key.
If a key has already landed in the repository history, deleting the line is not enough: revoke it and issue a new one.
Dependencies and the software supply chain
Most of the code you ship, you downloaded: libraries, base images, pipeline actions. That is your software supply chain. SLSA, from the OpenSSF, describes itself as "a set of incrementally adoptable guidelines for supply chain security", and covers risks such as unauthorized changes after source control, artifacts built outside the expected platform, and attacks on the build platform.
The basics:
- pinned versions with a lock file in the repository;
- regular, planned updates instead of a two-year jump;
- artifacts built only by the pipeline, never on a laptop;
- minimal container images that do not run as root.
Cloud permissions and infrastructure as code
In the cloud, the serious incidents often start with permissions that are too broad: a service account with admin rights, a storage bucket left public after a test. Least privilege means every service and every person gets only what their job needs.
Infrastructure as code, with a tool such as Terraform, makes that reviewable. A permission change becomes a code change: reviewed, approved, recorded and reversible. NIST SP 800-204C lists infrastructure as code and policy as code among the code types of a cloud-native application, next to the application code itself.
Who does what in a real company
DevSecOps does not need a new department. In a small or mid-sized company, this split works:
| Who | What they own |
|---|---|
| Developers | Write the code, fix what the checks flag, review each other's changes |
| Platform owner | Pipeline, secrets, cloud permissions, infrastructure as code |
| Security owner | Rules and priorities, incident response, checking that the controls stay on |
| Management | Accepts residual risk explicitly and gives the time to fix things |
Often the first two rows are the same people, and the security owner is part-time or external. That is the role I take as a DevSecOps consultant: I set up the pipeline and the checks, and leave the team with automation and documentation it can run on its own.
How to get started, and the usual mistakes
The order I follow:
- inventory: repositories, pipelines, environments, secrets, who can access what;
- protect the main branch and require approval for releases;
- move secrets out of the code and scan every commit;
- scan dependencies and images;
- reduce cloud permissions and move infrastructure to code;
- test backups with a real restore.
Three mistakes come up again and again. Buying a tool and switching on every rule at once, so the team drowns in alerts and stops reading them. Running an audit that ends in a PDF while the pipeline stays the same. Making security one person's job, which turns that person into a bottleneck.
If your code is largely written with AI assistants, a few extra checks apply. I cover them in DevSecOps for AI-written apps.
Frequently asked questions
What does DevSecOps stand for?
Development, Security and Operations. The name says that the three groups share responsibility for the software, from the first commit to production, with security built into the same automated workflow.
Is DevSecOps cybersecurity?
It is one part of it. DevSecOps covers how software is built, shipped and run: pipelines, code, dependencies, infrastructure. Cybersecurity is wider and also includes networks, endpoints, identity and incident response across the whole company.
What is the main goal of DevSecOps?
To find and fix security problems as early and as cheaply as possible, without slowing down releases. Automated checks on every change catch most issues while they are still small.
Do you need expensive tools for DevSecOps?
No. Many basic checks come with the development platform you already use or with open source tools. The rules matter more than the tools: who approves releases, where secrets live, and what each service is allowed to do.