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; without one, you spend days making phone calls. We ensure the list is generated automatically with every build, so it cannot 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 contained in your software: for each component, its name, version, origin and licence. That may sound limited, but it is exactly enough to answer the two questions that really matter: does this affect us, and may we use it this way? More important than the fields is the scope – a list covering only the components you chose yourself misses most of the picture, because the surprises lie in what came along with them.

The reason this is appearing everywhere now is twofold. The Cyber Resilience Act requires manufacturers to provide a machine-readable SBOM covering at least the top-level dependencies, and customers have started including it in their procurement terms. Those who have to put it together when the first request arrives lose days; those who generate it automatically can send a file and come across as stronger.

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

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

Three types of engagement we take on here.

Where you start depends on whether you need to demonstrate something, want to find something out, or both. In the first conversation we will tell you which option will deliver results fastest.

First engagement · fixed sprint budget

Generate in the build pipeline

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

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

Licences and obligations at a glance

Most open-source licences impose few requirements, but a handful impose obligations that can extend to the code you build around them. You want to know that before you build, not after a client or buyer asks. We set up a check in the pipeline that blocks unwanted licences, and record deliberate exceptions in a register along with the reason.

Licence policyPipeline gateExceptions registerProvenance check
Larger project · fixed sprint budget

Integration with vulnerability sources and VEX

The list only becomes useful once it is checked against what is already known. We integrate it with sources such as the national vulnerability database and open sources, and apply a weighting so that you don't treat every alert as equally urgent. With VEX you then record that a reported vulnerability does not affect you because the vulnerable function is never called in your environment, which saves your team and your customers a great deal of unnecessary worry.

Ongoing comparisonWeighting by impactVEX statementsNotifications to customers

What you have at the end of an engagement.

A list that maintains itself, plus the two applications that make it more than a file in a folder.

  • Generation in your own build pipelineRuns alongside every build, in SPDX or CycloneDX, covering the top-level and transitive dependencies, and works with the languages and package managers you use.
  • An archive per released versionThe corresponding list is kept for every release, so you can establish afterwards exactly what was in a specific version that is still running somewhere.
  • Licence policy with a gateDefines which licences are permitted, with a check that blocks the rest and a register for the exceptions you make deliberately.
  • Ongoing comparison with vulnerability sourcesThe list is automatically checked against known vulnerabilities, with weighting that takes your own situation into account rather than only the published severity score.
  • A shareable copy for customersA version you can send unedited in a procurement process or hand to a regulator, with a 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 sounds familiar.

Four reasons why 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 immediate trigger, but the real benefit lies in the reporting deadline: without an overview, you will not meet the 24-hour window.

Customers ask for it

It is written into procurement terms

Standard terms for ICT procurement now stipulate that a supplier provides insight into the software and third parties it uses. Those who compile this by hand for each request lose time and credibility at the same time.

A vulnerability in the news

“Does this affect us?” costs a day

A vulnerability is reported in a widely used component, and a day goes into establishing whether you use it. This recurs several times a year, and each time ends 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 will be asked what the software contains and under which licences. An existing list shortens that investigation considerably and prevents surprises at the worst possible moment.

How such a project runs.

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 request from a customer, or simply the insight itself? That determines which format and level of detail make sense.

2

First list and findings

We generate a first complete list and go through it with you. Almost invariably, the same things turn up: there are more components than anyone assumed, a handful haven't been updated in years, and there's a licence in the mix that nobody had checked for suitability. That isn't bad news; it's the outcome.

3

Building it into the pipeline

Generation runs as part of the pipeline, with storage for each released version. At the same time, we set up the licence policy and put the gate in place, initially 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

Integrating with vulnerability sources

The list is continuously compared against what is 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 exceptions and how often, and an agreement on what happens when the gate stops something. Without that last agreement, a gate is circumvented 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 common and both are accepted. SPDX is an ISO standard and is widely used where licence information is central, for example in due diligence. CycloneDX comes from the security side and fits slightly 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're 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 in with your choices and that you never wrote down yourself. By default we generate the full tree and, where the top layer suffices, supply an extract of it as well. It takes the same effort, and the answer becomes far more useful.
Do we have to make the list public?
No. The obligation is that you have it and can produce it on request to those entitled to see it, primarily the market surveillance authority. What you share with customers is your decision. Some organisations share a complete copy under non-disclosure, others only confirm that a specific component is not used. That is a commercial consideration rather than a legal one.
What if a supplier won't give us a list?
It's the same question, one link further along the chain. For purchased components you can often establish what's inside by scanning the delivered artefacts yourself, but that is rarely complete. The practical route is to write it into 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 recording whether a reported vulnerability actually affects your product. A critical flaw in a component you ship but never invoke is no problem for your customer, but without a statement their scanner only sees the component and its score. You need this as soon as your customers start scanning for themselves, because it saves you both a lot of needless questions.
Does this change how we develop?
Very little, and that is the point. Generation happens automatically and requires no action. What does change is that a new dependency with an unwanted licence or a known flaw becomes visible the moment someone adds it, rather than months later. That is a short conversation at the right time, and it prevents the long conversation at the wrong time.
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 have not been updated in years, and there is at least one licence nobody consciously accepted. Most findings are resolved with a version update. The value lies not 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 is often where it is most useful. For a system that has been running for years, nobody usually knows exactly what is in it any more. Generation works the same way, although very old build pipelines may require some integration work. In practice the first list delivers the most value there, and it is often the starting point for a conversation about modernisation.
What about containers and operating systems?
They are part of it. A container image contains, alongside your code, an operating system layer with dozens of packages, and a large share of reported vulnerabilities sit there. We include that layer in the list, because otherwise the scan gives a clean picture while the flaw sits one level down. The same applies to base images you obtain from a supplier.
Will this cost us a new subscription?
Not necessarily. Generation itself can be done with open tooling that fits 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 from what you already run. Any recurring costs we will set out for you in advance.
Who should manage this on our side?
Generation maintains itself. What requires attention is reviewing the exceptions: which component deliberately stays on an older version and why, and when we look at it again. That belongs with the same person or role who assesses vulnerabilities, because it is the same judgement. Without an owner, the exceptions register grows until nobody looks at it any more.

Talk to us about your component inventory.

A no-obligation introductory call of half an hour. Tell us what is running and what prompted the question, and we will say how we would approach it and what the first list will probably show, even if we ultimately don't work together.

Edit content