Back to Blog

Software Engineering

User Acceptance Testing (UAT): A Buyer's Guide for Bespoke Software

User acceptance testing (UAT) is where your business, not the developer, checks that new software does the job before you accept it. Here is how to plan it, write test cases, handle defects and sign off with confidence.

Azhar Ali Dar

Software Developer

November 18, 20269 min read

User acceptance testing (UAT) is the last stage of testing before new software goes live, where the business that commissioned it checks it does what the business needs. Real users run through realistic tasks and test each one against the acceptance criteria agreed at the start. If it passes, the business formally signs off and accepts the software.

Most UAT guides are written for testers and QA teams. This one is for the other side: a UK business that has commissioned bespoke software and now has to decide whether to accept it. It covers who should test, how to write test cases, what data to use, how to handle defects and what sign-off really commits you to.

What is user acceptance testing, and what isn’t it?

Bespoke software goes through several kinds of testing, and most of it is the supplier’s job. UAT is the one that belongs to you.

Testing Who does it What it checks
Unit and integration testing Supplier’s developers Each piece of code works, and the pieces work together
System and QA testing Supplier’s testers The whole system works as specified, including performance and security
User acceptance testing Your users and business owner The software does the job your business needs, in realistic conditions
Usability testing Designers, with sample users People can work out how to use it, ideally done much earlier

The difference is easy to summarise. QA testing asks “did we build it right?” UAT asks “did we build the right thing?” A system can pass every QA test and still fail UAT if it follows the specification but doesn’t fit how your team works.

UAT is also not the time to discover requirements. If testers keep saying “it should also do X”, that’s a sign the requirements were thin. Those items are change requests, not defects (more on that below). A clear software requirements specification at the start is what makes UAT quick at the end.

Who should do UAT on a bespoke project?

Three roles matter:

  • A business owner who has the authority to accept the software and is accountable for the decision. One named person, not a committee.
  • Testers from the business, ideally the people who will use the software every day. A finance clerk will find problems in an invoicing workflow that a project manager won’t.
  • A UAT coordinator who schedules testers, tracks results and triages defects with the supplier. On a small project this can be the business owner.

The supplier’s role is to support, not to accept. They should provide a stable test environment that matches production, brief your testers on what’s ready to test, and fix defects quickly. It’s a warning sign if a supplier offers to “run UAT for you” and hands you a signed-off report.

When does UAT happen, and how long should it take?

On a traditional project, UAT happens once, after the supplier finishes system testing and before go-live. On an agile project, it’s better to accept work in smaller pieces: a short acceptance check at the end of each sprint or milestone, then a final end-to-end UAT before launch. Problems found early cost far less to fix.

Plan it like any other piece of work:

  • Book your testers’ time in advance. UAT usually slips because the business’s testers are busy doing their day jobs, not because the software is late.
  • Check the acceptance period in your contract. Many software contracts give the buyer a set number of working days after delivery to test and accept or reject. Some also include deemed acceptance: if you don’t respond in time, the software counts as accepted. Know which applies before delivery day.
  • Allow time for at least one round of fixes and retesting. A plan that assumes everything passes first time will be late.

How do you write UAT test cases?

Write them from the acceptance criteria in your requirements, not from the finished screens. Each test case checks one thing and can only pass or fail.

Field Example
ID UAT-14
Requirement FR-12: managers approve or reject holiday requests
Preconditions Test user “Line manager A” has a pending request from someone in their team
Steps 1. Sign in as Line manager A. 2. Open the pending request. 3. Click Approve.
Expected result Status shows Approved. The employee gets an email. Their balance drops by the requested days.
Actual result, pass/fail, tester, date Filled in during testing

If your requirements already use the Given/When/Then format of Gherkin, each scenario becomes a test case almost word for word:

Given a pending request from someone outside my team, when I open it as a line manager, then I can’t approve or reject it.

Cover more than the happy path. For each important workflow, include tests for:

  • Permissions: can each role see and do only what it should?
  • Mistakes: what happens with missing fields, wrong formats or a double click on Submit?
  • Real volumes: does the report still work with a year’s worth of data, not ten test records?
  • Integrations: does the order actually arrive in your accounting or CRM system, with the right values?
  • Devices and browsers: the ones your staff and customers actually use.
  • Accessibility: if your requirements name a standard such as WCAG 2.2 level AA, include keyboard-only and screen-reader checks. The GOV.UK Service Manual explains how public services test for this.

What data should you use for UAT?

Realistic data finds more problems, but live customer data in a test system creates a data protection problem. Copying personal data into a test environment is still processing under UK GDPR. It needs a lawful basis and the same care over security, access and retention as the live system, and test environments rarely get that care.

In order of preference:

  1. Synthetic data that looks real (realistic names, addresses, amounts and edge cases) but describes nobody. Ask your supplier to generate it as part of the project.
  2. Anonymised data, where nobody can be identified even when combined with other information. This is harder to do properly than it sounds.
  3. Live data, only if testing genuinely can’t be done without it, limited to what’s needed, with access restricted and deleted after testing.

Note that pseudonymised data, where names are swapped for reference codes but the link can be restored, is still personal data under UK GDPR. The ICO’s guidance on anonymisation and pseudonymisation covers where the line sits.

How should you report and triage defects?

Log every issue in one shared place, such as the supplier’s ticket system or a shared tracker, never in emails and chat. Each report needs the test case ID, steps to reproduce, what you expected, what happened, and a screenshot.

Then agree a severity for each one:

Severity Meaning Usual rule for sign-off
Critical A core process can’t be completed, or data is lost or exposed Must be fixed before sign-off
High A core process works only with an awkward workaround Usually fixed before sign-off
Medium A non-core feature is wrong, with a workaround Can be accepted with an agreed fix date
Low Cosmetic, such as a typo or misaligned button Can be accepted and fixed later

Agree these definitions and the sign-off rule before UAT starts, so the conversation is about facts, not tempers.

The hardest call is defect or change request? A defect is where the software doesn’t meet an agreed requirement. A change request is where it meets the requirement, but the requirement turns out not to be what you needed. Under a fixed-price contract, defects are the supplier’s cost and changes are usually yours. Our guide to fixed price vs time and materials explains why this matters so much. Clear, testable requirements make the call easy. Vague ones make it a negotiation.

What does UAT sign-off commit you to?

Sign-off is a formal statement that the software meets the agreed acceptance criteria. Depending on your contract, it often:

  • triggers a payment milestone,
  • starts a warranty or defect-fixing period, after which fixes may fall under a paid support agreement,
  • moves the software into live use, with all the data protection and operational responsibilities that brings.

So read the acceptance clause before you sign. If the software is ready to go live apart from a few medium and low issues, you can usually give conditional acceptance: sign off with a written list of known issues and the dates they will be fixed. That’s better than refusing to sign over trivia, and much better than signing a clean acceptance under deadline pressure and finding the gaps later.

A UAT checklist you can copy

Before UAT
[ ] Business owner named, with authority to accept
[ ] Testers booked, from the people who will use the system
[ ] Acceptance period and deemed-acceptance terms checked in the contract
[ ] Test cases written from the requirements' acceptance criteria
[ ] Severity levels and the sign-off rule agreed with the supplier
[ ] Test environment ready, matching production as closely as possible
[ ] Test data prepared: synthetic or anonymised where possible

During UAT
[ ] Every result recorded against a test case ID
[ ] Every issue logged in one tracker, with steps and screenshots
[ ] Each issue classified: defect or change request, and severity
[ ] Fixes retested, plus a quick check that nothing else broke

At sign-off
[ ] No open critical or high defects (or as agreed)
[ ] Remaining issues listed with fix dates (conditional acceptance)
[ ] Warranty period and support arrangements confirmed
[ ] Sign-off recorded in writing by the business owner

Accepting software with confidence

User acceptance testing works when it’s planned from the start: testable requirements, named testers, agreed rules for defects and a clear contract. Done that way, sign-off is a confident decision rather than a leap of faith. If you’re planning a bespoke software project and want acceptance built in from the first requirement, talk to us.

Frequently asked questions

What is the difference between UAT and QA testing?

QA testing is done by the supplier's team to check the software works as built: that the code is correct, features don't break each other and the system holds up under load. UAT is done by the business that commissioned the software, to check it does what the business needs in realistic conditions. QA asks 'did we build it right?'; UAT asks 'did we build the right thing?'.

Who should do user acceptance testing?

People from the buyer's side who will actually use the software or own the process it supports, such as the staff who will process orders or approve requests. A named business owner should be responsible for signing off. The supplier supports UAT by preparing the test environment, explaining features and fixing defects, but shouldn't be the one doing the accepting.

How long should UAT take?

It depends on the size of the release and how many people need to test, so agree it in the project plan rather than squeezing it into the last few days. Many software contracts set an acceptance period, a fixed number of working days after delivery in which the buyer must test and either accept or report defects. Check how long yours is and make sure your testers are available then.

Can we use real customer data for UAT?

Avoid it where you can. Copying live personal data into a test environment is still processing under UK GDPR, so it needs a lawful basis, security and minimisation like the live system. Synthetic data, or data that has been properly anonymised, is usually safer. Pseudonymised data, where names are swapped for codes, is still personal data in law.

What happens if we find a defect after UAT sign-off?

That depends on your contract. Many bespoke software contracts include a warranty or defect-fixing period after acceptance, during which the supplier fixes defects at no extra cost. After that, fixes usually fall under a support and maintenance agreement. Check both before you sign off, so you know what you are agreeing to.

About the author

Software Developer

Azhar Ali Dar works on custom software engineering at CyberSpark and handles Employer of Record and statutory compliance solutions at EOR Services (https://www.eor-services.co.uk/), writing about distributed teams, payroll and UK employment law.

Continue reading

Related Articles

Explore additional perspectives related to this topic and expand your implementation strategy.

Want to talk this through?

Tell us about your project and a person on our team will reply with practical next steps.

Contact us