Your team probably spends considerable effort securing your application. WAFs, rate limiting, input validation, penetration testing. Then code passes through a CI/CD pipeline that runs with privileged credentials, executes arbitrary code from third-party actions, has broad network access to internal systems, and logs secrets in plain text if someone makes one configuration mistake.
The pipeline that builds and deploys your secure application is itself the least secure system in your infrastructure.
Think about what a CI/CD pipeline actually is from an attacker’s perspective. It is a system that automatically executes code, often with administrative access to your cloud accounts, container registries, databases, and production environments. It pulls dependencies from the public internet. It runs plugins and actions written by strangers. It often has access to every secret needed to deploy to every environment. If you designed a system specifically to be an attractive target for supply chain attacks, you would design a CI/CD pipeline.
The XZ Utils backdoor was a masterclass in exploiting this exact attack surface. A patient attacker spent years building trust in an open-source project, then introduced a backdoor that would have propagated through build systems worldwide. That attack was caught by accident. The next one might not be. And your pipeline is running builds right now that pull in hundreds of dependencies, each of which is a potential vector.
Here is what a hardened pipeline actually looks like. First, pipeline credentials should be scoped to the minimum required for each stage, not a single service account that can do everything. Second, third-party actions and plugins should be pinned to specific commit SHAs, not tags that can be silently updated. Third, pipeline execution environments should be ephemeral and isolated, with no network access beyond what is explicitly required for that build step. Fourth, every pipeline run should produce a signed provenance attestation that can be verified independently.
Most organizations are nowhere near this. They are running Jenkins instances that have not been patched in months, GitHub Actions workflows that use community actions pinned to “latest,” and build agents with permanent credentials stored in environment variables. The gap between how seriously we take application security and how casually we treat pipeline security is the biggest unaddressed risk in modern DevOps. And it will take one high-profile breach through a CI/CD vector to make everyone suddenly care.