User Acceptance Testing: A Practical Sign-Off Checklist
What should a user acceptance testing checklist cover?
A user acceptance testing checklist should confirm that representative users can complete real business workflows against agreed requirements before sign-off. It should cover suitable test data, complete scenarios, clear expected results, defect severity, retesting and documented approval. The acceptance decision should show what passed, what remains unresolved and who accepts any remaining limitations.
For a founder or product owner, the central question is practical: can the people who will use this software complete the work it was built to support?
What are you agreeing to accept?
Start with the requirements for the work being reviewed. Turn each requirement into an outcome someone can observe; these software acceptance criteria examples show how to word them.
“Order approval works” leaves too much open. A clearer acceptance criterion is: “An authorised manager can approve a submitted order, the order status changes, and the requester can see the decision.”
Agree on the boundary of acceptance before testing begins:
- Which workflows and user roles are included?
- Which requirements must each workflow satisfy?
- Which devices and access methods need checking?
- Which outputs must users receive?
- What must pass before approval?
- Who can accept an unresolved issue?
Keep exclusions explicit. If an external connection is simulated, record that limitation and identify the later check needed before relying on it.
For the wider testing picture, see best practices for software testing and quality assurance.
Who should carry out acceptance testing?
Choose people who represent the work, including its exceptions. For an order workflow, that might mean someone who submits requests, someone who approves them and someone who handles corrections.
Ask participants to use accounts with the permissions their roles require. Testing everything through an administrator account leaves ordinary access rules unexamined.
Give users the scenario, starting information and expected business outcome. Avoid coaching them through every click unless those instructions will also be available during normal use. Record where they need help: the task may be technically possible but still unclear.
Name a business owner for the final decision. Participants provide evidence; the accountable owner decides whether that evidence meets the acceptance conditions.
What test data should you prepare?
Prepare data that lets users exercise both routine work and agreed exceptions.
| Data type | Example to prepare | What to check |
|---|---|---|
| Routine records | A complete request ready for approval | The normal workflow reaches its expected result |
| Incomplete records | A request missing a required detail | The user receives a clear, useful response |
| Boundary cases | Values at an agreed limit | The rule behaves as specified |
| Role-specific records | Requests owned by different users | Each role has the intended access |
| Existing records | A previously approved request | Later actions preserve the agreed history |
| Output examples | Records with known expected content | Reports, messages and downloads match expectations |
Prefer synthetic data that represents the work without including real personal or confidential information. Where realistic sensitive data is necessary, agree on its handling and access before testing.
Write down the expected result for each dataset. Without that reference, a plausible-looking total or report is difficult to judge. For related considerations, read data security in modern applications.
How do you write a complete test scenario?
Describe the journey from its starting condition to its business outcome. Include handoffs, saved records and anything that leaves the application.
A scenario record should contain:
- The requirement being checked.
- The user role and starting conditions.
- The test data to use.
- The actions to perform.
- The expected result.
- The observed result and supporting evidence.
- A status: passed, failed, blocked or not run.
Keep blocked and not-run scenarios visible. Neither demonstrates acceptance.
Illustrative example: purchase request approval
A requester submits a purchase request. The assigned approver reviews it and sends it back for correction. The requester updates the request and resubmits it. The approver accepts it.
Check the whole journey: who can see the request, whether the correction is saved, whether the status is accurate and whether each person receives the expected message. If a download forms part of the requirement, open it and inspect its contents.
Also test an agreed exception, such as an unauthorised user attempting approval. Define the expected refusal and message before running it.
What should the practical checklist include?
Use this checklist as an acceptance record. Attach evidence or a reference wherever a tick alone would hide an important detail.
Before testing
- [ ] Requirements and acceptance criteria are agreed.
- [ ] Included workflows, exclusions and dependencies are recorded.
- [ ] Representative users and the approval owner are named.
- [ ] Role-specific accounts and suitable test data are ready.
- [ ] Scenarios include routine journeys, exceptions and handoffs.
- [ ] Expected outputs and pass conditions are written down.
- [ ] Defect severity and release-blocking rules are agreed.
During testing
- [ ] Users complete scenarios with their intended permissions.
- [ ] Actual results are compared with expected results.
- [ ] Saved changes remain correct when reopened.
- [ ] Reports, downloads and messages are inspected.
- [ ] Failures include enough detail to reproduce them.
- [ ] Blocked and untested scenarios remain visible.
Before sign-off
- [ ] Required scenarios have passed.
- [ ] Blocking defects have been fixed and retested.
- [ ] Related workflows affected by fixes have been checked.
- [ ] Remaining issues have an owner and an explicit decision.
- [ ] The tested version and supporting evidence are recorded.
- [ ] The business owner has documented approval or rejection.
How should you classify defects?
Agree on severity using business impact. Keep it separate from priority: severity describes the consequence, while priority describes when to address it.
The following is a suggested starting point, not a universal standard.
| Severity | Suggested meaning | Suggested acceptance rule |
|---|---|---|
| Critical | Essential work cannot continue, or the result creates unacceptable harm | Block approval |
| High | A required workflow fails and has no acceptable workaround | Block approval |
| Medium | A requirement is affected, but a reviewed workaround is acceptable | Require explicit owner acceptance |
| Low | A minor issue leaves the required outcome intact | Record an owner and follow-up decision |
For every defect, record the starting state, steps, expected result and actual result. Add evidence without exposing sensitive information.
Do not downgrade an issue because a deadline is close. Record the impact honestly, then make the acceptance decision against the agreed rules.
What needs retesting after a fix?
Rerun the failed scenario using the corrected version and relevant data. Confirm the expected result yourself rather than closing the issue on the strength of a completion message.
Then check related behaviour that the fix could affect. A change to approval permissions, for example, warrants checking both permitted approval and refused approval.
If the fix changes the requirement or expected behaviour, obtain agreement on that change before judging the result. Do not quietly rewrite an acceptance criterion to match what the software happens to do.
What should documented sign-off contain?
Make approval specific enough that another reader can understand its scope.
Record the tested version, included workflows, results, unresolved issues and evidence references. Include the approving person's name, business role and approval date.
A useful approval statement is:
“Approved for the listed workflows on the tested version. Required scenarios passed. The listed remaining issues are accepted with their recorded workarounds, owners and follow-up commitments.”
Use that wording only when the evidence supports it. If a blocking condition remains, record rejection or pending approval instead. Separate acceptance from the deployment decision where other checks remain outstanding.
For guidance on keeping these records usable, see documentation best practices in software projects.
What common mistakes should you avoid?
Treating a demonstration as acceptance. Watching someone present a feature does not record whether representative users completed the scenarios.
Testing only the easiest path. Include corrections, rejected actions and handoffs that belong to the agreed scope.
Checking screens but ignoring outputs. Open the report, read the message and inspect the saved record.
Approving with vague exceptions. Replace “minor issues remain” with a list of accepted issues, their impact and their owners.
Treating UAT as every kind of testing. Keep separate evidence for security, performance and other specialist checks. A completed business workflow does not establish those results.
What else do founders ask about UAT?
Can the product owner run all the tests?
The product owner can coordinate testing and make the acceptance decision. Include representative users wherever their responsibilities differ, particularly for permissions, handoffs and exception handling.
Must every defect be fixed before sign-off?
Set that rule before testing. Require blocking defects to be resolved, and accept lesser issues only through a documented decision that names the impact, workaround and owner.
What if requirements change during testing?
Separate a newly requested capability from a failure to meet an agreed requirement. Assess the change, agree on its scope and update the affected scenarios before approval.
When testing surfaces new requests, see how software change requests should be priced.
Accessibility deserves its own acceptance pass; see how to check software accessibility before sign-off.
When a scenario fails, a clear report speeds the fix; see how to write a bug report developers can act on.