Skip to main content
Security guideReviewed

SBOM: what a software bill of materials lists, how to produce one at each release, and where it stops

A software bill of materials (SBOM) is a machine-readable inventory of the components a piece of software is built from.

This guide explains what one holds under the 2021 NTIA minimum elements and the 2026 joint guidance that replaced them, how CycloneDX and SPDX differ, how a small team produces one for a web application at every release, how a component is identified so an advisory can be matched to it, and what a VEX statement adds. It comes with a worked component record and triage table across two releases, and a lab that generates real SBOMs offline.

SBOM component record, VEX triage table and offline SBOM lab

A component record with one line for each fact an advisory needs: product and release, SBOM document, component identity, dependency path, build provenance, advisory match, VEX status and the question that still needs application analysis, with the source behind each line. A worked record for an invented application follows one component across two releases, from affected to fixed, and prints the triage table.

How to use it

The offline Node.js lab that produced it generates real CycloneDX and SPDX documents with npm sbom, and its files and outputs were copied in from a real run.

sbom.txt

Introduction3 lines

SBOM COMPONENT RECORD, VEX TRIAGE TABLE AND OFFLINE SBOM LAB ILLUSTRATION AND TEMPLATE. Part A is a blank component record to copy into a ticket or spreadsheet. Part B fills it in for an invented application, sbomlab-invented-bookings, across two releases, against an invented advisory, INVENTED-SBOMLAB-0001. Part C is the offline lab that produced every value Part B copies. Every package name sits under the invented scope @sbomlab-invented, the organisation and the host vex.sbomlab-invented.example are invented, and the advisory describes no real flaw. Nothing here is a real package, vulnerability, VEX document, organisation or client. The SBOMs are real output of npm sbom, run against the invented project with npm's offline setting on.

What an SBOM is

A software bill of materials (SBOM) is an inventory of what a piece of software is made of.

The 2021 report from the United States Department of Commerce and NTIA, The Minimum Elements For a Software Bill of Materials (SBOM), defines it as a formal record containing the details and supply chain relationships of various components used in building software.

The 2026 joint guidance that replaced that report, written by CISA with 17 partner organisations, describes an SBOM as a nested inventory, a list of ingredients that make up software applications and systems.

For a web application, the components are the packages the build installs: the framework, the libraries your developers chose, and the libraries those brought with them. Your lockfile already holds a version of that list. An SBOM puts it into a format that someone outside the team, or a tool that has never seen your repository, can read: an entry for each component with a name, a version and an identifier, and a record of which component depends on which.

NTIA's report says an SBOM provides those who produce, purchase and operate software with information that enhances their understanding of the supply chain, most notably the potential to track known and newly emerged vulnerabilities and risks. It adds that SBOM will not solve all software security problems. Both halves matter, and this guide spends as long on the second as on the first.

This page covers the inventory itself. How a compromised package or build step reaches a site belongs to the supply chain attacks guide, and finding and updating vulnerable packages belongs to the dependency security guide. The CI/CD security guide covers the pipeline that should produce the SBOM, the SAST guide covers analysing your own source code for flaws, and the planned Node.js security guide covers the runtime.

Who asks for an SBOM

A request for an SBOM can come from a customer's procurement or security team, from a standard that customer works to, or from your own engineers after an incident.

CISA's Secure by Demand guide, written for organisations that buy software, asks whether the manufacturer generates an SBOM in a standard, machine-readable format and makes it available to customers, and whether the SBOM enumerates all third-party dependencies, including open source software components. The vendor security questionnaire template on this site carries a version of that question.

Two OWASP documents ask for the inventory. ASVS 5.0 requirement 15.1.2, at Level 2, is that an inventory catalogue, such as a software bill of materials, is maintained of all third-party libraries in use, including verifying that components come from pre-defined, trusted and continually maintained repositories. OWASP Top 10:2025 lists centrally generating and managing an SBOM among its prevention measures for A03 Software Supply Chain Failures.

One government instrument explains where the minimum elements in the next section came from. Executive Order 14028 of 12 May 2021, as published in the United States Federal Register, says in section 4(e) that the Secretary of Commerce, acting through the Director of NIST, shall issue guidance identifying practices that enhance the security of the software supply chain, and that the guidance shall include standards, procedures or criteria regarding providing a purchaser a Software Bill of Materials (SBOM) for each product directly or by publishing it on a public website.

Section 4(f) says the Secretary of Commerce, in coordination with the Assistant Secretary for Communications and Information and the Administrator of NTIA, shall publish minimum elements for an SBOM within 60 days.

Section 4(k) says the Director of OMB shall take appropriate steps to require that agencies comply with the section 4(e) guidance with respect to software procured after the date of the order.

Those clauses are addressed to United States federal officials. This page quotes the 2021 text as published and says nothing about what is in force today.

The 2026 joint guidance frames the request in general terms. Its key actions are that organisations should request SBOMs that satisfy the updated minimum elements, should use available tools to generate, ingest and analyse SBOM data, and should generate SBOMs that satisfy them.

It also says the minimum elements do not create new requirements, and that the publication does not constitute advice for compliance, regulatory or legal purposes. This page does not say whether any of these documents applies to your business.

What an SBOM lists: the minimum elements

Two documents define the baseline, and the second replaces the first.

NTIA's report of 12 July 2021 set out minimum elements in three areas: Data Fields, Automation Support, and Practices and Processes. Its seven data fields are Supplier Name, Component Name, Version of the Component, Other Unique Identifiers, Dependency Relationship, Author of SBOM Data and Timestamp. Under Automation Support it named SPDX, CycloneDX and SWID tags as the data formats being used to generate and consume SBOMs.

Its practices and processes are Frequency, Depth, Known Unknowns, Distribution and Delivery, Access Control, and Accommodation of Mistakes. Its scope section says the minimum elements should not be interpreted to create new federal requirements.

The replacement is 2026 Minimum Elements for a Software Bill of Materials (SBOM), published on 29 July 2026, which says it updates and replaces the NTIA publication. Its version history lists three versions: 1.0, the initial version of 12 July 2021; 2.0, a draft document published on 22 August 2025; and 2.1, of 29 July 2026, updated in collaboration with co-authoring organisations and based on comments received in response to a request for comment on a draft.

The authors are CISA and 17 partners, among them the United States NSA and FBI and the Australian Signals Directorate's Australian Cyber Security Centre.

The 2026 document sets baseline expectations in two groups: Data Fields, the data that makes up the SBOM document, and Practices and Processes, how an entity engages with and documents the SBOM data. The data fields come in two sets.

  • SBOM Metadata, nine fields about the SBOM document itself: SBOM Author, SBOM Author Signature, SBOM Data Format Name, SBOM Data Format Version, SBOM Generation Context, SBOM Timestamp, SBOM Tool Name, SBOM Tool Version and SBOM Version.
  • Component Data, eight fields about the target component, meaning the software the SBOM is generated for, and every subcomponent it lists: Component Producer, Component Dependency Relationship, Component Hash Value, Component Hash Algorithm, Component Identifiers, Component License, Component Name and Component Version.
  • Practices and Processes, six elements: Accommodation of Updates to SBOM Data, Coverage, Distribution and Delivery, Explicitly Identifying Unknown Information, Frequency and Machine-Processable Data.

What changed from 2021

Four of the changes bear on a small team, in this page's judgement. Component Producer replaces Supplier Name, which the document says has proven ambiguous in practice, particularly around distributors of software. Coverage replaces Depth: an SBOM should include information for all components that make up the target software, including transitive dependencies, with no minimum depth, where the 2021 minimum was the top-level dependencies with enough detail to seek out the transitive dependencies recursively.

SWID tags are no longer on the list of data formats.

And where information for a data field is not provided, the author is asked to state explicitly whether it is unknown to them or is being withheld.

What an SBOM leaves out

An SBOM is an inventory, and both documents are plain about that.

The 2026 guidance says an SBOM alone is data about software components, and that analysis of SBOMs transforms data into insights about associated risks. NTIA's report says SBOM data is primarily static, reflecting the properties of the specific built software at a point in time, while vulnerability data is dynamic and evolves over time, and it recommends that vulnerability data be tracked in separate data structures from the SBOM.

Read against a web application, that leaves several things outside the document. These are this page's own observations, not a list from either source:

  • Flaws in the code your team wrote. An SBOM names components. It does not examine how your own code uses them.
  • Whether a listed component's vulnerable function is called, and whether input from outside can reach it.
  • Configuration: which features are switched on, what the server sends, and who may call which route.
  • Anything that is not a declared dependency. npm's documentation for CLI version 11 describes npm sbom as listing the dependencies for the current project. Code pasted into the repository, or a script the browser loads from another server, is not one of those.
  • The services the application runs on and calls: the host, the database and third-party APIs. The SBOMs npm wrote in this page's lab list packages only.

CycloneDX and SPDX: the two formats

The 2026 guidance names two data formats as currently widely used by software ecosystem stakeholders to generate and consume SBOMs: SPDX and CycloneDX.

It says organisations should accept any widely used, interoperable and machine-processable SBOM format, and should avoid accepting SBOMs for new software generated in deprecated versions of any format.

CycloneDX

CycloneDX is developed by the OWASP Foundation and Ecma International. 1 min read

SPDX

SPDX's specifications page calls the SPDX specification an international open standard, ISO/IEC 5962:2021, and lists 3.0 as the current version. 1 min read

What the difference means for a small team

For a small team the choice is less about the formats than about who will read the file. 1 min read

Producing an SBOM at each release

For a Node.js project, npm has a command for the job. npm's documentation for CLI version 11 describes npm sbom as generating a Software Bill of Materials listing the dependencies for the current project, in either SPDX or CycloneDX format, with the options omit, package-lock-only, sbom-format, sbom-type, workspace and workspaces. sbom-format takes cyclonedx or spdx, with a documented default of null, and sbom-type is the type of package the generated SBOM describes: library by default, or application or framework.

The documentation page read for this guide covers version 11.21.2, which it marks as Legacy. The lab ran npm 11.12.1, whose own help text lists the same six options.

When to generate one is the Frequency element. The 2026 guidance says each software version or update should have an associated SBOM, and that when a component producer issues a new build or release, they or the SBOM author should also generate a new SBOM to reflect the changes.

For a web application deployed from a pipeline, this page reads that as one SBOM for each release you deploy, stored under that release's version.

Where it is generated matters as much. NTIA's report says that, while there are many unique circumstances, those requesting SBOM data should try to obtain it from the instance of the build, since the instance of the build captures the details of the software as built, including any changes made by the compiler or other tools.

The 2026 guidance adds a field for this, SBOM Generation Context: the relative software lifecycle phase and data available at the time the SBOM was generated, for which references such as before build, build and after build are enough. The CycloneDX 1.7 reference says lifecycles communicate the stage or stages in which data in the BOM was captured: its pre-build phase is a BOM consisting of information obtained prior to a build process, and its build phase is one consisting of information obtained during a build process where component inventory is available for use.

The lab shows the field at work. Run against the installed tree, npm sbom wrote the phase build. Run again with package-lock-only, which npm's documentation for CLI version 11 says loads only the information in the package lock, it wrote pre-build, and that line, the serial number and the timestamp were the only three lines that differed between the two files.

This page's advice follows from both sources: generate the SBOM in the pipeline, from the same clean install that produced the release, and not on a developer's machine. npm ci is the install that npm's documentation, read at CLI version 12, says is meant for automated environments such as continuous integration and deployment.

It needs an existing lockfile, and exits with an error instead of updating the lockfile when its dependencies do not match those in package.json. The lab adds a reason of its own: npm wrote the name of the folder it ran in into the application's name field, release-1 in one SBOM and release-2 in the other, for an application whose package name is the same in both.

Where to keep it

Keep each SBOM with the release it describes. The 2026 guidance says SBOMs should be available promptly to those who need them, and gives examples of how: an SBOM can accompany installation, or be accessible through a version-specific URL, an API to a database, or a public repository.

Executive Order 14028's definition says SBOMs gain greater value when collectively stored in a repository that can be easily queried by other applications and systems.

For a small team, this page's advice is modest. Store the file beside the release artefact, named by release version and commit, and keep every release's file, not only the latest, because the question an advisory raises is which releases contained the component. Decide who may read it, since an SBOM tells its reader exactly which versions you run.

If it goes to customers, the guidance has a field for signing it: SBOM Author Signature, a digital signature attributable to the SBOM author, which it says provides assurance that the information was not modified after signature generation.

Component identity: one package, several names

Matching an advisory to an SBOM depends on both documents naming the same thing the same way, and that is the hard part of the whole exercise.

NTIA's report says the challenges created by the lack of a single, well-understood and widely used name space for software are well documented. The 2026 guidance says there is not yet a universal solution to the problem of software identification, though there has been progress, and asks for at least one software identifier for a component, using common identifiers such as Common Platform Enumeration (CPE) and Package-URL (PURL).

A package URL, or purl, is the identifier npm wrote for every component in the lab. The README of the Package-URL project's purl-spec repository describes a purl as a URL composed of seven components: scheme:type/namespace/name@version?qualifiers#subpath. In the README's component table, the scheme is the constant pkg.

The type is the package type or protocol, such as npm, maven or pypi. The namespace is optional and type-specific, the name is required, and the version, qualifiers and subpath are optional. The README says the components form a hierarchy from the most significant on the left to the least significant on the right.

Its examples include pkg:pypi/django@1.11.1 and pkg:npm/%40angular/animation@12.3.1. It says PURL is an Ecma standard, ECMA-427, and that the core PURL syntax is defined in the Package-URL Specification, ECMA-427.

The second example shows a detail worth knowing before you search an SBOM as text. In the npm type, the namespace is used for the scope of a scoped package, and the type definition says the scope's @ sign is always percent encoded. So the package that package.json calls @sbomlab-invented/date-parse appears in the lab's SBOMs as pkg:npm/%40sbomlab-invented/date-parse@1.4.0.

The lab's two SBOMs for one release name that one package four ways: the name field (@sbomlab-invented/date-parse), the CycloneDX bom-ref (@sbomlab-invented/date-parse@1.4.0), the SPDX identifier (SPDXRef-Package-sbomlab-invented.date-parse-1.4.0) and the purl. The lab's script matches on the purl with the version removed, and one of its regression tests changes a component's name field to confirm the match still holds.

What a dependency path tells you

An SBOM that listed components without relationships could say a package is present.

One that carries the dependency graph can also say why. The 2026 guidance defines Component Dependency Relationship as the relationship between two components, where one component is necessary for the operation of the other, and says the information supports the capability to build a dependency graph.

Both formats have a rule about silence in that graph. The CycloneDX 1.7 reference says a component that has no dependencies of its own must be declared as an empty element within the graph, and that a component not represented in the graph may have unknown dependencies.

In SPDX 2.3.1, NONE on the right hand side of a relationship indicates that an element has no other elements connected by that relationship, and NOASSERTION that the author is not asserting whether there are any.

The path is what turns a match into a task. In the lab, the package the invented advisory names is not in the application's package.json. The graph shows it arriving through one direct dependency, a form helper, so the fix is first a question about that dependency, and the form helper is the first code to read when asking whether the affected function is called.

The dependency security guide covers the npm commands that print the same chain from an installed tree, and the routes for updating a package several levels down.

SBOM vulnerability management: matching an advisory to an SBOM

The 2026 guidance describes the use directly: after learning new vulnerability information, an organisation can assess whether its SBOMs contain or reference a vulnerable component.

Under Coverage it gives the reverse case as an example: the recipient of an SBOM should be able to conclude that a newly reported vulnerability does not affect them if the SBOM does not list the component associated with the vulnerability. That conclusion leans on the SBOM being complete, which is this page's reading of why Coverage asks for all components, transitive dependencies included.

An advisory supplies the other half of the match. The OSV schema, for one, describes affected versions as a timeline of events, among them the version that introduces a vulnerability and the version that fixes it. Matching is then four checks, and the order is this page's advice:

  • Identity. Write the advisory's package as a purl without a version, and look for components whose purl, with its version removed, is the same. Do not search on the name field alone.
  • Version. Compare each listed version with the advisory's range, taken from its version fields. A version the comparison cannot parse is unknown, not clear.
  • Every copy. The 2026 guidance says multiple instances of a component with differences in metadata should each be listed separately. On this page's reading, that means one package can appear more than once.
  • Every release still running. Run the check against the SBOM of each release that is deployed anywhere, not only the newest.

A match is a question, not a finding

NTIA's report says not all vulnerabilities in components create risks in the software that depends on them, and that focusing on upstream vulnerable components that have been deemed not to have an impact on the downstream software will waste time and resources. Someone has to do the deeming. A way to record their answer is what VEX provides.

What a VEX statement adds

VEX stands for Vulnerability Exploitability eXchange.

CISA's Minimum Requirements for VEX, published in April 2023, says VEX indicates the status of a software product or component with respect to a vulnerability. A VEX statement conveys a single status for a single vulnerability and one or more products. The document allows four status values, some with further requirements:

  • not_affected: no remediation or mitigation is required, and the vulnerability does not affect the listed products. The statement should provide a justification, and must provide an impact statement explaining how or why if it does not.
  • affected: actions are recommended by the author to remediate, mitigate or otherwise address the vulnerability. The statement must include an action statement, which should describe actions to remediate or mitigate it.
  • fixed: the listed products contain fixes for the vulnerability.
  • under_investigation: the author or other relevant parties are investigating and have not yet declared a final status. The document expects this status to change once the investigation has reached a conclusion.

Justifications, and who may issue a statement

A justification is one of five values: Component_not_present, Vulnerable_code_not_present, Vulnerable_code_not_in_execute_path, Vulnerable_code_cannot_be_controlled_by_adversary and Inline_mitigations_already_exist. The document describes the first as the vulnerable subcomponent not being included in the product. On this page's reading, that is the one of the five an SBOM can support directly.

The other four are statements about code and behaviour. The dependency security guide works through a not_affected decision for a function the code does not call, with the evidence such a record needs.

On who may issue one, the document says VEX documents can be authored by the supplier of the software or by a third party. A VEX document must identify its author, the author must be an individual or organisation, and the author is responsible for the content of the document.

It also says VEX does not specify, assume or imply any default status that is not explicitly provided in VEX statements. This page reads that plainly: a release nobody has made a statement about has no status, which is different from not_affected. The document says it does not represent official CISA policy and does not impose or mandate compliance.

Formats, and why their status names should not be mixed

CISA's document says that, as of its writing, CSAF, CycloneDX and OpenVEX can contain or be used to generate VEX documents. The lab's VEX document uses OpenVEX field names. The OpenVEX specification, version 0.2.0, uses the same four status labels, requires @context, @id, author, timestamp, version and statements at document level, lets a product's @id take a purl as its value, and gives a product a subcomponents list, which it says will most often be one or more of the product's dependencies.

It also allows an identifier of your own for the vulnerability: for internal identifying schemes, its only requirement is that the vulnerability has an ID string to address it.

CycloneDX records the same kind of judgement under different names. In version 1.7, a vulnerability's analysis state is one of resolved, resolved_with_pedigree, exploitable, in_triage, false_positive and not_affected, and its justifications are a different list, among them code_not_present and code_not_reachable, whose description is that the vulnerable code is not invoked at runtime.

Only not_affected is spelt the same in both vocabularies. This page's advice is that a record should say which format it is written in and use that format's own values.

Where SBOM data helps triage, and where it stops

Put the pieces together and an advisory raises eight questions.

This split is the page's own. An SBOM kept for each release, with a VEX document beside it, answers five of them from documents alone:

  • Is the component present? The SBOM lists it or does not.
  • Which version? The component entry says, and the advisory's range says whether that version is covered.
  • By which dependency path? The graph names the direct dependency that brings it in.
  • In which releases? One SBOM for each release answers for each.
  • Has its supplier said the product is affected? A VEX statement records a status, and who made the call.

The three questions no inventory answers

Three questions remain, and they need someone to analyse the application:

  • Is the vulnerable function called? The advisory may name it. Whether your code, or the dependency between your code and it, calls that function is a fact about code.
  • Can data an outsider controls reach it? A function called only with values your own code builds is a different exposure from one fed a form field.
  • Is a mitigating setting on? A feature switch, a parser option or a limit in front of the function can change the answer, and none of them is in the SBOM.

What each document is evidence of

NTIA's report says the supplier must make some reliable determination that a vulnerability does not affect a specific piece of software, and that this could be for a range of reasons: the compiler might remove the affected code from the component, the vulnerability may not be reachable in the execution path, in-line protections exist, or, in its words, a host of other reasons.

Reading those as reasons of the same kind as the three questions above is this page's own comparison, not NTIA's.

The OpenVEX specification is candid about two of the justifications. Of vulnerable_code_cannot_be_controlled_by_adversary and of inline_mitigations_already_exist it says the justification could be difficult to prove conclusively.

So read each document for what it is. An SBOM with no matches means no published advisory has been matched to a listed component on the day you checked. It says nothing about flaws in your own code, or in components nobody has reported on.

A fixed status means the author says the release contains the fix. A not_affected status is a claim with an author and a date, and with evidence if it was done well.

None of the three is a statement that an application has no vulnerabilities, and this page does not treat any of them as one.

The worked record on this page follows one component through that sequence: listed in release 1.0.0 inside the advisory's range, reached through one direct dependency, analysed and declared affected, then updated in release 1.1.0 and declared fixed. Its last line for each release is the question the documents leave open.

What to do with a match

When an advisory matches a component in one of your SBOMs, work through it in this order.

The order is this page's advice.

  • Confirm the match: the purl, the version against the advisory's range, every copy, and every release still deployed.
  • Check for exploitation. CISA says organisations should use its Known Exploited Vulnerabilities catalogue as an input to their vulnerability management prioritisation framework. The dependency security guide covers severity and exploit evidence.
  • Follow the dependency path to the code that calls the affected package, and answer the three questions above. If someone outside the team is waiting, under_investigation is the status that says so.
  • Decide. If the affected code is called with input from outside, this page would record affected, with an action statement that says what to update to or what to switch off meanwhile. If it is not, record not_affected with its justification and the evidence.
  • Fix it and keep the evidence. Update the package, ship the release, generate that release's SBOM from its build, and compare it with the previous one. The comparison should show the component's version change and nothing you did not expect.
  • Publish the new status. Add a fixed statement for the new release and leave the affected statement for the old one in place, since each describes its own release. Check the VEX document against the SBOMs before it goes out: the lab's script reports a conflict and exits with code 1 when a statement says fixed for a release whose SBOM still lists a version inside the advisory's range.
  • Keep the SBOMs, the VEX document and the notes from the analysis together, by release.

Build provenance is a separate record

An SBOM says what is inside a build.

Provenance says where the build came from, and it is a different document. SLSA describes provenance as the verifiable information about software artifacts describing where, when and how something was produced. Its build provenance format identifies the build platform (builder.id) and the template that defined the build process (buildType), includes the external interface to the build (externalParameters), captures the artefacts the build fetched, if known (resolvedDependencies), and identifies the artefacts the build produced (subject). npm has a provenance attestation of its own for packages on its registry: npm says it publicly provides a link to a package's source code and build instructions from the build environment, and that publishing with provenance requires a supported cloud CI/CD provider using a cloud-hosted runner.

The lab's packages are local folders that were never published, so no provenance statement exists for them, and the worked record shows the provenance fields as a labelled illustration with nothing filled in from evidence. For a published dependency the two records answer different questions: the SBOM entry gives the version you have, and the provenance details npm shows for a package published with provenance include its source commit and build file.

The CI/CD security guide covers what a deployer can check in an attested artefact, and the supply chain attacks guide covers what provenance does not prove.

Where a security review or test fits

Clever Ops does not monitor dependencies and does not sell a scanning subscription.

Scans are a step inside a check or test. The component record and the lab on this page are for your own team to run at each release.

Components come into Clever Ops work as part of reviewing an application. A secure code review reads the lockfile against the package manifest and checks new packages and versions against published advisories. A vulnerability assessment confirms a component by its exact version and by whether the affected feature is switched on.

Each report covers the build that was reviewed, on the dates it was reviewed, so a release published afterwards is outside what it can speak to.

If Clever Ops built or hosts the site, the work is a security review rather than an independent test, and the report says who built it and who hosts it.

Frequently asked questions

A software bill of materials: an inventory of the components a piece of software is built from. NTIA's 2021 report defines it as a formal record containing the details and supply chain relationships of various components used in building software. For a web application that means the packages the build installs, each with a name, a version and an identifier, and the relationships between them.

Both are open formats for the same inventory, and the 2026 joint guidance from CISA and 17 partner organisations names them as the two currently widely used. CycloneDX, developed by the OWASP Foundation and Ecma International, is at version 1.7 and lists ECMA-424 as its standard. SPDX gives 3.0.1 as its latest edition, and ISO/IEC 5962:2021 is its version 2.2.1. They arrange the same facts differently: CycloneDX keeps a components list and a separate dependency graph, while SPDX 2.3 expresses dependencies as relationships between packages.

VEX is Vulnerability Exploitability eXchange. CISA's Minimum Requirements for VEX says it indicates the status of a software product or component with respect to a vulnerability, using one of four values: not_affected, affected, fixed or under_investigation. The same document says VEX documents can be authored by the supplier of the software or by a third party, and that a VEX document must identify its author.

At every release. The 2026 guidance says each software version or update should have an associated SBOM, and that a new build or release should come with a new SBOM that reflects the changes. NTIA's 2021 report says that, while there are many unique circumstances, those requesting SBOM data should try to obtain it from the instance of the build. This page's advice is to generate it in the pipeline, from the same clean install that produced the release.

With npm sbom. npm's documentation for CLI version 11 describes the command as generating an SBOM listing the dependencies for the current project in either SPDX or CycloneDX format, chosen with the sbom-format option. In the lab on this page, npm 11.12.1 wrote CycloneDX 1.5 and SPDX 2.3 documents from an installed tree with npm's offline setting on, and a local listener standing in for the registry received no request from it. Check which format version your recipient accepts.

An identifier for a software package, written as a URL. The README of the Package-URL project's purl-spec repository gives its seven components as scheme:type/namespace/name@version?qualifiers#subpath, where the scheme is the constant pkg and the type is the package type, such as npm. In the npm type the scope's @ sign is always percent encoded, so a scoped package begins pkg:npm/%40. This page's advice is to match on the purl, not the name field, when checking an advisory against an SBOM.

No. An SBOM lists components, and matching compares those components with advisories published so far. It says nothing about flaws in code your team wrote, about components nobody has reported on, or about whether a matched flaw can be reached in your application. NTIA's report says SBOM will not solve all software security problems, and the 2026 guidance says an SBOM alone is data about software components.

No. Clever Ops does not monitor dependencies or sell a scanning subscription. A secure code review reads the lockfile against the package manifest and checks packages and versions against published advisories for the build reviewed. The record and lab on this page are for your team to run between reviews.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.