What Makes AppSec Hard: Observations From the Field
After four years of application security work in e-commerce, retail, luxury, insurance, banking and telecom, I keep seeing the same pattern: the tools are there, but the problems come from how teams are organized and how
After four years of application security work in e-commerce, retail, luxury, insurance, banking and telecom, I keep seeing the same pattern: the tools are there, but the problems come from how teams are organized and how processes work. Here are seven challenges from the field, with what helped and one mistake of my own.
For the last four years, my main job has been helping large organizations with application security. As an AppSec engineer, on a large e-commerce platform and across an entire retail group, my role was to:
- integrate the security scans
- manage and prioritize vulnerabilities
- help teams fix them
- review architectures at design time
I've also run DevSecOps and AppSec maturity audits in luxury, insurance, banking and telecom. The sectors were different, but the same patterns kept coming back. Here's a typical one.
When I arrived on the e-commerce platform, the security tool was already there. Some scans were integrated, though not configured properly, and they ran fairly early in the cycle.
But the release criterion wasn't "are there serious vulnerabilities?". It was "has a security scan been run?"
So the scans ran, the results piled up, and teams discovered their vulnerabilities at go-live, when someone finally looked. The information had existed for weeks. It just wasn't connected to any decision.
Nobody was careless there. The tools worked, the scans ran, and the teams did what the process asked of them. The process just wasn't built to make anyone act on what the scans found.
I've seen versions of this in almost every organization I've worked with. Most of the time, the problem wasn't a missing tool or a lack of technical knowledge. It was somewhere between the tools, the teams and the way work actually gets done.
This article is a field report: seven things I keep running into, in the order they show up when software gets built. I'll come back to that platform a few times, and I'll share one mistake of my own along the way.
!7 challenges on the lifecycle@2x (1).png.png)
1. Security arrives too late
The story above isn't unusual. On many projects, security may run early, but it only really counts at the end, just before go-live. By then, the architecture is done and the date is fixed. Anything serious turns into a negotiation.
It happens at design time too. Security requirements usually exist somewhere, in a policy or a standard. But if nobody turns them into backlog items, nobody builds them, and the gap only shows up at go-live.
In both cases, detection wasn't the problem. Security information didn't reach the people making decisions at the moment they were making them.
What helped: putting security where teams already look.
- Security requirements written as acceptance criteria, like any other requirement.
- Scan results tied to the release decision, instead of sitting in a separate tool.
2. Plenty of tools, not much use
Large companies usually aren't short on security tools. If anything, it's the opposite.
Tools nobody uses. I worked with one group that had standardized an SCA tool across all its entities. It was bought, deployed, and on paper every project was covered.
In practice, nobody was using it. It had been chosen centrally, mostly for compliance, and never made part of how the teams worked.
Tools that are too slow. Giving developers security feedback directly in their IDE sounds ideal. But when the scan takes too long, developers don't use it, and I can't really blame them.
Tools that don't talk to each other. I've also seen three different scanners running side by side, each looking at different things or in different ways (SAST and DAST, or IaC scanning and CSPM, for example), with no correlation between their results and no link to the ticketing system.
These tools are often managed by different teams that rarely talk to each other, so nobody has the full picture.
What helped: involving developers in choosing security tools, not just the security team. They're the ones who live with the tool every day. A tool that security likes and developers ignore doesn't protect anything.
3. Security that slows delivery doesn't stick
This is where I made one of my own mistakes.
On that platform, part of my job was to add the missing SAST and SCA scans and to fix the integrations already in place. A full scan took more than 45 minutes.
My first move was to put it in the regular build pipeline, because that's what you're supposed to do. Adoption was very bad, very quickly. For teams that build many times a day, adding 45 minutes to every build just wasn't realistic.
Changing the tool wasn't an option either. It was already integrated, and the contract was signed for several years.
So I stepped back and worked with the tech leads, the DevOps team, the delivery manager and the release manager to design something that fit what they already did:
- The scan moved to a separate workflow, running in parallel, so it no longer slowed the build.
- The deployment gate was rebuilt and plugged into the release process the teams already followed.
Instead of blocking on every finding, we agreed on a rule the teams could live with. A deployment was blocked only by:
- High or Critical vulnerabilities, to keep the gate focused on what really mattered,
- introduced in new code, so teams weren't held responsible for years of existing debt every time they shipped,
- after a 40-day grace period, so teams had time to qualify findings and a false positive could never block a release on its own.
It worked much better than my first version, mostly because the teams had built it as much as I had.
The lesson for me: a control that ignores how a team ships gets ignored in return.
4. Lots of findings, few fixes
At the start of many of my missions, I found the same situation:
- the scanning tool was integrated
- results were coming in
- nobody was actually managing the vulnerabilities
No prioritization, no follow-up, no owner. I call it read-only security: you can see everything, and nothing changes.
Part of the reason is that we tend to count what we find rather than what we fix. A big backlog can look like progress.
On that platform, fixing the scan integrations was only half the job. I also worked with the architecture team, the lead developers and the project teams so the tool fit into their process, and I set up how vulnerabilities would actually be managed and handled.
What helped: a shared backlog. We put the findings into the teams' backlog and prioritized them by severity for the upcoming sprints. Each finding was qualified together by the architecture team, the lead developers and me on the security side, so we could assess both its impact and how hard it would be to fix.
The other thing that made a difference was fixing things together. I remember a server-side template injection (SSTI) we worked on over a call with one of the developers. They had the context and knew the code. I had the application security side. Neither of us could have fixed it properly alone.
And the next time that kind of vulnerability came up, they could handle it on their own. A ticket wouldn't have done that.
5. Code you don't control
A big part of the code in large companies is written by external vendors. That changes more than people expect.
Training. As an AppSec engineer, I had set up a security awareness and training program for developers, with some gamification to make it less of a chore. It worked well with internal teams.
Then I learned that in France, we couldn't train external developers the same way: training a vendor's staff directly can be treated as illegal labour lending.
For them, we had to stick to awareness: talks, a community, documentation and shared materials, but no actual training. A large share of the people writing the code were getting the lighter version.
Ownership. For outsourced applications, clients often couldn't tell me who owned the code or where it was stored.
- Were developers working with vendor accounts or client accounts?
- On the vendor's infrastructure or the client's?
It's hard to build security into the code when you don't know where the code is or who it belongs to.
What helped: treating it as a contract issue first. Who owns the code, where it lives, what security obligations apply and for how long all need to be written down before the work starts. Fixing it afterwards, from the security side alone, is much harder.
6. Nobody really knows what they own
Underneath all of this sits a simpler problem: many organizations don't have an accurate picture of what they own.
I've asked CISOs questions like these, and not gotten a clear answer:
- "How many applications do you have?"
- "Which of your critical applications haven't been scanned in the last six months?"
The CMDB rarely matches what's actually running. There are orphaned apps, repositories with no clear owner, and APIs people forgot about.
And it isn't only applications. On one application with many third-party services integrated, it was impossible to get a list of them: which services were used, which keys, when they expired, which environments they pointed to. Any developer could sign up for a third-party service and start using it in their code.
That isn't a personal failing. Inventories go out of date almost as soon as they're written. But it does mean every other effort rests on a guess. You can't scan or prioritize something you don't know exists.
What helped: starting from what really exists, and reconciling it with the CMDB afterwards, instead of trusting the CMDB first:
- code repositories
- CI/CD pipelines
- cloud resources
For dependencies, SCA gives you part of the picture. Scanning manifest files like package.json, pom.xml or requirements.txt shows at least some of what an application relies on.
Most SCA tools can also export that as an SBOM (Software Bill of Materials), a standard, machine-readable list of an application's components that you can keep and update for each release. It's far from complete, but it's a starting point.
7. AI will make the speed problem worse
What worries me most about AI in AppSec isn't the new attack types. It's speed.
Many AppSec tools were already too slow for the way teams worked before AI. A 45-minute scan was already a problem.
Teams ship faster. I now see developers producing code noticeably faster with tools like Claude Code and GitHub Copilot. And the business has noticed: requests come in faster, and expectations go up with them.
Code nobody can fix. I've also seen applications built entirely with Claude Code by people with no technical background. That raises a simple question: when a vulnerability shows up, who fixes it? The person who built the application often can't read the code, and there may be no developer who knows it.
Tools catching up, unevenly. Some AppSec vendors have added genuinely useful features:
- AI pre-triage and qualification of findings
- remediation suggestions (not always adapted to the context)
Others are clearly falling behind.
Shadow AI, prompt injection and over-privileged agents matter too, but they're familiar problems. Keeping up is the new one.
It's changing fast, and it deserves more than one section. I'll come back to it in several upcoming articles.
What ties it together
Looking back over this list, most of it isn't technical. It's mostly about how people organize themselves and how processes actually work:
- who owns what
- when security gets involved
- whether the secure option is also the convenient one
The scanning story is the one that convinced me of something I now see everywhere: developers generally want to do things properly. The same teams that ignored my first setup adopted the second one, because it fit how they worked and they had helped build it. To me, that says more about how security is designed than about the developers.
That's what I want to write about here. Each of these topics deserves its own article, and I'll also cover things that didn't fit, like metrics and budgets, supply chain security and secrets management. The next one is about AppSec vs DevSecOps vs SecDevOps, and what actually changes between them in practice.
If you work in this space, I'd like to know: which of these do you run into most, and what have I missed?
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.