Acceptance criteria that business users can sign off describe observable behaviour in the users' own vocabulary, with one testable statement per rule, explicit exclusions and a named person who approves each one. Write them before build starts, and test each line against a real workflow.
Key takeaways
- Write each criterion as behaviour a user can observe, not as an implementation detail.
- Use the vocabulary of the people who will approve the work, and define any term they could read differently.
- State exclusions explicitly, because unstated scope tends to surface as a dispute after delivery.
- Pair each criterion with an example input and an expected result that a non-technical reviewer can check.
- Agree on the sign-off owner and keep a written record before development begins.
What makes an acceptance criterion signable?
A signable criterion is one a business reviewer can read, understand and check without asking an engineer what it means. It describes a result the user sees, such as an order appearing in a shared list on the same screen, rather than how the code produces it.
Three properties separate signable criteria from wishes. They are observable, so someone can watch the system and say yes or no. They are scoped, so the boundary of the rule is written down. They are owned, so a named person accepts the outcome.
How do you write each criterion?
Write each criterion as a short statement with a trigger, a condition and a result. Keep one behaviour per line, so that a rejected line does not block the whole story.
- Start from the user's goal and list the situations in which it can fail, including the unhappy paths.
- Replace adjectives such as fast, easy or accurate with the observable event that proves them.
- Attach one concrete example with realistic values and the expected outcome.
- Name every term that has a company-specific meaning, such as what counts as an approved invoice.
- Write exclusions as explicit lines, for example that bulk import is out of scope for this release.
If the work is a new internal tool, the same wording discipline applies to requirements gathered for custom software development, where reviewers often hold different mental models from the developers building the screens.
Which format suits business reviewers?
A short checklist suits simple rules, Given-When-Then scenarios suit rules with a clear trigger and state, and a worked example table suits calculations and field mappings. Most teams combine two of these for a single story.
| Format | Best for | Main weakness |
|---|---|---|
| Checklist of observable statements | Screens, permissions and simple outputs | Misses sequence, timing and state changes |
| Given-When-Then scenarios | Workflows with a clear trigger and state | Verbose for long rules and easy to over-specify |
| Worked example table | Calculations, pricing rules and mappings between fields | Shows only the rows someone chose to add, so edge cases stay hidden |
Checklists fail when the order of events matters, because a reviewer can tick every box and still miss a step that happens too early. Scenarios fail when they are written in technical language or when every minor detail becomes a scenario. Example tables fail silently, so they need a row for each boundary the reviewer cares about.
Where does sign-off usually fail?
Sign-off usually fails when criteria are vague, when they hide technical terms, or when nobody has defined what evidence counts as proof. Each failure looks minor at writing time and becomes expensive at review.
Vague adjectives
Words such as quick, intuitive or reliable cannot be tested by a reviewer with a stopwatch and a list of steps. Replace them with the event, the screen or the message that makes the claim true or false.
Hidden technical terms
Terms such as idempotent, synced or cached may be accurate, but they invite reviewers to approve something they do not understand. Describe the visible effect instead, and keep the technical term in a note for the development team.
Missing exclusions
When a criterion does not say what is excluded, the reviewer assumes the widest reading. Write a short out-of-scope list beside the criteria and ask the approver to confirm it explicitly.
Undefined evidence
If nobody agrees how a criterion is shown to be met, sign-off becomes a demonstration with no record. State the evidence for each line, such as a recorded run with named test data or a screenshot of the resulting record.
How do you cover exceptions and non-functional needs?
Cover exceptions as separate criteria, and state non-functional needs as targets the owner agrees to, each with a stated test method. Performance, security and recovery requirements written as adjectives cannot be signed off.
When a feature moves data between systems, criteria should describe what happens when the other system is unavailable or returns an unexpected value. Projects of this kind usually need their own failure criteria, and the system integration services page describes the kind of connected-system work where these cases arise.
Hypothetical examples of approval wording
Here are two hypothetical scenarios:
Scenario one, weak wording: the system should send reminders quickly to overdue customers. The reviewer cannot tell what triggers a reminder, who receives it, or what counts as quick, so approval would rest on trust.
Scenario two, signable wording: when an invoice is past its due date by a number of days set in the billing settings and has no open dispute, the system sends one reminder email to the billing contact on the customer record. An invoice with an open dispute receives no reminder, and the dispute owner receives a notification instead. A reviewer can test both branches with two prepared invoices.
The second version works because each branch has a trigger, a result and a test the reviewer can run. It also states what does not happen, which is where most disagreements begin.
What should the sign-off process look like?
A sign-off process works when the owner reviews criteria in one session using realistic example data, records each decision, and routes later changes through a written change request. Verbal agreement without a record usually returns as a dispute after delivery.
- Send the criteria and the out-of-scope list at least a working day before the review, so the approver can prepare questions.
- Walk through each example with the approver, and mark every line as approved, rejected or needs rewording.
- Record the approver's name, the date and the version number in the ticket or document.
- Freeze the approved version as the baseline for testing and acceptance.
- Route every later change through a short change request that states what changed, why, and who approved it.
Teams selecting an outside partner for this kind of work can compare approaches in this guide to choosing a software development partner in Belgium, which covers how requirements are documented and reviewed.
Conclusion
Acceptance criteria that business users can sign off are observable, scoped and owned. They name the trigger and the result, they state what is excluded, and they show the evidence that will be used to decide. Writing them this way costs some time at the start, but it moves disagreements to the moment when changes are cheap. If you want a second engineering review of your criteria before development begins, request a project consultation at the Rui Codex contact page, or email info@ruicodex.com to discuss your project.
Frequently Asked Questions
What is the difference between acceptance criteria and a user story?
A user story states who needs what and why, while acceptance criteria state the conditions under which the story counts as done. The story is the request and the criteria are the test the reviewer applies to the finished result. Keeping them separate lets the reviewer approve the outcome without rereading the goal each time.
Who should sign off acceptance criteria?
The person who owns the business outcome should sign off, usually a process owner or operations lead, with the development lead confirming that the criteria are feasible. Name one approver per story so that accountability is not spread across a group. Record the approval in the ticket with the date and the version of the criteria.
How many acceptance criteria should one user story have?
Most stories need only a handful of criteria, and a story with a very long list is often two stories. If the list grows, split the work by outcome so each part can be reviewed and released separately. Include the unhappy paths in the count, since they frequently make up a large share of the list.
Can acceptance criteria change after development has started?
Yes, but changes should go through a written change request that states what changed, why, and who approved it. Treat the approved version as a baseline so the team can measure delivery against what was agreed. Wording fixes that do not alter behaviour can be recorded as clarifications.