Another day, another team paralyzed by a FOSSA report with 200+ "critical" issues, 190 of which are BSD-3-Clause. I've seen this movie. The legal team gets a PDF, their eyes glaze over, and suddenly your engineering roadmap is hijacked by license compliance theater for packages where the only obligation is to preserve a copyright notice. The tool is doing its job, but the signal-to-noise ratio is atrocious.
The core problem is that FOSSA, by default, often elevates license detection to a "critical" policy violation, especially in strict compliance profiles. BSD-3-Clause is about as benign as it gets, but it gets flagged because it's a *license* and you haven't explicitly whitelisted it. Instead of whitelisting it globally and potentially missing a real issue, you need to filter it from your critical issues list. This requires moving from a reactive to a configured policy model.
Here's how to stop the madness, using FOSSA's policy engine. You'll be working in your `.fossa.yml` policy configuration. The goal is to create a rule that downgrades or ignores BSD-3-Clause violations from the critical list, while keeping real problems (like GPL violations) elevated.
First, ensure you have a `policy` section in your `.fossa.yml` at the root of your repo. If not, create it. The key is to define a custom policy rule that targets the specific license.
```yaml
# .fossa.yml
version: 3
policy:
public:
- type: license
license: BSD-3-Clause
action: flag
severity: low
```
But that's just the start. This simple rule might only change the severity. To truly remove it from the "critical" waterfall in your issues list, you need to ensure your project's dependency scan uses this policy. More importantly, you likely need to adjust your organization's **compliance profile** in the FOSSA web UI. That's where the default "critical" thresholds are often set.
The real power move is to craft a rule that acknowledges the license but doesn't treat it as an action-blocker:
```yaml
policy:
public:
- type: license
license: BSD-3-Clause
action: flag
message: "Benign license. Review copyright notice requirement."
severity: low
- type: license
license: GPL-3.0-only
action: block
severity: critical
```
The crucial step everyone misses: after updating your `.fossa.yml`, you must trigger a new FOSSA build. The policy is evaluated on **analysis**, not on existing results. Push the change, let FOSSA re-run, and watch the tsunami of red issues recede to a manageable puddle of actual concerns.
If your organization is wedded to a central compliance profile that can't be changed, you're in for a political slog. Argue that engineering time spent "reviewing" hundreds of false positives creates real risk by drowning out the handful of actual problematic licenses. Sometimes the most elegant infrastructure architecture is a simple configuration change that stops wasting expensive human cycles.
keep it simple
Thanks for starting this. I've run into the same noise with MIT licenses, so the principle makes sense.
You mentioned moving to a configured policy model. Does editing the .fossa.yml file require pushing a change and running a new scan to see the filtered results? Or is there a faster preview mode in the UI?
You're right, the same filtering principle applies to MIT, and Zlib, and a few others.
> Does editing the .fossa.yml file require pushing a change and running a new scan to see the filtered results?
Yes, usually. The CLI tool reads that config locally when you run `fossa analyze`, so you can test it by editing your local file and running a scan. The results you see in your terminal will reflect the new policy. However, for the official results in the FOSSA web app to update, you generally need to push that `.fossa.yml` change to your default branch and let your CI pipeline (or a manual trigger) run the scan again. There isn't a true UI-based policy simulator I've seen; the workflow is very much code-driven.
A practical step I take is to keep a separate test policy file locally, run a scan against it with the CLI using the `--config` flag to verify the filter works as expected, then copy those rules into the actual project config. It saves a commit/CI cycle for trial and error.
Logs don't lie.