DevSecOps (development, security, and operations) is the practice of placing automated security checks at every stage of software delivery, from commit to production. Security stops being a gate at the end of the process and becomes part of the pipeline. It does not slow delivery when each check has a clear blocking criterion, an owner, and a known time cost.
For CTOs and CISOs, the hard part is rarely choosing tools: it is deciding what blocks a build, what only opens a ticket, and who owns the rest. This guide covers security at each pipeline stage, rules that protect delivery speed, safeguards for the pipeline itself, and what to require from a software factory or any other vendor.

What DevSecOps is
According to Red Hat, DevSecOps is an approach to culture, automation, and platform design that treats security as a shared responsibility across the entire software lifecycle. In practice, automated checks run alongside development instead of a single audit before launch.
The term shift left sums up the idea: move security earlier in the cycle, where fixes are usually simpler. It is also worth stating what DevSecOps is not: it is not a single tool, not an isolated security team that approves releases, and not a replacement for penetration testing or architecture reviews. It extends DevOps, with the same automation and fast-feedback practices. For the fundamentals of writing safer code, see What Is Secure Coding? Importance and Best Practices.
Why security becomes a bottleneck?
Security becomes a bottleneck when it enters late, generates too many alerts, and has no decision criteria. The result is approval queues, ignored scanners, and informal exceptions. Usually the problem lies in process and culture, not tooling.
DORA (Google’s research program on software delivery) points in this direction. In its 2022 report, which made software supply chain security a central theme, researchers concluded that a strong, collaborative culture matters more than any technical capability for building secure software (see full report at dora.dev).
The 2025 report adds another factor: volume. AI adoption among software professionals reached 90%, 14 percentage points above the previous year, in a survey of nearly 5,000 people (Google). According to Google Cloud, AI speeds up development, but that acceleration can expose weaknesses downstream. In editorial terms: more code reaches the pipeline each week, and security checks must absorb that volume without becoming a queue.
Security at each pipeline stage
The OWASP DevSecOps Guideline explains how to build and run a secure pipeline with a vendor-neutral toolset: secret scanning in repositories, software composition analysis (SCA), static analysis (SAST), and checks for infrastructure as code (IaC) and containers. The NIST SSDF (SP 800-218, published in February 2022) organizes secure development practices into four groups: prepare the organization, protect the software, produce well-secured software, and respond to vulnerabilities.
The breakdown below combines these references. The blocking criteria are an editorial proposal from NextAge: adjust them to the risk of each system.
Before and at commit: secrets
Passwords, keys, and tokens in code give direct access to systems, so secret scanning comes first and runs on every commit.
- Blocks: a valid, exposed secret.
- Only opens a ticket: a suspicious pattern without confirmation.
Pull request: SAST, SCA, and IaC
SAST analyzes source code without running it; SCA checks third-party dependencies for known vulnerabilities; IaC checks review the files that describe infrastructure. They run while the developer still has the context of the change, and the result should appear in the pull request itself, with remediation guidance.
- Blocks: a critical, exploitable vulnerability in new code; a dependency with a known critical flaw.
- Only opens a ticket: medium and low severity; old debt (see the baseline rule below).
Build: containers, SBOM, signing, and provenance
This stage covers container image scanning and the SBOM (a software bill of materials, an inventory of the components in each version). It also covers artifact signing and provenance. SLSA defines increasing levels of assurance that software has not been tampered with and can be traced to its origin; provenance records who built the artifact, through which process, and with which inputs.
- Blocks: an image with a critical flaw that already has a fix; an unsigned artifact headed to production, if company policy requires signing.
- Only opens a ticket: a package with a flaw that has no fix yet (monitor it).
Staging: DAST and authorization
DAST tests the running application by simulating an attacker’s requests, and finds flaws that static analysis cannot see. It is slower, so it should run in parallel or off the critical path. Manual penetration testing remains a complement, not a substitute.
- Blocks: authentication or authorization failures; data exposure.
- Only opens a ticket: informational findings.
Production: monitoring and response
In production, security does not block the deploy: it monitors, manages vulnerabilities, and triggers response, with remediation deadlines by severity. This corresponds to the SSDF group on responding to vulnerabilities.
Seven rules to keep delivery moving
- Block only what is likely to be impactful and exploitable. Everything else becomes a ticket, with an owner and a deadline.
- Give each check a time budget. Slow checks run in parallel or off the critical path; the team sets the time target.
- Create a baseline for legacy code. Block only what is new; old debt goes into a separate plan.
- Show results in the pull request, with remediation guidance, instead of a separate report.
- Treat a false positive as a rule defect. Tune the rule; do not teach the team to ignore alerts.
- Record exceptions with an owner, a justification, and an expiry date.
- Measure speed and security together. Track the DORA metrics (deployment frequency, lead time for changes, change failure rate, and recovery time) alongside scan time, false-positive rate, and time to fix. This is how you prove that security did not cost speed.
Protect the pipeline itself
The pipeline has access to code, credentials, and production environments, which makes it a target. The OWASP Top 10 CI/CD Security Risks lists the ten main risks in this environment, starting with insufficient flow control mechanisms (CICD-SEC-1). Two recent cases show the problem in practice:
- Compromised GitHub Action (2025): the tj-actions/changed-files action, used in more than 23,000 repositories (DevOps.com), was compromised before March 14, 2025 and began leaking secrets in the logs of affected public repositories (Wiz). The case was assigned CVE-2025-30066 and was added to CISA’s Known Exploited Vulnerabilities catalog on March 18, 2025 (record). Wiz notes GitHub’s recommendation to pin actions to a commit hash rather than a version tag.
- XZ Utils backdoor (2024): the flaw CVE-2024-3094, with the maximum score (CVSS 10.0), affected versions 5.6.0 and 5.6.1 (The Hacker News). According to TechTarget, a maintainer compromised the project over two years through updates that looked legitimate. CISA issued an alert on March 29, 2024.
Good practices that follow from these cases: least-privilege tokens, actions and dependencies pinned by hash, secrets kept out of code and rotated, isolated runners, branch protection, and a log of everything the pipeline does. AI-generated code should go through the same pipeline; for a broader view of AI in IT, see What Will Change with Generative AI by 2027.
A four-phase adoption roadmap
This is an editorial proposal, with no guaranteed timelines: the pace depends on the size of the codebase and the team’s maturity.
- Secrets and dependencies. Secret scanning and SCA with a severity-based policy: they deliver quick visibility with low integration effort.
- SAST and IaC in the pull request. With a baseline for legacy code and rule tuning to reduce false positives.
- Containers, SBOM, and DAST. They come in once the first two phases are stable; DAST runs in staging.
- Metrics and continuous improvement. DORA indicators, scan and fix times, rule reviews, and security champions (developers who support security within each team).
What to require from a software factory or vendor
When outsourcing development, a CTO should demand what they would demand of an in-house team: security requirements from the start, an auditable pipeline, and evidence with every delivery. CISA summarizes NIST’s guidance: integrate the SSDF into existing practices, express secure development requirements to third-party suppliers using SSDF conventions, and acquire software that meets those practices.
In financial services, regulation applies too. BCB Resolution 85/2021 (Brazil’s central bank) requires that the procedures and controls of the cybersecurity policy also apply to the development of secure information systems (consolidated text); CMN Resolution 4,893 covers the same subject for financial institutions, with harmonized content.
Checklist for the contract and the acceptance meeting (an editorial proposal from NextAge):
- Secret scanning on every commit, blocking valid secrets.
- SCA with a severity-based policy and a component inventory (SBOM).
- SAST in the pull request, with a baseline for legacy code.
- IaC and container image checks before deploy.
- DAST in staging.
- The pipeline treated as a product: least privilege, third-party actions pinned by hash, secrets kept out of code.
- Branch protection and mandatory review for high-risk changes.
- Exceptions recorded, with an owner and an expiry date.
- Remediation deadlines by severity, defined by the company and tracked.
- An audit trail (who approved what, when, and with which evidence) and a response plan for vulnerabilities found after delivery.
At the NextAge Software Factory, NextAge takes responsibility for delivery: the client defines the business goal, and a full team handles the entire lifecycle. The process has five stages, from discovery (which maps goals, integrations, and risks) to development in sprints with deliveries every two weeks, and to validated quality, with dedicated QA, automated tests, and AI-assisted code review. The repository, documentation, and intellectual property belong to the client. These elements support applying the checklist above: discovery is the moment to record security requirements, and the biweekly deliveries are the point to ask for evidence. To see how the process works, read Software Development Stages in a Software Factory; to understand the model, read Software Factory: What It Is and Why Your Company Should Hire One.
Frequently asked questions
What is DevSecOps?
It is the practice of integrating automated security checks into every stage of software delivery, from commit to production. Security becomes a shared responsibility across development, security, and operations, rather than an audit done only at the end. The goal is to find and fix flaws early without losing speed.
What is the difference between DevOps and DevSecOps?
DevOps integrates development and operations to deliver software with more speed and reliability. DevSecOps extends that logic to security: checks enter the same automation pipeline, with blocking criteria and fast feedback. It is not a separate discipline but the natural evolution of DevOps practices.
What does shift left mean in security?
Shift left means moving security checks to the beginning of the development cycle, when code is still being written and fixes are simpler. In practice, it means running secret scanning, SCA, and SAST at commit and pull request time, instead of concentrating tests right before launch.
What is the difference between SAST, DAST, and SCA?
SAST analyzes source code without running it. DAST tests the running application by simulating an attacker. SCA checks third-party dependencies for known vulnerabilities. Each covers a different type of risk and fits a different pipeline stage: SAST and SCA in the pull request, DAST in staging.
How can you adopt DevSecOps without slowing delivery?
Block only what is likely to be impactful and exploitable, give each check a time budget, use a baseline for legacy code, show results in the pull request, and treat false positives as rule defects. Measure scan time and DORA metrics to prove that speed was preserved.
Where should you start implementing DevSecOps?
With secret scanning and dependency analysis (SCA), which give quick visibility with low integration effort. Then add SAST and IaC checks in the pull request, followed by containers, SBOM, and DAST. The last phase is measuring and tuning rules based on indicators.
How do you measure whether DevSecOps is working?
Combine delivery indicators (deployment frequency, lead time for changes, change failure rate, and recovery time, the DORA metrics) with security indicators: scan time, false-positive rate, mean time to fix, and number of expired exceptions. The goal is growing security without loss of speed.
Conclusion: three next steps
DevSecOps works when security is designed as part of delivery, with clear criteria and measurement. Three actions are worth taking this week:
- Map the current pipeline: which checks exist, at what stage they run, and what blocks a build.
- Start with secrets and dependencies, with a severity-based policy and a baseline for legacy code.
- Bring the checklist to your next acceptance meeting with the vendor or the in-house team.
Want a team that takes ownership of delivery, with quality validated in every sprint? Talk to a NextAge specialist.

English
Português










