# Software Composition Analysis (SCA): What SCA Tools Find and How to Triage the Results

Source: https://truvocyber.com/blog/software-composition-analysis
Published: 2026-11-21
Topic cluster: Cybersecurity

> Software composition analysis (SCA) explained: what SCA tools find in open-source dependencies, how SCA differs from SAST and DAST, triage steps and SBOMs.

Software composition analysis (SCA) is an automated scan of the open-source and third-party packages an application depends on, including transitive dependencies, that matches each package and version against vulnerability and license data. SCA tools report known vulnerabilities, license conflicts and unmaintained packages, so the team can update, replace or formally accept each package.

At a glance

- **What SCA scans**: Dependency manifests, lockfiles and container images: the code a team imports
- **What SCA finds**: Known vulnerabilities (CVEs and advisories), license issues, unmaintained or outdated packages
- **Where SCA runs**: Pull request checks, CI build gates, scheduled repository scans, SBOM generation at release
- **Triage questions**: Production or dev-only, fix available, vulnerable code reachable, exposed or exploited
- **Fix tools**: Dependabot and Renovate open pull requests that bump dependency versions
- **SBOM formats**: SPDX (ISO/IEC 5962:2021) and CycloneDX (ECMA-424)
- **Framework fit**: SOC 2 CC7.1 and CC8.1, ISO/IEC 27001:2022 A.8.8, A.8.25 and A.8.28

## What does software composition analysis find?

Software composition analysis finds risk in third-party code. Every package version carries the vulnerabilities and license terms of that release. SCA tools look for four kinds of issue:

- **Known vulnerabilities:** a package version with a published CVE or security advisory, matched against vulnerability databases such as [OSV](https://osv.dev). The [OWASP Top 10 (2021)](https://top10.owasp.org/A06_2021-Vulnerable_and_Outdated_Components) lists this risk as A06:2021 Vulnerable and Outdated Components.
- **License issues:** a dependency under a license the company cannot accept for the product, for example a strong copyleft license in software the company distributes, or a package with no declared license.
- **Unmaintained packages:** a dependency with no recent releases or a deprecation notice, which means no one will publish a fix for the next vulnerability.
- **Outdated versions:** a dependency several major versions behind. The gap makes the next security upgrade larger and riskier.

An SCA tool reads the manifests and lockfiles in the repository, for example `package-lock.json`, `poetry.lock`, `pom.xml` or `go.mod`, builds the full dependency tree, and reports each finding with the affected package, the vulnerable version range and the first fixed version, where one exists. Container image scanners such as Trivy and Grype apply the same method to an image and add the base image's operating system packages.

## Why do transitive dependencies show up in SCA results?

Transitive dependencies show up in SCA results because every package a team installs brings further dependencies, and SCA tools scan the whole tree. A vulnerable package can be one no engineer ever chose.

At one SaaS company of under 20 people preparing for SOC 2, a developer saw warning icons on several dependencies that were no longer maintained. The dependency tree explained the warnings:

- A single core dependency pulled in seven transitive dependencies.
- Two of those seven pulled in three more.
- The warning icons were often on packages the team had never directly chosen.

Upgrading the top-level dependency cascaded updates to the transitive dependencies, so the fix was simpler than the warning list suggested. The usual first step for a transitive finding is to upgrade the direct dependency that pulls the vulnerable package in.

When the direct dependency has no fixed release yet, a version override such as `overrides` in npm or `resolutions` in Yarn forces the transitive version, provided the test suite passes.

Key insight

**Commit the lockfile so SCA scans the versions that go to production.**

A manifest with version ranges can resolve to different transitive versions on each install. The lockfile pins the exact tree, so the SCA result matches what the build deploys.

## How is software composition analysis different from SAST and DAST?

Software composition analysis checks the third-party code an application imports. SAST checks the code the team writes, and DAST tests the running application from outside. Each scan type finds a different class of problem.
Scan typeWhat the scan type checksWhat the scan type findsWhen the scan type runsExample toolsSoftware composition analysis (SCA)Dependency manifests, lockfiles, container imagesKnown vulnerabilities and license issues in open-source packagesPull request, CI, scheduled scans, releaseOSV-Scanner, OWASP Dependency-Check, Dependabot alerts, Trivy, GrypeStatic application security testing (SAST)First-party source code, without running the codeCode flaws such as injection, unsafe deserialization, hard-coded secretsPull request, CICodeQL, SemgrepDynamic application security testing (DAST)The running application, through HTTP requestsRuntime issues such as misconfiguration, authentication and session flawsAgainst staging after deployOWASP ZAPContainer image scanningBuilt images: OS packages and application packagesKnown vulnerabilities in the base image and installed packagesAfter the image build, and on the registryTrivy, Grype

SAST tools need rules for the language and framework version: one small SaaS team on an older framework version found that every commercial SAST tool they evaluated supported only newer versions. SCA support depends on the package manager and lockfile format instead. For wiring all four scan types into one GitHub Actions pipeline, see the [guide to automating CI/CD security for SOC 2](/blog/automate-cicd-security-soc2-cto-guide).

## Where should software composition analysis run in the development workflow?

Software composition analysis should run at several points, because new dependencies arrive with code changes and new vulnerabilities arrive with disclosures. My approach places SCA at four points:

1. **Pull request check.** The scan compares the dependency changes in the pull request against the main branch and shows new findings on the pull request, before merge.
2. **CI build gate.** The build fails on findings above an agreed threshold, for example a Critical or High vulnerability with a fixed version available. A gate with a fix-available condition blocks avoidable risk without blocking every merge on a vulnerability no one can fix yet.
3. **Scheduled repository scan.** A daily or weekly scan of the default branch, and of every deployed release branch, catches vulnerabilities disclosed after the code merged.
4. **SBOM generation at release.** The build produces a software bill of materials for each release and stores the SBOM with the release artifacts.

Key insight

**Scheduled SCA scans catch vulnerabilities in code that has not changed.**

A pull request scan checks the dependencies at merge time only. A package that was clean at merge can have a CVE published next month, and a repository with no new commits gets no new pull request scan.

## Which SCA tools fit a small engineering team?

SCA tooling is an architecture decision that depends on team size, technical capability and budget. One SaaS company of under 20 people compared three ways to add SCA, SAST, DAST and secret detection to the pipeline:

- **Individual open-source tools stitched together:** examples include OSV-Scanner, OWASP Dependency-Check, npm audit and pip-audit for SCA. The lowest cost per tool, with the heaviest integration and maintenance work.
- **Source control platform features:** examples include Dependabot alerts on GitHub and dependency scanning on GitLab. Moderate integration effort, with gaps in coverage for some scan types.
- **An all-in-one security platform:** a commercial platform such as Snyk that covers SCA alongside other scan types in one interface. Higher cost, less maintenance, and easier for non-developers to read.

With limited developer capacity, the team chose the all-in-one platform for two reasons:

- The platform attached scan results to pull requests in a standard format, which created audit evidence on every change.
- The scan output had to feed the company's GRC platform for compliance evidence, which narrowed the viable options.

For a self-hosted source control example, the [SOC 2 secure development guide for self-hosted GitLab](/blog/soc2-sdlc-self-hosted-gitlab) covers dependency scanning inside the merge request workflow.

## How should a team triage software composition analysis findings?

A team triages software composition analysis findings by asking a short set of questions in order, then recording one outcome for each finding. My approach uses five questions:

1. **Is the package in production or dev-only?** A vulnerability in a test framework carries less risk than one in a runtime library. Build tools still count, because build tools execute in CI with access to secrets and deploy credentials.
2. **Is a fixed version available?** A finding with a fix is usually a version bump and a test run. A finding with no fix needs a compensating control or a replacement package.
3. **Is the vulnerable code reachable?** Reachability analysis checks whether the application calls the vulnerable function. Some SCA tools do the check automatically. Without tool support, an engineer reads the advisory and searches the code for the affected function.
4. **Is the component exposed or exploited?** A vulnerable package in an internet-facing service, or a CVE in the [CISA Known Exploited Vulnerabilities catalog](https://www.cisa.gov/known-exploited-vulnerabilities-catalog), goes to the top of the queue. The [risk-based vulnerability management guide](/blog/risk-based-vulnerability-management) covers ranking by KEV, EPSS, exposure and reachability.
5. **Is the package direct or transitive?** A transitive finding is fixed by upgrading the direct parent, or by a version override when the parent has no fixed release.

Each SCA finding ends with one of three outcomes:
SCA finding outcomeWhen the team uses the outcomeWhat the team recordsUpdateA fixed version exists and tests passThe merged pull request that bumps the versionReplaceThe package is unmaintained or the license is unacceptableThe change that removes the package and adds the replacementAcceptNo fix exists, the code is unreachable, or the update waits for a planned cycleA risk acceptance with the reason, compensating controls, owner and review date

For the approval workflow and what auditors sample, see the [SOC 2 vulnerability risk acceptance guide](/blog/soc-2-vulnerability-risk-acceptance).

## How do Dependabot and Renovate keep dependencies current?

Dependabot and Renovate are dependency update bots: each tool watches the dependency files in a repository and opens pull requests that bump package versions, so the next security upgrade stays small.

- **[Dependabot](https://docs.github.com/en/code-security/dependabot/dependabot-security-updates/about-dependabot-security-updates)** is built into GitHub. Dependabot alerts flag vulnerable dependencies. Dependabot security updates open a pull request that bumps a vulnerable dependency to the minimum patched version. Dependabot version updates open pull requests to keep dependencies current even when no vulnerability exists, configured in `.github/dependabot.yml`.
- **[Renovate](https://docs.renovatebot.com/)** is an open-source update bot that works with GitHub, GitLab, Bitbucket, Azure DevOps, Gitea, Forgejo and other platforms. Teams configure grouping, schedules and automerge rules in a Renovate configuration file in the repository.

My approach to update bots keeps the pull request volume manageable:

- Group minor and patch updates into one weekly pull request per ecosystem.
- Automerge patch updates only when the test suite passes and branch protection checks are green.
- Review major version updates manually, with the changelog open.
- Treat security update pull requests as remediation work with a due date, tracked like any other vulnerability.

Watch out

**Do not let update bot pull requests pile up unmerged.**

An open Dependabot pull request is a dated record that the team knew about a fix and left the fix unapplied. An auditor sampling the repository can count the age of every stale update pull request.

## What is an SBOM and how does software composition analysis produce one?

A software bill of materials (SBOM) is a machine-readable inventory of every component and version in a software release. SCA tools build the dependency tree for each scan, so the same tools can export the tree as an SBOM at build time. Syft and Trivy are examples of tools that generate SBOMs.

Two SBOM formats are widely used:

- **[SPDX](https://spdx.dev/about/overview/)**, a Linux Foundation project recognized as the international standard ISO/IEC 5962:2021.
- **[CycloneDX](https://cyclonedx.org/specification/overview/)**, an OWASP standard, also published by Ecma International as ECMA-424.

An SBOM stored with each release turns a new disclosure into a search: the team checks the stored SBOMs to find which releases contain the affected version, without rebuilding old versions. The same SBOM can answer a customer security review that asks which open-source components the product includes. For the vendor side of supply chain risk, see [supply chain cyber risk for SMBs and enterprises](/blog/supply-chain-cyber-risk-smbs-enterprises).

## What does proof of dependency management look like?

Proof of dependency management is a documented record that the team monitors dependencies, assesses and acts on each finding. The record of decisions is the evidence, with or without warnings left in the report.

The SaaS company with the warning icons assumed the warnings meant automatic audit failure. Documented risk acceptance is a valid path, and the audit risk comes from warnings with no evidence that anyone noticed them. The team needed to show three things for each unmaintained dependency:

- The team knew about the dependency.
- The team assessed whether the dependency introduced a vulnerability.
- The team updated the dependency, or formally accepted the risk with compensating controls.

Periodic dependency reviews with a documented outcome for each package (updated, accepted, or planned for the next cycle) satisfied the control. Examples of dependency management evidence:

- SCA configuration in the pipeline, and the pull request check history showing scans on every change
- Dated results from the scheduled repository scan
- A review record for each cycle: package, finding, outcome, owner
- Risk acceptances for unmaintained or unfixable packages, each with a review date
- Merged update pull requests from Dependabot or Renovate
- An SBOM for each release, where the build generates one

Key insight

**Review dependencies on a fixed cadence and record the outcome for every finding.**

Quarterly is a workable starting cadence for a small team, with critical findings handled as they arrive. A dated review record turns a list of warnings into evidence of a working risk management process.

## Which SOC 2 and ISO 27001 controls does SCA evidence support?

Software composition analysis produces evidence for vulnerability management and secure development controls as a byproduct of the scans, reviews and pull requests above.
FrameworkControlSCA evidence the auditor can sampleSOC 2 ([AICPA Trust Services Criteria](https://www.aicpa.org/resources/download/trust-services-criteria))[CC7.1](/blog/soc-2-cc7-1-vulnerability-management), detection of new vulnerabilitiesScheduled scan history, triage records, risk acceptancesSOC 2CC8.1, change managementPull request checks with SCA results, merged update pull requestsISO/IEC 27001:2022 ([ISO](https://www.iso.org/standard/27001))A.8.8, management of technical vulnerabilitiesScan results, remediation and acceptance recordsISO/IEC 27001:2022[A.8.25, secure development life cycle](/blog/iso-27001-a-8-25-secure-development-lifecycle)SCA gate in CI and the rule that a failing gate blocks a releaseISO/IEC 27001:2022[A.8.28, secure coding](/blog/iso-27001-a-8-28-secure-coding)Dependency inventory, SCA reports, update records

## Where does software composition analysis fit in an effective security program?

Software composition analysis is one part of the secure development capability, next to SAST, code review, secrets management and the change process. Any of the tool options above works when the team keeps the operating loop around the tool: scans on every change and on a schedule, triage with recorded outcomes, and updates merged on time. Truvo Cyber designs that loop as part of [security architecture](/services/security-architecture) work, and a [security capability assessment](/services/security-capability-assessment) scores where secure development stands today across the roughly 19 capabilities of an effective security program.

### Build SCA into secure development

Truvo designs the scans, triage and evidence behind an effective security program, then hands the loop to the team.[Book Your Strategy Call](/contact-us)

## Frequently asked questions

### What is the difference between SCA and SAST?

Software composition analysis (SCA) scans the open-source and third-party packages an application imports and matches each version against known vulnerability and license data. Static application security testing (SAST) scans the source code the team writes for flaws such as injection. SCA finds vulnerabilities someone else published. SAST finds vulnerabilities in first-party code.

### Is Dependabot an SCA tool?

Dependabot covers part of software composition analysis on GitHub. Dependabot alerts flag dependencies with known vulnerabilities, and Dependabot security updates open pull requests that bump each vulnerable package to the minimum patched version. Teams that need license checks, reachability analysis or SBOM export often add a dedicated SCA tool alongside Dependabot.

### What is an SBOM in software composition analysis?

A software bill of materials (SBOM) is a machine-readable list of every component and version in a release. SCA tools build the dependency tree during each scan and can export the tree as an SBOM in SPDX or CycloneDX format. Stored SBOMs let a team find which releases contain a newly disclosed vulnerable package.

### Does SOC 2 require software composition analysis?

SOC 2 names no specific tool. Under CC7.1, the organization uses detection and monitoring procedures to identify new vulnerabilities, and dependency vulnerabilities fall within that scope for software companies. SCA is a common way to meet CC7.1 for application dependencies, with scan history, triage records and risk acceptances as the evidence auditors sample.

### How often should SCA scans run?

SCA scans should run on every pull request, in the CI build, and on a schedule against the default branch and deployed releases. Daily or weekly scheduled scans catch vulnerabilities disclosed after the code merged. A periodic dependency review, for example quarterly, records an outcome for every open finding.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the difference between SCA and SAST?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Software composition analysis (SCA) scans the open-source and third-party packages an application imports and matches each version against known vulnerability and license data. Static application security testing (SAST) scans the source code the team writes for flaws such as injection. SCA finds vulnerabilities someone else published. SAST finds vulnerabilities in first-party code."
      }
    },
    {
      "@type": "Question",
      "name": "Is Dependabot an SCA tool?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Dependabot covers part of software composition analysis on GitHub. Dependabot alerts flag dependencies with known vulnerabilities, and Dependabot security updates open pull requests that bump each vulnerable package to the minimum patched version. Teams that need license checks, reachability analysis or SBOM export often add a dedicated SCA tool alongside Dependabot."
      }
    },
    {
      "@type": "Question",
      "name": "What is an SBOM in software composition analysis?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A software bill of materials (SBOM) is a machine-readable list of every component and version in a release. SCA tools build the dependency tree during each scan and can export the tree as an SBOM in SPDX or CycloneDX format. Stored SBOMs let a team find which releases contain a newly disclosed vulnerable package."
      }
    },
    {
      "@type": "Question",
      "name": "Does SOC 2 require software composition analysis?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "SOC 2 names no specific tool. Under CC7.1, the organization uses detection and monitoring procedures to identify new vulnerabilities, and dependency vulnerabilities fall within that scope for software companies. SCA is a common way to meet CC7.1 for application dependencies, with scan history, triage records and risk acceptances as the evidence auditors sample."
      }
    },
    {
      "@type": "Question",
      "name": "How often should SCA scans run?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "SCA scans should run on every pull request, in the CI build, and on a schedule against the default branch and deployed releases. Daily or weekly scheduled scans catch vulnerabilities disclosed after the code merged. A periodic dependency review, for example quarterly, records an outcome for every open finding."
      }
    }
  ]
}
