Software Bill of Materials in CI/CD: Generate, Validate, Store, and Use SBOMs for Releases
SBOMsoftware supply chainDevSecOpsCI/CDCycloneDXSPDX

Software Bill of Materials in CI/CD: Generate, Validate, Store, and Use SBOMs for Releases

QQuickFix Cloud Editorial Team
2026-11-17
7 min read

A practical SBOM CI/CD checklist covering generation points, CycloneDX and SPDX, validation, storage, vulnerability response, and review.

An SBOM is most useful when it is produced as part of the release process, tied to a specific artifact, checked for completeness, and retained where responders and auditors can find it. This guide provides a reusable SBOM CI/CD checklist covering source dependencies, container layers, release artifacts, validation, storage, vulnerability response, and exception review.

Overview

A software bill of materials (SBOM) is an inventory of software components contained in or used to build a product. Depending on the scope, it may describe application dependencies, operating-system packages, container layers, build tools, or other components that are relevant to the delivered artifact.

The central design decision is not simply which SBOM generator to install. It is deciding where the inventory is generated, what it describes, how it is validated, and how it remains associated with the release. A source-level SBOM can show what a project declares, while a final-artifact SBOM can show what customers actually receive. These inventories are related but are not interchangeable.

For most teams, a practical workflow has four points:

  1. Source and dependency inventory: inspect manifests, lockfiles, and relevant build inputs.
  2. Build or container inventory: inspect installed packages and image layers after construction.
  3. Release-artifact inventory: generate or verify an SBOM for the exact package, image, binary, or deployment bundle being released.
  4. Post-release use: store the SBOM with the release, search it during vulnerability response, and review exceptions until they are closed.

SBOMs do not replace vulnerability analysis, secure development practices, or testing. They provide evidence about component composition so that those activities can be more targeted and repeatable.

Checklist by scenario

1. Source and dependency inventory

  • Identify every supported package manifest and lockfile in the repository.
  • Generate an SBOM from the resolved dependency state, not only from broad version ranges in a manifest.
  • Include direct and transitive dependencies when the generator supports that distinction.
  • Record the repository, commit or source revision, build target, and generation time as metadata.
  • Run the inventory in CI so changes to dependencies produce a reviewable result.
  • Compare the generated component set with the lockfile and investigate unexpected additions or removals.

A source SBOM is especially useful for pull-request review, dependency updates, and identifying which projects may be affected by a newly disclosed component issue. Link this process to your dependency update workflow rather than treating it as a separate security job. The Dependency Updates in CI guide provides a useful companion workflow for batching and reviewing changes.

2. Container and operating-system inventory

  • Generate an SBOM from the built image, preferably after all package installation and build steps have completed.
  • Record the image name, immutable digest, platform or architecture, and base-image reference.
  • Include application packages and operating-system packages where the tooling can identify them.
  • Check whether multi-stage builds leave build-only packages out of the final image; do not assume the source inventory describes the runtime image.
  • Scan the same immutable image that will be promoted, rather than scanning only a local or intermediate tag.
  • Attach the SBOM to the image record or store it in a location that can be resolved from the digest.

Container images can contain components introduced by the base image, package manager, or build process. A final-image SBOM therefore complements source analysis. For the broader scan, prioritize, sign, and rebuild workflow, see the Container Image Security Workflow.

3. Release-artifact inventory

  • Define the release unit: binary, archive, installer, container image, Helm package, serverless bundle, or another deployable artifact.
  • Generate or verify the SBOM after packaging, signing, and relevant transformation steps.
  • Use a stable artifact identifier that includes the product, version, target, and artifact digest where available.
  • Store the SBOM beside the artifact or attach it through the registry or release system.
  • Preserve the exact source revision and build-run identifier used to create the artifact.
  • Make the lookup path usable by incident responders who may not have access to the original CI job.

The release SBOM should answer a simple operational question: “What components are in version X of this exact artifact?” If the answer requires reconstructing an old build from a mutable tag or an expired workspace, the workflow is not complete.

4. Choose and compare SBOM formats

Two widely used interchange formats are CycloneDX and SPDX. Both can represent component inventories, relationships, licenses, and identifiers, but field names, relationship models, and tool behavior vary. Select one as the team default where possible, then document conversion rules for consumers that require another format.

Decision areaCycloneDXSPDXPractical check
Primary useComponent and dependency inventories with relationships and service-oriented detailDetailed package, file, licensing, and provenance informationChoose the format supported by your registries, scanners, and customer workflows
Component identityCan use package URLs and other ecosystem identifiersSupports package and document identifiers with rich metadataRequire stable identifiers where the ecosystem supports them
RelationshipsUseful for describing dependency and composition relationshipsUseful for describing document, package, file, and relationship dataConfirm that downstream tools preserve relationships during import
ValidationValidate against the selected CycloneDX schema versionValidate against the selected SPDX specification and serializationPin the format version and test upgrades before changing it in production

The format matters less than consistency and traceability. A small, accurate SBOM tied to a known artifact is more useful than a large document with missing identifiers, unclear scope, or no release association.

What to double-check

Completeness and scope

  • Does the SBOM state what it covers: source dependencies, runtime packages, build tools, or the final artifact?
  • Are transitive dependencies present where they are relevant to the runtime?
  • Are generated files, vendored dependencies, plugins, and bundled assets handled consistently?
  • For containers, does the inventory describe the final image rather than only the application directory?
  • Are platform-specific dependencies separated when artifacts differ by operating system or architecture?

Identity and freshness

  • Does each release SBOM contain the artifact digest, version, source revision, and build identifier?
  • Can a reviewer distinguish a current document from one generated for an earlier build?
  • Are package names, versions, and ecosystem identifiers normalized enough for vulnerability matching?
  • Does the pipeline fail, warn, or create a review task when the generator cannot identify a component?
  • Is the SBOM regenerated when the base image, lockfile, compiler, or packaging process changes?

Storage, access, and response

  • Is the document stored with the immutable artifact rather than only as a CI log attachment?
  • Does the retention period cover the period in which the release may remain deployed or supported?
  • Can security and operations teams search SBOMs by component, version, artifact, or release?
  • Is there a defined path for updating vulnerability status when a component issue is disclosed?
  • Are signed documents or attestations used where the team needs evidence that an SBOM belongs to a particular build?

When a vulnerability is announced, use the SBOM to identify affected artifacts, environments, and owners. Then verify the finding against the actual execution context, exposure, and available fix. An SBOM supports vulnerability management; it does not by itself establish exploitability or priority.

Common mistakes

  1. Generating only at the start of the pipeline. A source inventory may miss packages added during image construction or packaging. Generate again at the artifact boundary.
  2. Attaching an SBOM to a mutable tag. Tags can move. Prefer an immutable digest, release identifier, or content-addressed record.
  3. Publishing without declaring scope. Readers need to know whether the document represents direct dependencies, the complete runtime, or another boundary.
  4. Ignoring unknown components. Unresolved names and versions reduce the value of vulnerability matching. Track them as quality issues instead of silently accepting them.
  5. Treating a scanner result as the SBOM. A scanner may consume an SBOM, generate one, or add findings to it. Keep inventory data distinct from vulnerability findings and policy decisions.
  6. Keeping no exception record. If a component cannot yet be upgraded, document the affected artifact, reason, owner, compensating control, and review date. Exceptions should expire or be reassessed.
  7. Changing formats without testing consumers. A format conversion can lose identifiers, relationships, or metadata. Validate the converted document in every system that reads it.

When to revisit

Review the SBOM workflow before planning cycles and whenever the delivery system changes. At minimum, revisit it when the team:

  • adopts a new language, package manager, build system, registry, or container base image;
  • changes artifact types, release channels, supported platforms, or deployment targets;
  • updates the SBOM generator, schema version, scanner, registry integration, or signing process;
  • needs to satisfy a new customer delivery requirement or internal audit request;
  • responds to a dependency incident and discovers missing identifiers, stale documents, or unclear ownership;
  • changes retention, access control, release support, or incident-response procedures.

Use this short review sequence as an action plan:

  1. Pick one current production artifact and locate its SBOM using only the documented release identifier.
  2. Confirm that the document describes the final artifact and includes its digest, source revision, generation time, and format version.
  3. Compare its components with the lockfile, image contents, or package manifest that should define the release.
  4. Run a vulnerability lookup and verify that the result can identify affected artifacts and owners.
  5. Record any gaps as implementation tasks with an owner and review date.
  6. Repeat the test after generator, schema, registry, or pipeline changes.

That recurring check keeps an SBOM from becoming a one-time compliance file. It turns the software bill of materials into a practical release record for secure deployment, incident response, dependency maintenance, and configuration quality.

Related Topics

#SBOM#software supply chain#DevSecOps#CI/CD#CycloneDX#SPDX
Q

QuickFix Cloud Editorial Team

DevOps and Cloud-Native Technology Editors

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.