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.
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.
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.
In the template
Copy it as it is. There is no email step, and nothing on this page is behind one.
# 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.
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. |
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.
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.
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.
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.
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.
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.
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.
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.
Template
A copyable test plan template covering scope, approach, entry and exit criteria, environments, roles and risks. The short version teams actually keep updated.
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.
Template
A copyable test strategy template with a filled-in example: product risks, test levels, environments, tools, roles, entry and exit rules, and review.
Environment, console and network attach themselves, on the free plan.