Lost in Translation: Cross-Tool Deduplication in DefectDojo

For anyone who is at all preoccupied with how they express themselves, learning a second language is an interesting challenge.
For me, learning French has been particularly difficult, especially coming from English. So many components of French simply do not exist in English. I’m confounded by gendered nouns that alter articles and adjectives, specific verb conjugations for each subject, and even the basic ordering of words, to say nothing of French’s distinct pronunciation. (That infernal “r” sound means I can’t sing Édith Piaf’s “Non, je ne regrette rien” without sounding like I’m eating oatmeal.)
The challenge is not made any easier by the frustration of knowing exactly how I would express myself organically in my mother tongue. The words I know are right there, but I have to use different ones.
Even so, if anything good has come of this frustration, it has been a heightened appreciation for the art of translation.
Between any two languages, there is more than one way to say the same thing, and there is rarely one single “most correct” way to translate one phrase into another. One translator may choose a direct phrase, while another may take a more nuanced approach to express the same idea. The words will differ, but the underlying meaning stays consistent.
Security tools have a similar problem. A dependency scanner, a container scanner, and an SBOM-based scanner may each encounter the same vulnerable library and report it in completely different language.
Each scanner is rightly flagging an issue, but the question is whether your security platform can recognize that they are describing one problem instead of three.
So Is There One Problem, or Three?
Organizations often rely on multiple security tools to examine their environments. So imagine that three scanners report the same vulnerability in OpenSSL 1.1.1.
Each tool has its own way of identifying, describing, and reporting vulnerabilities. The first calls it “Critical: Outdated OpenSSL.” The second says “CVE-2026-84783 detected in base image,” while the third flags “Vulnerable dependency: OpenSSL 1.1.1.” This single issue could generate three separate tickets that your team now has to investigate, prioritize, track, and eventually close.
This is more than an inconvenience. Duplicate Findings consume triage time, fragment ownership, obscure the true size of the problem, and make remediation progress harder to measure. The goal of deduplication across tools is to make the relationship between equivalent Findings apparent before they make your backlog seem longer than it already is.
Of course, not every Finding involving the same vulnerability is automatically a duplicate. Two results about OpenSSL may look identical in a list, but if one lives in your payments service and the other in an internal tool, they’re different problems with different owners. (Services or Asset Hierarchy divisions can be set up to make this distinction clear.)
But the challenge of recognizing when different reports refer to the same vulnerability still remains. Your platform needs a way to recognize what the scanners are all talking about, even if they don’t speak the same language.
When the Same Problem Speaks Different Languages
Instead of three unrelated tickets, you want one original Finding that represents the issue, with the other Findings linked as duplicates. The team can see that multiple tools found the issue, assign one owner, and remediate it once, even if each tool expressed the issue differently.
In this context, DefectDojo’s cross-tool deduplication can do the translating.
Building a Shared Vocabulary
Before DefectDojo can determine whether two Findings are duplicates, it needs to be able to compare them.
When a report arrives, DefectDojo’s parsers map each result into a common Finding format: title, severity, Common Weakness Enumeration (CWE), vulnerability identifiers such as CVE or GitHub Security Advisory (GHSA), component name and version, file path and line, and endpoints.
Different scanners may use different terminology, formats, and identifiers, but DefectDojo organizes their Findings into a lingua franca by mapping them to fields every Finding has in common. This makes it possible to compare information across tools rather than treating every scanner’s output as an entirely separate language.
The original wording might be different, but now there’s a shared basis for comparison.
Spotting the Cognates
For cross-tool matching, DefectDojo’s hash-based deduplication algorithms compare fields across tools and generate a hash code for each Finding. You decide which fields go into that hash, such as vulnerability ID, CWE, component name and version, file path and line, or endpoint, and both tools need to be set up to hash the same fields. DefectDojo does the translating, but you supply the glossary.
When two Findings produce a matching hash, DefectDojo recognizes them as duplicates and marks them accordingly, leaving you with the one that actually needs attention.
Matching is exact, so tuning matters. If two software composition analysis (SCA) tools hash the same fields but one adds a GHSA ID to the vulnerability ID, the hashes differ and the duplicate slips through. That’s why you choose fields whose values stay consistent across tools.
Importantly, you can specify the scope to which this deduplication applies. By default, a new Finding is compared with other Findings in the same Asset, preventing unrelated projects from collapsing into one another. However, you can narrow the deduplication scope further with Engagement isolation enabled, or broaden it with Dedupe Pools (Pro only), to facilitate deduplication between Assets.
One Original, Many Translations
When a cross-tool match occurs, the oldest matching Finding remains the original and stays active for triage and remediation. The other duplicate Findings are marked as Inactive, Duplicate. Matching Findings in subsequent scans are also linked to the original and tagged similarly. The original Finding’s Found by field records every tool that reported the issue.
This approach allows teams to consolidate their view of an issue without losing the context of how it was discovered. Now there’s just one issue, one owner, and one path to remediation, and you still have a record of every tool that identified that Finding.
Found in Translation
Translation is difficult because language is imperfect. The same idea can be expressed in many ways, and no single phrasing perfectly captures every nuance.
Security tooling has the same challenge. Different scanners see different parts of your environment and describe what they find in different terms. But that diversity is only useful if your platform can recognize when those reports converge on the same issue.
Cross-tool deduplication gives security teams that recognition. By normalizing Findings and comparing stable attributes, DefectDojo can turn a chorus of overlapping reports into one actionable Finding.
Using more than one security tool? DefectDojo is fluent in 500+ of them. See how your parsers can start speaking the same language.