PricingBlogLog in
SBOMfirmwarePLMBOM managementCyber Resilience ActIoThardware startupsecurity

SBOM vs BOM: Treat Your Firmware Like an Assembly

By · · 10 min read

SBOM vs BOM: Treat Your Firmware Like an Assembly

TL;DR

A BOM lists the parts you build a product from; an SBOM lists the software components inside its firmware and where each one came from. Under the EU Cyber Resilience Act, a manufacturer has 24 hours to send an early warning once it knows a vulnerability in its product is being actively exploited, and that's only possible if you can trace a vulnerable library to firmware revisions, board revisions, and shipped units. Get firmware into git first, generate a machine-readable SBOM (SPDX or CycloneDX) on every tagged release, and model each firmware release in your BOM as an assembly whose child lines are its top-level libraries, with the SBOM attached. The BOM gives you the hardware pairing; the SBOM gives you the full dependency list.

Somewhere in your shipped product is a library you didn't write and haven't thought about since the week you added it. When a security advisory names it, the question you have to answer isn't technical. It's a records question: which of the units you shipped have it?

Since September 11, 2026, if you sell into the EU, that question has a deadline. The Cyber Resilience Act gives a manufacturer 24 hours from becoming aware of an actively exploited vulnerability in its product to send an early warning, 72 hours to send the full notification, and 14 days after a fix exists to file a final report. The clock starts when you know. It doesn't wait for you to find out which firmware build the vulnerable code went into.

The EU isn't the only one asking. In the US, Section 524B of the FD&C Act has required an SBOM, "including commercial, open-source, and off-the-shelf software components," in premarket submissions for internet-connected medical devices since March 2023; if that's your market, it sits alongside the rest of what a medical device startup needs from PLM. And where no regulator asks, your customers and your CM will, the morning an advisory makes the news.

What That Clock Looks Like in Practice

Here is a real case that's still open. In August, Siemens published an advisory for CVE-2026-58115, a CVSS 10.0 flaw in its SIMATIC IoT2050 industrial gateways: the Node-RED web interface accepts commands without authentication. On October 30, VulnCheck caught attackers exploiting it to install a Linux bot. Siemens updated the advisory again on November 10.

Read the advisory closely and you'll see where the hard part is. The affected units aren't "every IoT2050." They're IoT2050s running Industrial OS before V4.3.4-1 with Node-RED installed. Node-RED is an open-source component that lives inside the device's software image. That's a statement about software composition, unit by unit, and it's exactly what an SBOM records.

Now picture the startup version. This is a composite, not a story about any one company: an advisory lands for the TLS library inside your ESP32 firmware. Your lead firmware engineer left in June. The build that went to your CM last spring came off their laptop. You have 24 hours, and the first six go to working out which release even included that library.

SBOM vs BOM: Two Lists, Two Audiences

A BOM lists the physical parts, subassemblies, and quantities that make up a product. Your engineers, your purchasing lead, and your contract manufacturer read it, and it changes when the design changes.

An SBOM lists the software components inside the product's firmware: each library, its version, and where it came from. The CRA defines it as "a formal record containing details and supply chain relationships of components included in the software elements of a product." Security scanners and regulators read it, so it has to be machine-readable.

BOM SBOM
Lists Parts, subassemblies, quantities Libraries, SDKs, binary components, versions
Read by Engineering, purchasing, your CM Security tooling, auditors, regulators
Format Whatever your PLM or spreadsheet holds SPDX or CycloneDX (JSON or XML)
Changes when The design or a sourced part changes Any dependency in a firmware build changes
Answers What do we build this from? What code is running on it?

You need both, and they have to point at each other. The SBOM can tell you that firmware v4.5 contains the vulnerable library. Only the BOM can tell you that v4.5 shipped on board revision C, and that revision C went out in the March and May builds.

Step Zero Is a Central Repo

This sounds too basic to write down, and it still gets skipped. Hardware teams that would never let a schematic live only on someone's laptop let firmware do exactly that: a project folder on one engineer's machine, a .hex emailed to the CM, a zip on a shared drive named fw_final_v2_REAL.

Get the firmware into git, on GitHub or GitLab or wherever your team already works, and tag every build that leaves the building. Tying that tag to the BOM line it belongs to is the first bridge between software and hardware. Every SBOM you'll ever generate starts from a tagged commit; without one, you can't prove what code a binary came from.

What Git Doesn't Know

A repo stores your code faithfully. It's much worse at recording where that code came from.

GitHub can export an SBOM from its dependency graph, but the graph mostly works by reading package manifests from ecosystems like npm, pip, and Cargo. Embedded C doesn't usually have one. Your firmware probably includes a vendor SDK or HAL copied in at a specific version, a sensor driver pasted from a vendor's example repo, an RTOS pulled in as a submodule, and a precompiled radio stack or Wi-Fi library that ships only as a binary. To the repo, the copied code is just more files with your commit history on top. Nothing records that third_party/ holds the vendor's 2023 driver with two local patches.

The toolchain is a dependency too. The same source compiled with a different GCC version is a different binary, and when you're answering for shipped units, the binary is what counts.

None of this means git is the wrong foundation. It's the right foundation for the code. What it can't tell you is where each piece came from, and you have to record that somewhere else, deliberately.

Model the Firmware as an Assembly

Here is the structure I'd use. Give each firmware release a part number and a revision, and treat it as an assembly. Its child lines are its top-level dependencies: the RTOS or SDK, the TLS and networking stacks, vendored drivers, binary blobs. The compiled binary and its release note attach to the assembly. The assembly sits under the hardware revision it runs on, the same way a PCBA sits under the product.

For an ESP32-based sensor, release 4.5 might look like this:

Line Rev Source Notes
FW-0012 Sensor firmware 4.5 git tag v4.5.0 Assembly; .hex, release note, SBOM attached
ESP-IDF 5.2.2 Espressif, GitHub Includes mbedTLS and lwIP
Wi-Fi/BLE libraries per ESP-IDF 5.2.2 Espressif, precompiled Binary only, no source
Humidity sensor driver vendor commit a1c9e40 Vendor example repo Vendored, 2 local patches
Bootloader 4.5 git tag v4.5.0 Built from same tag

That structure buys you a few things. A library bump becomes a new revision of the firmware assembly, which means it goes through the same change record as anything else on the BOM instead of a version number quietly edited in a cell. A where-used query on a library line tells you which firmware releases contain it. And because the firmware is pinned under a hardware revision, every library has a traceable path down to a board.

You don't need special SBOM fields to start. Name, revision, and a notes field carry the version, the source, and anything odd, like local patches. That's how it works in oroForge today: the firmware is an assembly, the libraries are child parts, and the release artifacts attach to the assembly.

Generate the Machine-Readable SBOM in CI, Link It in the BOM

Don't try to hand-type every transitive dependency into your BOM. That's the build system's job.

Two formats cover nearly everything: SPDX, a Linux Foundation project published as ISO/IEC 5962, and CycloneDX, an OWASP project. Embedded tooling increasingly produces them for you; Zephyr's west spdx, Espressif's esp-idf-sbom, and Yocto's SPDX output all generate one from the actual build. Run that step in CI on every tagged release, and keep the file next to the binary.

Then split the work between the two records. The SBOM carries the full dependency tree, generated, complete, and machine-readable. The firmware assembly in your BOM carries the top-level dependencies a human needs to reason about, the hardware pairing, and the release's SBOM file attached. The CRA's own floor lines up with this: its SBOM requirement covers "at the very least the top-level dependencies of the products." Those top-level dependencies are what your child lines already list.

Your PLM Only Knows What You Put In It

PLM stands for product lifecycle management, and the lifecycle part is the point. Firmware updates, library patches, and security advisories keep arriving for as long as units are in the field. A PLM that holds your mechanical and electrical BOM but not the software inside the product covers only part of that lifecycle.

If you're the technical program manager or product manager, the PLM is the tool you work from. It's where you check what's in a build, what changed between revisions, and what a change will touch. When an advisory lands, you're the one asked which products and customers are exposed, and the PLM is where you'll look first.

If the firmware is a single line with a version number, and the libraries live only in a repo you never open, the PLM gives you a confident, incomplete answer. You get blindsided, usually after a security researcher or a customer has already found the problem.

A PLM is only as useful as the product data in it. Mechanical parts, electrical parts, firmware, and the software components inside that firmware are all part of the product. Leave one out and every where-used query, impact assessment, and change review has a blind spot in exactly the place the risk is.

Running the 24-Hour Drill

With that in place, the advisory from the composite example plays out differently. Search the attached SBOMs, or just the child lines, for the affected library version: releases 4.3 through 4.5 have it. A where-used on those firmware assemblies shows they run on board revisions B and C. Your build records show which lots and serial ranges shipped with each pairing. You can file the early warning with real scope in the first hour instead of the twentieth.

I'll be straight about where this stops. Your BOM records which firmware each hardware revision should run. It doesn't know which firmware a specific unit is running today after over-the-air updates; that's the as-built gap no PLM closes, and it belongs to your device-management platform. If you push OTA updates, the drill has a second step: ask the fleet system which serials are still on an affected release. It's the same lesson as the supermarket fridge hack: you can't patch what you can't find.

Code You Imported Is Still Your Code

The habit worth breaking is treating firmware as finished once it's flashed. Every library in that image is a part you chose and shipped, with a revision, a source, and a supplier you're answerable for. The only difference is that it doesn't have a reel label.

We're building a GitHub link into oroForge so a firmware assembly points straight at its repo and release tag, instead of relying on attached files and a tag typed into a notes field. Until then, the assembly structure above works with what's there today. See pricing if you want your firmware and hardware on one record before the next advisory lands.

Frequently Asked Questions

What is the difference between an SBOM and a BOM?
A BOM (bill of materials) lists the physical parts, subassemblies, and quantities needed to build a product, and it's read by engineering, purchasing, and your contract manufacturer. An SBOM (software bill of materials) lists the software components inside a product's firmware, with versions and where each came from, in a machine-readable format like SPDX or CycloneDX, and it's read mostly by security tooling and regulators.
Does the EU Cyber Resilience Act require an SBOM?
Yes. The CRA requires manufacturers of products with digital elements to draw up a software bill of materials in a commonly used, machine-readable format covering at least the product's top-level dependencies. Full obligations apply from December 11, 2027, but the duty to report actively exploited vulnerabilities, with a 24-hour early warning, has applied since September 11, 2026.
Can a git repository serve as an SBOM?
Not by itself. Git is the right source for an SBOM because it holds the exact code for every release, but it doesn't record where vendored code, vendor SDKs, or precompiled binary libraries came from. An SBOM generated from the build of a tagged release captures that, and the git tag tells you which code it describes.
Should the SBOM live in your PLM?
Yes, or at least be linked from it. PLM covers the whole product lifecycle, including firmware updates and security advisories after launch, and program and product managers use it to judge what a change or advisory affects. If the PLM holds the hardware BOM but not the firmware's software components, impact checks miss exactly the part a security issue touches.
How do you track firmware libraries in a BOM?
Model each firmware release as an assembly with its own part number and revision, and add its top-level libraries, SDKs, and binary blobs as child lines with their versions and sources. Attach the compiled binary and the release's machine-readable SBOM to the assembly, and place the assembly under the hardware revision it runs on.

Ready to manage BOMs without the enterprise overhead?

Free plan available. No sales call. Up and running in minutes.

David Orozco Cosio

Co-Founder, oroForge

MIT engineer with 10+ years building hardware products across IoT, robotics, and medical devices.