GainHQ
Go back

Acceptance Criteria Examples: 10 Templates and How to Write Them

Acceptance criteria card for a password reset story, with a Given, When, Then scenario and a checklist, marked ready to test

by GainHQ Editorial Team | Nov 15, 2026 | Software Development Insights | Editorial policy


Table of Contents
  1. Where acceptance criteria come from
  2. Acceptance criteria vs definition of done vs requirements vs test cases
  3. Two formats: checklist and Given/When/Then
  4. What makes acceptance criteria good
  5. 10 acceptance criteria examples
  6. Bad vs good: five rewrites
  7. How to write acceptance criteria: step by step
  8. Who writes acceptance criteria, and when?
  9. How many acceptance criteria should a story have?
  10. Acceptance criteria in Jira
  11. From acceptance criteria to automated tests
  12. Common mistakes
  13. How GainHQ can help

Acceptance criteria are the conditions a user story or feature must meet for the product owner or customer to accept it as complete. Each one is a pass/fail statement that can be tested, written before development starts. A story such as "As a user, I want to reset my password" might have criteria like "the reset link expires after 60 minutes" and "an expired link shows an error and offers a new link".

Good acceptance criteria describe the outcome, not the implementation. They tell the team what "working" means for this story, so developers, testers and the product owner share one definition before any code is written.

Where acceptance criteria come from

The idea is older than most agile tooling. Ron Jeffries described a user story as a card, a conversation and a confirmation, where the confirmation is the set of tests the customer will use to accept the work (Jeffries). Dan North, who introduced behaviour-driven development, put it more directly: a story's behaviour is its acceptance criteria, and he proposed the Given/When/Then template for writing them (North, 2006).

One point surprises many teams: the Scrum Guide does not mention acceptance criteria at all. It defines the Definition of Done. Acceptance criteria are a widely used team practice, not a Scrum rule.

Acceptance criteria vs definition of done vs requirements vs test cases

Acceptance criteria Definition of Done Requirements Test cases
Scope One story or feature Every item the team delivers The whole product or release One check of one behaviour
Who owns it Product owner, agreed with the team The Scrum team (often an organisational minimum) Product / business analysts Testers and developers
Question it answers Does this story do what was asked? Is this item finished to our quality standard? What must the product do? Does this specific input give this output?
Example "Expired reset links show an error and a 'send new link' button" "Code reviewed, tests pass, deployed to staging, docs updated" "Users can recover access to their account" "Open a link issued 61 minutes ago → error message shown"

The Scrum Guide treats the Definition of Done as the quality bar every increment must reach; work that misses it goes back to the Product Backlog. The Agile Alliance notes that individual stories may also have their own specific "done" criteria on top of the team-wide checklist. That is the gap acceptance criteria fill. A story is accepted only when it meets both.

Test cases are derived from acceptance criteria. One criterion usually produces several test cases (the happy path, boundaries and failures).

Two formats: checklist and Given/When/Then

Rule-oriented checklist. A bulleted list of conditions. Quick to write and easy to scan; best for simple stories and non-functional rules.

Scenario-oriented (Given/When/Then). Each scenario sets a starting context (Given), an action (When) and an observable outcome (Then). This is the format used by Gherkin, the language Cucumber and similar tools run as automated tests. Best when the behaviour depends on state or there are several paths.

Many teams mix them: a checklist for rules, scenarios for the tricky paths.

What makes acceptance criteria good

  • Testable. Someone can say pass or fail without debate. Bill Wake's INVEST checklist for user stories makes "Testable" its last letter: if a customer cannot say how they would test a story, the story is probably not clear enough yet (Wake, 2003).
  • Specific and measurable. Numbers, limits and named states instead of "fast", "easy" or "user-friendly".
  • Outcome-focused. What the user sees or the system records, not which library or table to use.
  • Complete about failure. Each important happy path has its error paths.
  • Short. If a story needs many criteria, it is usually two stories.

10 acceptance criteria examples

The examples below cover features most SaaS and web products build. Thresholds such as "60 minutes" are example values; set your own.

1. Password reset (Given/When/Then)

User story: As a registered user, I want to reset my password so that I can get back into my account.

Feature: Password reset

  Scenario: Request a reset link for a registered email
    Given a registered account with the email "sam@example.com"
    When the user requests a password reset for "sam@example.com"
    Then a reset email is sent to "sam@example.com" within 2 minutes
    And the reset link expires 60 minutes after it is issued

  Scenario: Request a reset for an unknown email
    Given no account exists for "nobody@example.com"
    When the user requests a password reset for "nobody@example.com"
    Then the page shows the same confirmation message as for a registered email
    And no email is sent

  Scenario: Use an expired link
    Given a reset link issued 61 minutes ago
    When the user opens the link
    Then the message "This link has expired" is shown
    And the page offers a button to send a new link

The second scenario matters: showing a different message for unknown emails would reveal which addresses have accounts.

2. SaaS onboarding checklist (checklist)

User story: As a new workspace admin, I want a setup checklist so that I can get my team working quickly.

  • The checklist appears on first login for workspace admins only.
  • It shows 4 steps: invite a teammate, connect an integration, create the first project, set notification preferences.
  • Each step is marked complete automatically when the action is done, without a page refresh.
  • The admin can dismiss the checklist; it does not reappear after dismissal.
  • Progress is saved per workspace, so a second admin sees the same completed steps.

3. Card payment at checkout (Given/When/Then)

Feature: Card payment

  Scenario: Successful payment
    Given a cart with a total of 49.00 USD
    When the customer pays with a valid card
    Then the order status is "Paid"
    And a receipt email is sent to the customer

  Scenario: Card declined
    Given a cart with a total of 49.00 USD
    When the payment provider declines the card
    Then the order status stays "Pending payment"
    And the customer sees the decline reason returned by the provider
    And the cart contents are unchanged

  Scenario: Double submission
    Given the customer has clicked "Pay" once
    When the customer clicks "Pay" again before the response arrives
    Then only one charge is created

4. REST API endpoint (checklist)

User story: As an integration developer, I want to fetch a customer by ID so that I can sync records.

  • GET /customers/{id} returns 200 and the customer JSON for an existing ID the caller can access.
  • Returns 404 with an error body for an ID that does not exist.
  • Returns 401 when no valid token is sent and 403 when the token lacks the customers:read scope.
  • Returns 429 with a Retry-After header when the caller exceeds the rate limit.
  • The response never includes the customer's password hash or payment token fields.

5. Search with filters (checklist)

  • Searching by product name returns matches that contain the search term, ignoring case.
  • Results load within 1 second for the 95th percentile of searches on the production catalogue.
  • Filters for category and price can be combined; the result count updates when a filter changes.
  • An empty result shows "No results" and a "Clear filters" link.
  • The search term and filters are kept in the URL, so a shared link reproduces the same results.

6. Role-based permissions (Given/When/Then)

Feature: Project deletion permissions

  Rule: Only workspace owners can delete projects

    Scenario: Owner deletes a project
      Given a user with the "Owner" role
      When the user deletes the project "Q4 Launch"
      Then the project is removed from the project list
      And the deletion is recorded in the audit log with the user and time

    Scenario: Member tries to delete a project
      Given a user with the "Member" role
      When the user opens the project settings for "Q4 Launch"
      Then the "Delete project" option is not shown

7. CSV data export (checklist)

  • Admins can export the contacts list as CSV from the contacts page.
  • The export includes the columns shown in the current table view, in the same order, with a header row.
  • Active filters apply to the export.
  • Exports of up to 50,000 rows download directly; larger exports are emailed as a link that expires after 7 days.
  • Dates use ISO 8601 format (YYYY-MM-DD) and the file is UTF-8 encoded.

8. Accessibility (checklist based on WCAG 2.2)

Non-functional criteria need thresholds just as much as functional ones. WCAG 2.2 gives measurable ones:

  • Text has a contrast ratio of at least 4.5:1 against its background, or 3:1 for large text (WCAG 1.4.3).
  • Every action in the form can be completed with a keyboard alone (WCAG 2.1.1).
  • Clickable targets are at least 24 × 24 CSS pixels, or have enough spacing (WCAG 2.5.8).
  • Input errors are identified and described to the user in text, not by colour alone (WCAG 3.3.1).

9. Page performance (checklist based on Core Web Vitals)

Google's Core Web Vitals define "good" thresholds measured at the 75th percentile of page loads:

  • Largest Contentful Paint is 2.5 seconds or less.
  • Interaction to Next Paint is 200 milliseconds or less.
  • Cumulative Layout Shift is 0.1 or less.
  • The three thresholds are met on both mobile and desktop for the pricing page.

Our guide to software performance testing covers how to measure these.

10. Email notification preferences (Given/When/Then with Scenario Outline)

Feature: Notification preferences

  Scenario Outline: Respect the user's email setting
    Given the user's email setting for "<event>" is "<setting>"
    When a "<event>" event occurs
    Then an email is <result>

    Examples:
      | event         | setting | result   |
      | new comment   | on      | sent     |
      | new comment   | off     | not sent |
      | task assigned | on      | sent     |
      | task assigned | off     | not sent |

Bad vs good: five rewrites

Vague criterion Why it fails Testable rewrite
The page should load fast. "Fast" is an opinion. LCP is 2.5 s or less at the 75th percentile on mobile.
Show a clear error message. "Clear" can't be tested. Show "Card declined: insufficient funds" (the provider's reason) above the Pay button.
The form should be user-friendly. No measurable outcome. All fields are reachable and submittable by keyboard; errors are described in text next to the field.
Users can export their data. No format, scope or limits. Admins can export contacts as UTF-8 CSV with the visible columns; up to 50,000 rows download directly.
Use Redis to cache search results. Describes implementation, not outcome. Search results load within 1 second for the 95th percentile of searches.

How to write acceptance criteria: step by step

  1. Start from the user story and the outcome the user wants. If the story itself is vague, tighten it first with these user story examples.
  2. List the rules the feature must follow (limits, permissions, formats).
  3. Add failure paths for each rule: invalid input, no permission, timeouts, duplicates.
  4. Add non-functional criteria that matter for this story (performance, accessibility, security), with numbers.
  5. Choose the format: checklist for rules, Given/When/Then for behaviour with state or several paths.
  6. Review together in backlog refinement with the product owner, a developer and a tester. If anyone reads a criterion differently, rewrite it.
  7. Split the story if the criteria cover more than one user outcome.

Who writes acceptance criteria, and when?

The product owner (or product manager) usually drafts them, because they own what "valuable" means. They are refined with developers and testers, who spot missing edge cases and untestable wording. Write them before the story enters a sprint, during backlog refinement, so the team can estimate against them. See our guide to sprint planning in agile for where this fits.

How many acceptance criteria should a story have?

There is no fixed rule. A small story often needs three to five. If you need many more, or the criteria describe different user goals, split the story. Long lists are a sign the story is too big to finish in one sprint.

Acceptance criteria in Jira

Teams record acceptance criteria in Jira in a few common ways: a dedicated "Acceptance criteria" section in the issue description, a checklist (using a checklist app or a custom field your admin adds), or sub-tasks for larger criteria. Whichever you choose, keep one convention across the project so testers know where to look, and link Gherkin feature files or test cases back to the issue.

From acceptance criteria to automated tests

Criteria written in Given/When/Then map directly to automated acceptance tests. In Gherkin, each Scenario is an executable example: Given sets the initial context, When describes the event, and Then states the expected outcome, which the test checks with an assertion. Rule groups scenarios for one business rule, and Scenario Outline with an Examples table runs the same steps with different data, as in example 10. Not every criterion needs automating, but ones that protect money, permissions or data should be. For where these tests sit in your test suite, see software testing strategies and QA automation vs manual testing.

Common mistakes

  • Writing criteria after development starts, so they describe what was built rather than what was needed.
  • Describing implementation ("use a modal", "store in Redis") instead of outcomes.
  • Only covering the happy path.
  • Using words like "fast", "clear", "simple" or "intuitive" without a measure.
  • Mixing team-wide quality rules (code review, test coverage) into one story's criteria. Those belong in the Definition of Done.

How GainHQ can help

GainHQ has spent 15+ years building software, including its own products Payrun and Gain.io. For product teams writing requirements, our guide to writing a product requirements document is a good next read. For delivery support, see our custom software development services.

Frequently asked questions

What are acceptance criteria?

The pass/fail conditions a user story or feature must meet for the product owner or customer to accept it as complete.

What is an example of acceptance criteria?

For a password reset story: "The reset link expires 60 minutes after it is issued" and "An expired link shows an error and offers to send a new link."

What is the format of acceptance criteria?

The two common formats are a rule-oriented checklist and scenario-oriented Given/When/Then. Many teams use both in one story.

What is the difference between acceptance criteria and the definition of done?

Acceptance criteria are specific to one story. The Definition of Done is a quality standard that applies to every item the team delivers. A story needs to meet both.

What is the difference between requirements and acceptance criteria?

Requirements describe what the product must do overall. Acceptance criteria are the testable conditions that confirm one story or feature meets its part of those requirements.

Who writes acceptance criteria?

Usually the product owner or product manager, refined with developers and testers during backlog refinement.

How do you write acceptance criteria for a user story?

Start from the story's outcome, list the rules and failure paths, add measurable non-functional criteria, choose a checklist or Given/When/Then, and review with the team before the sprint.

Are acceptance criteria part of Scrum?

No. The Scrum Guide defines the Definition of Done but does not mention acceptance criteria. They are a common practice that many Scrum teams use.

Related Blogs