↓ Skip to main content

Definition of Done Acceptance Criteria Agile

Definition of Done vs Acceptance Criteria, With Examples

Acceptance criteria say what one story must do. The Definition of Done is the quality checklist every story must pass. How they differ, with examples and templates.

Definition of Done vs Acceptance Criteria, With Examples

Acceptance criteria are the conditions one user story has to meet before the product owner accepts it. They describe what this particular piece of work should do. The Definition of Done is a single checklist the whole team applies to every story, whatever it is: the quality bar the work has to clear before anyone calls it finished. Acceptance criteria answer “did we build the right thing?” and are different for every story. The Definition of Done answers “did we build it properly?” and barely changes from one sprint to the next. A story is done when it passes both.

People mix them up for understandable reasons. Both are lists of checkboxes, both sit at the bottom of a ticket, and both decide whether something gets to move to the last column of the board. The argument they cause usually goes like this. A developer says a story is done because it does everything the ticket asked for. Someone else says it isn’t, because it hasn’t been reviewed, or it’s only been tested on a laptop, or nobody has looked at the Korean error messages. They’re both right, about different lists. When I wrote down the team norms for the first team I managed, “what done actually means” was one of the unspoken assumptions on the list, and this distinction is most of the answer.

The difference in one table
#

Acceptance criteriaDefinition of Done
Applies toOne user story or backlog itemEvery item the team finishes
Question it answersDoes it do what this story needs?Is it built to our standard?
Written byThe product owner, refined with the developersThe whole team, or the organisation as a minimum
Written whenBefore the story enters a sprint, in refinementOnce, then revisited in retrospectives
How often it changesDifferent for every storyRarely, and it should only get stricter
In the Scrum Guide?Not mentionedYes, as the commitment for the Increment
Example“An expired reset link says so and offers a new one”“Reviewed by another developer, tests pass in CI”

The Scrum Guide row surprises people. The 2020 guide defines the Definition of Done as “a formal description of the state of the Increment when it meets the quality measures required for the product”, and says that an item that doesn’t meet it “cannot be released or even presented at the Sprint Review”. Acceptance criteria don’t appear in it at all. They come from the user story tradition, Extreme Programming and later behaviour-driven development, and most Scrum teams use them anyway because a story without them is an invitation to guess.

One story, both lists
#

Here’s a story most products have somewhere in their backlog:

As a customer who has forgotten my password, I want to reset it by email so that I can get back into my account.

Its acceptance criteria, written as Given/When/Then scenarios:

Scenario: Requesting a reset link
  Given I'm on the sign-in page
  When I choose "Forgot password" and enter the email address on my account
  Then I receive a reset link by email within a minute
  And the page tells me to check my inbox

Scenario: Email address with no account
  Given no account uses the address I enter
  When I request a reset link
  Then the page shows the same "check your inbox" message
  And no email is sent

Scenario: Expired link
  Given my reset link is more than 30 minutes old
  When I open it
  Then I see that the link has expired
  And I can request a new one from the same page

Scenario: Choosing the new password
  Given I've opened a valid reset link
  When I enter a new password that meets the password rules
  Then I'm signed in
  And the old password and any other reset links stop working

The second scenario is the kind of thing acceptance criteria are for. Showing the same message whether or not an account exists stops the form from telling strangers which email addresses are registered. That’s a product decision, someone has to make it, and the best time to make it is before anyone writes the code, not in a review comment afterwards.

And here’s the team’s Definition of Done. It’s the same for this story as for every other one:

- [ ] Code reviewed and approved by another developer
- [ ] Automated tests written for the new behaviour, all passing in CI
- [ ] Acceptance criteria checked on staging, not only locally
- [ ] No new errors in the error tracker after the staging deploy
- [ ] User-facing text added in every language the product supports
- [ ] API docs or changelog updated if behaviour changed
- [ ] Product owner has seen it working

Notice the third line. The Definition of Done says the acceptance criteria have to be met, and the acceptance criteria say what they are. That’s how the two lists connect, and it’s why neither one should try to do the other’s job.

Where the Definition of Ready fits
#

The third term in this family is the Definition of Ready: a short checklist a story has to meet before the team pulls it into a sprint. A typical one asks for acceptance criteria, an estimate, known dependencies, and a size the team can finish within the sprint. It isn’t in the Scrum Guide either. The 2020 guide only says that items “that can be Done by the Scrum Team within one Sprint are deemed ready for selection”.

So the order is: the Definition of Ready at the start, acceptance criteria written before the sprint and checked at the end, and the Definition of Done at the finish line. A story with no acceptance criteria isn’t ready. If it can’t get them because nobody knows enough yet, it probably needs a spike first. Keep the Definition of Ready short, though. Treated as a strict gate, it turns into a way of refusing work, and the useful conversations about a half-understood story stop happening.

Writing acceptance criteria that help
#

Describe what the user or the system does, not the tasks. “Create a reset_tokens table” is how you’ll build it, and it belongs in the developers’ plan. “The old password stops working” is what has to be true, and that’s a criterion.

Make each one pass or fail without debate. “The email arrives quickly” will be argued about at the review, and “within a minute” won’t.

Cover the unhappy paths. The expired link, the unregistered address and the second click on the same link are where the bugs live, and they’re also where the undecided product questions hide.

Aim for somewhere between three and seven. Much more than that and the story is usually two stories.

Pick the format per story. Given/When/Then comes from behaviour-driven development and maps directly onto automated tests and UAT scripts, which is why I like it for anything with a flow. A plain checklist is fine for simple rules (“the field accepts 1–200 characters”). Forcing every criterion into Given/When/Then just produces long sentences.

Write them in refinement, with developers in the room. The product owner owns them, but the people who’ll build the thing are the ones who ask “what happens if the link is opened twice?”

Writing a Definition of Done people actually use
#

Start with what the team already does on a good day, not with an aspirational list. A Definition of Done that everyone quietly skips half of is worse than none, because it teaches the team that the checklist is decoration.

Put it where the work happens. The teams I’ve worked on kept theirs on a wiki page. That beats not writing it down at all, but a page only gets read when someone remembers to open it, and that tends to be at the retrospective. A checklist in the pull request template gets ticked on every change:

<!-- .github/pull_request_template.md -->
## What changed and why

## Definition of Done
- [ ] Tests added or updated, passing in CI
- [ ] Acceptance criteria checked on staging
- [ ] New user-facing text added in every supported language
- [ ] Docs or changelog updated if behaviour changed

Make every line checkable. “Code is clean” isn’t a line anyone can tick honestly. “Reviewed and approved by another developer” is.

Raise the bar on purpose. When the team is comfortably meeting the current list, add the next thing, such as a feature flag for anything risky or an alert for anything new that can fail quietly. The retrospective is the natural place to decide that.

If several teams work on one product, the Scrum Guide says they “must mutually define and comply with the same Definition of Done”. And if the organisation has a standard one, every team follows it “as a minimum”, which leaves teams free to add to it but not to take anything away.

Mistakes I’d watch for
#

Copying the Definition of Done into every story’s acceptance criteria. “Tests written” and “code reviewed” don’t belong in a story. They bloat every ticket and hide the criteria that are actually about the story.

Acceptance criteria that are really tasks, or really designs. “Use a modal” is a design decision. “I can request a new link without leaving the page” is a criterion, and it leaves the designer room to do better than a modal.

Changing acceptance criteria halfway through the sprint without saying so. If the requirement has changed, that’s a conversation with the product owner and often a new story, not a quiet edit to the old one.

“Done, but not done-done.” If a story counts as done when it’s merged but before anyone has checked it on staging, the team is running two definitions and calling them one. Say in the Definition of Done exactly where done ends.

A Definition of Done so long that nobody can meet it in a sprint. Then everyone skips different lines and nobody says so.

How they connect to UAT
#

Acceptance criteria are the natural starting point for user acceptance testing: each scenario becomes a test case someone outside the team can follow. UAT also checks the criteria themselves. Sometimes users get through every scenario and still can’t do their job, which means the criteria were wrong, not the code. That’s useful to know before the next story is written.

Templates
#

Acceptance criteria:

**Story:** As a [kind of user], I want [goal] so that [reason].

**Acceptance criteria**
- Given [starting state], when [action], then [result].
- Given [starting state], when [action], then [result].
- Given [starting state], when [action], then [result].

**Out of scope:** [what this story deliberately doesn't do]

The “out of scope” line is optional, and I’d keep it. It ends a lot of review-time arguments before they start.

A starting Definition of Done, to cut down or add to:

- [ ] Code reviewed and approved by another developer
- [ ] Automated tests written and passing in CI
- [ ] Acceptance criteria checked on staging
- [ ] No new errors or warnings in monitoring after the staging deploy
- [ ] User-facing text added in every supported language
- [ ] Docs, changelog or release notes updated if behaviour changed
- [ ] Product owner has seen it working

The short version
#

Acceptance criteria belong to one story. They say what it must do, they’re written by the product owner with the team before the sprint, and they’re different every time. The Definition of Done belongs to the team. It’s one checklist of quality standards every story has to pass, it lives somewhere the team sees it on every change, and it only changes when the team decides to raise the bar. The Definition of Ready, if you use one, sits in front of both and says a story has enough detail, acceptance criteria included, to be worth starting.

Further reading
#

On this site:

Elsewhere: