PCAOB and the Auditor’s View of Your DevOps Pipeline: Making CI/CD SOX-Auditable

The moment a developer can push a commit that reaches production without a second person’s sign-off, you have a segregation-of-duties gap that a SOX auditor is trained to find — and modern CI/CD is built to make exactly that push effortless.

Continuous delivery and Sarbanes-Oxley were designed by people who never spoke. One optimises for the shortest path from a merged pull request to running code. The other assumes that the person who authors a change and the person who releases it are different people, that every production change is approved, and that you can prove both after the fact. Reconciling them is not a matter of slowing the pipeline down. It is a matter of putting the control inside the pipeline and letting it emit its own evidence.

What the auditor is actually testing

Start with who is on the other side of the table. The PCAOB does not audit your company. It was created by the Sarbanes-Oxley Act to oversee and inspect the firms that audit public companies. The practical consequence is that your external auditor is itself inspected, and an inspection finding against them for accepting weak evidence is a serious professional event. That is why a good auditor is conservative about what they will accept as proof that a control operated. When people say “a PCAOB-minded auditor”, they mean one who assumes their working papers will be re-examined.

Free · 4 minutes

Is your engineering team shipping safely, or quietly accumulating risk?

Fourteen questions on how work gets from idea to production — cadence, testing, rollback, and the key-person risk in your delivery. Banded finding on screen, full sheet by email.

The standard your auditor works to for the internal-control opinion is AS 2201, the integrated audit of internal control over financial reporting, formerly Auditing Standard No. 5. Under SOX Section 404 management asserts that its controls are effective and the auditor attests to that assertion. For any system that feeds the financial statements, the relevant controls are IT general controls — and within ITGC, the two your pipeline touches directly are change management and segregation of duties. The auditor is not asking whether your deployments are fast or your tests green. They are asking a narrower question: can an unauthorised or unreviewed change reach a financially relevant system, and can you show it cannot?

Where the control has to live now

In the old world the control lived in a change advisory board. A ticket was raised, a meeting approved it, someone from operations promoted the build, and the ticket was the evidence. That model does not survive contact with continuous delivery, because the whole point of the pipeline is that no human hands the artefact from one stage to the next. If you bolt a manual CAB on top, engineers route around it, and the approval becomes a formality applied after the fact — which is worse than no control, because it looks like assurance and provides none.

The control has to move to where the change actually flows. That means two enforced choke points. First, change authorship: a commit cannot become part of the release candidate on the protected branch without an independent reviewer’s approval. Second, release authorisation: the merged code cannot be promoted to production without a distinct approval by someone who did not write it. Get those two right and segregation of duties is structural rather than procedural. The person who authored the change is definitionally not the person who released it, because the platform will not let them be.

Branch protection and the deploy gate, as code

The reason to express these controls as code, rather than as settings clicked into a console, is that the auditor can then read the control itself, see it under version control, and see who changed it and when. The configuration becomes part of the evidence. Here it is for GitHub, using Terraform.

# Branch protection + production deploy gate as code (Terraform, GitHub provider).
# Encodes the two SOX ITGC controls an auditor tests on a pipeline:
# change approval, and segregation between a change's author and its releaser.

resource "github_branch_protection" "main" {
  repository_id = github_repository.app.node_id
  pattern       = "main"

  required_pull_request_reviews {
    required_approving_review_count = 1
    require_last_push_approval      = true   # author cannot approve their own final push
    dismiss_stale_reviews           = true   # new commits invalidate a stale approval
  }

  required_status_checks {
    strict   = true
    contexts = ["ci/tests", "policy/opa"]
  }

  enforce_admins = true                      # no bypass path, admins included
}

resource "github_repository_environment" "production" {
  repository  = github_repository.app.name
  environment = "production"

  reviewers {
    teams = [github_team.release_approvers.id]  # a team the authoring dev is not on
  }

  deployment_branch_policy {
    protected_branches     = true
    custom_branch_policies = false
  }
}

The line that does the segregation-of-duties work is require_last_push_approval: it stops a developer from slipping a change in after review and approving their own latest push. The production environment’s required reviewers are the release gate — the deployment job blocks until a named approver from a team the author is not on clicks Approve, and GitHub records who did in the deployment timeline. enforce_admins matters more than it looks: an auditor will specifically ask whether anyone can bypass the control, and a documented answer of “no, including administrators” closes that line of enquiry.

The evidence a PCAOB-minded auditor accepts

A control that operates but cannot be evidenced is, to an auditor, a control that did not operate. The evidence has to be produced by the system as a by-product of running, not assembled by a human at year-end. For each production release you want an immutable record that links the change to its approver: the commit SHA, the pull request and its independent reviewer, the release approver, the timestamp, and the deployed artefact’s digest. Think of it as a bill of materials for the deployment — the same discipline I have argued for elsewhere with a bill of materials for models, weights and training data, applied to the release rather than the model.

Two properties make that record hold up. It must be immutable — write-once storage or an append-only log the deploying identity cannot rewrite, so the evidence cannot be edited by the same people it constrains. And it must be complete: sampled correctly, a random production change from the period should trace cleanly to its reviewer and its approver with no gaps. Auditors test by sampling. One release in the sample that cannot show an independent approver is enough to put the whole control in question, because it demonstrates the control can be circumvented.

Where this quietly fails

The gaps are rarely in the happy path. They are in the exceptions. Hotfixes pushed straight to a release branch at two in the morning. Break-glass access that lets an on-call engineer deploy without the gate and is never reconciled afterwards. Infrastructure changes that reach production through a separate Terraform pipeline nobody thought to protect. Direct database migrations run by hand outside the application deploy. Service accounts and bots with production rights that no named human stands behind. Each is a legitimate operational need and each is a hole in segregation of duties unless it has its own compensating control — a second approver on the emergency path, an alert and mandatory post-hoc review on every break-glass event, the same branch protection and change discipline on the infrastructure and data-migration paths that you apply to application code. The same rigour that makes a versioned API contract governable, which I have written about in the context of designing the contract before the code, is what these side channels lack.

“Developers can deploy to production” does not have to be an audit finding. It becomes one only when the deploy is unreviewed, unlogged, and unprovable. Make the pipeline itself the control, let it write down who approved what, and the sentence changes meaning entirely: developers can deploy to production, because the platform will not let them do it alone.

Free interactive tool

Website compliance checklist

What your site has to do, based on what it actually does

Answer as much or as little as you like — the list builds as you go. Nothing is stored against your name and no email is required.

Can you trust the architecture you have?

Architecture diagrams rarely show the reality of how systems actually operate. An independent review establishes what is really there.