Estimating & project management

User acceptance testing: how to sign off a delivery

User acceptance testing explained: who tests what, writing test cases from your requirements, ranking defects, exit criteria and signing off with confidence.

Your provider says the new application, or the new release, is ready. Now they need you to approve it, and that signature matters: it often triggers a payment, a go-live date and the end of free changes. User acceptance testing (UAT) is the step where you check, with your own people and your own cases, that the software does the job you paid for.

This guide is for business owners and managers, not testers. You will see who tests what, how to turn your requirements into test cases, how to rank defects, when to start and stop, and what to put in the sign-off, with a scenario template you can copy.

What user acceptance testing is, and what it is not

User acceptance testing is the last check before a delivery is accepted. It answers one question: can the people who will use this software every day do their work with it?

It is not the provider’s testing. A good provider runs its own checks before handing over, including a full pass of quality assurance (QA). Those prove that the software works as built. UAT proves that it was built for the right thing. Neither replaces the other.

Nor is it parity testing. When an old system is rewritten, automated parity tests check that the new one behaves exactly like the old one. UAT is done by people, against the business needs, including the ones the old system never met.

Who tests what

UAT works when everyone knows their part before testing starts.

  • The sponsor (often the owner or a director) decides what “good enough” means, settles disputes about severity and signs the acceptance.
  • Key users, a few people who know the daily work well, run the scenarios. Pick people who will use the tool, not only the most senior: the person who issues quotes all day will find what a manager never sees.
  • The UAT coordinator keeps the scenario list and the defect log and reports progress. In a small business this is often the sponsor.
  • The provider prepares the test environment and data, explains each release and fixes defects. It does not run your scenarios for you.
  • IT or the administrator, if you have one, checks access rights, exports and the connections to your other tools.

Block the testers’ time in their diaries. UAT squeezed between two client calls is UAT that does not happen.

Writing UAT test cases from your requirements

Your test cases come from what you asked for. If you wrote a software requirements specification, each requirement should already carry acceptance criteria: short, checkable statements of what must be true. “A quote can be sent as a PDF from the customer’s page” is an acceptance criterion. “Quotes are easy to send” is not.

Start from real work, not from screens

Write scenarios as a day in the life: “a returning customer asks for a quote and accepts it the same day”. Then add the awkward cases you meet every month: a customer with two addresses, a cancelled order, a refund, a user on a phone with a weak connection.

Cover the parts people forget

A sound UAT checklist goes beyond the main screens:

  • each role sees and does only what it should;
  • generated documents, with real names that contain accents and long addresses;
  • emails and notifications: who receives them, and when;
  • imports, exports and the link to your accounting tool or CRM;
  • lists and searches with realistic volumes, not ten test records;
  • the devices and browsers your team really uses;
  • data moved from the old system: totals, open items and history.

A test-scenario template

Illustrative example (fictitious data):

Field Example
ID UAT-07
Requirement R-12: send a quote from the customer’s page
Role Sales assistant
Starting data Customer “Harbour Bakery”, 2 previous orders
Steps 1. Open the customer. 2. Create a quote with 3 lines. 3. Apply a 5% discount. 4. Send it by email.
Expected result PDF with the 3 lines, the discount and the right total; email received; quote marked “Sent”
Actual result, status Filled in by the tester: Passed, Failed or Blocked
Tester, date, defect Name, date, and defect reference if failed

A shared spreadsheet is enough for a small project. What matters is that every requirement has at least one scenario, and every scenario has a result.

Logging and ranking defects

When a scenario fails, the tester logs a defect at once: the scenario ID, the steps, what was expected, what happened, a screenshot, the user and the time.

Each defect then gets a severity. Agree these levels with your provider before testing, not in the middle of an argument:

  1. Blocking: a key task cannot be done, data is wrong or lost, or a security rule is broken. No workaround.
  2. Major: the task can be done, but only through an awkward workaround.
  3. Minor: a small error that does not stop the work, such as a wrong label or a slow page.
  4. Cosmetic: spelling, alignment, colours.

Some reports are not defects but new wishes that were never in the requirements. Log them separately as change requests: they may be worth doing, but they are priced and planned on their own, so they do not quietly delay the acceptance.

Hold a short triage meeting every day or two. The sponsor, the coordinator and the provider confirm severities and agree what goes into the next test release.

Entry and exit criteria: when to start and when to stop

Entry criteria stop you from wasting your team’s time on a delivery that is not ready. Before UAT starts, check that:

  • the provider has finished its own testing and shared the results;
  • the test environment is separate from your live system;
  • the test data looks like your real data, anonymised where needed;
  • testers have their accounts, the scenarios and a short briefing;
  • known open defects are listed.

Exit criteria tell you when you can sign:

  • every scenario has been run at least once;
  • no blocking defect remains open;
  • each open major defect has an agreed workaround and fix date;
  • minor and cosmetic defects are listed with a plan;
  • failed scenarios have been run again on the fixed release and passed.

Write these criteria into the project plan, ideally into the contract. They turn “is it ready?” from a feeling into a check.

Signing off with confidence

The sign-off is a short document, not a formality. It states the release accepted and the date, the scenarios run and their results, the open defects with their agreed handling, any reservations (points accepted on condition they are fixed by a given date), and the signatures of the sponsor and the provider.

Signing with reservations is normal and healthy. You go live on time and keep a written record of what is still owed.

Read your contract before you sign. Depending on the contract and the country, signing, or simply using the software in production without objecting, can count as acceptance and start a warranty period. This is general information as of October 2026: it does not replace the advice of your lawyer, who must confirm what applies to you.

When our founder, Anass Chabbab, led a custom CRM and ERP for a Sydney law firm in his previous role at DIGIIT Solutions, the first release came in under 6 months and the system grew to more than 100 users. With that many people relying on one tool, a release is only finished when the people who use it agree that it does their job. That is why we plan acceptance into our custom software projects from the start, not at the end. And whether a provider takes UAT seriously is a fair question when choosing an IT provider.

Frequently asked questions

How long should user acceptance testing take?

It depends on the size of the release and on how many people can test. Plan at least one round to find defects and one round to check the fixes, and time-box each round so testing does not drift. If the provider’s own testing was thin, UAT will take longer: your entry criteria protect you from that.

Who should write UAT test cases?

The business should own them, because only your team knows the real cases. Key users write the scenarios from the requirements and their daily work, and the coordinator checks that every requirement is covered. The provider can help with the format, but scenarios written only by the people who built the software tend to test what they built rather than what you need.

Can we go live with known defects?

Yes, if none is blocking and everyone agrees in writing. Most go-lives carry a list of minor issues. Record each one in the sign-off with its workaround and a fix date, and check after go-live that they are closed. Do not accept an open blocking defect, or a major one with no workaround on a daily task.

In short

User acceptance testing is where your own people check that a delivery does the job, using scenarios built from your requirements and acceptance criteria. Agree the roles, the severity levels and the entry and exit criteria before testing starts. Log every defect, keep new wishes apart, and retest the fixes. Then sign a sign-off that records what was accepted and what is still owed.

Expecting a delivery soon and not sure how to accept it? Book a free 30-minute discovery call: we look at your project together and work out a test plan that fits it.

Related servicesCustom softwareModernisation

Have a project in mind?

Let’s talk about it on a 30-minute discovery call, free and with no obligation.

Book a discovery call

Further reading

All articles