A UAT plan that produces a decision

A UAT plan needs to settle four things before anybody opens the build: which business processes are in scope, who accepts on behalf of the business, what the acceptance criteria are, and which severities block sign-off. Without those, the session collects impressions and the release argument is decided by whoever feels most strongly about it.

  • Template
  • 10 fields, explained
  • Updated

User acceptance testing asks a different question from every stage before it. Those ask whether the software behaves as specified; UAT asks whether the specification was right. That is why it is run by the people who asked for the software rather than by the team that built it, and it is why the plan has to be written in business processes rather than in screens.

Watercolour of a rubber stamp resting on its side beside a dried ring of orange ink

In the template

  1. Purpose
  2. Scope
  3. Participants and sign-off
  4. Acceptance criteria
  5. Environment and data
  6. Scenarios
  7. Entry criteria
  8. Exit criteria
  9. Defect handling
  10. Schedule

UAT test plan template, ready to copy

Copy it as it is. There is no email step, and nothing on this page is behind one.

Which version of the artefact to show
# UAT plan: [release or feature]

## 1. Purpose
The business outcome this release is meant to deliver.

## 2. Scope
In scope (business processes, not screens):
Out of scope:

## 3. Participants and sign-off
Business users testing, by role:
Who accepts on behalf of the business:
Who supports them technically:

## 4. Acceptance criteria
The conditions agreed before the work started.
Restated here so the verdict is checkable, not an opinion.

## 5. Environment and data
Environment:
Data set, and who prepares it:
Accounts and permissions each participant needs:

## 6. Scenarios
| # | Business scenario | Who runs it | Pass / Fail | Notes |
|---|-------------------|-------------|-------------|-------|
| 1 |                   |             |             |       |
| 2 |                   |             |             |       |

## 7. Entry criteria
What must be true before UAT starts.

## 8. Exit criteria
What must be true before UAT is called complete.
Which severities block sign-off.

## 9. Defect handling
How a participant reports a failure, and who triages it.

## 10. Schedule
Start, end, and the checkpoint where progress is reviewed.
# UAT plan: pay by invoice

## 1. Purpose
Customers can pay by invoice, and finance can reconcile those payments without a manual export.

## 2. Scope
In scope (business processes, not screens): raising an invoice, chasing an unpaid one, reconciling a payment against a bank statement line.
Out of scope: refunds and credit limit changes, neither of which was touched.

## 3. Participants and sign-off
Business users testing, by role: two credit controllers and one finance manager.
Who accepts on behalf of the business: the finance manager.
Who supports them technically: the product owner, in the room on both afternoons.

## 4. Acceptance criteria
An invoice raised on Monday appears in the finance export the same day, with the purchase order attached.
An overdue invoice can be chased without leaving the invoice.
A payment matched to an invoice clears it with no manual export.

## 5. Environment and data
Environment: staging
Data set, and who prepares it: anonymised August invoices, seeded by the product owner the day before.
Accounts and permissions each participant needs: one credit controller account each and one finance manager account, signed into once the afternoon before.

## 6. Scenarios
| # | Business scenario | Who runs it | Pass / Fail | Notes |
|---|-------------------|-------------|-------------|-------|
| 1 | Raise an invoice against an existing purchase order | credit controller | Pass | |
| 2 | Chase an invoice overdue and partly paid | credit controller | Fail | UAT-07 |
| 3 | Reconcile a payment short by the bank charge | finance manager | Not run | Bank sandbox unavailable both days |

## 7. Entry criteria
All functional testing complete on this build, and every participant signed in once, the day before.

## 8. Exit criteria
Every scenario carries a result, including Not run with its reason. No blocker open and no major on invoice creation.
Which severities block sign-off: blocker and major block. Minor is listed and accepted.

## 9. Defect handling
Reported from inside the app, so the environment and the failed request travel with the report. Triaged the same afternoon by the product owner and the engineering lead.

## 10. Schedule
Two afternoons, 14 and 15 September, with a review at the end of the first. Anything unrun by the second is recorded Not run and named in the decision.

The plan below is structured around the verdict it has to produce. Every section exists to make sign-off a determination two people would reach independently, rather than a negotiation at the end of a week.

What each field is for

Scroll the table sideways for the examples.

Field Why it earns its place Example
Purpose The business outcome the release is meant to deliver, in one sentence. Participants judge against this, so leaving it implicit means each of them judges against their own version of it. Customers can pay by invoice, and finance can reconcile those payments without a manual export.
Scope What is being accepted, described as work people do rather than as features. A scope written as screens invites participants to review the interface instead of the outcome. In scope: raising an invoice, chasing an unpaid one, reconciling a payment. Out of scope: refunds.
Participants and sign-off Who tests, in which role, and specifically who accepts on behalf of the business. An unnamed acceptor is the most common reason UAT ends without a decision. Two credit controllers and one finance manager test. The finance manager signs off.
Acceptance criteria The conditions agreed before the work started, restated here. This is what makes the outcome checkable rather than a matter of taste, and it is the field that stops the session becoming a wish list. An invoice raised on Monday appears in the finance export the same day, with the purchase order attached.
Environment and data Where testing happens, who prepares the data, and which permissions each participant needs. Business users cannot resolve their own access problems, and an hour spent on logins is an hour of a booked session. Staging, seeded with anonymised August invoices. Each tester has a credit controller account, prepared the day before.
Scenarios The list of business situations to work through, each with an owner and a pass or fail. Written as goals rather than as steps, so that participants find their own route and reveal the ones nobody designed for. Chase an invoice that is overdue and partially paid. Owner: credit controller. Result: Fail, see UAT-07.
Entry criteria What must be true before the window opens. Its job is to stop a booked session being spent on a build that was never ready, which costs a room full of people rather than one tester's afternoon. All functional testing complete on this build, and every participant signed in once, the day before.
Exit criteria What must be true before UAT is called complete, including which severities block sign-off. Without the severity rule the last day is spent arguing about whether a known problem counts. No blocker open, no major on invoice creation, and every scenario carrying a result.
Defect handling How a participant reports something that fails and who triages it. Business users will not file a structured report unprompted, so the route has to be decided in advance rather than improvised. Reported from inside the app; triaged the same afternoon by the product owner and the engineering lead.
Schedule The window, and what happens to a scenario that does not get run inside it. A plan that names dates without answering that ends in a sign-off covering work nobody did, which is the quietest way UAT fails. Two afternoons, 14 and 15 September. Anything unrun by the second is recorded Not run and named in the decision.

A UAT scenario that reviews the screen, and one that tests the outcome

Not this

Scenario 2: test the invoice chasing screen.

This instead

Scenario 2: chase an invoice that is overdue and partly paid, and leave the customer with a correct balance.
Owner: credit controller. Run in the credit controller role.

A scenario written as a screen invites a participant to review the interface, and they will: you will be told the button is the wrong blue. Written as an outcome, they have to find their own way there, and the way they find is the one they use at work. That is where the session earns its cost, because it surfaces the screen nobody designed for and the step that is obvious to whoever built it and impossible for somebody doing it forty times a day.

Write scenarios as goals, not as steps

A scripted UAT session verifies that the path the team designed works, which the team has already verified. The value of putting real users in front of the software is that they take routes nobody anticipated, and a step-by-step script removes exactly that. Giving a participant an outcome to reach and letting them find their own way there is what surfaces the screen somebody cannot find and the field whose label means something different in their department.

The exit criteria have to name severities

Every UAT run ends with known problems, so an exit criterion of no outstanding defects is never met and gets waived, which means it was never a criterion. Naming which severities block sign-off converts the final conversation from a negotiation into a check. It also protects the participants: without it, the pressure of a date lands on the people who found the problems rather than on the decision to ship with them.

Scheduling it late is what makes it theatre

UAT booked for the week before a release turns any real finding into a choice between shipping something known to be wrong and missing the date, and teams facing that choice reliably reclassify the finding. Running it while the answer can still change what gets built is the difference between validation and a formality. That usually means putting business users in front of the work more than once, on smaller pieces, rather than in a single session at the end.

Common questions

What should a UAT test plan include?

The business outcome being accepted, the scope written as processes rather than screens, the named participants and whoever signs off, the acceptance criteria agreed in advance, the environment and data, the scenarios to run, entry and exit criteria naming which severities block, and how defects are reported.

Who writes the UAT plan?

Usually the product owner or business analyst, with the team supplying the environment and data sections. The critical part is that the acceptance criteria come from whoever asked for the work, since a plan whose criteria the team wrote is verification wearing the name of validation.

How long should UAT take?

Long enough to work through every scenario without rushing, which for most releases is days rather than weeks. The more useful question is when it starts: a short session held early, while findings can still change what gets built, is worth more than a long one held after the build is frozen.

What happens when UAT fails?

The exit criteria decide. If a blocking severity was found, the release does not go, which is the criteria doing their job. If the finding is below the blocking threshold, it is recorded, triaged and scheduled, and the sign-off proceeds. That is why the threshold is agreed before anybody opens the build rather than after.

More templates

  • Watercolour of a folded paper map with one burnt orange route traced across its green ground

    Template

    Test plan template

    A copyable test plan template covering scope, approach, entry and exit criteria, environments, roles and risks. The short version teams actually keep updated.

    9 fields, explained ·

  • Watercolour of a blank index card lying alone, one orange tick mark bleeding into its surface

    Template

    Test case template

    A copyable test case template with the fields that make a run repeatable: preconditions, exact test data, per-step expected results, and a recorded outcome.

    9 fields, explained ·

  • Watercolour of a burnt orange plumb bob hanging from a taut string, its point above a soft olive wash

    Template

    Test strategy template

    A copyable test strategy template with a filled-in example: product risks, test levels, environments, tools, roles, entry and exit rules, and review.

    11 fields, explained ·

Or skip the template and capture the fields automatically.

Environment, console and network attach themselves, on the free plan.

<script src="…/widget.js" data-key="pb_pub_…">