StackLift
All playbooks

Playbook

User Acceptance Testing Plan

UAT is where the people who will use the software confirm it does their job. This template covers who tests, what they test, when UAT starts and ends, and how sign-off works.

Best reader

Product owners and business users approving software before release

Outcome

A signed acceptance decision backed by scenarios run, defects triaged, and evidence kept.

Use this sequence

1

Define scope, the build under test, and the environment.

2

Name testers, a UAT lead, and the approver.

3

Write scenarios from real business workflows with expected results.

4

Confirm entry criteria before testing starts.

5

Run scenarios and log defects with severity.

6

Triage daily: fix, defer with a named risk, or reject.

7

Check exit criteria and collect the sign-off.

Entry and exit criteria

State in advance what must be true to start, such as approved scenarios and a stable test environment, and what must be true to finish. Without a measurable exit, UAT never ends.

Entry: stable build and data

Exit: no open critical defects

Exit: scenarios run and passed or accepted

Named approver

Scenarios, not feature tours

Business users test best when they follow a real task from start to finish. Write each scenario with the starting state, steps, and expected result.

Real workflows

Realistic data

Failure paths

Roles and permissions

Sign-off is evidence

A signature should point to the build, the environment, and the results it covers. Sign-off on a different build does not count for this release.

Build and environment recorded

Known issues listed

Name, role, and date

Start in 60 seconds

Turn this checklist into a scoped plan.

Answer a few questions and get an AI-assisted, architect-reviewed scope, cost range, and timeline for your software project.

Frequently asked questions

What is the difference between UAT and QA testing?

QA checks that the software meets the specification. UAT checks that it does the business job for the people who will use it. Both are needed, and UAT comes after QA.

Who should run UAT?

Business users who do the work, coordinated by a UAT lead. Engineers support with environments and fixes but should not be the ones deciding that the work is acceptable.

The complete guide

User Acceptance Testing Plan: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

A user acceptance testing (UAT) plan lets the people who will use the software confirm it does their job before release. It names scope, the build and environment, testers, scenarios with expected results, entry and exit criteria, defect triage rules, and a signed approval that points to the exact build tested.

What is user acceptance testing?

User acceptance testing is the last round of testing before release, run by the business users who will rely on the software. QA checks that the software meets its specification. UAT checks that it does the business job, with real workflows and realistic data, in a setting that looks like production.

The output of UAT is a decision: accept, accept with known issues, or do not release. A plan makes that decision predictable. Without one, UAT turns into an open-ended round of opinions that ends when someone loses patience.

What does a UAT plan template contain?

Copy this outline and fill in each section. Keep it short. A plan people read is more useful than a thorough one they skip.

UAT plan template
SectionWhat to write
Purpose and scopeWhat is being accepted, which features are in, which are out
Build and environmentThe exact version under test, the test environment, and the data used
RolesUAT lead, testers by role, engineering contact, defect triage group, approver
ScheduleStart and end dates, daily check-ins, and a date for the decision
Entry criteriaWhat must be true before UAT starts
ScenariosThe workflows to test, with steps and expected results
Defect processHow issues are logged, rated, triaged, fixed, and retested
Exit criteriaWhat must be true to finish and accept
Risks and assumptionsTester availability, data quality, environment stability
Sign-offNames, roles, dates, and what each signature covers

How do you run UAT, step by step?

  1. Confirm the scope and the build under test. Output: a version number and a list of what is in scope.
  2. Choose testers who do the real work and a UAT lead who coordinates. Output: a named roster with time set aside.
  3. Write scenarios from real business tasks with expected results. Output: a scenario list the testers can follow.
  4. Prepare the environment and realistic data. Output: a stable test setup with test accounts for each role.
  5. Check the entry criteria and brief the testers. Output: a go to start.
  6. Run the scenarios and log every issue with steps and severity. Output: a defect log and a progress view.
  7. Triage daily with engineering. Output: each issue fixed, deferred with a named risk, or closed as not a defect.
  8. Retest fixes on the same build lineage. Output: confirmed fixes.
  9. Check the exit criteria and collect sign-off. Output: a recorded decision to release or not.

Start UAT only after QA has finished its own pass. UAT time is the business's time, and it is wasted on bugs engineering should have found.

What are good entry and exit criteria?

Entry criteria say when UAT may begin. Exit criteria say when it may end. Both should be checkable. A line such as "UAT is successful" is not a criterion, because nobody can tell whether it is true. Pick thresholds that fit your release risk and write them down before testing starts.

Example criteria (adapt to your project)
TypeCriterionHow to check
EntryRequirements and scenarios are reviewed and approvedSign-off on the scenario list
EntryQA has finished, and no known critical defects are open in scopeQA report and defect log
EntryThe environment is stable and holds realistic dataSmoke test passes
EntryTesters have accounts, training, and timeRoster confirmed
ExitAll planned scenarios were runExecution record
ExitNo open critical or high-severity defects, unless a named owner accepts the risk in writingDefect log
ExitKnown lower-severity issues are listed with a planKnown issues list
ExitThe approver has signed for the specific buildSign-off record

Your own thresholds for pass rates and severity should come from the cost of a failure in your setting. A payments flow needs a stricter bar than an internal report.

How do you write UAT scenarios?

A scenario follows a business task from start to finish, not a feature in isolation. It states the role, the starting state, the steps, and the result the user expects. Write them with the testers, because they know where real work gets awkward.

Scenario template with an example
FieldExample
ID and titleUAT-014: Approve a purchase request over the limit
RoleDepartment manager
Starting stateA request above the manager's limit is waiting for approval
StepsOpen the request; review items; approve; confirm the next approver is notified
Expected resultThe request moves to the finance approver and the manager sees it as approved
Failure paths to tryReject with a reason; approve while another user edits; session expires mid-approval
Result and notesPass, fail, or blocked, with a screenshot or note
  • Cover every role and what each may not do.
  • Include end-of-period and exception tasks, not just the daily routine.
  • Use data that looks like the real thing, including awkward records.
  • Include migrated data if you moved any, as in the data migration plan.
  • Test the integrations the workflow depends on.

How do you triage defects during UAT?

Not every issue blocks release. Agree on severity levels before testing, and meet briefly each day to rate new issues. Testers sometimes report a missing feature as a defect, so triage also sorts defects from change requests. New wishes go through the change request path so they do not stall acceptance.

Severity levels and the usual decision
SeverityMeaningUsual decision
CriticalBlocks a core workflow, loses data, or creates a security or legal problemFix before release
HighA main workflow works only with a hard workaround or is wrongFix before release, or accept in writing
MediumA workflow works with a minor workaroundSchedule; may ship with a note
LowCosmetic or rareBacklog
Change requestA new need not in the agreed scopeEstimate and decide separately

Track each issue to a state: new, accepted, fixed, retested, closed, deferred. Deferred issues carry a named owner and a date.

What should a UAT sign-off say?

A sign-off is a record of a decision, so it needs to be specific. It names the build and environment, the scenarios run, the results, the known issues accepted, and who accepted them. A signature on an older build does not cover a later one. If a fix changes the build, say whether the retest covers the change.

  • Release name and build identifier, and the environment tested.
  • Scenarios planned, run, passed, failed, and blocked.
  • Open defects by severity, and who accepted each one.
  • Conditions, such as a fix promised within a set period after release.
  • Name, role, date, and signature or recorded approval for each approver.

Keep the record with the project. It is evidence if someone asks later why the system was released as it was. At StackLift, clients see approvals, releases, and project state in the client portal, so acceptance sits in one place with the rest of the project.

What mistakes make UAT fail?

Common mistakes and fixes
MistakeResultFix
Testers lack timeLittle real testing and a rushed approvalSet aside time and agree it with managers
Using the wrong dataReal problems stay hiddenUse realistic data, including odd records
No exit criteriaUAT never endsWrite them before you start
Engineers act as testersBiased resultsLet business users decide acceptance
Scope changes during UATMoving target and delaysRoute new wishes through change requests
Sign-off with no build referenceUnclear what was approvedRecord build and environment
Skipping launch readinessA passed UAT but a fragile releaseAlso run the production readiness checklist

UAT confirms that the software suits the business. It does not replace automated tests, security review, or monitoring. After acceptance, use the software handover checklist to make sure ownership transfers cleanly. To scope testing for your project, see the QA and testing cost range, run the free estimate, or contact us.

Questions people ask

What is the difference between UAT and QA testing?

QA checks that the software meets its specification and finds defects. UAT checks that it does the business job for the people who will use it. Both are needed, and UAT follows QA.

Who should do user acceptance testing?

Business users who do the work, coordinated by a UAT lead. Engineers support with environments and fixes, but they should not decide whether the work is acceptable.

How long should UAT take?

It depends on scope, the number of scenarios, and tester availability. Plan a fixed window with daily check-ins and a date for the decision, and leave time for fixes and retesting.

What are UAT entry criteria?

Conditions that must be true before UAT starts: approved scenarios, finished QA with no known critical defects, a stable environment with realistic data, and trained testers with time. Starting early wastes the testers' time.

What are UAT exit criteria?

Measurable conditions to finish: planned scenarios run, no open critical or high defects unless a named owner accepts the risk, known issues listed, and a signed approval for the specific build.

What happens if UAT fails?

The team fixes the blocking defects, retests, and may rerun affected scenarios. If the problems are deep, delay the release. A failed UAT before launch is cheaper than a failure after it.

Is UAT needed for AI features?

Yes, and it should include real examples of what the AI will see, including awkward ones. Users should judge the outputs and the handoff to a person. Add the checks from the AI agent evaluation checklist for repeatable measurement.

Sources

Sources and further reading

The standards, rules, research and official documentation this page draws on.