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.

Vulnerability Remediation: Process, Steps, and Examples

Vulnerability remediation is the process of fixing a confirmed security weakness so it can no longer be exploited. For code you own, that means changing the source, a dependency or a configuration file, verifying the change, and shipping it. A finding is remediated when the fix is merged and deployed, not when a ticket is filed.

This guide covers the vulnerability remediation process step by step: how remediation differs from mitigation and patch management, how each type of finding gets fixed, three worked examples, how to measure it, and which parts are safe to automate.

What is vulnerability remediation?

Vulnerability remediation is the work of removing a vulnerability at its cause, so the weakness no longer exists in the code, dependency or configuration that shipped it. It's the last stage of vulnerability management, after a weakness has been found, confirmed and prioritized.

Remediation is one of three ways to respond to a confirmed vulnerability:

ResponseWhat it doesExampleWhen to use it
RemediationRemoves the weaknessReplace string-built SQL with a parameterized queryThe default for any real, reachable finding
MitigationReduces the chance or impact of exploitation without removing the weaknessAdd a WAF rule that blocks the injection patternNo fix is ready yet, or the fix needs planning
AcceptanceRecords the risk and leaves it in place, with an owner and a review dateAccept a low-severity finding in an internal tool scheduled for retirementThe cost of fixing outweighs the risk, and someone accountable signs off

Mitigation buys time. It doesn't close the finding. A WAF rule can be bypassed, and the vulnerable code is still there for the next attacker to find another route to.

Vulnerability remediation vs vulnerability management vs patch management

The three terms often get used interchangeably. They describe different jobs.

  • Vulnerability management is the whole program: finding, prioritizing, fixing and reporting on vulnerabilities across your environment.
  • Patch management installs vendor patches on operating systems and third-party software running on servers and laptops. The fix already exists. The work is scheduling and rollout.
  • Vulnerability remediation is the fixing stage. For infrastructure, it often means applying a patch. For the code your team writes, there's no vendor patch to install. Someone has to write the change.

This guide focuses on that second case: source files, dependency manifests and infrastructure as code. It's the slower kind of remediation, because every fix has to be written, reviewed and proven.

Why vulnerability remediation is the bottleneck

Detection isn't the hard part anymore. Teams that run several scanners get findings faster than anyone can fix them.

Two things make the pile worse than it looks. First, a large share of it is noise: across 14,847 SAST findings triaged over 90 days in five Nullify production tenants, 57% were classified as false positives.

Second, every real finding still needs a person to understand it, write a fix, get it through CI and find a reviewer. That's where the time goes, and where mean time to remediate (MTTR) stretches out.

A finding is a task. A merged fix is an outcome.

The vulnerability remediation process in 6 steps

A remediation process that engineers trust runs the same six steps for every finding:

  1. Confirm the finding is real and reachable.
  2. Prioritize it by exploitability, exposure and business context.
  3. Find the owner and gather the code context.
  4. Write the smallest fix that removes the root cause.
  5. Verify the fix with builds, tests and exploit replay.
  6. Merge, deploy and close the finding with a record.

Skip one and the work becomes another queue to triage.

1. Confirm the finding is real

Fixing a false positive wastes a reviewer's time and teaches developers to ignore security. Before anyone writes code, check reachability (can untrusted input get to this code?), exploitability and whether the code runs in production at all.

Record the verdict, not just the outcome. Unreachable code isn't the same as a false positive: the flaw is real, it just can't be reached today. Where an exploit can be run safely, running it is the strongest evidence.

2. Prioritize by risk, not severity alone

A CVSS score describes the vulnerability in general. It doesn't know that this service is internet-facing and handles payment data. Rank confirmed findings by exploitability, exposure and business context, then set the deadline from your remediation SLA.

For known CVEs, two public signals help. CISA's Known Exploited Vulnerabilities catalog lists vulnerabilities with evidence of exploitation in the wild, and FIRST's EPSS estimates how likely a CVE is to be exploited in the next 30 days. Severity is a property of the bug. Priority is a decision about your program.

3. Find the owner and gather context

A fix written from the flagged line alone is often wrong. Whoever writes it needs the callers, the data flow, the framework conventions and the tests. They also need to know who owns the code, usually through commit history or the CODEOWNERS file.

Security teams usually find and prioritize. The team that owns the code reviews and merges the fix, because they answer for what it changes.

A parameterized query is only the right fix if you know which database driver the service uses.

4. Write the smallest root-cause fix

The fix should close the vulnerability at its cause and touch nothing else. A one-line input check at the wrong layer can hide a flaw from the scanner and leave it exploitable.

A 400-line refactor is correct and unreviewable. Minimal and root-cause is the target.

5. Verify the fix

The change has to build, pass the existing tests and actually close the vulnerability. When there's a working exploit, replay it against the patched code: if the attack still lands, the fix isn't done.

Then rescan to check the change didn't open a new hole.

6. Merge, deploy and close the loop

Opening the pull request is the halfway point. CI fails, reviewers ask questions, the base branch moves. Someone has to carry the PR to merge, confirm the fix is deployed, and close the finding with a record of what changed.

If a PR stalls, escalate it before the SLA runs out, not after.

How to remediate each type of vulnerability

Dependencies, code, configuration and secrets each need a different fix. Most programs handle all four at once.

Finding typeHow it's remediatedWhat can be automatedWhere it gets hard
Vulnerable dependencyBump the package to a patched version in the manifest or lockfileVersion bumps for known CVEs with a patch releaseMajor-version upgrades with breaking changes, transitive dependencies in some ecosystems
Code vulnerabilityChange the source: parameterize the query, validate the path, add the missing checkAI-generated or rule-based fixes for injection, SSRF, path traversal and similar flawsFixes that need a design decision, or span several services
Cloud or IaC misconfigurationEdit Terraform, CloudFormation or Kubernetes manifests at the sourcePublic buckets, open security groups, missing encryption flagsResources managed outside code, or changes that need a migration
Leaked secretRotate the credential with the provider, then remove it from the code and historyDetection and ticketingRotation is an action outside the repository

Dependency updates are the most established automated fix. GitHub's Dependabot security updates, for example, open a pull request that raises a vulnerable dependency to the minimum version that includes the patch.

When one fix pattern applies across many repositories, such as moving every service off a vulnerable library, run it as a planned remediation campaign instead of one ticket at a time.

Vulnerability remediation examples

These three worked examples follow the six steps on the finding types teams see most. They're illustrative, not customer cases.

Example 1: A vulnerable dependency

A scanner reports a CVE in a JSON parsing library pinned at a version with a known deserialization flaw. The patched release is a minor version up.

The fix bumps the version in the manifest and regenerates the lockfile. The build and tests run, and a PR that links the advisory goes to the service owner. The engineer reads a two-line diff and merges.

Example 2: SQL injection in a search endpoint

A finding flags string concatenation in a query built from a request parameter. Reachability analysis confirms the parameter comes straight from an HTTP request. The fix replaces concatenation with a parameterized query:

# Before
cursor.execute("SELECT * FROM orders WHERE customer = '" + name + "'")

# After (placeholder style matches this service's driver)
cursor.execute("SELECT * FROM orders WHERE customer = %s", (name,))

The existing tests pass. Replaying the injection payload against the patched endpoint now returns no extra rows. The PR goes to the file's code owner with the payload, the before and after responses, and the test results.

Example 3: A public S3 bucket in Terraform

A cloud audit finds an S3 bucket with public read access, created by a Terraform module. The fix adds a public access block to the bucket in the module, not in the console, so the next terraform apply doesn't undo it. The PR goes to the team that owns the module.

Manual vs automated vulnerability remediation

Steps 1 through 6 can all be done by hand. Most of them can now be automated, and the volume of findings is the main reason to do it. Automated vulnerability remediation tools validate the finding, write the fix, run the checks and open the pull request. An engineer still reviews and merges.

Automated fixes fail in predictable ways, so know them before you turn anything on:

  • The fix is incomplete. It blocks the one payload the scanner tried and leaves the flaw. GitHub's own responsible-use guidance for Copilot Autofix warns that a suggested fix may only partly address the vulnerability, or introduce new ones.
  • The fix breaks behavior. Code that compiles can still change what the program does. Tests only catch what they cover.
  • The fix adds a dependency that doesn't exist. Code-generating models sometimes recommend packages that were never published, and attackers register those names. A USENIX Security 2025 study measured this "package hallucination" problem across 16 models. Every new dependency in a fix needs checking.
  • Too many PRs at once. A tool that opens a pull request for every finding buries developers, and they start closing them unread.
  • Auto-merge. Merging generated fixes without review turns every risk above into a production change. Automate up to merge readiness and leave the merge to a person.

Some findings should stay manual, with the analysis done and handed to a person:

  • Authorization model changes. Fixing an IDOR properly can mean changing who is allowed to see what. That's a product decision.
  • Fixes that span services. If the vulnerable value is produced in one service and consumed in another, a single-repo patch may move the problem rather than solve it.
  • Breaking upgrades. A major-version bump that changes an API needs planning, not a PR on a Tuesday afternoon.
  • Leaked secrets. The code change is the easy part. The credential has to be rotated with the provider.

How to measure vulnerability remediation

Count outcomes, not activity. Five numbers tell you whether remediation is working:

  1. MTTR: time from a confirmed finding to a deployed fix.
  2. SLA compliance: the share of findings fixed within the deadline for their risk level.
  3. Fix merge rate: the share of fix PRs that merge. A PR nobody merges fixed nothing.
  4. Reopen rate: how often a "fixed" finding comes back, which catches incomplete fixes.
  5. Backlog age: how long open, confirmed findings have been waiting, by severity.

Tickets created and PRs opened are the numbers not to optimize. They rise fastest when the process is at its noisiest.

Vulnerability remediation checklist

Use this whether you fix by hand, automate, or both.

  • Only fix findings that have been confirmed as real and reachable.
  • Rank by exploitability, exposure and business context, not CVSS alone.
  • Route each fix to its owner through commit history or CODEOWNERS.
  • Keep fixes minimal and at the root cause, and reject broad rewrites.
  • Require every fix to build and pass existing tests before review.
  • Replay the exploit against the patch wherever one exists.
  • Check every new or changed dependency exists and is the intended package.
  • Use mitigation only as a stopgap, with a date to remediate.
  • Escalate stalled fixes before the remediation SLA runs out.
  • Never auto-merge. A human approves every change.

How Nullify handles vulnerability remediation

Nullify confirms findings before they reach anyone. Triage scores each finding on reachability, exploitability, business context and confidence, and filters out unreachable code, test fixtures and benign configuration first.

For confirmed findings, Nullify writes a minimal, root-cause fix that matches the repository's style. An independent review step sends it back if it misses the cause, changes behavior or isn't minimal. Nullify then attempts the scanner, build, test and exploit checks your workflow has, records the result, and opens a draft pull request.

Nullify then works the PR through review: it reads CI output and pushes fixes, answers reviewer comments, and rebases when the branch moves. PRs route to the authors of the changed lines, then CODEOWNERS, then the owning team. Nullify keeps at most three open fix PRs per repository so developers aren't flooded. Leaked secrets go to manual rotation with a tracking ticket instead of an automatic fix.

Nullify never merges. Your engineers approve every change, because a finding is a task and a merged fix is the outcome. See how it works on the triage and remediation page.

Frequently asked questions

What is vulnerability remediation?

Vulnerability remediation is the process of fixing a confirmed security weakness so it can no longer be exploited. For application code, that means changing the source, a dependency or a configuration file, verifying the change and shipping it.

What are the steps in the vulnerability remediation process?

Confirm the finding is real, prioritize it by risk, find the owner and gather context, write the smallest root-cause fix, verify the fix with builds, tests and exploit replay, then merge, deploy and close the finding.

What is the difference between remediation and mitigation?

Remediation removes the vulnerability. Mitigation reduces the chance or impact of exploitation, for example with a WAF rule or a feature flag, while the vulnerability stays in place. Mitigation is a stopgap until a fix ships.

What is the difference between patch management and vulnerability remediation?

Patch management installs vendor patches on operating systems and third-party software. Vulnerability remediation is the broader job of fixing any confirmed vulnerability. For code your team owns, there's no vendor patch, so the fix has to be written, reviewed and proven.

Can vulnerability remediation be automated?

Most of it can. Tools can confirm findings, write fixes, run builds and tests, and open pull requests. The merge should stay with an engineer who can see the evidence, and some fixes, such as authorization changes and secret rotation, need a person throughout.