How do team-owned automated acceptance checks differ from a business user acceptance sign-off?
answer
- Two activities, one name
- Repeatable machine check versus a one-off judgement
- Beware the ritual walk-through of known-green criteria
- Automation cannot audit its own premises
- Sign-off must name the exact build
basics
~20 sAutomated acceptance checks are owned by the delivery team and run on every build to prove the agreed criteria still hold. A user acceptance sign-off is the business owner's one-off judgement that the release is fit to use.
solid answer
~50 sThey answer two different questions. The automated checks answer *do the agreed criteria still hold on this build* -- repeatable, machine-run, cheap to repeat, and therefore also regression protection for the criteria themselves. The sign-off answers *is this fit for us to take live*, which is a judgement only the person accountable for the requirement can make, and it is made once per release against a named build. The two fail in opposite directions. If the business is asked to re-verify by hand what the automated checks already cover, the sign-off degrades into a rubber stamp and its scarce attention is wasted. If the automated pass is treated *as* the sign-off, nobody ever notices that a criterion itself was wrong. So automate the enumerated criteria, spend human attention on unwritten expectations and judgement calls, and record which build was signed, by whom, against which criteria.
go deeper
Be able to say who owns which: the delivery team writes and runs the automated acceptance checks on every build, while the business owner makes a separate, one-off decision that the release is fit to use.
Explain the mechanics and the two failure modes -- a sign-off degraded into re-walking automated criteria, and an automated pass substituted for judgement -- and describe how findings from a sign-off flow back into the criteria set.
Show how you protect the business owner's scarce attention: publish what the automated run already proves, set real tasks with real data instead of scripts, and treat every rejection as a criteria defect with a new check added.
Own the shape across teams: who is entitled to sign, what evidence a signature has to reference, how sign-off scales when releases become frequent, and when to replace a per-release ceremony with continuous evidence plus a fast rollback path.
### Two owners, two questions Inside the acceptance level there are two very different activities that share a name, and the interview question is really about telling them apart. **Team-owned automated acceptance checks.** Written by the delivery team, living in the same repository as the code, executed on every build. Each one corresponds to a stated criterion. Their question is narrow: *do the agreed criteria still hold?* Because they are cheap to repeat, they double as regression protection at the requirement level -- if someone later changes the archive path in a document e-signing flow, the check for "every signer receives a countersigned copy" fails on the build, not in a meeting three weeks later. **Business user acceptance sign-off.** Performed by the people accountable for the requirement -- the sponsor, the operating department, sometimes selected end users. Their question is broad: *is this fit for us to use?* It is a judgement, made once per release, against a specific build, and it can legitimately fail on something that no criterion mentioned: the wording is legally wrong for one jurisdiction, the flow needs six clicks where the old one needed two, the counter-signature ordering is unusable for their approval chain. ### The two ways this goes wrong The first failure is **the rubber stamp**. Business users are handed a script that walks the same 27 criteria the automated run already checked. They click through it, find nothing (of course -- a machine verified it an hour ago), sign, and everybody records that acceptance happened. The organisation now pays for the ritual and receives none of the judgement, and worse, the participants learn the exercise is pointless and delegate it downward until it is done by someone with no authority to reject anything. The second failure is **automation as sign-off**. The automated run is green, so the change ships. But every one of those checks was written from the same criteria, by the same team, with the same understanding. If the criterion itself was wrong -- if "notify the signer" was implemented and agreed as an in-product notice when the department needed a mailed copy for their records -- nothing in the pipeline can discover it. Automated checks are self-consistent by construction; they cannot audit their own premises. ### Dividing the work deliberately The useful split follows from the two questions: - **Automate everything enumerated.** Every criterion that can be stated as an observable outcome goes into the team-owned run and stays there forever, so it is checked on build 4471 and on every build after. - **Spend human sign-off on what was never written down.** Give the business owner the build, the list of what the automated run already proves, and time to try their real work: their documents, their approval chains, their awkward cases. Ask them explicitly for what is missing rather than for confirmation of what is present. - **Feed findings back into the criteria.** When a sign-off rejects something the automated checks pass, the outcome is a *criteria* change: amend or add the criterion, add the corresponding automated check, and note why it was missed. This is the loop that makes the level improve instead of repeating. ### The record matters as much as the activity A sign-off that does not name the build it applies to is worthless, because the build ships changed. The minimum record is: build identifier, the criteria set and its version, the automated run result, what the human reviewers exercised, who accepted, and when. That record is what lets you answer, months later, whether the behaviour now in production is the behaviour someone approved. ### A worked example of the gap In an e-signing rollout, all 27 criteria pass automatically. During sign-off the operations lead tries a real case: a round is abandoned midway with two of three signatures collected. The product voids the round and discards the partial signatures -- a partial-failure rollback the team chose sensibly and nobody had written down. For this department that is unacceptable: their counterparties will not re-sign, and they need the partial state preserved for 30 days. No automated check could have found this, because the behaviour matched every written criterion. That is precisely the value the human sign-off exists to add, and it only appears if the reviewer was asked to use the system rather than to re-walk the checklist. ### Saying it crisply in an interview "Automated acceptance checks tell me the agreed criteria still hold on this build; sign-off tells me the business is willing to take it live. I automate every criterion so the sign-off never spends its attention re-checking them, and I treat anything the sign-off rejects as a defect in the criteria, not just in the code."
- During sign-off the business rejects behaviour that every automated acceptance check passes. What has gone wrong, and what do you fix?The criteria were wrong or incomplete, not the checks. Amend or add the criterion with the requirement owner, add an automated check for the corrected behaviour so it is protected from now on, and record why the gap survived -- usually an assumption nobody stated. Changing only the code leaves the same blind spot in place for the next release.
- How do you stop a user acceptance sign-off turning into a second regression run?Give the reviewers the list of what the automated run already proves and explicitly ask them for what is missing instead of for confirmation of what is present. Set them real tasks with their own data rather than a step-by-step script, and timebox it. If the only thing a sign-off session ever produces is ticks against known criteria, it is costing attention and returning nothing.
- Who should own the automated acceptance checks -- the delivery team or a separate group?The delivery team, in the same repository as the code. Checks owned elsewhere drift out of step with the implementation, break with every refactor and end up disabled or ignored, and the people who could fix them fastest are not allowed to. The business owns the criteria and the sign-off decision; the team owns the executable checks that demonstrate the criteria.
saying these in an interview costs you the question
- Treats a green automated acceptance run as the business sign-off
- Hands business reviewers a script re-walking already-automated criteria
- Signs off without naming the build the decision applies to
- Fixes only the code when sign-off finds an unstated expectation
- Puts automated acceptance checks outside the delivery team's repository
- Believes the business must re-verify every criterion by hand