Quick answer
UAT (user acceptance testing) is the final test before release, in which the people who will use or own the software check that it does the job the business needs, using scenarios that state who does what and what result they should see, including whether tracking events fire as planned.
Formula: Event pass rate = events that arrived with required-property completeness at or above the threshold ÷ events in scope
What is UAT testing?
UAT (user acceptance testing) is the last test before release, in which the people who will use or own the software check whether it does the job the business needs. The ISTQB glossary defines it as acceptance testing "performed to determine if intended users accept the system". The output is a decision, accept or reject, not a bug count.
That decision is what separates UAT from the testing that comes before it. Unit, integration and system tests ask whether the software matches its specification. UAT asks whether the specification, now built, actually works for the people paying for it: can the finance team close the month, can a shopper with a coupon check out, can a support agent find the customer's last order. Software can pass every technical test and still fail UAT because the requirement was misunderstood.
To make that decision checkable, acceptance criteria have to be written as scenarios: who does what, and what result they should see. And because releases are now judged with analytics, one of those results should be that the tracking events fire as the tracking plan says. A checkout that works but sends no purchase event will pass the eye test and fail the first revenue report.
The term is sometimes written "UAT testing", which is redundant (the T already means testing) but is how most people search for it. Other names include end-user testing, business acceptance testing and acceptance testing.
UAT vs QA, alpha and beta testing
| QA / system testing | Alpha testing | Beta testing | UAT | |
|---|---|---|---|---|
| Who tests | QA engineers | Employees outside the dev team | Real external users who opt in | Business owners, key users or the client |
| Environment | Test environment | Developer's environment | Users' own devices | Staging / UAT environment close to production |
| Measured against | Functional and technical specification | "Can it be used at all?" | Real-world quality and stability | Agreed business requirements |
| Typical output | Defect reports, test pass rate | Exit decision for beta | Exit decision for release | Formal sign-off or rejection |
| Who can stop the release | QA lead | Product team | Product team | The accepting business owner |
The main confusion is between UAT and QA. QA checks that the "apply coupon" button calls the discount service and returns the right total. UAT checks that the marketing manager can launch the weekend promotion the way it was planned, with the coupon, the email link, the order confirmation and the report that shows how many orders used it.
Alpha testing and beta testing are defined by who tests and where; UAT is defined by who decides. In ISTQB's vocabulary alpha and beta are themselves types of acceptance testing. For consumer apps a closed beta often doubles as UAT; for internal systems and client projects UAT is usually a separate, scheduled phase with named approvers. After sign-off, a canary release can still limit the damage of anything UAT missed.
Types of acceptance testing
- Business (user) acceptance testing. Key users run real business scenarios end to end. This is what most people mean by UAT.
- Operational acceptance testing. The team that will run the system checks backups, monitoring, alerting, recovery and support procedures. ISTQB lists it as a separate type.
- Contract acceptance testing. The software is checked against acceptance criteria written into a contract, typical for agency and client work.
- Regulatory acceptance testing. The system is checked against legal or industry rules, such as consent handling or audit logs.
- Alpha and beta testing. Acceptance by users in the developer's environment and in their own, as covered above.
Who performs UAT, and when
UAT is run by people who represent the users and own the outcome: a product owner, the operations or finance lead for an internal system, the client for an agency build, or a group of key users chosen by them. Developers and QA support the session, fix defects and prepare data, but they do not sign off.
It starts when system testing is finished, no critical defects are open, the UAT environment mirrors production (same configuration, realistic data, same integrations) and the scenarios are written and agreed. It ends with a sign-off document that lists each scenario, its result and any accepted known issues. If any of those preconditions is missing, UAT turns into a second round of QA, done by people who are not trained for it.
How to write acceptance scenarios
A scenario names a role, a starting state, an action and an observable result. The Given / When / Then format from Gherkin works well because each part can be checked by someone who has never seen the code. Five examples for an online shop launching coupons:
- Given a signed-in shopper with a valid code SPRING20 in the cart, when they apply the code, then the order total drops by 20% and the line "SPRING20 −20%" appears before payment.
- Given an expired code, when a shopper applies it, then the total does not change and the message "This code has expired" is shown.
- Given a marketing manager, when they create a code limited to 500 uses, then the 501st attempt is refused.
- Given a completed order that used SPRING20, when the support agent opens the order, then the coupon and discount amount are visible.
- Given a completed order that used SPRING20, when the order is placed, then the events
coupon_applied(withcoupon_code) andcheckout_completed(withorder_idandrevenue) arrive in analytics within minutes, with every required property filled.
Scenario 5 is the one most UAT plans leave out. It is just as checkable as the others, and if it fails, the promotion's results cannot be measured even though the feature works.
Data acceptance checklist
Before signing off a release that changes user-facing flows, check the data the same way you check the screens. The tracking plan is the specification:
- Every planned event arrives. Each event in scope for the release shows hits from the UAT environment, from the scenarios that should trigger it.
- Required properties are filled. Completeness of required properties is close to 100%, not "mostly there". Set a threshold in advance, for example 95%.
- Values have the right type and format. Revenue is a number, not a string with a currency sign; IDs match the format downstream systems expect.
- No unplanned events. Renamed or misspelled events show up as new names that nobody planned.
- Test traffic is separable. UAT hits can be filtered out or are sent to a test project, so they do not leak into production reports.
- Reports that depend on the events still work. The funnel or revenue report the business will use after launch shows the UAT orders correctly.
Worked example: event pass rate
Sample data: the coupon release above has 12 events in scope in the tracking plan. During a 24-hour UAT window, testers run every scenario. The pass rule, agreed beforehand: an event passes if it arrived and at least 95% of its hits have every required property.
| Event | Hits in 24 h | Required property | Hits with it filled | Completeness | Result |
|---|---|---|---|---|---|
checkout_completed | 412 | order_id, revenue | 412 | 100% | Pass |
coupon_applied | 58 | coupon_code | 51 | 51 ÷ 58 = 87.9% | Fail |
signup_completed | 120 | plan | 109 | 109 ÷ 120 = 90.8% | Fail |
| 9 other events | all > 0 | various | ≥ 98% each | Pass |
Event pass rate = events passing ÷ events in scope = 10 ÷ 12 = 83.3%.
All five business scenarios passed on screen, so a UAT without a data check would have signed off. The data check shows two problems. Seven coupon_applied hits (58 − 51) were sent without the code, which turned out to happen when the coupon is applied from the email link instead of typed into the cart. Eleven signup_completed hits (120 − 109) lacked the plan, because the free plan sends no value. The campaign report would have undercounted coupon use by 12.1% (7 ÷ 58) and shown 9.2% (11 ÷ 120) of signups with no plan.
The decision rule turns this into a clear outcome: both events feed launch reports, so the release is not signed off until both are fixed and pass a new 24-hour check. The fix took one property assignment in each code path; the re-check showed 100% on both.
Common mistakes
- Treating UAT as more QA. If users are finding crashes and broken buttons, the build was not ready for UAT. Send it back.
- Vague acceptance criteria. "The checkout should work well" cannot be passed or failed. Write who, what and the expected result.
- Testing with unrealistic data. Ten tidy test products hide the problems that 10,000 real ones cause.
- No named approver. Without a person who can say no, UAT ends when the release date arrives.
- Leaving tracking out of scope. Events are verified after launch, when the first report looks wrong and the campaign is already running.
- Mixing UAT traffic into production numbers. Test orders inflate conversion and revenue unless they are filtered or sent elsewhere.
Checking tracking data during UAT in TapCub
The worked example maps directly onto the TapCub tracking plan: the 12 events, the 24-hour window and the completeness threshold.
- Put the release's events in the plan before UAT. In All-platform analytics › Data › Tracking plan, each row holds the event name, platforms, trigger, properties (with a required flag), owner and status. Events that are built and waiting for acceptance go to the Accepting status, which means events have arrived and you are still checking properties. See create a tracking plan.
- Turn on Live verification (24 h) during the UAT window. It adds two columns to the plan: hits in the last 24 hours and completeness of required properties. That is the table in the example:
coupon_appliedat 58 hits and 87.9% stands out next to rows at 100%. Low completeness is a warning only; it does not block intake unless you add a validation rule in the property dictionary. - Catch unplanned events. A misspelled or renamed event does not slip into the reports silently: new event names land in All-platform analytics › Data › Event inbox and only join the formal definitions after someone claims them.
- Find lost data. If an event shows fewer hits than the scenarios produced, All-platform analytics › Data › Data quality shows at which step data was dropped: a domain mismatch, an exclusion rule, a quota, a rate limit or a bad payload.
- Mark accepted events live. After sign-off, move the rows to Live; syncing the plan to definitions marks those definitions live too.
TapCub does not manage UAT test cases, approvers or sign-off documents. It checks the data half of the scenarios: whether each planned event arrived, and arrived complete.
Sources
- ISTQB Glossary, user acceptance testing.
- ISTQB Glossary, acceptance criteria.
- Cucumber, Gherkin reference.
Was this explanation clear?
We use your answers to fix and expand this page.
Couldn’t send. Please try again in a minute.
Thanks for the feedback. We’ll use it to improve this page.You’ve already sent feedback on this page. Thanks.

Data Engineer
Writes about event design, data quality, and collection workflows, with verifiable implementation methods for reliable analytics.