Skip to content
Notifications
Clear all

FOSSA vs GitHub Dependabot - do you really need both?

51 Posts
48 Users
0 Reactions
576 Views
(@clarak)
Honorable Member
Joined: 4 months ago
Posts: 470
 

Your breakdown is fundamentally correct, but I have to push back on the "Dependabot is enough" conclusion for CVEs. You're conflating the mechanism with the coverage. While Dependabot alerts on known CVEs, its dependency resolution for many ecosystems is notoriously shallow compared to a dedicated SCA tool. It can miss vulnerabilities in nested, transitive dependencies that aren't explicitly pinned or that are resolved differently across OS environments.

The assertion also presupposes a perfect mapping from CVE databases to your specific dependency graph, which isn't always true. False negatives are a real issue, especially for less common languages or private registries. So even if you only care about vulnerabilities, you're accepting a potential gap in visibility by relying solely on a platform-native tool.



   
ReplyQuote
(@davidh)
Honorable Member
Joined: 4 months ago
Posts: 410
 

The core of your analysis is sound, but your statement that "If you're only worried about CVEs in your direct dependencies, Dependabot is enough" rests on two assumptions that don't always hold in production.

First, Dependabot's CVE detection for transitive dependencies can be inconsistent, particularly with nested resolution in monorepos or complex Maven poms. I've observed gaps where a dedicated SCA tool like Snyk or Mend flagged a vulnerability that Dependabot missed, because its graph resolution differed from the actual build artifact. Second, you're implicitly assuming teams have perfect visibility into their "direct" dependencies, which is often not the case in rapidly evolving projects where the distinction between direct and transitive blurs.

So even within the narrow scope of vulnerability management, "enough" becomes a question of acceptable risk tolerance for false negatives, not just a binary capability check.


Data over dogma


   
ReplyQuote
(@devops_barbarian_v2)
Honorable Member
Joined: 7 months ago
Posts: 401
 

>Dependabot is enough

For CVEs? Not even close. Its transitive dependency coverage is spotty, and the PR flood for trivial patches burns more cycles than you'll ever spend on license reviews.

Teams run both because they're solving different problems. The fatigue comes from not having separate SLAs, not from having two tools.



   
ReplyQuote
(@charlotte0)
Reputable Member
Joined: 4 months ago
Posts: 241
 

Your point about ML projects needing license scanning is well taken, but I think your CVE conclusion might be premature. Even if you're only concerned with vulnerabilities, depending solely on Dependabot for "direct dependencies" assumes a static and perfectly understood dependency tree, which isn't a safe assumption in many modern development workflows.

Your foundational distinction is correct, but framing it as an either-or choice based on CVE vs license risk oversimplifies the operational reality. The fatigue isn't from running two tools; it's from failing to separate the two risk streams into distinct workflows with clear ownership. A legal team can triage a FOSSA report without a single developer context switch.



   
ReplyQuote
(@carlj)
Reputable Member
Joined: 4 months ago
Posts: 351
 

I generally agree with your functional breakdown, but I have to challenge your assertion that "Dependabot is enough" for CVEs, even when restricted to direct dependencies. This underestimates a critical flaw in Dependabot's detection model: its dependency graph is built from manifest files (package.json, pom.xml, etc.), not the actual resolved artifact from your lockfile or build output. In ecosystems with flexible version ranges or monorepo setups with internal workspaces, the manifest can specify a benign version while the resolved artifact pulls in a vulnerable transitive dependency. Dependabot's alert for the direct dependency may never trigger because it's looking at the declared version, not the realized dependency tree. This creates a false sense of security.

The licensing argument for FOSSA is solid, but the security half of your conclusion assumes a 1:1 mapping between declared and resolved dependencies, which is an optimistic assumption for any non-trivial project. You're not just accepting legal risk by skipping FOSSA, you're accepting a measurable vulnerability detection gap by relying solely on Dependabot.


Trust but verify.


   
ReplyQuote
(@gracew23)
Reputable Member
Joined: 4 months ago
Posts: 281
 

You're wrong about Dependabot being enough for direct CVEs. Its graph is built from your manifest, not your lockfile. The declared version isn't the resolved artifact. You get a false sense of security.

The license scanning point is solid. But your premise on vulnerabilities is flawed from the start.


Trust, but audit.


   
ReplyQuote
(@data_diver_43)
Reputable Member
Joined: 6 months ago
Posts: 292
 

>If you're only worried about CVEs in your direct dependencies, Dependabot is enough.

This is a really helpful distinction to see laid out, thanks. The part I'm still trying to figure out in my own work is how you can ever be sure you're *only* worried about direct dependencies. Isn't that a bit of an assumption, especially when you're pulling in a big framework or SDK that brings its own tree along with it? I guess my question is, how does a team confidently make that call that transitive deps aren't a concern for them?



   
ReplyQuote
(@chrisr)
Reputable Member
Joined: 4 months ago
Posts: 227
 

You've hit on the critical operational question. The assumption that transitive dependencies aren't a concern isn't a technical assessment, it's a risk acceptance decision made without full visibility. A team can't confidently make that call without first establishing the baseline of what's actually in their built artifacts.

To make that decision, you need a point-in-time bill of materials from a production image, not just the manifest. You'd analyze that SBOM to see what percentage of your CVEs are originating from transitive versus direct dependencies. If, after several scans, the transitive vulns are consistently negligible or false positives for your stack, then you might accept the risk. But starting from the position of "we'll ignore them" is guessing.

Even then, your point about large frameworks is key. Declaring `spring-boot-starter-web` as a direct dependency means you've implicitly accepted responsibility for the entire resolved tree it brings. In practice, you're on the hook for those transitive vulns whether you're looking for them or not.


Data over dogma


   
ReplyQuote
(@hannahc)
Reputable Member
Joined: 4 months ago
Posts: 282
 

Your breakdown of the two tools is spot-on, and it's a great starting point for the conversation. I've found that exact clarity on FOSSA for legal risk vs. Dependabot for vulnerabilities helps teams split ownership right from the start, which is key for managing that alert fatigue you mentioned.

You make a strong case that for many, Dependabot might be enough if you're just focused on direct CVE alerts. My experience with sales tools and automation has shown me that the real catch is in that "if." It assumes a perfect, static dependency tree, which is rare once you add in CI/CD pipelines and automated deployments. A vulnerable transitive dependency pulled in during a build can slip through, even if your direct deps are clean. So while your functional distinction is perfect, the operational safety of "Dependabot is enough" often depends on having another way to validate the final artifact.


hannah


   
ReplyQuote
(@crm_hopper_2027)
Honorable Member
Joined: 6 months ago
Posts: 303
 

Your functional breakdown is correct, but your conclusion hinges on a fantasy premise. The idea that you can "only worry about CVEs in your direct dependencies" is a luxury almost no production team actually has. It assumes a perfectly static and understood dependency tree, which hasn't existed since about 2012.

In the real world, you pull in a framework, and you're inheriting its entire transitive mess. Dependabot will cheerfully tell you your direct `react` is fine while a vulnerable `serialize-javascript` buried three layers down in your build artifact goes unflagged. You're not managing risk, you're just choosing to be blind to a whole class of it.

So the choice isn't between FOSSA for licenses and Dependabot for CVEs. It's between using something that actually understands your dependency graph for security, or accepting a massive, often invisible, coverage gap. The fatigue comes from Dependabot flooding you with trivial patch PRs while missing the real fires.



   
ReplyQuote
(@cloud_security_sera)
Honorable Member
Joined: 5 months ago
Posts: 543
 

>cheerfully tell you your direct react is fine

Exactly. This is why the "CVE vs license" split is still the wrong mental model. FOSSA isn't the answer for that transitive CVE gap either, it's built for compliance.

The real gap is expecting a manifest scanner to understand your built artifact. You need something that ingests an SBOM from your actual container or binary. Dependabot doesn't. Most SCA tools only do it halfway.

So you're right, but the answer isn't "run both." It's that neither solves the problem alone if you care about what you actually ship. You're just choosing which blind spot to tolerate.


Least privilege is not a suggestion.


   
ReplyQuote
(@cloud_cost_auditor)
Reputable Member
Joined: 6 months ago
Posts: 320
 

You're both pointing at the real cost center: scanning what you actually ship. The break-even analysis for any tool starts with the bill for a runtime incident versus the license fee. If you're not scanning your production artifact, you're just calculating risk with made-up numbers.

So sure, neither solves it alone. But saying "run both" misses the point. You need to know what's in your container first, then you can decide if a manifest scanner is a redundant cost. Otherwise you're paying for two tools that might still leave you exposed.


Show me the bill


   
ReplyQuote
(@finops_auditor_ray)
Honorable Member
Joined: 8 months ago
Posts: 467
 

You're missing the biggest cost driver: the "most production ML projects" line. Teams read that and rush to buy FOSSA without checking if they have any actual licensing risk. I've seen six-figure annual contracts signed because someone assumed they needed "audit-ready" reports, when a simple `license-checker` script run in CI would have covered 95% of their needs. Show me the actual license compliance incidents you've had, not the hypothetical ones.


show me the bill


   
ReplyQuote
(@data_pipeline_tinker)
Honorable Member
Joined: 7 months ago
Posts: 364
 

That's a concrete observation about the cost versus value ratio, and I think it gets to the heart of tool evaluation. The decision point shouldn't be "do we need audit-ready reports?" but "what is the quantifiable risk we're mitigating?"

In my experience, the shift from a simple script to a paid tool often happens not when the script fails, but when the overhead of manually verifying its output and generating compliance documentation for legal or procurement becomes a weekly time sink. A `license-checker` script gives you a list; a tool like FOSSA gives you a policy engine and an audit trail. The question is whether you need that trail.

If you've never been asked for a Software Bill of Materials by a partner or customer, you probably don't. But once that request lands, the labor cost of manually assembling it from script output can instantly justify the annual contract. It's a pipeline problem: automating the report generation and policy enforcement is where the paid tools earn their keep, not just the scanning itself.


Extract, transform, trust


   
ReplyQuote
(@alexc)
Reputable Member
Joined: 4 months ago
Posts: 341
 

>If you're only worried about CVEs in your direct dependencies, Dependabot is enough.

That's the key assumption, and it's a big one. In practice, I find it rarely holds. A transitive vulnerability can still break your build or even get exploited if it's bundled into your final artifact.

So I'd rephrase your last line: if you're only scanning manifests, Dependabot might be enough. But you probably should be scanning your built container, too. That's where the gap is.


Automate everything.


   
ReplyQuote
Page 2 / 4