Nobody on our six-person team planned to learn anything about supply-chain security. We were building a booking app for a group of orthopedic clinics — appointment slots, reminders, the usual. Then a hospital group wanted to buy it, and their procurement email arrived with a line we had to read three times: “Please provide a software bill of materials for each release, with build attestation.” That sentence, it turns out, is how most teams meet DevSecOps evidence requirements: not through ideology, but through paperwork somebody bigger than them asked for.
Week one: finding out what we had actually shipped
The first job was embarrassing in a useful way. An SBOM — a bill of materials for software — is simply a list of every component inside your build, and we had never once looked at ours end to end. Running a generator over the project surfaced 214 dependencies. Two of them were libraries someone had vendored by copy-paste in 2023 and nobody remembered. One was duplicated at different versions in the same app. The formats are standard, for what it’s worth: CycloneDX and SPDX are the ones you’ll meet, and both are fine — the buyer accepted either. What they would not accept was “we use npm, it manages that sort of thing”. Six people, one afternoon, and a spreadsheet nobody was proud of, but the ingredient list finally existed.
Week two: signing things, and learning what a signature is not
Next came signatures. The Sigstore tooling made this easier than we feared: cosign for the signing itself, Fulcio issuing the short-lived certificates, Rekor keeping the public log. Signing takes minutes to set up. Understanding it takes longer, because a signature only proves who built this — it says nothing about whether the build process was sane. That’s where provenance comes in: a record of how the artifact was produced, which workflow ran, which sources went in. The SLSA framework grades this stuff. Build levels run from zero (no guarantees) to three (hardened, isolated builds), and the Source track — newer, from the v1.2 revision — grades how well the repository itself is protected, up to level 4.
Week three: the DevSecOps settings already sitting switched off
Here’s the pleasant surprise. Our CI was already on GitHub, and artifact attestations come out of that pipeline at SLSA Build level 2 without heroics. Level 3 is reachable too, if you pin reusable workflows — the difference is whether the build definition itself is tamper-resistant. Nobody on the team had ever clicked into those settings. Two days of reading, one afternoon of configuration, and we could hand the buyer a link to attestations generated automatically on every release. The lesson stuck with all of us: a lot of DevSecOps maturity is already sitting in the platform, switched off.
The DevSecOps half everyone skips: checking at the other end
A month in, our tech lead made the observation that reframed the project: “We sign everything, and then deploy without looking.” A signature nobody verifies is a wax seal on an envelope that goes straight in the bin. Verification belongs at deploy time — the pipeline should refuse to run an artifact whose signature or provenance doesn’t check out. That single habit converts all the paperwork from decoration into a working control, and it’s the step most teams genuinely forget. Sign at build, verify at deploy. Both halves, or neither counts. After we wired the check in, an interrupted release proved its worth within the month: a mis-built artifact failed verification and never reached staging, which would previously have been a debugging afternoon nobody had spare.
Why we stopped complaining about the homework
The XZ Utils episode settled any lingering grumbling. In March 2024, that backdoor — CVE-2024-3094 — landed in liblzma and sat undetected in downstream builds. CISA’s advice included stepping back to version 5.4.6 while things got sorted. Notice what made response possible: knowing, quickly and precisely, which of your systems contained the affected component. An SBOM doesn’t prevent a backdoor; what it buys you is speed of answer when the question arrives at 6 p.m. on a Friday. Our buyer wasn’t collecting documents for fun. They were buying the ability to answer that question fast. We rehearsed it after reading the case: someone asked “which services contain library X?” at random, and the SBOM answered in minutes — a query that, the year before, would have sent us grep-hunting through half a codebase for a day and a half.
What we’d tell a team at week zero
- Generate the SBOM first, before anything else — the ingredient list is the foundation the rest stands on.
- Turn on attestation in your existing CI before shopping for tools; you may already be at Build level 2.
- Add deploy-time verification early, because retrofitting it later means retraining habits.
- Keep the Source track in mind: protecting the repository matters as much as protecting the build.
- Write down where each piece of evidence lives, or the next person inherits a mystery.
The deal closed, for what it’s worth. Choosing that buyer taught us something too — they’d done their own verification homework — the same diligence you’d bring to choosing an orthopedic hospital when your hip pain will not quit: credentials examined, never assumed. And if your team wants the wider map we navigated, The Ops Atlas guide to DevSecOps covers the evidence practices in more depth, alongside this take on resilient infrastructure for the bigger operational picture.
We still ship every two weeks. The only difference is that now every release carries its own autobiography — ingredients, builder, and a signature — and the deploy step actually reads it before letting anything out the door.
