Service · Software development

SBOM creation.

A vulnerability is reported in a widely used component. The question is not whether it is serious, but whether it affects you. If you have an up-to-date SBOM, you can answer that in minutes; if you don't, you spend days making phone calls. We make sure the list is generated automatically with every build, so it can't go out of date.

SPDX & CycloneDXIn the build pipelineLicence checkVEX

What an SBOM is, and why it should be generated automatically.

A Software Bill of Materials is a list of everything that goes into your software: for each component, the name, version, origin and licence. That may not sound like much, and it is exactly enough to answer the two questions that ultimately matter: does this affect us, and are we allowed to use this as we do. More important than the fields is the scope – a list covering only the components you chose yourself misses most of what is there, because the surprises are in what came along with them.

There are two reasons this is suddenly coming up everywhere. The Cyber Resilience Act requires manufacturers to provide a machine-readable SBOM covering at least the top layer of dependencies, and customers have started asking for it in their procurement terms. If you have to compile it at the first request, you lose days; if you have it automatically, you simply attach a file and come across as the stronger party.

What we do is build the generation into your build pipeline, in SPDX or CycloneDX, and connect the two applications that make it useful: the licence check and the integration with vulnerability sources. This ties in directly with vulnerability management and with the requirements of the Cyber Resilience Act. We often do it as part of setting up DevSecOps, because it touches the same place in the pipeline.

We do this on its own and as part of custom software development. For certification, it ties in with ISO 27001-compliant development, and in an acquisition with the question of how much technical debt there is in the code. Our information security policy describes how we handle this data ourselves.

Three kinds of engagements we get in this area.

Where you start depends on whether you need to demonstrate something, want to know something, or both. In the first conversation we'll tell you which option delivers results fastest.

First engagement · fixed sprint budget

Generating in the build pipeline

A list compiled by hand is already out of date by the next release. That is not a matter of discipline but of pace. We therefore hook generation into the build itself, using tooling that fits your languages and package managers, in SPDX or CycloneDX. The list is created as a by-product of something that already happens, and it cannot go out of date without the build stopping. For every released version, the corresponding list is kept.

SPDX or CycloneDXPer buildArchive per versionMultiple languages
Mid-sized project · fixed sprint budget

Licences and obligations at a glance

Most open-source licences place few demands on you, but a handful impose obligations that can carry over to the code you build around them. You want to know that before you build, not after a customer or buyer asks about it. We put a check in the pipeline that blocks unwanted licences, and record deliberate exceptions in a register along with the reason.

Licence policyGate in the pipelineExceptions registerProvenance check
Larger project · fixed sprint budget

Integration with vulnerability sources and VEX

The list only becomes useful once it checks itself against what is known. We link it to sources such as the national vulnerability database and open sources, and add a weighting so you don't treat every alert as equally urgent. With VEX, you can then record that a reported vulnerability doesn't affect you because the vulnerable function is never called in your software – which saves your team and your customers a lot of needless worry.

Continuous comparisonImpact weightingVEX statementsNotifications to customers

What you have at the end of an engagement.

A list that keeps itself up to date, plus the two uses that make it more than a file in a folder.

  • Generation in your own build pipelineRuns with every build, in SPDX or CycloneDX, covering the top layer and the layers beneath it, and works for the languages and package managers you use.
  • An archive per released versionThe list belonging to each release is kept, so you can establish afterwards what was in a specific version that is still running somewhere.
  • Licence policy with a gateA record of which licences are permitted, with a check that blocks the rest and a register for the exceptions you make deliberately.
  • Continuous comparison against vulnerability sourcesThe list is automatically checked against known vulnerabilities, with a weighting that takes your own situation into account rather than just the published severity score.
  • A shareable copy for customersA version you can send along in a procurement process or hand to a regulator without editing, with the timestamp included.
  • Handover to your teamA working session in which your developers go through the findings of the first list themselves and fill in the exceptions register.

When this applies to you.

Four reasons organisations come to us for this. There is usually a direct trigger, and the benefits turn out to be broader.

Legal obligation

The Cyber Resilience Act affects your product

You place software or a connected device on the European market and must be able to provide a machine-readable component overview. That is the direct trigger, but the real gain lies in the reporting deadline: without an overview, you won't meet the 24 hours.

Customers are asking for it

It's in the procurement terms

Standard terms for ICT procurement now state that a supplier must provide insight into the software and third parties used. Compiling that manually for each request costs you time and credibility at the same time.

A vulnerability in the news

Finding out whether this applies to you takes a day

A vulnerability is reported in a widely used component and a day goes by working out whether you use it. That happens a few times a year, and every time you end up with the same uncertainty.

Acquisition or due diligence

A buyer wants to know what's inside

In an acquisition, an investment round or a certification, you are asked what is in the software and under which licences. A list that already exists shortens that investigation and prevents surprises at the worst possible moment.

How a project works.

1

Introduction and inventory

Which languages, package managers and build pipelines do you use, how many products and versions are there, and what is the trigger: a legal obligation, a customer request, or the insight itself. That determines which format and depth make sense.

2

First list and findings

We generate a first complete list and walk you through it. The result is almost always the same: there are more components in it than anyone thought, a handful haven't been updated in years, and there is a licence in there that nobody had checked for suitability. That isn't bad news but the point of the exercise.

3

Building it into the pipeline

Generation becomes part of the pipeline, with storage for every released version. At the same time, we set up the licence policy and add the gate, first as a warning and only blocking once the list is clean. Blocking on a pile of open findings only leads to the gate being switched off.

4

Linking to vulnerability sources

The list is continuously compared against what is publicly known, with a weighting that takes into account where a component sits in your product. Where an alert doesn't affect you, we record that as a VEX statement so the same discussion doesn't come back every month.

5

Handover and rhythm

A working session with your team, agreements on who reviews the exceptions and how often, and an agreement on what happens when the gate blocks something. Without that last agreement, a gate gets bypassed within a month.

Frequently asked questions about SBOMs.

What development teams, product owners and security officers ask us before they get started.

SPDX or CycloneDX: which should we choose?
Both are widely used and both are accepted. SPDX is an ISO standard and is common where licence information is central, for example in due diligence. CycloneDX comes from the security world and fits somewhat more naturally with vulnerability management and VEX. In practice, you can convert almost any list between the two, so it is rarely a choice you are locked into. We look at what your customers ask for and which tooling you already use, and follow that.
How deep should the list go?
The Cyber Resilience Act requires at least the top layer of dependencies. For answering the question "does this affect us?", that is too shallow: most reported vulnerabilities sit in components that came along with your choices and that you therefore never wrote down yourself. By default, we generate the full tree and also deliver an extract of the top layer for where that is sufficient. It takes the same effort and makes the answer far more useful.
Do we have to make the list public?
No. The obligation is that you have it and can provide it on request to those entitled to it, primarily the market surveillance authority. What you share with customers is up to you. Some organisations share a full copy under a non-disclosure agreement, others only confirm that a specific component is not used. That is a commercial consideration, not a legal one.
What if a supplier doesn't give us a list?
That is the same question, one link further down the chain. For purchased components, you can often establish what is inside yourself by scanning the delivered artefacts, but the result is rarely complete. The practical route is to put it in your procurement terms and enforce it at renewal. We can help draft that wording; it is the same clause your own customers are now putting to you.
What is VEX and do we need it?
VEX stands for Vulnerability Exploitability eXchange: a statement in which you record whether a reported vulnerability actually affects your product. A critical flaw in a component that you ship but never call is no problem for your customer, but without a statement their scanner only sees the component and the score. You need it as soon as your customers start scanning themselves, because it saves you and them a lot of unnecessary questions.
Will this change how we develop?
Very little, and that is the intention. Generation happens automatically and requires no manual step. What does change is that a new dependency with an unwanted licence or a known vulnerability becomes visible the moment someone adds it, rather than months later. That is a short conversation at the right moment, and it prevents the long conversation at the wrong moment.
What does the first list usually show?
Almost always the same picture: the number of components is a multiple of what the team expected, a handful haven't been updated in years, and at least one licence was never knowingly accepted. Most findings are resolved with a version update. The value isn't in the count but in the fact that the question can be answered for the first time.
Does this also work for older software?
Yes, and that's often where it's most useful. With a system that has been running for years, usually nobody knows exactly what's in it any more. Generating the list works the same way, although very old build pipelines may need some adaptation. In practice, the first list delivers the most value here, and it often becomes the starting point for a conversation about modernisation.
What about containers and operating systems?
They're included. A container image contains, besides your code, an operating system layer with dozens of packages, and that's where a large share of reported vulnerabilities sit. We include that layer in the list, because otherwise the scan gives a clean result while the vulnerability sits one level lower. The same applies to base images you source from a vendor.
Will this cost us a new subscription?
Not necessarily. Generating the list itself can be done with open tooling that fits into your existing build pipeline. For managing the lists across many products and versions, a central system is useful, and there are both open and paid options. We advise based on how many products and versions you have, and start with what you already run. We'll discuss any recurring costs with you upfront.
Who needs to manage this on our side?
Generating the list manages itself. What needs attention is assessing the exceptions: which component deliberately stays on an old version and why, and when do we review it again. That belongs with the same person or role that assesses the vulnerabilities, because it's the same trade-off. Without an owner, the exceptions register grows until nobody looks at it any more.

Talk to us about your component overview.

A no-obligation introductory call of half an hour. Tell us what's running and what prompted this, and we'll explain how we would approach it and what the first list is likely to show – even if we don't end up working together.

Edit content