Software composition analysis (SCA) is the practice of automatically identifying every open-source and third-party component inside an application and checking each one against databases of known vulnerabilities, license terms and maintenance status. In application security, SCA addresses a risk that code review of first-party source cannot reach: modern applications often consist of 70 to 90 percent borrowed code, pulled in through package managers, container images and copied libraries.
The practice is also widely called dependency scanning, although mature SCA covers more than the dependency manifest. It feeds remediation workflows, release gates and the software bill of materials (SBOM) that customers and regulators increasingly request.
How software composition analysis builds an inventory
SCA works by first producing a complete component inventory and then matching that inventory against vulnerability and license intelligence. The inventory step determines the quality of everything that follows, because a component that is never detected can never be flagged.
Tools combine several detection techniques. Manifest parsing reads files such as package.json, pom.xml or requirements.txt; lockfile analysis resolves the exact versions installed, including transitive dependencies that the developer never chose directly. Binary and container analysis inspects compiled artifacts and image layers, while file fingerprinting uses hashes or code snippets to recognize libraries that were vendored or copied without a manifest.
The following table compares the main detection techniques and what each one tends to miss.
| Technique | What it inspects | Typical blind spot |
|---|---|---|
| Manifest parsing | Declared dependencies and version ranges | Exact resolved versions, copied code |
| Lockfile resolution | Pinned direct and transitive versions | Components installed outside the package manager |
| Binary analysis | Compiled JARs, DLLs, shared objects | Heavily modified or obfuscated code |
| Container image scanning | Operating system packages and layers | Application libraries without metadata |
| Snippet fingerprinting | Hashes of files or code fragments | Small or rewritten snippets; higher cost |
After identification, each component is normalized to a standard identifier, commonly a Package URL (purl) or a CPE name, and matched against sources such as the National Vulnerability Database, the GitHub Advisory Database and OSV. Identifier mismatches between ecosystems remain a leading cause of both false positives and missed findings.
What SCA findings report
An SCA finding links a specific component version to a specific risk category, most often a CVE, a license obligation or an operational concern. Good tools report all three, because a vulnerability-free component can still create legal or maintenance exposure.
The categories below summarize the typical outputs and the decisions they drive.
| Finding type | Example signal | Usual response |
|---|---|---|
| Known vulnerability | CVE with CVSS score and fixed version | Upgrade, patch or mitigate |
| License risk | Strong copyleft such as GPL or AGPL | Legal review, replacement or compliance steps |
| Unmaintained component | No release for several years | Plan migration to an active alternative |
| Malicious package | Typosquatted or hijacked package name | Remove immediately and investigate exposure |
| Outdated version | Several major versions behind | Schedule upgrade to reduce future debt |
Severity alone is a poor guide to priority. Mature programs add exploitability context: the EPSS probability score, inclusion in the CISA Known Exploited Vulnerabilities catalog and, above all, reachability analysis, which checks whether the application actually calls the vulnerable function. Reachability can cut the actionable backlog substantially, although results depend on language support and the accuracy of call-graph construction.
SCA compared with SAST, DAST and SBOM
SCA differs from other testing methods because it examines code the team did not write. Static application security testing (SAST) analyzes first-party source for flaws such as SQL injection or XSS, while dynamic testing (DAST) probes the running application from outside.
The comparison below clarifies where each practice fits.
| Practice | Primary target | Typical output |
|---|---|---|
| SCA | Third-party and open-source components | Vulnerable or risky dependencies |
| SAST | First-party source code | Coding flaws with file and line |
| DAST | Running application | Exploitable behavior at runtime |
| SBOM | Component inventory as a document | CycloneDX or SPDX file |
| Secrets scanning | Repositories and build artifacts | Exposed keys and credentials |
An SBOM is best understood as a standardized output of the inventory step rather than a competing tool. SCA produces and consumes SBOMs in CycloneDX or SPDX format, and continuous SCA keeps the SBOM meaningful by re-evaluating it as new advisories appear.
Integrating SCA into the development lifecycle
SCA delivers the most value when it runs at several points in the lifecycle, not as a single pre-release audit. Each placement catches a different class of problem at a different cost.
- In the IDE and pull request, so developers see a risky dependency before it is merged.
- In the CI pipeline, with a policy gate that blocks builds containing critical, reachable vulnerabilities or forbidden licenses.
- In artifact registries and container registries, to stop unapproved packages from entering the organization.
- In production monitoring, because a component that was clean at release can receive a new CVE months later.
Policy design matters more than tool choice. A gate that fails every build on any medium finding quickly produces alert fatigue and bypassed controls. Effective policies combine severity, reachability, fix availability and exposure of the affected service, and they allow documented, time-limited exceptions when no fix exists.
Automated pull requests that propose version upgrades reduce remediation effort, but they still require regression testing, because a minor version bump can introduce breaking behavior.
Limitations and common mistakes
SCA is only as reliable as its inventory and its vulnerability data, and both have systematic gaps. Teams that treat a clean report as proof of safety misread what the tool measures.
The table lists frequent problems, their causes and practical fixes.
| Symptom | Likely cause | Remedy |
|---|---|---|
| Thousands of open findings | No prioritization by reachability or exposure | Add reachability and EPSS-based triage |
| Vulnerable library not reported | Vendored or copied code without manifest | Enable fingerprinting or binary scanning |
| Different results between tools | Divergent advisory sources and identifiers | Standardize on purl and compare sources |
| Findings reappear after fixes | Transitive dependency pulls old version | Use overrides or resolutions in the lockfile |
| Zero-day not detected | Advisory not yet published | Combine SCA with runtime monitoring |
SCA also cannot judge intent or behavior: a newly published malicious package without an advisory may pass unnoticed. Supply-chain defenses such as package provenance verification, signed artifacts and curated internal mirrors complement SCA rather than replace it.
Explained without jargon
Most software is assembled from ready-made parts written by other people. A house is built the same way, from bricks, pipes and wiring bought from suppliers. Software composition analysis lists every one of those parts. It then checks whether any part has been recalled for a safety defect. It also checks whether a part comes with rules on how it may be used.
Without this check, a team may not know which parts its product contains. With it, the team gets a clear list. It learns which parts are dangerous and which ones to replace first.
A typical use case
A mid-sized online retailer runs a Java checkout service with 40 direct dependencies that resolve to roughly 310 components in total. When a critical remote code execution flaw is announced in a widely used logging library, the security team queries its SCA platform and finds the vulnerable version in seven services, five of them through transitive dependencies that no developer had chosen consciously.
Reachability analysis shows that only three services actually invoke the vulnerable code path, so those are patched within 24 hours while the remaining four are upgraded in the next scheduled release. The CI policy is then updated to block any build containing the affected versions, and the refreshed SBOM is shared with two enterprise customers who had requested evidence of remediation.