How Do You Find Security Vulnerabilities in Old Code Before You Rebuild?

Author
Christie Pronto
Published
November 18, 2026

How Do You Find Security Vulnerabilities in Old Code Before You Rebuild?

Every new enterprise customer comes with a security questionnaire now. 

Most of it is routine, and your team fills it in without much trouble.

Then there are the three or four questions about the system that's been running since before most of your team got here: who can get into it, what it writes down, and whether anything underneath it still gets patched.

Nobody is sure. So the deal waits while your team goes looking.

You might be planning to replace that system anyway, and that's a reasonable plan. It doesn't help with the form on your desk this week, though. 

Reading the code now tells you what you can close in the next few weeks and what only the new system will fix, and both are worth knowing before you've spent a dollar on the rebuild.

‍

Why can't you answer security questions about a legacy system?

You can't answer them because the answers were never written down anywhere, which is a different problem from the answers not existing.

The information is all in the code. Every permission, every connection to another system, every component that stopped receiving updates is sitting there and can be found. It has just never been collected in one place, because until the questionnaire arrived there was no reason to.

These are the questions that usually cause the delay:

  • Which parts of the software no longer get security updates, and what depends on them
  • Where sensitive data is stored, and who can reach it
  • Who has administrative access, and what that access lets them do
  • What the system records, and whether those records would satisfy an auditor
  • When the code was last read by a developer specifically checking for weaknesses

The hardest part of securing an old system is knowing which questions to ask about it, and that's the part that goes missing when the people who built it leave.

None of that is anyone's fault. Systems outlive the people who build them, and whatever documentation exists was written for a team that has mostly moved on. But the questions still need answers, and a contract is waiting on them.

‍

What does a security audit of old code actually find?

You find them by auditing the code, which usually turns up three things: software that no longer receives updates, permissions that grew over time, and unreviewed connections to other systems.

Unsupported software is the one with a deadline attached to it now. On February 5, 2026, CISA issued BOD 26-02, giving federal agencies three months to inventory equipment that no longer receives security updates and a year to start removing it. Nick Andersen, who runs cybersecurity at the agency, said unsupported devices should never remain on enterprise networks, and that CISA is encouraging other organizations to do the same.

That directive covers network equipment, not application code. But it's the same standard your customer is applying in their questionnaire, and they're applying it now rather than in a year.

‍

Which security findings actually matter in a legacy system?

Security is a wall, and the only question worth asking about any gap in it is what sits on the other side.

You can always make the wall taller, and there's no such thing as unhackable software, so the work is never finished. The findings worth your week are the ones sitting in front of something worth taking. A weak permission on a system holding a few names and email addresses deserves less attention than the same weakness on one holding payment details or claims data.

So sort by what's behind the wall before you sort by severity score. A critical-rated finding guarding nothing valuable is a worse use of your team than a moderate one sitting in front of your members' information.

That also points at a cheaper fix than an audit usually produces. Some of what you're defending doesn't need to be in your system at all. Payment details can live with a payment processor, identity verification with a provider built for it, and every category you move out is one you stop defending forever.

‍

Which vulnerabilities should you close now, and which wait for the rebuild?

Once you know what matters, findings split into what you can close on the system you have now and what only closes when the architecture changes.

Sorting them matters, because the two groups have very different timelines:

  • Close now. A library with a patch available. A permission broader than the job requires. An admin account that should have been turned off when an employee left. Logging that was never switched on. Most of these take days.
  • The rebuild closes it. Authentication that can't support MFA without being redesigned. A database storing information it shouldn't hold. A framework the vendor stopped supporting, with no upgrade path. These are projects, and treating one as a quick fix is how three weeks turns into six months.
  • The group that gets missed. Fixes that are cheap today and will reappear in the new system unless they're written into its requirements.

UnitedHealth bought Change Healthcare for $13 billion in late 2022. In February 2024, attackers used stolen credentials to get into a Change Citrix portal that had no multifactor authentication on it, and a claims platform handling one in three patient records was down for more than a month.

That portal had been sitting there since before the acquisition. Turning on multifactor authentication is a close-now fix on a system holding exactly the kind of data worth defending. It never got sorted into either group, because the system was never read.

‍

How does Big Pixel audit a legacy system with Claude Mythos?

We're approved for Defense Access in Anthropic's Cyber Verification Program, which is how we work with Claude Mythos.

On a legacy audit we point it at the code you already run.

We break it first, so we can build it stronger. With Claude Mythos on our side we uncover the vulnerabilities in your system, the ones you already know about and the ones you never knew existed. Then we make the complicated simple. We shore up those gaps and bring AI in where it makes your system better, keeping it out of the places where it would only add complexity. Knowing the difference takes more than 100 years of combined experience.

Every finding goes to a developer before it reaches you, because a finding is only a claim until a person who knows the system confirms it and works out what a fix would break. It's the same review we run on defensive testing for software we build ourselves, applied here to code we didn't write.

‍

What do you get at the end of a legacy code security audit?

You get a written list that sorts every finding by what it's protecting and when it can be closed, with an owner against each line.

What's on it:

  • Each finding written in language that makes sense outside engineering
  • Which part of the system it affects, and whether that part still receives updates
  • What sits behind it, and what that data is worth to someone who wants it
  • Close now or the rebuild handles it, with the reason
  • What it would take, in days or as a project
  • Who owns it

That list changes what you can tell people. Your customer's security team gets specific answers with dates against them instead of assurances, which is usually what gets a contract moving again. Your insurer gets the same answers at renewal. And when the rebuild gets scoped, the second column is most of its requirements already, so you're pricing a project against findings a developer has confirmed.

ComplianceDashboard came to us with a platform that was twelve years old and carried HIPAA, 401(k) and healthcare compliance work for their own clients. We started the way we always do, by understanding what the old system did and what depended on it, and the re-architecture that followed had every release coordinated to protect existing client data.

We believe that business is built on transparency and trust, and that good software is built the same way, which on an audit means you read every finding yourself, including the ones that make the rebuild bigger.

‍

What should you do before the next security questionnaire?

Before the next questionnaire arrives, write down what sensitive data your business actually holds and which system each kind of it sits in.

  • Every category of sensitive data, and the system holding it
  • Every component past end of support, with its dependencies listed
  • A named owner, and a backup, for each system holding something valuable
  • The last date a developer read the code looking for weaknesses
  • Which connections to other systems hold standing access, and under whose credentials

The reasonable objection is that this is money spent on software you intend to replace. The replacement is a year out, though, and the risk is there the whole time. The audit also tells the rebuild what it has to fix, which is the difference between a scoped project and an estimate. Finding vulnerabilities got cheaper this year, so the next finding on your oldest system may well come from outside your company.

Start with whichever system holds the data you'd least like to lose. Find out what's protecting it, when that protection was last checked, and who would know if it failed.

Author
Christie Pronto
Published
November 18, 2026
White dots forming a halftone pattern on a black background in the top right corner.White dots forming a halftone pattern on a black background in the top right corner.

Check out the BIZ/DEV podcast

Our weekly tech podcast focusing on AI, our industry, the founder's journey, and more.

biz/dev podcast
Free Strategy Session