Software Acceptance Criteria Examples You Can Test
What are software acceptance criteria?
Software acceptance criteria are observable conditions that define whether a requirement has been met. Useful software acceptance criteria examples cover successful use, invalid inputs, permission limits, and failures, with an expected result for each. Write them so someone can exercise the feature and decide whether it passes without guessing what you meant.
For a founder or product owner, the practical question is: “What must I be able to see or verify before I accept this feature?”
“Users can create tasks” describes a capability. It leaves unanswered who can create them, what information is required, and what happens when saving fails. Acceptance criteria make those decisions explicit.
How do you turn a requirement into testable conditions?
Start with a small requirement and identify four things:
- Actor: Who is taking the action, and what access do they have?
- Starting state: What must already be true?
- Action: What does the person do?
- Expected result: What changes, what appears, and what must remain unchanged?
Use a concrete example to expose missing decisions. Instead of “validate the task title,” specify whether the title is required, how spaces are handled, and what happens when it is too long.
Choose each boundary deliberately. The title limit in the worked example below is illustrative, not a recommended standard.
You can write criteria as short statements or use Given / When / Then:
> Given a starting state, when someone takes an action, then an observable result follows.
The wording is optional. The explicit starting state and result are what make the criterion useful.
What do good acceptance criteria look like in practice?
Consider this illustrative requirement:
A project editor can create a task with a title. A project viewer can read tasks but cannot create them.
For this example, a title must contain between 1 and 80 characters after leading and trailing spaces are removed. These numbers are illustrative product choices. Internal spaces count towards the limit.
| Case | Starting state and action | Expected result |
|---|---|---|
| Normal use | An editor enters “Review welcome screen” and saves | One task appears in the selected project with that title |
| Persistence | The editor reloads after a confirmed save | The task remains visible with the saved title |
| Empty input | An editor submits an empty title | No task is created; “Enter a task title” appears beside the field |
| Spaces only | An editor submits a title containing only spaces | The same required-field message appears; no task is created |
| Boundary input | An editor submits an 80-character title | The title is accepted and saved in full |
| Over the limit | An editor submits an 81-character title | No task is created; “Use 80 characters or fewer” appears |
| Permission denied | A viewer attempts to create a task | The action is denied and no task is created |
| Confirmed save failure | Saving is rejected before a task is created | The entered title remains available; no success message appears |
| Uncertain outcome | The connection drops before save confirmation arrives | The interface says it cannot confirm the result and provides a way to check |
Notice that the failure rows describe different outcomes. A confirmed rejection and a missing response need different user messages: in the second case, the criterion does not assume whether the task exists.
The table is a starting point. Expand any row where the expected behaviour still leaves room for disagreement.
How should you specify invalid inputs?
Replace “show a helpful error” with the precise behaviour you want accepted.
For the illustrative task form:
- Submitting an empty title displays “Enter a task title” beside the title field.
- The message is available to someone using assistive technology.
- The title remains editable after validation fails.
- Correcting the title and submitting again creates the task without requiring a page reload.
- An overlength title is preserved for editing rather than silently shortened.
These conditions cover both rejection and recovery. They also prevent a technically valid result from hiding a poor experience: blocking an invalid submission is only part of the requirement.
Include relevant boundaries rather than every imaginable input. For a title, empty values and length limits matter. For a booking, availability and date order may matter. Choose cases based on the feature’s actual rules.
How should you write permission criteria?
Name the role, the action, and the scope of access.
“Only authorised users can create tasks” leaves the authorisation rule undefined. For the example, write:
- An editor assigned to the selected project can create a task there.
- A viewer cannot create a task in that project.
- An editor in one project cannot create tasks in another project without editor access there.
- A denied attempt creates no task.
- The restriction holds even when someone attempts the action outside the normal screen.
Hiding a create button can be one visible requirement. Keep the underlying permission requirement explicit too.
For related considerations, read data security in modern applications. Keep each acceptance criterion focused on the access decision this feature needs.
How should you describe failures and retries?
Specify what the user sees, what happens to their input, and how they can continue.
For a confirmed save rejection, the example could require:
Given an editor has entered a valid title, when saving fails before the task is created, then the form retains the title, displays “Task could not be saved. Try again,” and allows another attempt.
For an uncertain outcome, use a separate criterion:
Given the editor submitted a task, when confirmation is unavailable, then the interface displays “We could not confirm whether your task was saved” and offers a way to check the task list.
If retrying is supported, add an explicit duplicate rule: retrying the same submission must not create an additional task if the original attempt succeeded.
Do not leave “try again” as a complete specification. Define what retrying means and what result counts as correct.
How are acceptance criteria different from implementation instructions?
Acceptance criteria describe required behaviour. Implementation instructions describe how to produce it.
| Acceptance criterion | Implementation instruction |
|---|---|
| A valid submission creates one task | Use a particular database operation |
| A viewer’s creation attempt is denied | Put a role check in a named component |
| The entered title remains after a failed save | Store the title in a particular state library |
| Retrying the same submission creates no duplicate | Use a particular request identifier design |
A technical constraint can still be necessary. For example, an integration may require a specific interface. Record that constraint separately and explain why it is required.
This separation lets you assess the result while leaving technical choices open where they do not affect the requirement.
What common mistakes make criteria hard to test?
Using adjectives without a boundary. “Fast,” “intuitive,” and “robust” do not identify a pass condition. Define the action, conditions, and measurable outcome that matter.
Covering only the successful path. Add relevant invalid inputs, access restrictions, and failure recovery.
Combining unrelated behaviours. Split creation, editing, and deletion when they have separate rules.
Confusing acceptance criteria with test scripts. Criteria state the required outcome. A test script adds the exact data and steps used to check it.
Treating a few criteria as complete quality assurance. Feature acceptance does not replace broader checks for accessibility, security, compatibility, or unintended effects elsewhere. See software testing and quality assurance for the wider testing context.
Before accepting a feature, check that each criterion has a clear starting state, an action, an observable result, and a way to fail.
What questions come up most often?
How many acceptance criteria should a requirement have?
Use enough to cover its distinct rules and meaningful outcomes. Do not aim for a fixed count. If the list becomes difficult to follow, check whether the requirement contains several separate capabilities.
Must acceptance criteria use Given / When / Then?
No. A table or short checklist works when the starting conditions and expected results are clear. Use the format that makes ambiguity easiest to spot.
Can acceptance criteria change?
Yes. Revise them when a product decision changes or an overlooked case becomes clear. Make the change explicit so everyone evaluates the feature against the same expectations.
Do acceptance criteria need automated tests?
They need a credible way to verify the outcome. Some suit automated tests; others need direct inspection or a person using the feature. Choose a check that can expose a failure, and retain enough evidence to explain the result.
When the criteria are written and the feature is built, use our user acceptance testing checklist to run the sign-off.
To check progress against criteria like these during a build, see how to verify progress on an outsourced software build.