skip to content

An auditor asks which ruleset was live for each of last quarter's sweeps — what do you show?

level: seniorimportance: nice to knowfreq 35%

answer

  1. identify what ran, not whether it passed
  2. records point forward to a digest
  3. digests must resolve back to content
  4. mutable current destroys the record
  5. repository history is about source only

basics

~20 s

Each sweep record must carry the digest of the ruleset it loaded, and every published ruleset must still be retrievable by that digest so its rule text can be read back. A digest you can no longer resolve to content proves nothing.

solid answer

~50 s

The claim being tested is not `were you compliant` but `was the control you describe the one actually running`. That needs a two-sided binding. Forward: every sweep record names the digest of the ruleset it loaded. Backward: an archive of published rulesets addressed by digest, so any recorded digest resolves to exact rule text — including whether the encryption-at-rest rule was in it. On top of that, the publish log, so the sequence of digests across the quarter is continuous and every change has a who and a when. What usually makes this impossible is a distribution point that serves a mutable `current` name and overwrites it, so the old content is simply gone, or sweeps that recorded results without any ruleset identity. Note the limit: this establishes what ran, not that the estate was clean.

go deeper

for a junior

Know that proving which rules were running needs two things: the result records naming a ruleset, and a way to read that ruleset's text back later.

for a middle

Explain why a version label is weaker than a content digest, and why the source repository documents intent while the distribution point determines what actually ran.

for a senior

Walk an auditor through the chain end to end — per-run digests, a digest-addressed archive, a publish log with no gaps — and name the failure modes that break it, starting with mutable names.

for a principal

Decide what your organisation commits to attesting and for how long, and set the retention and immutability of published rulesets and run records so the commitment is reachable rather than aspirational.

## What the auditor is really asking When someone asks which ruleset was live, they are testing whether your description of the control matches the thing that executed. Everything downstream depends on it: a beautifully written control description is worth nothing if the enforcer was running something else. Answering well means producing a chain that someone who does not trust you can follow. ## The two-sided binding **Forward — every result names its ruleset.** Each sweep record carries the digest of the ruleset that was loaded for that run. Not a version string somebody typed, not the git branch it was supposed to come from: a digest over the content the enforcer actually held. A version label is an intention; a digest is an observation. **Backward — every digest resolves to content.** An archive of published rulesets, addressed by digest and written append-only, so any digest in any record can be exchanged for the exact rule text months later. Without this half, the digests in your records are opaque strings. You can prove the ruleset did not change between March and May, and still be unable to say what it contained. The two halves fail independently, and organisations routinely have one without the other. ## The publish log makes the sequence legible Digests alone give you a set of points. The publish log — who published, when, resulting in which digest — turns them into a story with no gaps: every digest that appears in a sweep record traces to a publish event, and every publish event traces to a reviewed change. Two things should draw attention immediately. A digest that appears in run records with no corresponding publish event means something reached the enforcer outside the pipeline. A publish event whose digest never appears in any run means what you shipped is not what is running. ## Why the rule repository's history is not the answer Candidates reach for the source repository first, and it is the wrong artifact. Repository history is evidence about the *source*: what was proposed, reviewed and merged. What the enforcer loaded came from the *distribution point*. Between the two sits a publishing step, and that step is precisely where they can diverge — a build that packaged a stale working tree, a job that published from the wrong branch, a hand-placed object, a compromised credential. Offering commit history is asserting that source and served content matched, when the whole question is whether they did. Digests recorded at both ends turn that assertion into a comparison. ## The failure modes that make this unanswerable - **Mutable names.** The distribution point serves one object under a name like `current` and each publish overwrites it. You may still have digests in your records, but the content behind the old ones no longer exists anywhere. - **Results without identity.** Sweep output stored findings and timestamps but never the ruleset. Now you are reconstructing from deployment history and hoping. - **Retention shorter than the audit period.** Run records aged out after thirty days while the question covers ninety. - **Digests over the wrong thing.** A digest computed over the archive you built rather than the content the enforcer loaded — it proves what you published, not what ran. ## What to do when you do not have it Say so, precisely, and bound the claim: name the period you can attest to, describe what is missing and why, and state the change you are making so the next quarter is answerable. Auditors deal with imperfect evidence constantly; the thing that damages you is an overstated claim that unravels under one follow-up question. If a gap appears in the sequence — a digest with no publish record — investigate it as an unexplained change to a control and report the outcome, rather than leaving it as a blank in the table. ## What this evidence does and does not support It supports one specific sentence: *for each sweep in the period, the ruleset loaded was this one, and here is its text*. It does not establish that the rules were correct, that they covered every control you claim, or that the enumeration reached the whole estate. Those are separate claims needing separate evidence, and volunteering that boundary yourself reads as competence rather than weakness.

  • Why is the rule repository's commit history not sufficient evidence?
    It documents the source, not what was served. The enforcer loaded from the distribution point, and the publishing step between them is exactly where the two can diverge — a stale build, the wrong branch, a hand-placed object. Digests recorded at both ends make it a comparison rather than an assertion.
  • The auditor finds a fortnight where the live digest changed with no publish record. What now?
    Treat it as an unexplained change to a control and investigate it as an incident: reconstruct from the store's own object and access history, identify the credential used, and state plainly in the evidence which period you can attest to. An honest, investigated gap is far stronger than a papered-over one.
  • What can you legitimately claim from this evidence?
    That a specific ruleset, whose text you can produce, was the one loaded for each sweep in the period. Not that it was correct, not that it covered every control, and not that enumeration reached the whole estate. Naming that boundary yourself is what makes the rest credible.

saying these in an interview costs you the question

  • Offers the rule repository's history as proof of what ran
  • Overwrites the published ruleset under a mutable name
  • Records sweep results with no ruleset identity at all
  • Claims a live ruleset proves the estate was compliant
  • Keeps run records for less time than the audit period

context