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 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.
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:
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.
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:
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 security update | Root-cause dependency fix | |
|---|---|---|
| What changes | Manifest and lock file | Manifest, lock file and the code that calls the package |
| Target version | Minimum patched version | Minimum patched version, plus any code changes that version needs |
| When the build fails | The PR stays open for a human to fix | CI logs are read and corrective commits are pushed |
| Ownership | Repository-level alert | Routed to the engineer who owns the affected code |
| Volume control | Opens PRs for every open alert with a patch (or none, if disabled) | Capped and prioritized by real risk |
| Cost | Included with GitHub | A 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.
You can sort your open Dependabot PRs into three groups without buying anything.
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.
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:
The upgrade is the same one Dependabot would have proposed. The difference is that the PR arrives finished.
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.
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.
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.
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.
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.
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.