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.

Dependabot Security Updates vs Root-Cause Dependency Fixes: What to Do When a Version Bump Breaks the Build

Dependabot security updates open a pull request that bumps a vulnerable dependency to the minimum version that contains the patch. For most alerts that is exactly right, and it's free. The trouble starts when the bump changes an API your code relies on, the build goes red, and the PR sits open for weeks. A root-cause dependency fix finishes that job: it upgrades the package and changes the code that broke, then gets the PR back to green.

This guide covers what Dependabot does well, where its PRs stall, and how to tell which alerts need more than a version bump.

What do Dependabot security updates actually do?

According to GitHub's documentation on Dependabot security updates, when an alert is raised for a dependency declared in a manifest or lock file, Dependabot tries to fix it automatically. It raises a pull request that updates the dependency to "the minimum version that includes the patch" and links the PR to the alert.

A few details matter for what follows:

  • It checks the dependency graph first. If the upgrade can't be made without breaking the graph, Dependabot reports an error on the alert instead of opening a PR.
  • Transitive dependencies vary by ecosystem. npm can update a parent package. In several other ecosystems, Dependabot can't update a transitive dependency if that would also require updating its parent.
  • Compatibility scores estimate breakage from the share of CI runs that passed for the same update in other public repositories.
  • Grouped security updates can combine several vulnerable dependencies in one ecosystem into a single PR.

Notice what isn't on that list. The documentation describes changes to manifests and lock files. It doesn't describe editing your application code to fit the new version.

Why do some dependency PRs break the build?

That's not a flaw in Dependabot. It's the boundary of the job it was designed for.

A version bump is a promise about the package, not about your code. When the patched release is a patch-level change, the promise usually holds. When the fix only exists in a new major or minor version, it often doesn't.

The common breakages look like this:

  • A removed or renamed API. The vulnerable function was deprecated, and the patched version deletes it.
  • A changed default. A parser that used to be permissive is now strict, so a test fixture that relied on the old behavior fails.
  • A peer or parent conflict. The patched version needs a newer framework, which drags a second upgrade into the PR.
  • A transitive dependency you never chose. The vulnerable package sits three levels down, and the only route to the fix is upgrading something you do import.

In every case the PR is technically correct and practically stuck. Someone has to read the failing CI log, understand the breaking change, edit the calling code, and push again.

That someone is usually nobody. The PR was opened by a bot, it isn't assigned to anyone in particular, and it doesn't appear in anyone's sprint. This is how dependency alerts become backlog.

Dependabot vs a root-cause dependency fix, compared

Dependabot security updateRoot-cause dependency fix
What changesManifest and lock fileManifest, lock file and the code that calls the package
Target versionMinimum patched versionMinimum patched version, plus any code changes that version needs
When the build failsThe PR stays open for a human to fixCI logs are read and corrective commits are pushed
OwnershipRepository-level alertRouted to the engineer who owns the affected code
Volume controlOpens PRs for every open alert with a patch (or none, if disabled)Capped and prioritized by real risk
CostIncluded with GitHubA separate tool or internal effort

The point isn't that one replaces the other. The point is that most of the cost sits in the PRs that need code changes, and that's the slice a version bump can't reach.

How to tell which alerts need more than a bump

You can sort your open Dependabot PRs into three groups without buying anything.

  1. Green and patch-level. CI passes and the version change is a patch release. Review and merge these in batches. Grouped security updates help here.
  2. Red on a breaking change. CI fails, and the patched version is a new major or minor release. These need code changes. Assign each one to the owner of the calling code, not to the repository.
  3. Blocked on a parent. Dependabot reports an error or can't update a transitive dependency. Decide whether to upgrade the parent, replace the package or accept the risk, and record that decision.

Then ask one more question before anyone spends time on group 2 or 3: is the vulnerable function reachable from your code? A vulnerable package that's imported but never called on the vulnerable path is real, but it isn't urgent. Reachability is what separates the PR you fix this week from the one you schedule.

What a root-cause dependency fix looks like

Take an illustrative case. A service pins an XML library whose patched release removes a legacy parsing function. Dependabot bumps the version. Two tests fail because the service still calls the removed function.

A root-cause fix does four things:

  • Plans the minimal change. Upgrade to the patched version and replace the two calls with the supported API.
  • Matches the codebase. Keeps the service's existing error handling and logging, so the diff reads like the team wrote it.
  • Gets the PR to green. Reads the CI failure, pushes a corrective commit, and rebases if the branch falls behind.
  • Hands it to the right person. Assigns the engineer who last changed those lines, not the whole repo.

The upgrade is the same one Dependabot would have proposed. The difference is that the PR arrives finished.

How Nullify fixes vulnerable dependencies

Nullify's Autofix treats a vulnerable dependency like any other triaged finding. It only works on findings triaged as real and worth fixing. It plans a minimal root-cause change, edits the code to match the repository's style, sends the change through an independent review step, and runs the scanner, build and test checks the workflow has before it opens a draft PR.

After the PR opens, Nullify reads failing CI logs and pushes fixes, replies to reviewer comments, rebases when the branch falls behind, and moves the PR to ready for review once it's green. It routes the PR to the recent authors of the changed lines, then CODEOWNERS, then the owning team.

Two guardrails keep it from turning into another flood: at most three open Nullify fix PRs per repository, and five new PRs per remediation plan. For a planned sweep such as "upgrade every CVE-affected dependency", security leaders run it as a campaign in Security Program Management.

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

Should you turn Dependabot off?

No. Keep Dependabot security updates on for the green, patch-level PRs it handles well. Point your root-cause tooling, or your engineers' time, at the red PRs and blocked alerts, where a version bump alone was never going to be enough.

The real question isn't "Dependabot or something else?" It's who finishes the PRs a version bump can't.

Frequently asked questions

Do Dependabot security updates change application code?

GitHub's documentation describes Dependabot security updates as changes to the dependency in manifest and lock files, raised as a pull request to the minimum patched version. It doesn't describe editing application code to fit the new version, so breaking changes are left for an engineer to fix.

Why does Dependabot say it can't update a dependency?

Dependabot checks whether the upgrade can be made without disrupting the dependency graph. If it can't, for example because a transitive dependency would also require updating its parent in that ecosystem, it reports an error on the alert instead of opening a PR.

What is a Dependabot compatibility score?

It's GitHub's estimate of whether an update will break your project, based on the percentage of CI runs that passed when other public repositories made the same version update. It's a useful signal, but it reflects other codebases, not yours.

What is a good Dependabot alternative for breaking upgrades?

Look for a tool that changes the calling code as well as the version, works the PR through CI failures, and routes it to the code owner. Many teams keep Dependabot for simple patch bumps and use a root-cause fixer only for the upgrades that break the build.