<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/">
  <channel>
    <title>Acceptance Criteria · Jared Lynskey</title>
    <link>https://jared.lynskey.co.nz/en/tags/acceptance-criteria/</link>
    <description>Short stories of value on software engineering and engineering leadership — performance reviews, hiring and scaling teams, CI/CD, DevOps monitoring and agentic AI. Written from Seoul.</description>
    <generator>Hugo</generator>
    <language>en</language>
    <copyright>© 2026 Jared Lynskey</copyright>
    <lastBuildDate>Mon, 16 Nov 2026 00:00:00 +1300</lastBuildDate>
    <atom:link href="https://jared.lynskey.co.nz/en/tags/acceptance-criteria/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Definition of Done vs Acceptance Criteria, With Examples</title>
      <link>https://jared.lynskey.co.nz/en/posts/2026/definition-of-done-vs-acceptance-criteria/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/en/posts/2026/definition-of-done-vs-acceptance-criteria/</guid>
      <pubDate>Mon, 16 Nov 2026 00:00:00 +1300</pubDate>
      <dc:creator>Jared Lynskey</dc:creator>
      <category>Definition of Done</category>
      <category>Acceptance Criteria</category>
      <category>Agile</category>
      <category>Scrum</category>
      <category>User Stories</category>
      <category>Sprint Planning</category>
      <category>User Acceptance Testing</category>
      <category>Managing</category>
      <description>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.</description>
      <content:encoded><![CDATA[<p>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 &ldquo;did we build the right thing?&rdquo; and are different for every story. The Definition of Done answers &ldquo;did we build it properly?&rdquo; and barely changes from one sprint to the next. A story is done when it passes both.</p>
<p>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&rsquo;t, because it hasn&rsquo;t been reviewed, or it&rsquo;s only been tested on a laptop, or nobody has looked at the Korean error messages. They&rsquo;re both right, about different lists. When I wrote down the <a href="https://jared.lynskey.co.nz/en/posts/2024/2024-05-05-team-norms/" >team norms</a> for the first team I managed, &ldquo;what done actually means&rdquo; was one of the unspoken assumptions on the list, and this distinction is most of the answer.</p>

<h2 class="relative group">The difference in one table
    <div id="the-difference-in-one-table" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#the-difference-in-one-table" aria-label="Anchor">#</a>
    </span>
    
</h2>
<table>
	<thead>
			<tr>
					<th></th>
					<th>Acceptance criteria</th>
					<th>Definition of Done</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Applies to</td>
					<td>One user story or backlog item</td>
					<td>Every item the team finishes</td>
			</tr>
			<tr>
					<td>Question it answers</td>
					<td>Does it do what this story needs?</td>
					<td>Is it built to our standard?</td>
			</tr>
			<tr>
					<td>Written by</td>
					<td>The product owner, refined with the developers</td>
					<td>The whole team, or the organisation as a minimum</td>
			</tr>
			<tr>
					<td>Written when</td>
					<td>Before the story enters a sprint, in refinement</td>
					<td>Once, then revisited in retrospectives</td>
			</tr>
			<tr>
					<td>How often it changes</td>
					<td>Different for every story</td>
					<td>Rarely, and it should only get stricter</td>
			</tr>
			<tr>
					<td>In the Scrum Guide?</td>
					<td>Not mentioned</td>
					<td>Yes, as the commitment for the Increment</td>
			</tr>
			<tr>
					<td>Example</td>
					<td>&ldquo;An expired reset link says so and offers a new one&rdquo;</td>
					<td>&ldquo;Reviewed by another developer, tests pass in CI&rdquo;</td>
			</tr>
	</tbody>
</table>
<p>The Scrum Guide row surprises people. The 2020 guide defines the Definition of Done as &ldquo;a formal description of the state of the Increment when it meets the quality measures required for the product&rdquo;, and says that an item that doesn&rsquo;t meet it &ldquo;cannot be released or even presented at the Sprint Review&rdquo;. Acceptance criteria don&rsquo;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.</p>

<h2 class="relative group">One story, both lists
    <div id="one-story-both-lists" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#one-story-both-lists" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>Here&rsquo;s a story most products have somewhere in their backlog:</p>
<blockquote><p>As a customer who has forgotten my password, I want to reset it by email so that I can get back into my account.</p>
</blockquote><p>Its acceptance criteria, written as Given/When/Then scenarios:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gherkin" data-lang="gherkin"><span class="line"><span class="cl"><span class="k">Scenario:</span><span class="nf"> Requesting a reset link
</span></span></span><span class="line"><span class="cl"><span class="k">  Given </span><span class="nf">I&#39;m on the sign-in page
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">When </span><span class="nf">I choose &#34;</span><span class="s">Forgot password</span><span class="nf">&#34; and enter the email address on my account
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">Then </span><span class="nf">I receive a reset link by email within a minute
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">And </span><span class="nf">the page tells me to check my inbox
</span></span></span><span class="line"><span class="cl"><span class="nf">
</span></span></span><span class="line"><span class="cl"><span class="k">Scenario:</span><span class="nf"> Email address with no account
</span></span></span><span class="line"><span class="cl"><span class="k">  Given </span><span class="nf">no account uses the address I enter
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">When </span><span class="nf">I request a reset link
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">Then </span><span class="nf">the page shows the same &#34;</span><span class="s">check your inbox</span><span class="nf">&#34; message
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">And </span><span class="nf">no email is sent
</span></span></span><span class="line"><span class="cl"><span class="nf">
</span></span></span><span class="line"><span class="cl"><span class="k">Scenario:</span><span class="nf"> Expired link
</span></span></span><span class="line"><span class="cl"><span class="k">  Given </span><span class="nf">my reset link is more than </span><span class="s">30</span><span class="nf"> minutes old
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">When </span><span class="nf">I open it
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">Then </span><span class="nf">I see that the link has expired
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">And </span><span class="nf">I can request a new one from the same page
</span></span></span><span class="line"><span class="cl"><span class="nf">
</span></span></span><span class="line"><span class="cl"><span class="k">Scenario:</span><span class="nf"> Choosing the new password
</span></span></span><span class="line"><span class="cl"><span class="k">  Given </span><span class="nf">I&#39;ve opened a valid reset link
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">When </span><span class="nf">I enter a new password that meets the password rules
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">Then </span><span class="nf">I&#39;m signed in
</span></span></span><span class="line"><span class="cl"><span class="nf">  </span><span class="k">And </span><span class="nf">the old password and any other reset links stop working</span></span></span></code></pre></div></div>
<p>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&rsquo;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.</p>
<p>And here&rsquo;s the team&rsquo;s Definition of Done. It&rsquo;s the same for this story as for every other one:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-markdown" data-lang="markdown"><span class="line"><span class="cl"><span class="k">- [ ]</span> Code reviewed and approved by another developer
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Automated tests written for the new behaviour, all passing in CI
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Acceptance criteria checked on staging, not only locally
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> No new errors in the error tracker after the staging deploy
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> User-facing text added in every language the product supports
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> API docs or changelog updated if behaviour changed
</span></span><span class="line"><span class="cl">- [ ] Product owner has seen it working</span></span></code></pre></div></div>
<p>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&rsquo;s how the two lists connect, and it&rsquo;s why neither one should try to do the other&rsquo;s job.</p>

<h2 class="relative group">Where the Definition of Ready fits
    <div id="where-the-definition-of-ready-fits" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#where-the-definition-of-ready-fits" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>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&rsquo;t in the Scrum Guide either. The 2020 guide only says that items &ldquo;that can be Done by the Scrum Team within one Sprint are deemed ready for selection&rdquo;.</p>
<p>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&rsquo;t ready. If it can&rsquo;t get them because nobody knows enough yet, it probably needs a <a href="https://jared.lynskey.co.nz/en/posts/2023/2023-10-18-spike/" >spike</a> 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.</p>

<h2 class="relative group">Writing acceptance criteria that help
    <div id="writing-acceptance-criteria-that-help" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#writing-acceptance-criteria-that-help" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>Describe what the user or the system does, not the tasks. &ldquo;Create a reset_tokens table&rdquo; is how you&rsquo;ll build it, and it belongs in the developers&rsquo; plan. &ldquo;The old password stops working&rdquo; is what has to be true, and that&rsquo;s a criterion.</p>
<p>Make each one pass or fail without debate. &ldquo;The email arrives quickly&rdquo; will be argued about at the review, and &ldquo;within a minute&rdquo; won&rsquo;t.</p>
<p>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&rsquo;re also where the undecided product questions hide.</p>
<p>Aim for somewhere between three and seven. Much more than that and the story is usually two stories.</p>
<p>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 (&ldquo;the field accepts 1–200 characters&rdquo;). Forcing every criterion into Given/When/Then just produces long sentences.</p>
<p>Write them in refinement, with developers in the room. The product owner owns them, but the people who&rsquo;ll build the thing are the ones who ask &ldquo;what happens if the link is opened twice?&rdquo;</p>

<h2 class="relative group">Writing a Definition of Done people actually use
    <div id="writing-a-definition-of-done-people-actually-use" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#writing-a-definition-of-done-people-actually-use" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>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.</p>
<p>Put it where the work happens. The teams I&rsquo;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:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-markdown" data-lang="markdown"><span class="line"><span class="cl"><span class="cm">&lt;!-- .github/pull_request_template.md --&gt;</span>
</span></span><span class="line"><span class="cl"><span class="gu">## What changed and why
</span></span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="gu">## Definition of Done
</span></span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Tests added or updated, passing in CI
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Acceptance criteria checked on staging
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> New user-facing text added in every supported language
</span></span><span class="line"><span class="cl">- [ ] Docs or changelog updated if behaviour changed</span></span></code></pre></div></div>
<p>Make every line checkable. &ldquo;Code is clean&rdquo; isn&rsquo;t a line anyone can tick honestly. &ldquo;Reviewed and approved by another developer&rdquo; is.</p>
<p>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 <a href="https://jared.lynskey.co.nz/en/posts/2023/2023-09-01-retrospecs/" >retrospective</a> is the natural place to decide that.</p>
<p>If several teams work on one product, the Scrum Guide says they &ldquo;must mutually define and comply with the same Definition of Done&rdquo;. And if the organisation has a standard one, every team follows it &ldquo;as a minimum&rdquo;, which leaves teams free to add to it but not to take anything away.</p>

<h2 class="relative group">Mistakes I&rsquo;d watch for
    <div id="mistakes-id-watch-for" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#mistakes-id-watch-for" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>Copying the Definition of Done into every story&rsquo;s acceptance criteria. &ldquo;Tests written&rdquo; and &ldquo;code reviewed&rdquo; don&rsquo;t belong in a story. They bloat every ticket and hide the criteria that are actually about the story.</p>
<p>Acceptance criteria that are really tasks, or really designs. &ldquo;Use a modal&rdquo; is a design decision. &ldquo;I can request a new link without leaving the page&rdquo; is a criterion, and it leaves the designer room to do better than a modal.</p>
<p>Changing acceptance criteria halfway through the sprint without saying so. If the requirement has changed, that&rsquo;s a conversation with the product owner and often a new story, not a quiet edit to the old one.</p>
<p>&ldquo;Done, but not done-done.&rdquo; If a story counts as done when it&rsquo;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.</p>
<p>A Definition of Done so long that nobody can meet it in a sprint. Then everyone skips different lines and nobody says so.</p>

<h2 class="relative group">How they connect to UAT
    <div id="how-they-connect-to-uat" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#how-they-connect-to-uat" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>Acceptance criteria are the natural starting point for <a href="https://jared.lynskey.co.nz/en/posts/2023/2023-08-27-user-acceptance-testing/" >user acceptance testing</a>: 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&rsquo;t do their job, which means the criteria were wrong, not the code. That&rsquo;s useful to know before the next story is written.</p>

<h2 class="relative group">Templates
    <div id="templates" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#templates" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>Acceptance criteria:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-markdown" data-lang="markdown"><span class="line"><span class="cl">**Story:** As a [kind of user], I want [goal] so that [reason].
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="gs">**Acceptance criteria**</span>
</span></span><span class="line"><span class="cl"><span class="k">-</span> Given [starting state], when [action], then [result].
</span></span><span class="line"><span class="cl"><span class="k">-</span> Given [starting state], when [action], then [result].
</span></span><span class="line"><span class="cl"><span class="k">-</span> Given [starting state], when [action], then [result].
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="gs">**Out of scope:**</span> [what this story deliberately doesn&#39;t do]</span></span></code></pre></div></div>
<p>The &ldquo;out of scope&rdquo; line is optional, and I&rsquo;d keep it. It ends a lot of review-time arguments before they start.</p>
<p>A starting Definition of Done, to cut down or add to:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-markdown" data-lang="markdown"><span class="line"><span class="cl"><span class="k">- [ ]</span> Code reviewed and approved by another developer
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Automated tests written and passing in CI
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Acceptance criteria checked on staging
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> No new errors or warnings in monitoring after the staging deploy
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> User-facing text added in every supported language
</span></span><span class="line"><span class="cl"><span class="k">- [ ]</span> Docs, changelog or release notes updated if behaviour changed
</span></span><span class="line"><span class="cl">- [ ] Product owner has seen it working</span></span></code></pre></div></div>

<h2 class="relative group">The short version
    <div id="the-short-version" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#the-short-version" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p>Acceptance criteria belong to one story. They say what it must do, they&rsquo;re written by the product owner with the team before the sprint, and they&rsquo;re different every time. The Definition of Done belongs to the team. It&rsquo;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.</p>

<h2 class="relative group">Further reading
    <div id="further-reading" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#further-reading" aria-label="Anchor">#</a>
    </span>
    
</h2>
<p><strong>On this site:</strong></p>
<ul>
<li><a href="https://jared.lynskey.co.nz/en/posts/2023/2023-10-18-spike/" >What Is a Spike in Agile?</a> for the stories that can&rsquo;t get acceptance criteria yet</li>
<li><a href="https://jared.lynskey.co.nz/en/posts/2023/2023-08-27-user-acceptance-testing/" >User Acceptance Testing (UAT)</a>, where acceptance criteria become test scripts</li>
<li><a href="https://jared.lynskey.co.nz/en/posts/2024/2024-05-05-team-norms/" >Engineering Team Norms That Actually Stick</a>, including agreeing what &ldquo;done&rdquo; means</li>
<li><a href="https://jared.lynskey.co.nz/en/posts/2023/2023-09-01-retrospecs/" >Retrospectives</a>, where the Definition of Done should get revisited</li>
</ul>
<p><strong>Elsewhere:</strong></p>
<ul>
<li><a href="https://scrumguides.org/scrum-guide.html"  target="_blank" rel="noreferrer">The Scrum Guide (2020)</a>, for the Definition of Done in its own words</li>
<li><a href="https://dannorth.net/introducing-bdd/"  target="_blank" rel="noreferrer">Introducing BDD</a> by Dan North, where Given/When/Then comes from</li>
<li><a href="https://martinfowler.com/bliki/GivenWhenThen.html"  target="_blank" rel="noreferrer">Given When Then</a> by Martin Fowler</li>
</ul>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2026/definition-of-done-vs-acceptance-criteria/featured.jpg" medium="image" type="image/jpeg" />
    </item>
  </channel>
</rss>
