Articles
Congratulations... Everyone now owns application security
This article was written by Randy Pagels, Matt Olson

That's a scary phrase for development teams. The security world is a confusing jungle of acronyms -- CWEs, CVEs, weirdly named tools -- and it was never supposed to be your problem. But delivery speed has outpaced security practices, and the gap keeps widening. Teams ship faster than ever while vulnerabilities pile up unpatched for months.
The truth is, everyone in the software development lifecycle (SDLC) has some ownership over application security. Software engineers, business analysts, DevOps engineers, SREs... if there's a weak link in the process, there's an opening for a vulnerability. Organizations are learning this, and they're shifting security left into what we now call the SSDLC - the Secure Software Development Lifecycle.
Here are eight hard truths organizations are learning as secure software development becomes a business-critical capability.
1) Speed Without Safety = Technical Debt With Interest
Modern development teams are rewarded for speed. Features need to launch quickly, releases never stop, and the pressure to deliver keeps climbing. That pressure often leads to shortcuts, and one of those common shortcuts is either skipping or subverting security practices.
Credentials are temporarily hard-coded. Packages are added without proper review. AI-generated code is accepted too quickly. Developers promise themselves they will “fix it later.” Unfortunately, later rarely comes. On average, once a security vulnerability is added to a product backlog it can sit there for 8-12 months. An attacker's greatest asset is time, and an organization has very little time to stop an attack from happening. By the time an attacker has been detected, it's too late.
What starts as a small technical shortcut can quickly become a serious business problem once vulnerabilities reach production. Security incidents no longer affect only developers or IT teams. They directly impact customers, operations, trust, and reputation. The true costs of a breach are usually far greater than a dollar amount; it's the customers leaving because they can no longer trust that their data is safe. Reputation is an organization's biggest asset, and data breaches destroy customer trust.
Organizations are discovering that moving fast is no longer enough. The real challenge is learning how to move fast safely. Unfortunately, many organizations end up discovering this the hard way, and too late.
2) Developers Are The First Line Of Defense
For years, security was treated as a separate discipline. Developers wrote software, and security teams reviewed it afterward. Clearly, that model no longer works. Modern software development moves too quickly for security reviews that happen weeks or months after code is written. By the time vulnerabilities are discovered late in the process, developers have already moved on. Context is lost, and remediation becomes expensive.
Developers are increasingly becoming the first line of defense. That does not mean every developer must become a security expert overnight. It means security tooling and processes must integrate directly into environments where developers already work. They need to be not only developer-first, but developer-friendly. Replace cryptic messaging like CWE-89 and "Improper Neutralization of Special Elements" with plain language like "This query depends on a user-provided value." Show the full path of the vulnerability, not just the final line of code where the vulnerability lies. Better yet, suggest a fix and keep it in the same workflow.
The organizations succeeding in AppSec are not forcing developers into separate workflows. They are embedding security directly into the normal developer workflow of Pull Requests, Code Reviews, and even Git Commits and Pushes. That's why GitHub Advanced Security is a developer-first tool - it is tightly integrated into the developer's normal GitHub workflow and encourages and empowers development teams to own the security of their applications.
3) Secret exposure is still one of the most common failures
The easiest way to break into someone's house is to find the spare key "hidden" under the mat or in a plant outside the front door or somewhere that they thought only they knew about. Attackers do the same with secrets — they have time to look around in your organization's public code for a way in. Once a thief has entered your house, do you have time to be analytical and strategize?
One of the easiest ways to gain entry into a company's IT systems is secrets exposure. Despite years of awareness, exposed secrets remain one of the biggest security risks in software development. API keys, tokens, connection strings, and passwords still frequently end up in source code, and sometimes this source code is publicly accessible. In fast-moving environments, developers sometimes hard-code a credential for a feature they're working on temporarily and accidentally incrementally push that commit (and that credential) into the repository.
Truffle Security found around 22,000 live and verified secrets in public Bitbucket and GitLab repositories. Six months later, they found that no attempts had been made to remediate 64% of them. After that six month period, 81% of those initial 22,000 secrets were still live. They found a few common antipatterns were being used to remedy the problems - file overwrites, reintroduction (the secret was removed and then put back), or in 2% they found that the entire repository had simply been deleted.
The problem is that once secrets enter source control, they remain exposed indefinitely through commit history. This leaves one option, and it is usually very messy and comes with unintended consequences - rewriting history.
Modern secret scanning and push protection capabilities are changing how organizations handle this problem. GitHub's Push Protection tools do just that - prevention. It happens as part of a developer's normal workflow, which is exactly where prevention needs to live. Instead of discovering exposed secrets after deployment, teams can now identify and block them before they ever reach the repository. That shift is significant because prevention is always better than remediation. Once a secret is exposed, assume that the entire world has seen it. If we can prevent the exposure from ever happening to begin with, we no longer require rotating and revoking this secret.
4) Your Dependencies May Be Someone Else's Vulnerabilities
Credentials are one entry point; dependencies are another. Modern applications depend heavily on external frameworks and libraries. We often refer to them as dependencies. These dependencies are often Open-Source, which can be a great asset. The community is great at maintaining, managing and securing these dependencies, and it's a lot quicker to fix bugs in a dependency when your development team is everybody on the internet. Unfortunately, that also means that it's a lot harder to secure these dependencies because your development team is...well...everybody on the internet.
In most enterprises, the majority of production code comes from dependencies - around 80-90%. That has enormous advantages for speed and innovation. It also creates risk. Every dependency introduces potential vulnerabilities into the application, including indirect dependencies developers may not even realize exist. That's right - dependencies have dependencies, which have their own dependencies, and, well, you get the picture. If any of the dependencies in that chain have a vulnerability, your application now has that vulnerability.
Organizations increasingly understand that even if they did not write vulnerable code themselves, they still own the security consequences of shipping it. Supply chain attacks are becoming more and more popular, and it is up to you to ensure that your software composition is secure. This has made dependency management a critical component of modern AppSec strategies.
Organizations now need continuous visibility into vulnerable packages, dependency chains, upgrade paths and supply chain risks. Without automation, managing this at scale becomes impossible. Dependency Graph and Dependabot are practical examples of how teams can continuously manage this risk.
5) AI Fights For Both Teams
Developers use AI to write code faster. Attackers use it to find vulnerabilities faster. Organizations are now turning it around to remediate those vulnerabilities too. The result is a new reality where AI exists on both sides of the security equation.
AI-assisted remediation tools can now analyze vulnerabilities, suggest fixes, validate changes, re-run security scans, and explain security findings contextually. None of this eliminates the need for human oversight. Security still requires engineering judgment. But AI is dramatically reducing the operational burden associated with remediation. The organizations that learn how to operationalize AI safely inside the SDLC will gain a significant advantage over those still relying entirely on manual processes.
In GitHub, this is already showing up in practical ways: Dependabot alerts can be assigned to Copilot's coding agent to propose dependency updates and handle related code changes; code scanning alerts can use Copilot Autofix to draft fixes. Importantly, this still runs through human review, status checks, and existing PR controls.
6) Developers Won't Use Tools They Hate
Acceleration fails if developers reject the tools. One of the biggest reasons AppSec programs struggle is not technical capability; it's the developer experience. If security tooling creates friction or drowns developers in noise, they will eventually work around it. That's why developer-centric security design matters so much. Security teams get better outcomes when tools are seen as guardrails, not barriers.
To be developer-first, modern security tooling must fit naturally into engineering workflows, explain vulnerabilities clearly, minimize false positives, provide actionable findings, focus on prevention rather than alerting, and support fast remediation. This is what it's going to take for developers to stop hating their security tools and instead embrace them.
Fit into engineering workflows
Developers want everything to appear within a single pane of glass. Put another way, they don't want to have to bounce around a slew of applications to find out if their code is okay. Even better - developers want those results to appear in their normal workflows, which exist largely as Git commits and Pull Requests.
Explain vulnerabilities clearly
Have you ever seen Office Space? Remember the scene where Peter, Michael and Samir are standing around a printer giving them an error like "PC Load Letter" and they didn't understand it? That's how developers feel a lot of the time with security alerts - "What is a CWE-90?! And how do I fix it?" It is a lot more meaningful when the error says "This LDAP query relies on a user-provided value which hasn't first been sanitized." That not only explains the error, but hints at how to fix it.
Minimize false positives
Noise creates a lack of sensitivity to noise. Think about this - when's the last time you heard someone's car alarm go off and thought that they were really in trouble or that their car was getting stolen? Exactly. It's the same here - too many false positives will lead to developers ignoring the alerts, which means they're ignoring the true positives too.
Provide actionable findings
Simply telling developers there's a problem is not enough. Developers have enough stuff to think about, and figuring out the best way to solve a vulnerability in a codebase (which probably works) for clear-text logging of sensitive information is not high on the list of things they want to worry about. If the tool can suggest how to fix the vulnerability, it's much more likely to be fixed faster and with a much better overall development experience.
Focus on prevention rather than alerting
Another way to think of this is to prioritize guardrails instead of gates. Developers make mistakes. They're human, just like anyone else. If the tools can help to prevent them making mistakes, and provide a potential solution to the problem, developers are much more likely to find value in the tool, and in turn less likely to try to subvert using them.
Support fast remediation
Everything developers work on takes time. In a sprint, that time equates to capacity, and developers are often faced with not having capacity set aside to fix bugs or security problems. They usually don't even have extra capacity to fix issues in a feature that was assigned to them to implement. If the security tool can work faster to provide remediations, it leaves more capacity for new feature work.
GitHub Advanced Security is one example of this model: prevention-first controls, in-workflow feedback, and AI-assisted remediation that still keeps humans in the loop. It is also extensible, so teams can upload third-party SAST results and keep findings in one place. Security adoption improves when developers feel enabled instead of blocked.
7) Prevention Bests Detection by Orders of Magnitude
That is why prevention has to be designed into workflow. Most organizations already have ways to detect vulnerabilities. A lot of tools also have ways to suggest how to remediate vulnerabilities, especially with the uptick in AI adoption. The real challenge is preventing vulnerabilities from entering the code in the first place.
According to EdgeScan Security, around 45% of vulnerabilities remain unpatched after 12 months of being placed on the backlog. Another study from Pixee showed that, on average, vulnerabilities sit unpatched for around 250 days. Rezilion and Ponemon found that, out of the organizations they looked at, 66% of them had over 100,000 vulnerabilities sitting on the backlog, and they also found a 17:6 ratio of vulnerabilities found versus fixed.
Want to know how long an attacker needs to weaponize a vulnerability once they've found it? Around 15 days. And that's assuming there's not a Metasploit module already available for your vulnerability, or some other pre-made POC that they can use to exploit the vulnerability.
How long does a vulnerability exist in your application if the vulnerability never got merged in the first place? 0 days.
This is where “shifting left” becomes critical. Security controls need to move earlier into the development lifecycle. Rulesets can require code scanning results before merge. Dependency changes can be gated against known vulnerabilities. Secret scanning push protection can stop exposed credentials before they land in the repository. When a vulnerability is identified before code is merged, developers can fix it before it ever had a chance to be merged into your codebase. As an added bonus, the developer fixing the vulnerability has fresh context of the code they wrote and the requirements around it which makes the likelihood of introducing defects due to lack of context a lot lower.
Prevention changes security from a reactive process into a proactive one. Every vulnerability prevented is one less incident to respond to and one less production risk to manage. The most mature AppSec programs are increasingly focused not just on visibility, but on intelligent prevention.
8) Security Is A Team Sport, Not A Team
Developers need dedicated capacity to fix vulnerabilities — not "when there's time," but as a first-class sprint commitment. Business Analysts need to define security requirements as part of acceptance criteria before development starts; if they skip it, the developer builds the wrong thing securely or the right thing insecurely. DevOps engineers need to rotate secrets and favor short-lived, scoped tokens because if a long-lived credential sits in a pipeline, every prevention control upstream becomes irrelevant. SRE teams should default to Just-In-Time (JIT) access so that a compromised account can't reach sensitive systems. And security teams still own governance and risk oversight, but they can't be the only ones carrying the weight.
Tooling alone won't sustain a strong security posture. Every role in the SDLC has a security job to do. This is what transforms the SDLC into the SSDLC — Secure Software Development Lifecycle. Not a tooling upgrade. A shared ownership model where security is everyone's operating concern, not a last-minute checkpoint. Security teams still own the governance and risk oversight, but they're no longer the only ones carrying the weight.
Final Thoughts
The era of treating security as someone else's responsibility is over. Every development team is now a security team — whether they planned for it or not. The organizations that win will be the ones that make "0 days" the goal: prevent vulnerabilities from ever reaching the codebase, so there's nothing left to detect, triage, or explain to customers.
References
The following studies were referenced throughout this article:
The Vulnerability Backlog Crisis: Why 45% of Enterprise Vulnerabilities Never Get Fixed
How to Reduce Your Security Backlog: 4-Step Plan to Cut Vulnerabilities
Cost of a Data Breach Report 2025
Leaked and Still Live - Why Developers Fail to Remediate Exposed Credentials
The Rising Threat of Software Supply Chain Attacks: Managing Dependencies of Open Source Projects
State of the Software Supply Chain
---
This article first appeared in XPRT. Magazine #22: Commit to the Unknown. Download the full edition.
Written by
Randy Pagels
I am a DevOps Architect and Trainer at Xebia USA. I lead and educate customers in designing and implementing solutions that adhere to industry standards and DevOps best practices.
Contact














