The Only Things DevSecOps Teams Should Care About
When attackers breached the open-source development platform Nx earlier this year, the fallout rippled across the global development community.
By inserting malicious code into legitimate updates, the attackers stole developer credentials and even created new repositories inside victims’ GitHub accounts. And it was all carried out through trusted, automated channels.
With over four million weekly downloads, Nx offered an enormous attack surface, turning a single compromise into a far-reaching supply chain incident.
So, whether it’s the recent NPM or Chalk attack, these shouldn’t be thought of as one-offs, but rather signs of changing times. Open-source platforms like Nx were designed to improve productivity through access to a vast repository of third-party components, but this comes with a trade-off of greater exposure to hidden vulnerabilities and malicious code.
So how can DevSecOps teams get ahead of these new threats and ensure resilience across the software supply chain?
The Expanding Blast Radius Of Software Supply Chain Attacks
The Nx compromise illustrates the fact that many software build pipelines are now part of a densely interconnected global supply chain. One weak link in the chain can cascade through thousands of interconnected projects. Modern development depends on open-source components, so the very elements that make development faster and more efficient also make it fragile.
As a result, attackers no longer need to breach production systems directly. By targeting upstream packages, build scripts or dependencies, they can distribute malicious code at scale, exploiting the implicit trust built into CI/CD (Continuous Integration/Continuous Delivery) processes.
Remember that attackers are always one step ahead looking to exploit the weakest link in your chain.
We’re facing an ecosystem where code can move faster than its verification, and a single breach can create a huge blast radius. Many development and security teams are aware of this threat but are struggling to contain it.
In fact, Checkmarx research found that more than a third (35%) of organisations expect software supply chain breaches within the next 12 to 18 months, yet fewer than 15% feel prepared to defend against them.
There’s a foundational difference between preventing code vulnerabilities and protecting against malicious components in your ecosystem. Code vulnerabilities are created due to human error. A developer writes code that has a security issue that may or may not get exploited once your application gets deployed. Malicious packages however, are written by attackers to do just that: attack.
A malicious package in your development environment means game over. You’ll be waking everyone up to immediately handle that.
Balancing Speed & Security In DevSecOps
Behind the headlines of these pipeline breaches there are often internal, organisational issues at play. Development teams are under pressure to ship software faster, while security teams are tasked with ensuring vulnerabilities don’t slip through and risk can be managed a right way. These priorities for speed and caution pulling in opposite directions mean some level of compromise is inevitable. Unfortunately, many organisations lean towards the riskier side of the balance.
Checkmarx has found that 81% of organisations knowingly release vulnerable code, often viewing security trade-offs as the price of progress. More than a third (38%) admit they deploy risky code to meet deadlines, planning to patch later, and a third of organisations simply hope issues will remain undiscovered.
However, this approach can prove to be extremely risky as a single weakness in a trusted workflow is enough to compromise countless projects downstream.
Securing Your Software Supply Chain Is About Every Part Of The Chain
Securing the software supply chain ultimately comes down to securing every component that is not being created by your in-house developers. Developers must be especially cautious about any third-party assets they introduce into their codebase, and they must also be aware of their responsibility for anything they are themselves introducing into the wider software supply chain. This is true of CI/CD plugins, IDE plugins, compliers and, of course, open-source software.
Unsecured or purposefully malicious code introduced through the supply chain can sometimes bypass traditional testing and code reviews. Security must be fully integrated into the CI/CD pipeline, or developers risk leaving the door open for threat actors seeking to introduce vulnerabilities into the codebase and access sensitive data.
When it comes to securing their own code, Checkmarx found that while most organisations have mature security tools in place, only around half actively use foundational controls such as container scanning, Dynamic Application Security Testing (DAST), or Infrastructure as Code (IaC). This gap between tool ownership and operational use leaves pipelines vulnerable to misconfigurations and poisoned builds.
Resilience begins when security becomes part of every stage of the CI/CD process to validate integrity, enforce trust, and ensure that speed does not come at the expense of control.
Building Resilient CI/CD Pipelines
True resilience for the modern software supply chain comes from embedding security into the tools, tactics, and processes for CI/CD process. The following principles outline where DevSecOps teams should focus their efforts.
The first step is securing the dependencies used to create an application. Enforcing signed commits, verified contributors, and dependency provenance checks will help ensure third-party code is secure and reliable. This includes adopting a Software Bill of Materials (SBOM) to maintain visibility into every third-party and open-source component, and validate that integrity after every build, not just before release.
This is even more important as code created by AI coding assistants becomes more prevalent. Checkmarx estimate that 60% of new code now originates from AI tools, yet only 18% of organisations have approved governance policies. This gap creates “shadow AI” - unmonitored assistants shaping production code.
The development environment itself also needs to be considered here, and access must be controlled. Key fundamentals include rotating and minimising credentials, applying least privilege to service accounts, and monitoring for unusual actions such as unplanned repository creation. Policy-as-code can automate checks on configuration drift and unapproved workflow changes.
Finally, it’s important to test for compromise like any other disaster scenario. Keep immutable logs, prepare rollback mechanisms for poisoned builds, and ensure the organisation can restore integrity faster than attackers can exploit a breach.
From Awareness To Accountability
Take your pick: Nx, NPM, or Chalk, these incidents made one fact impossible to ignore: securing the software supply chain is now one of the most critical aspects of DevSecOps.
Modern software development requires an engineering toolchain, but the speed and efficiency it delivers must be balanced with effective security measures across the development lifecycle. With security firmly in place, organisations can enjoy the benefits of safer apps with fewer vulnerabilities and avoid costly security incidents.
Ori Bendet is VP Product at Checkmarx
Image: Ideogram
You Might Also Read:
Banks Hacked With Open-Source Software:
If you like this website and use the comprehensive 8,000-plus service supplier Directory, you can get unrestricted access, including the exclusive in-depth Directors Report series, by signing up for a Premium Subscription.
- Individual £5 per month or £50 per year. Sign Up
- Multi-User, Corporate & Library Accounts Available on Request
- Inquiries: Contact Cyber Security Intelligence
Cyber Security Intelligence: Captured Organised & Accessible






