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 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.
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:
| Response | What it does | Example | When to use it |
|---|---|---|---|
| Remediation | Removes the weakness | Replace string-built SQL with a parameterized query | The default for any real, reachable finding |
| Mitigation | Reduces the chance or impact of exploitation without removing the weakness | Add a WAF rule that blocks the injection pattern | No fix is ready yet, or the fix needs planning |
| Acceptance | Records the risk and leaves it in place, with an owner and a review date | Accept a low-severity finding in an internal tool scheduled for retirement | The 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.
The three terms often get used interchangeably. They describe different jobs.
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.
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.
A remediation process that engineers trust runs the same six steps for every finding:
Skip one and the work becomes another queue to triage.
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.
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.
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.
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.
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.
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.
Dependencies, code, configuration and secrets each need a different fix. Most programs handle all four at once.
| Finding type | How it's remediated | What can be automated | Where it gets hard |
|---|---|---|---|
| Vulnerable dependency | Bump the package to a patched version in the manifest or lockfile | Version bumps for known CVEs with a patch release | Major-version upgrades with breaking changes, transitive dependencies in some ecosystems |
| Code vulnerability | Change the source: parameterize the query, validate the path, add the missing check | AI-generated or rule-based fixes for injection, SSRF, path traversal and similar flaws | Fixes that need a design decision, or span several services |
| Cloud or IaC misconfiguration | Edit Terraform, CloudFormation or Kubernetes manifests at the source | Public buckets, open security groups, missing encryption flags | Resources managed outside code, or changes that need a migration |
| Leaked secret | Rotate the credential with the provider, then remove it from the code and history | Detection and ticketing | Rotation 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.
These three worked examples follow the six steps on the finding types teams see most. They're illustrative, not customer cases.
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.
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.
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.
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:
Some findings should stay manual, with the analysis done and handed to a person:
Count outcomes, not activity. Five numbers tell you whether remediation is working:
Tickets created and PRs opened are the numbers not to optimize. They rise fastest when the process is at its noisiest.
Use this whether you fix by hand, automate, or both.
CODEOWNERS.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.
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.
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.
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.
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.
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.