User acceptance testing for client projects, with a UAT plan template
User acceptance testing (UAT) is the last test before release, where the client or its users check the software against the agreed acceptance criteria and accept or reject it. This post is for agencies and software houses that hand a web app to a client and need the client's written yes before they invoice. Download the free UAT plan template as an Excel spreadsheet with 14 sheets, from acceptance criteria to the signed release sign-off; there's no form and no email address. The order of regression testing vs UAT matters: a green regression run decides whether the client gets the build at all.
What is user acceptance testing?
User acceptance testing is the last test level, run by the client or its users, that decides whether to accept the software against agreed acceptance criteria. Our wording is based on the ISTQB glossary, the standard list of testing terms. It ends in a decision.
On a client project, the contract sets the criteria. UAT decides whether the agency can hand over and invoice.
What does UAT stand for?
UAT stands for user acceptance testing, also called client acceptance testing on agency projects.
What are the four types of acceptance testing?
The ISTQB glossary lists four types of acceptance testing:
- User acceptance testing: the intended users check that the software suits their needs.
- Operational acceptance testing: the operators check that backup, recovery and maintenance work.
- Contract acceptance testing: testers check the system against the criteria written in a contract.
- Regulation acceptance testing: testers check the system against legal and industry rules.
On a client project, contract acceptance testing matters most. It decides when the agency can invoice.
Who tests what in QA vs UAT, and in which order?
QA is the agency's own testing: it checks that the software works as built, before the client sees it. UAT is the client's testing: it checks that the software does what the business needs. QA runs first, and it runs again after every fix that UAT triggers.
| QA | UAT | |
|---|---|---|
| Who runs it | The agency's testers, or an automated suite | The client's testers |
| What it checks | The software against the requirements and its own behaviour | The software against the client's business processes and acceptance criteria |
| When | Before the build goes to the client, and after every fix | After QA has passed, in the UAT window |
| What ends it | The agency's own release decision | The client's sign-off |
What's the difference between QA and UAT?
QA finds defects before the client sees the build; UAT lets the client decide whether the finished build is acceptable. QA asks "did we build it right?" The client asks "is this what we agreed on?" A build can pass the first question and fail the second.
What comes first, UAT or QA?
QA comes first. A client who finds a broken login in the first ten minutes starts to doubt the rest of the build. UAT starts when QA is done and the build is stable. QA runs again after each fix that UAT triggers.
What must pass in QA before release so the client can test the build?
Four entry criteria decide whether a build goes to the client at all:
- Internal QA is done.
- The last automated regression run is green, and its report is attached.
- Known defects are logged and triaged.
- The UAT environment, the test data and one account per role are ready.
Each criterion needs evidence you can attach to the plan, such as a dated report.
Automation still leaves decisions to a person. In the measured run on Kimai, about 17% of test cases (11 of 66) were blocked for a human decision.
Is regression testing part of UAT?
No. Regression testing is an entry criterion of UAT, and it runs again after each fix that UAT triggers. Our hub post on automated regression testing for web apps covers the method, and Playwright can automate the run.
What is a UAT plan?
A UAT plan is the document that fixes what the client tests, who tests it, on which data and when, and what counts as accepted. It turns the acceptance criteria of the contract into scenarios and a schedule. Our template has 14 sheets, one per section, in this order:
- Project and release
- Purpose and scope
- Acceptance criteria
- Entry criteria
- Roles and responsibilities
- Environment and accounts
- UAT scenarios
- Schedule and communication
- Defect handling
- Exit criteria
- Risks and contingencies
- Handover evidence
- Release sign-off
- Appendix
The sections adapt the test plan and the test completion report of ISO/IEC/IEEE 29119-3:2021, the standard for test documentation, to a client handover.
Where can I download a free UAT plan template?
Download the UAT plan template (uat-plan-template.xlsx). It is one Excel workbook that also opens in Google Sheets. There's no form and no email address. Every sheet starts with one grey line of guidance and holds an example entry that you replace.
The scenario sheet has one row per scenario, with an ID like UAT-001. Its columns are: business process, role, device and browser, preconditions, steps, expected result, acceptance criterion, actual result, status, tester, date, defect ID and retest status. Status is a drop-down with pass, fail, blocked and not run. The guide to writing the scenario rows helps with the steps and the expected results.
The template is licensed under CC BY 4.0 (Creative Commons Attribution). Keep the attribution line in the footer when you reuse it.
Who should not use it: A regulated client with a prescribed acceptance procedure should follow that procedure instead. A one-page site needs no 14 sheets. A team with no automated regression run yet can't fill the entry criteria.
How this template was built: we adapted a test plan to a client handover, where sign-off and evidence matter most. No client project stands behind it. The advice is our position. The Kimai figures come from the public report, which says "about" and states its limits.
How do you run user acceptance testing on a client project?
Running user acceptance testing on a client project produces one thing: a signed accept or reject decision against agreed criteria. Every step below serves that decision. Follow the nine steps from the contract clause to the signature. Each one has a note on what goes wrong.
- Agree acceptance criteria in the contract or statement of work. A criterion the app does not meet surfaces at sign-off. In the Kimai run, TC-WEB-001 and TC-WEB-002 expect this: after logout, the browser back button does not show protected page content. The app doesn't meet it.
- Name the client's testers and the person who signs off. Without a person who holds the authority to accept, the decision stalls.
- Write UAT scenarios from the client's business processes. Scenarios that copy the feature list miss the client's processes. Learn how to write test cases from the process first.
- Prepare the environment, test data and one account per role. When testers share an account, they overwrite each other's data.
- Run the scenarios and log every result. A result that lives in chat is missing from the plan.
- Fix the defects. A fix that ships without a severity ruling lets a cosmetic issue block acceptance.
- Retest the fixed scenarios. A retest that covers the fix and skips the scenario around it misses the side effect.
- Re-run the regression suite. A fix can break a scenario that already passed.
- Close with the release sign-off. A sign-off that omits the known issues the client accepted invites a dispute after launch.
What is UAT testing with an example?
The example below is a release sign-off filled from the Kimai run. That run is a measured run on one app, not a client project. The Kimai run behind this example is open source, and every figure comes from its public report.
| Field | Entry |
|---|---|
| Build | Kimai 2.67.0, Playwright 1.49.0, Chromium 131.0.6778.33 |
| Scope | About 66 of 350 test cases processed; roles super admin, regular user and no-login; Desktop Chrome and iPhone 13 |
| Results | About 55 landed and 11 blocked; about 98 tracked rows (96 pass + 2 pass partially = 98), 0 failed; a row is one test case in one project, so 55 distinct test cases sit behind the rows; the pass-rate gate passed at about 100% (55 of 350 test cases, one app) |
| Decision | |
| Known issues accepted | TC-WEB-001 and TC-WEB-002: the app does not meet "after logout, the browser back button does not show protected page content". TC-SEC-004: skipped because the environment runs over HTTP. The other blocked cases, which the report puts down to three causes: Kimai defects, criteria the app does not meet, and a test-environment limit |
| Name | |
| Role | |
| Date |
Read the rows with their limits. The 98 rows cover 55 distinct test cases: 43 ran on two projects and 12 on one (43 x 2 + 12 = 98). The pass rate covers those 55 landed test cases, not all 350, and the run covers one app.
The decision, name, role and date stay blank. The signer fills them at signing, because the report records no decision and no signer. If the signer accepts, the known issues above go on the accepted sign-off.
Who is responsible for UAT?
The agency project manager owns the plan and the schedule, and leads triage; the client's sign-off authority owns the pass/fail line, and nobody else signs. In our view, UAT run as "the client clicks around" leaves nobody owning that line. We have no client project behind this view; it is a position.
| Role | Plan | Run | Triage | Fix | Sign |
|---|---|---|---|---|---|
| Agency project manager | Writes the plan | Runs the schedule | Leads | Schedules | None |
| Agency QA | Reviews the plan | Supports the testers | Joins | Retests | None |
| Client product owner | Approves | None | Joins | None | Recommends |
| Client testers | Review the scenarios | Execute | Report defects | None | None |
| Sign-off authority | None | None | None | None | Signs |
A small team without a QA engineer can outsource QA for the entry criteria. Then its developers do not test their own work.
What is a UAT checklist?
A UAT checklist is a short list of things to confirm before, during and after UAT. Ours has ten items in three phases.
Before:
- Put the acceptance criteria in the contract or statement of work.
- Name the client's testers and the signer.
- Meet the entry criteria and attach the evidence.
- Prepare the environment, test data and role accounts.
During:
- Record a result, a tester and a date for every scenario.
- Triage failures at the agreed time.
After:
- Retest every fix.
- Run the automated regression suite after the last fix.
- List the accepted known issues.
- Sign and date the sign-off.
What is a release sign-off, and what does the client sign?
A release sign-off is the point where the client states in writing whether it accepts the build. Without it, "done" is an opinion. The sign-off holds eight fields: build, scope, results, decision, known issues accepted, name, role and date.
How to prepare a sign-off document?
Prepare two decisions in advance: accepted or rejected. An accepted sign-off lists the known issues the client accepts, and a rejected one names the failed criterion. A rejection for something outside the acceptance criteria is a change request. The "Release sign-off" sheet of the template holds all eight fields.
What do you hand over to the client with the build?
The handover pack holds four things: the UAT results, the last regression run report, the known-issues list and the release notes. Give it to the client with the build. The regression report is the part a client can read without a tester.
We produce that report with qa-signoff Pro, a tool we built and sell. It writes a report folder per run, with the execution report, the log and the JSON results.
The execution report holds the release gate, which says PASS or BLOCKED. The gate checks a pass rate of 80% or more, regressions, tests whose test case changed, and orphaned, missing or misplaced tests. Attach the folder to the sign-off as evidence. The measured run on Kimai: 350 test cases from one crawl shows such a folder in full.
FAQ
What is acceptance testing in simple words?
Acceptance testing is the check where the people who ordered or will use the software try it and decide whether to accept it. It happens at the end of the project, against criteria agreed beforehand. If the criteria are met, the client accepts; if not, the agency fixes the build and reruns the affected scenarios.
Is end-to-end testing the same as UAT?
No. End-to-end testing follows one flow through the whole system, and testers or automation usually run it. The client runs UAT against the acceptance criteria and decides. A green end-to-end suite does not replace that decision: it checks the flows the agency chose, and the client checks the flows the business runs.
Does QA come before or after UAT?
QA comes before UAT and runs again after every fix UAT triggers. The agency's own checks, such as the automated regression run, are the entry criteria of UAT. The QA vs UAT section has the order in a table, with who runs each step and what ends it. A build that fails the entry criteria does not go to the client.
What is a QA signoff?
A QA signoff is the written record in which a named person states whether a build is accepted. It names the build, scope, results, decision, known issues accepted, and the name, role and date of the signer. The agency can sign off its own QA before the handover. The client signs the release sign-off at the end of UAT.
What is the difference between user acceptance testing and beta testing?
User acceptance testing is a planned test by named users against agreed criteria, and it ends in a sign-off. Beta testing gives the build to some customers to collect feedback before a wider release. It has no contractual decision at the end. If you want the plan for your own client, download the template and replace the example entries.
Download the UAT plan template (xlsx)
Licensed under CC BY 4.0. Attribution: qa-signoff, https://qa-signoff.com/en/blog/user-acceptance-testing-plan-template/
Hand the client a release gate: qa-signoff Pro writes a report folder per run and a PASS or BLOCKED line you can attach to the sign-off.
See Pro prices