Many engineering organisations still run security the way factories once ran quality control: build the product, then inspect it at the end of the line. In software, that usually means a penetration test or a security sign-off shortly before a major release. The record of the past decade suggests this model breaks down in predictable ways. Below are eight evidence-backed reasons end-of-pipeline security reviews fail, each paired with the step-level safeguard that addresses it. The common thread is simple: a check placed inside each stage of delivery surfaces a problem where it begins, while a check placed only at the exit discovers it after it has spread.
1. Defects compound as later work builds on them
A flawed design decision made in week two does not sit still. Developers write code that depends on it, testers build cases around it, and integrations assume it. By the time a final review identifies the flaw, removing it means unpicking every layer added since. This is the oldest argument in software quality, and it applies with extra force to security, where a single weak assumption about authentication or data access can ripple through dozens of components.
Step-level response: brief threat-modelling sessions during planning, so risky assumptions are questioned before any code depends on them.
2. Final reviewers see artefacts, not intent
An external tester sees what the software does, not why the team built it that way. Without that context, reviews tend to report symptoms rather than causes, and teams patch the symptom while the underlying pattern repeats in the next feature. The people with the richest context are the ones writing the code, at the moment they write it.
Step-level response: static analysis and secret detection triggered by each commit, giving the author feedback while the reasoning is still fresh in their head.
3. The gate erodes under schedule pressure
When security is concentrated in one late checkpoint, it becomes the most visible obstacle between a team and its deadline. Experienced engineering leaders will recognise the pattern: findings are downgraded, exceptions are granted “just for this release”, and the review becomes a formality. The weakness is structural. Any control that depends on a single act of discipline under maximum pressure will eventually be bypassed.
Step-level response: distribute small automated checks so that no single gate carries enough weight to be worth arguing about.
4. Dependencies change after the review is finished
Modern applications are assembled largely from open-source components. A review conducted in spring says nothing about a vulnerability disclosed in autumn. The clearest illustration is Log4Shell, the critical flaw in the Log4j logging library disclosed in December 2021. Organisations with an up-to-date inventory of their components could identify exposure within hours; those relying on periodic reviews often spent days or weeks searching.
Step-level response: dependency scanning and a software bill of materials generated with every build, so the component list is always current. Scanners such as Trivy make this routine.
5. The build system itself can become the target
The SolarWinds compromise, which came to light in December 2020, showed that attackers can tamper with the build process rather than the source code. Malicious code was inserted during compilation and shipped inside signed, legitimate updates. A final review of the source would not have revealed it, because the source was not where the problem lived.
Step-level response: integrity checks on the build environment and the artefacts it produces, treating the pipeline as something to be protected rather than a neutral conveyor belt.
6. Credentials leak early and linger in history
API keys, tokens and passwords tend to leak at the moment of writing code or configuring pipelines, not at release time. Once committed, they persist in version-control history even after the visible file is cleaned up. A pre-release review may never examine old commits at all. The 2021 Codecov incident, in which a tampered uploader script was used to collect environment variables from customers’ CI systems, also underlined how much sensitive material lives inside build environments.
Step-level response: pre-commit secret scanning plus a dedicated secrets manager, so credentials never need to sit in code or pipeline files.
7. Known fixes wait too long to be applied
The 2017 Equifax breach is widely cited for a reason: the exploited Apache Struts vulnerability had a public patch available months before attackers used it. The organisation’s processes did not move that fix into production in time. A periodic review cycle builds this delay in by design, because patching becomes an event rather than a continuous habit.
Step-level response: policy gates that block releases containing components with known critical flaws, combined with automated upgrade proposals, so patching becomes part of every normal release.
8. One review cannot keep pace with frequent releases
Teams practising continuous delivery may deploy several times a week or several times a day. A manual review that takes days simply cannot sit in front of every release. In practice, such teams either slow delivery to match the review or, more commonly, stop reviewing most releases. Neither outcome is acceptable.
Step-level response: automate the checks that can be automated, keep each one fast, and reserve human expert review for genuinely novel or high-risk changes.
What the evidence points to
Read together, these eight failure modes share a root cause. End-of-pipeline reviews look at the finished product, but security problems are created throughout the process, and many are created in places the final product does not reveal: the planning conversation, the commit history, the build environment, the dependency tree. The logical response is to place a lightweight control inside each of those places. This idea is often summarised as security that belongs to the pipeline from the outset instead of being fastened on at the last minute.
That does not mean abolishing the final review. It means changing its role from primary defence to confirmation. Our earlier analysis of safer cloud deployment planning for application security describes how this layered approach plays out in cloud environments specifically.
Where to start if you can only fix two things
Few teams can introduce eight new controls at once. Based on the failure modes above, the highest-leverage starting points for most organisations are:
- Secret scanning on every commit. It is cheap to set up, produces almost no false alarms when tuned, and closes a gap that a pre-release review almost never inspects properly.
- Dependency scanning on every build. Given how much of a typical codebase is borrowed, keeping a live view of components addresses reasons four and seven together.
Once those two run quietly in the background, planning-stage threat modelling and release policy gates are the natural next additions. Measure progress simply, by asking how many of the final review’s findings could have been caught earlier, and move a check upstream whenever the answer is “most of them”.
Building the capability: skills and outside support
For consulting clients, the practical question is how to acquire these skills without stalling delivery. Two routes are common: train existing engineers, or bring in specialists to design the controls and hand them over.
DevSecOpsSchool, which specialises in DevSecOps education and enablement, supports both. Its certifications are aligned to roles, and the engineer-level track covers exactly the areas discussed above, from static and dynamic application testing to container, Kubernetes and infrastructure-as-code security. For organisations that prefer to start with expert design, it also offers consulting on threat modelling and secure CI/CD roadmaps, plus hands-on implementation of security automation. Readers weighing the engineering route can compare it with our piece on how engineering teams build DevSecOps capability, and those focused on code-level analysis may find the overview of raising code quality and security with SonarQube a useful companion.
Conclusion
The case against relying on end-of-pipeline security reviews does not rest on theory. It rests on a decade of high-profile incidents in which the decisive weakness sat somewhere a final inspection would struggle to see: in a dependency, a build server, a commit history or a slow patch process. Teams that place a small, fast safeguard at each stage of delivery are not doing more security work overall. They are doing it earlier, closer to the source, and at a fraction of the cost of finding the same problem at the end.

