Nullify

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

The Limits of Automated Remediation: Why Some Vulnerabilities Should Never Be Autofixed

A leaked AWS access key turns up in a config file committed six months ago. The scanner flags it. An eager autofix opens a PR that deletes the line.

The PR is green. It merges. The key still works.

Deleting a secret from the current commit doesn't revoke it, doesn't remove it from history, and doesn't tell you who used it. The fix closed the alert and left the risk exactly where it was.

An autofix that knows its limits is a tool. One that doesn't is a liability. The limits of automated remediation aren't a weakness to hide. They're the design.

A generated fix is a proposal

Automated remediation is very good at one shape of problem: a known-bad pattern at a known location, with a minimal change that removes it and a test that proves it. Injection, missing authorization checks, unsafe deserialization, a vulnerable dependency with a clean upgrade path.

It gets worse as the fix depends on facts that aren't in the code. Who owns this credential. What this endpoint is supposed to allow. Whether this behavior is a bug or a contract a customer relies on.

Those cases share a property: the right fix is a decision, not a diff.

Five kinds of findings that shouldn't be autofixed

1. Leaked secrets

A secret's risk lives with the provider, not in the repository. The real remediation is to rotate the credential, check access logs for use, and then remove it from code and history. None of that is a code change.

Nullify doesn't autofix leaked secrets. Secrets Detection verifies live credentials against the provider where it can, tags a suspected owner, and gives rotation guidance. Rotation itself is a provider-side action that Nullify has no standing access to, so the finding goes to manual rotation with a tracking ticket.

2. Business-logic flaws where the intended behavior is unclear

An endpoint lets a user apply a discount code twice. Is that a bug? Maybe. Maybe a promotion depends on it. The code can show you what happens. It can't tell you what should happen.

A fixer can propose the restrictive version. It shouldn't open a PR that silently changes pricing behavior. The right output is the finding, the evidence, and a question for the owner.

3. Fixes that change a public contract

Tightening an API's input validation may close a vulnerability and break every client that sends the old format. Removing a deprecated auth method may close a downgrade path and lock out a customer's integration.

When a fix changes what outside callers can do, it needs a migration plan, a changelog and usually a deprecation window. That's a product decision.

4. Architectural vulnerabilities

Some findings aren't a bad line. They're a bad shape: a service that trusts every caller on the internal network, a tenant boundary enforced in the UI and nowhere else. The real fix is a design change across several services. A minimal patch at one call site gives you false comfort and a closed ticket.

5. Findings you can't verify

If there's no build, no tests and no way to run the scanner again, a generated fix has nothing to stand on. It's a patch nobody can check. The honest output is fix guidance, not a PR that implies confidence the evidence doesn't support.

What to do with them instead

"Don't autofix" doesn't mean "ignore." Each of these needs a different path:

FindingWrong automated responseRight response
Leaked secretDelete the lineRotate at the provider, check usage, then clean code and history
Unclear business logicPatch the behaviorSend the evidence and a question to the owner
Public contract changeTighten validation silentlyPlan a migration and a deprecation window
Architectural flawPatch one call siteRaise a design ticket with the attack path
Unverifiable fixOpen a PR anywayGive fix guidance and a reproduction ticket

The pattern is the same in every row. When the fix is a decision, route the decision to the person who owns it, with the evidence attached.

Restraint is part of the product

It's tempting to judge an autofix tool by how many PRs it opens. That's the wrong scoreboard. A tool that opens a PR for every finding is guaranteed to open some that are wrong, and every wrong PR spends trust you need for the right ones.

The better measures are whether the PRs it does open get merged, and whether the findings it doesn't fix still reach someone who can act on them.

How Nullify decides what to fix

Nullify's Autofix only works on findings that triage has confirmed are real and worth fixing. It covers code vulnerabilities, dependency issues, cloud misconfigurations and validated pentest findings. Leaked secrets are deliberately out of scope.

When a generated fix isn't appropriate, Nullify falls back to fix guidance and a ticket with reproduction steps, tagged to the owner, and keeps the context for later. When it does open a PR, the change has passed an independent review for root cause, behavior and minimality, and the PR records which checks ran. Nullify's documentation says plainly that a generated fix is a proposal, not a guarantee.

Security leaders can tighten this further with an autonomy policy and blocked action types that control when Nullify opens PRs, files tickets or messages people.

Nullify never merges. A human always makes the final call.

Know the limits

The leaked key didn't need a PR. It needed a rotation and a look at the logs. An autofix that knows its limits is a tool. One that doesn't is a liability.

Frequently asked questions

Can automated remediation fix leaked secrets?

Not properly. Deleting a secret from code doesn't revoke it or remove it from git history. The credential has to be rotated at the provider and its usage checked. Tools can detect, verify and route leaked secrets, but rotation is a provider-side action.

What types of vulnerabilities are best suited to autofix?

Findings with a known-bad pattern at a known location and a minimal, testable fix: injection, missing authorization checks, unsafe deserialization, and vulnerable dependencies with a clean upgrade path. The more a fix depends on intent, ownership or external contracts, the less suited it is.

What are the risks of automated vulnerability remediation?

The main risks are fixes that close the alert without removing the risk, fixes that change legitimate behavior, new dependencies or vulnerabilities, and review fatigue from too many PRs. Guardrails such as triage-only fixing, independent review, PR caps and human merge approval reduce them.

Should automated remediation ever merge its own fixes?

No. Automation can prepare a fix through checks, CI repair and reviewer assignment, but a human should approve every security change. The merge is where someone accountable confirms the fix is right for the system.