Insights · Platform Engineering

CI/CD in regulated environments: pipelines your auditor can trust

GitLab CI/CDSBOM

Key takeaway

Regulation forbids unverifiable change, not CI/CD: signed builds, policy gates and traceability, enforced by the pipeline itself.

The regulated-delivery reflex — slow everything down, add a change advisory board, require a PDF — confuses ceremony with control. An auditor’s actual question is narrow: prove that what is running in production is what was tested, built from reviewed code, by an authorized process. A modern pipeline answers that question automatically, continuously, and with better evidence than any human ever assembled by hand. Google’s SRE book describes the target operating model in its release engineering chapter: self-service, high-velocity, hermetic builds with policy enforcement — gated approval for changes and deploys — where artifacts are “versioned by hash and signed” and every change is “logged and archived.” That is not a startup’s pipeline; it is the compliance-grade one.

Why the supply chain is the audit surface now

Regulators followed the threat model. The systematic taxonomy of open-source supply chain attacks (Ladisa et al., IEEE S&P 2023) cataloged “107 unique vectors, linked to 94 real-world incidents, mapped to 33 mitigating safeguards” — and the safeguards cluster around exactly the controls a pipeline can enforce: provenance, signed artifacts, protected builds, policy gates. The NIST SSDF (SP 800-218) turns that cluster into the normative vocabulary — protect the code, provide provenance, verify builds — that regulated contracts now cite. Your pipeline is where those practices either exist or don’t.

Provenance and signing: prove what you built

  • SLSA (“Salsa” — Supply-chain Levels for Software Artifacts) is the framework for build integrity: “a checklist of standards and controls to prevent tampering, improve integrity, and secure packages and infrastructure,” organized into “four compliance levels of increasing assurance,” with provenance generation as “the first on-ramp.” Provenance is the signed statement of what was built, from which source, by which builder — the artifact’s birth certificate.
  • in-toto supplies the metadata standard underneath: a CNCF-graduated framework that records “what steps were performed, by whom and in what order” across the supply chain, so the chain itself is attestable end to end.
  • Sigstore makes signing operable: keyless signing binds short-lived certificates to an OIDC identity (Fulcio), records verification material in Rekor — an “immutable, append-only ledger” — and signs with Cosign, so “there’s no need to manage keys.” The engineering objection to signing (key ceremonies nobody rehearses) is solved; the adoption barrier left is organizational, as the interview study of signing practice found — 18 practitioners across 13 organizations reported technical, organizational and human barriers, with experts disagreeing even on signing’s importance (Kalu et al., arXiv 2024). Plan the rollout like a product, not a flag flip.

Honesty about adoption friction matters here: an empirical analysis of SLSA deployment (Tamanna et al., arXiv 2024, mining 1,523 GitHub issues) documents “complex implementation and unclear communication” as real adoption challenges. Start with provenance and image signing; treat build-level ascent as a roadmap, not a sprint.

Policy gates in code, not tickets

Separation of duties is a regulatory staple — but enforcing it through meeting quorums produces both slow delivery and weak evidence. In the pipeline, separation of duties is mechanical: branch protection requires review; merge requires approval; deploy requires the policy engine’s verdict; production requires a second, distinct approver — each step attested. Policy as code turns the control catalogue into pipeline checks with deny effects, mapped to SSDF practices and CIS benchmarks, and — via OSCAL-class machine-readable control formats — emits the audit evidence itself. Research is already demonstrating automated compliance checking of infrastructure code against policy (ARPaCCino, arXiv 2025); the direction of travel is compliance evaluated per commit, not per quarter.

Environment promotion with an evidence trail

  1. Commit → review. Traceability starts at the linked work item: requirement ID to branch to peer review. Nothing merges unreviewed, including infrastructure changes.
  2. Build → provenance → sign. Hermetic builds from source; SLSA provenance attached; artifact signed. The artifact hash is the join key for everything downstream.
  3. Test gates. Unit, integration, security scans (SCA, secrets, IaC policy, DAST) — every gate emits a machine-readable result into the artifact’s attestation record.
  4. Promotion with four-eyes. Deploying to production requires two distinct authorized identities, checked by the deploy system — the same control the change board provided, enforced in seconds with a log entry instead of a meeting with a minute.
  5. Progressive rollout. Staged deployments “fit the deployment process to the risk profile of a given service” (the SRE book’s staged-rollout principle): canary, verify SLOs, widen. Rollback is rehearsed, not theoretical.
  6. Archive. Every artifact, approval, scan result and deployment event lands in an append-only record. The audit is a query.

What the empirical record actually says

Two findings keep regulated CI/CD honest. First, CI adoption alone doesn’t deliver: a study of 250+ open-source and proprietary projects (Rahman et al.) found CI’s quality benefits in open source but “we cannot make similar observations” for proprietary projects — process discipline, not tooling presence, carries the value. Second, the systematic review of CI’s effects across 101 empirical studies (Soares et al., 2021) confirms broadly positive effects on cooperation and quality while cataloguing the technical and process challenges — the ones the pipeline-evidence discipline above is designed to absorb. And the foundational idea remains Humble and Farley’s deployment pipeline: automated build-deploy-test pipelines where “quality is built in,” keeping code “always in a deployable state” (continuousdelivery.com).

Auditor’s question, pipeline’s answer

“Show me what’s running and prove it’s authorized” — artifact hash → provenance → reviewed commit → approvals → policy verdicts → deployment record, in one query, for every release. If that chain has a manual link, that link is your next finding.

Build the pipeline your auditor trusts

Sources