Business Analysis Canada Blog

Testable or Not Written: How to Write Acceptance Criteria Developers and Testers Can Use

by
Nov 2, 2026
.
Testable or Not Written: How to Write Acceptance Criteria Developers and Testers Can Use
Book a Free Consultation

Acceptance criteria are the conditions a piece of work must meet before the business accepts it, written so that a developer can build to them and a tester who missed every meeting can run them. A criterion is testable when it names an actor, a context, a trigger, an observable result, and a value; it fails when it uses an adjective where a number belongs. Given-When-Then fits behavior that depends on state and a trigger; a plain checklist fits data rules, lists, and thresholds. Each criterion becomes one or more UAT scripts, and the sign-off pack counts coverage against the criteria, not the scripts. This guide covers the two formats, the anatomy of a testable criterion, ten weak examples rewritten with their tests, and how criteria carry through to sign-off.

Introduction

The story said: "As a finance manager I want to approve invoices so that payments go out on time." The acceptance criterion underneath it said: "The system allows the finance manager to approve invoices." Development built an Approve button. Testing clicked it. Both passed. Three weeks after go-live, finance discovered that anyone with the finance manager role could approve their own expense claims, and that an invoice above the delegation limit went out with one signature instead of two.

Nothing in that story was false. It simply had no criteria in it, only the story restated as a sentence with "the system allows" in front. If your backlog is full of criteria like that, you are not alone, and the fix is not a template. It is a rule about what a criterion has to contain before anyone is allowed to call it one.

What are acceptance criteria?

Acceptance criteria are the specific, checkable conditions a requirement or user story must satisfy before the business accepts it as done. They are written before build, agreed by the person who will accept the work, and used three times: by the developer to know what to build, by the tester to know what to check, and by the process owner at UAT to know what they are signing.

The user story is the frame around them, and it is worth one paragraph. A story names a role, a goal, and a reason: who wants what, and why. It is deliberately short and deliberately vague about the how. The acceptance criteria are where the vagueness ends. A story with no criteria is a wish; a story with criteria that restate the wish is the example in the introduction. The format of the story matters much less than whether the criteria beneath it can be failed.

That last phrase is the working definition. A criterion is only a criterion if there is a way for the system to fail it. "The system allows the finance manager to approve invoices" cannot fail short of the button being missing. "An invoice above the approver's delegation limit cannot be approved by that approver; the Approve button is disabled and the message 'Requires second approval above $25,000' is shown" fails in six distinct ways, and each one is a test.

Key Takeaway: A criterion is something the system can fail. If you cannot describe the failing case, you have restated the story, not written a criterion.

Given-When-Then or checklist: which format fits which requirement?

Use Given-When-Then for behavior that depends on a starting state and a trigger; use a checklist for rules, lists, and thresholds that apply regardless of sequence. Teams that force every criterion into one format produce either unreadable scenario walls or checklists that hide the state the rule depends on.

Given-When-Then describes a scenario: given a context, when an action happens, then an observable result follows. It is built for workflow. "Given an invoice of $30,000 awaiting approval and an approver whose delegation limit is $25,000, when the approver opens the invoice, then the Approve button is disabled and the second-approval message is shown." Every element a tester needs is present: the data to set up, the action to take, the thing to look at. Its weakness is volume; a screen with twelve rules becomes twelve scenarios, and the reader loses the rules in the scaffolding.

A checklist fits the rules themselves. "Postal code accepts the Canadian format A1A 1A1 with or without the space, rejects any other pattern with the message 'Enter a valid Canadian postal code', and stores the value with the space." No state, no trigger, three checkable facts. Data validation, field lists, calculation rules, permissions matrices, and non-functional thresholds read better this way. Non-functional requirements as a category are covered in their own guide; here the point is only that a threshold is a checklist item, not a scenario.

The choice is per criterion, not per project. A story about invoice approval will carry Given-When-Then scenarios for the approval paths and a checklist for the field rules on the invoice form. The pattern we see most often is a team that adopted Given-When-Then as a standard and now writes "Given the user is on the form, when they look at the postal code field, then it validates correctly," which is a checklist item wearing a costume and has lost its value in the process.

The failure in the introduction was neither format. It was a criterion with no content, and the fix is the same in both: name the actor, the state, the action, the result, and the number. ID Business Analysis Canada writes criteria to that rule inside a Requirements Engagement, with the tester reviewing each one before the story is estimated, which is how the Woodlands ERP enhancements work ran: user stories with Given/When/Then acceptance criteria across four release cycles, and fewer defects reaching production because the criteria were testable before build rather than interpreted during it.

Key Takeaway: Scenarios for behavior that depends on state and trigger; checklists for rules and thresholds. Pick per criterion, and never let the format substitute for the content.

What makes an acceptance criterion testable?

Six parts, and a criterion that is missing any of them will be interpreted by whoever builds it. The actor, by role. The context, meaning the state the system and data are in before anything happens. The trigger, one action. The observable result, something a tester can see, read, or measure without asking a developer what happened inside. The value, a number, a message text, a state name, or a time. And the boundary, what happens at the edge of the rule and when the input is wrong.

Three habits produce most untestable criteria. Adjectives in place of values: "quickly," "appropriate," "user-friendly," "correctly." Each one is a decision deferred to the developer, who will decide it differently from the tester, who will decide it differently from the process owner. Replace every adjective with the number or the text it stands for; if nobody can supply the number, the requirement is not understood yet, and that is worth knowing before build. Compound criteria: "the user can search by name, date, or amount and export the results" is four criteria and will be tested as one, which means three of them will not be tested. One condition per criterion. And missing negatives: criteria describe what happens when everything is right and say nothing about the wrong input, the expired session, the duplicate record, the amount of zero. The negative paths are where production incidents live, and a criterion set with no negatives is half a set.

The test for a finished criterion is a person. Hand it to a tester who was not in the workshop and ask them to write the script. If they come back with a question, the question is the missing part. If they come back with a script, the criterion is done.

Key Takeaway: Actor, context, trigger, observable result, value, boundary. Delete every adjective, split every "and," and write the negative path, or the developer writes them for you.

What are examples of good and bad acceptance criteria?

Ten pairs, each a criterion the way it usually arrives and the rewrite, with the test the rewrite produces. They cover the cases that recur on business systems: approval limits, validation, search, export, permissions, notifications, performance, language, and accessibility.

As it arrives Rewritten The test it produces
The system allows the finance manager to approve invoices. Given an invoice awaiting approval within the approver's delegation limit, when the approver selects Approve, then the invoice status changes to Approved, the approver's name and timestamp are recorded, and the invoice appears in the payment run queue. Approve a $10,000 invoice as a $25,000 approver; check status, audit record, and queue.
Approvals respect delegation limits. Given an invoice above the approver's delegation limit, when the approver opens it, then Approve is disabled and the message "Requires second approval above $25,000" is shown; the invoice cannot be approved by that user through any route. Open a $30,000 invoice as a $25,000 approver; attempt approval through the screen and the bulk action.
Users cannot approve their own claims. Given an expense claim where the submitter and the approver are the same user ID, when the approval queue is loaded, then the claim is excluded from that user's queue and routed to their manager. Submit a claim as the approver's own ID; confirm it is absent from their queue and present in the manager's.
The postal code field is validated. Postal code accepts the format A1A 1A1 with or without the space, rejects any other pattern with "Enter a valid Canadian postal code," and stores the value with the space. Enter K1A0B1, K1A 0B1, 90210, and blank; check acceptance, message, and stored value.
Search returns relevant results quickly. Given 500,000 customer records, when the user searches by exact customer number, then the matching record is returned first within 2 seconds; a search with no match returns "No customers found" within 2 seconds. Time an exact-number search and a no-match search against the full test data set.
The report can be exported. When the user selects Export on the aged receivables report, then a .xlsx file downloads within 10 seconds containing the same rows, columns, and totals as the on-screen report, with the report date in the filename. Export, open the file, reconcile row count and totals to the screen, check the filename.
Only authorized users can see salary data. Given a user without the Payroll Viewer role, when they open an employee record, then the salary fields are not rendered and the record export omits them; the attempt is written to the access log. Open and export a record as a non-payroll user; inspect the screen, the file, and the log.
The requester is notified when the request is approved. When a request status changes to Approved, then an email is sent to the requester's address on file within 5 minutes with the request number and approver name in the body; if sending fails, the failure is logged and retried once. Approve a request; check the inbox, timing, body content, and the failure path with an invalid address.
The application supports French. Given the user's language preference is French, when any page in the payment path loads, then all labels, messages, and dates are shown in French with the date format AAAA-MM-JJ, and no English string appears. Walk the payment path in French; log every English string and every date format.
The form is accessible. Every field on the form has a visible label and a programmatic label, all functions are reachable by keyboard in a logical order, and error messages are announced by a screen reader; the form passes the agreed WCAG 2.1 AA checks. Complete the form by keyboard only and with a screen reader; run the automated checker and record the result.

Two things to notice across the ten. Every rewrite is longer, and the length is all content: a value, a message, a state, a path. And every rewrite produced a test without anyone having to interpret it, which is the point. The tester did not need to attend the workshop. The weak versions, by contrast, produced ten tests that would all have passed on the day the Approve button appeared.

Key Takeaway: If the rewrite is not longer than the original, it has not added a value, a state, or a negative path. Length that is all content is what testable looks like.

How do acceptance criteria connect to UAT and sign-off?

Each criterion becomes at least one UAT script, each script records who ran it and what happened, and the sign-off pack reports coverage against the criteria rather than against the scripts. That chain is the reason to write criteria well in the first place: a weak criterion produces a weak script, the weak script passes, and the sign-off reports a pass rate that means nothing.

The script is the criterion with setup and steps added: the data to create, the role to log in as, the actions in order, and the expected result copied from the criterion's "then." A criterion with a value makes this mechanical. A criterion without one makes the tester invent the expected result, which is a requirements decision taken in test by the person least placed to take it. The UAT guide covers who runs the scripts and who signs; the requirements verification guide covers deriving tests as a check on the requirements themselves. Between those two sits the criterion, and its quality decides both.

Coverage is counted against criteria for a reason the introduction's story shows. A story with one criterion and one script reports 100% coverage and misses the delegation limit, the self-approval rule, and the second signature. The same story with eight criteria and eight scripts reports the same percentage and has tested the business rule. Pass rates compare nothing unless the denominator is the criteria, and the criteria are complete.

One more consequence for teams building anything with a model in it. Criteria for AI-assisted features need the same six parts and an extra one, the accepted error, because the result is not deterministic; the BRD for AI features guide covers how to write that boundary. The rule is unchanged: if the criterion cannot be failed, it has not been written.

Key Takeaway: Count coverage against criteria, not scripts, and write each criterion so the expected result can be copied into the script rather than invented there.

Frequently Asked Questions

What is the difference between acceptance criteria and a definition of done?Acceptance criteria belong to one story or requirement and describe what that piece of work must do to be accepted: the behavior, the rules, the values. A definition of done applies to every story on the team and describes the state work must reach regardless of content: code reviewed, unit tests passing, deployed to the test environment, documentation updated. A story can meet the definition of done and fail its acceptance criteria, which means it was built properly and built wrong.

How many acceptance criteria should a user story have?Three to seven for most stories. Fewer than three usually means the negative paths are missing; more than seven usually means the story is two stories. The count matters less than the coverage: at least one criterion for the main path, one for each business rule the story touches, and one for each way the input or the state can be wrong. A story about an approval will carry more because it has limits, roles, and exceptions; a story about a label change may need one.

Who writes acceptance criteria?The business analyst drafts them with the person who will accept the work, and the tester reviews them before the story is estimated. The analyst brings the structure, the process owner brings the values and exceptions, and the tester's review is the first test: if they cannot write the script from the criterion, it goes back. Developers read them before estimating and may reject any criterion with an adjective in it. What fails is the developer or tester writing them alone afterward, which produces criteria that describe what was built.

How do we fix a backlog full of untestable criteria?Do not rewrite the whole backlog. Take the next two sprints' worth of stories and run each criterion through the six-part check: actor, context, trigger, observable result, value, boundary. Rewrite the ones that fail, split the compound ones, and add the negative paths. ID Business Analysis Canada does this as a scoped pass inside a Requirements Engagement, with a business analyst working the near-term backlog with the process owner and the test lead and returning criteria the tester can script without a meeting. Stories further out get fixed at refinement.

Conclusion

The Approve button worked. The criterion said the system allows the finance manager to approve invoices, and it did, including her own expenses and the ones above her limit. The criterion was not wrong. It was empty, and an empty criterion is filled in by whoever builds it, then whoever tests it, then whoever discovers the gap in production.

If your stories carry criteria that restate the story, ID Business Analysis Canada's Analysis & Design practice rewrites them to the six-part rule inside a Requirements Engagement, with the process owner supplying the values and the test lead confirming each one can be scripted before the story is estimated. Book a free consultation and bring the next sprint's stories; the first thing we will do is count the adjectives.

Sources

  1. Business Analysis Canada, Woodlands ERP enhancements and support, case study: user stories with Given/When/Then acceptance criteria, four release cycles, fewer defects reaching production.
  2. Business Analysis Canada, UAT Testing Explained, business-analysis.ca blog, October 2026.
  3. Business Analysis Canada, Prove It Early: Requirements Verification Methods That Catch Defects Before Build, business-analysis.ca blog, September 2026.
  4. Business Analysis Canada, Business Requirements Document for AI Features, business-analysis.ca blog.
  5. Business Analysis Canada, Under the Hood: Why Complex Initiatives Need a Technical Business Analyst, business-analysis.ca blog, August 2026.