Website

Acceptance Criteria for Software: How to Write Tests That Settle "Is It Done?"

November 11, 2026 · 5 min read · Etzal Group Team

The vendor says the approval feature is finished. The client says it is not, because a manager on leave cannot delegate approvals to a deputy. The vendor replies that delegation was never requested. Both are right, in the sense that the requirement said only "managers can approve purchase requests". The argument costs two weeks and some goodwill. Acceptance criteria written before the build would have raised the delegation question on day one, when answering it cost nothing.

What they are

Acceptance criteria are specific, testable statements of what must be true for a piece of work to be accepted. They sit between a requirement, which says what is wanted, and a test, which checks it.

Requirement: "Managers can approve purchase requests."

Criteria:

  • A request up to 10 million rupiah goes to the requester's direct manager.
  • A request above 10 million goes to the direct manager and then the finance head.
  • A manager can approve or reject, and rejection requires a reason.
  • A manager can delegate approval to a named deputy for a date range.
  • The requester is notified of the decision.
  • A user cannot approve their own request.

The fourth line is where the delegation question surfaces.

A format that works

The "given, when, then" form forces precision:

  • Given a starting situation,
  • when something happens,
  • then a result can be observed.

Example: Given a purchase request of 15 million rupiah approved by the direct manager, when the finance head opens the approval list, then the request appears with the manager's approval and date shown.

A plain checklist also works, provided every line can be answered yes or no by someone watching the screen.

The test of a good criterion

  • Observable. Someone can see whether it is true.
  • Specific. It contains numbers, names and states, not adjectives.
  • Independent of design. It says what happens, not which button colour.
  • Agreed. Both sides have read it and signed off.

Compare:

  • Weak: "The report loads quickly." Strong: "The monthly sales report for one branch displays within three seconds with 50,000 transactions in the database."
  • Weak: "The system is user-friendly." Strong: "A new cashier completes a sale with two items and a cash payment within two minutes after a fifteen-minute briefing."
  • Weak: "Data is secure." Strong: "A user with the cashier role cannot open the supplier price list, by menu or by direct address."

Cover more than the happy path

For each feature, ask five questions.

  1. Normal case. What happens when everything is as expected?
  2. Variations. Different amounts, roles, branches, currencies?
  3. Errors. What if a field is empty, a value is negative, the connection drops?
  4. Permissions. Who must not be able to do this?
  5. Limits. The largest file, the longest name, the busiest hour?

Most disputes come from questions 2 to 5, because the requirement described only question 1.

Criteria that are not about features

Some of the most important criteria apply to the whole system. Write them down as well.

  • Performance. Response time for key screens at an agreed data volume and number of concurrent users.
  • Availability. Hours of service and acceptable downtime.
  • Security. Roles, password rules, audit trail, encryption of sensitive data.
  • Compatibility. Browsers, devices, screen sizes, operating system versions.
  • Data migration. Record counts and control totals that must match the old system.
  • Backup and recovery. How much data may be lost and how quickly service must return.
  • Documentation. What manuals and technical documents are handed over.

Left unwritten, each is an argument waiting for go-live.

Defect classes

Not every failed test should block acceptance. Agree the classes in advance:

  • Critical. A core process cannot be completed, or data is wrong or lost. Blocks acceptance.
  • Major. A function fails but a workaround exists. Blocks acceptance unless both sides agree otherwise.
  • Minor. Cosmetic or inconvenient. Listed, fixed within an agreed time, does not block.

Then define acceptance itself: for example, no critical or major defects open, and no more than ten minor ones, each with a fix date.

Planning user acceptance testing

Criteria are checked in user acceptance testing, UAT. A plan on one page:

  1. Who tests. Real users from each role, not only the project team.
  2. Where. An environment that matches production, with realistic data.
  3. What. Test scenarios built from the criteria, following real work from start to finish: an order from entry to invoice to payment.
  4. How long. One to three weeks for a mid-sized system, with users' time reserved.
  5. How defects are recorded. One list, with steps, screenshots, class and status.
  6. How it ends. A signed acceptance record listing what was tested and what remains open.

Reserve the users' time. UAT done in spare moments between daily work finds little, and the defects appear after go-live instead.

Common mistakes

  • Writing criteria after the build, when they describe what was built.
  • Adjectives in place of numbers.
  • Only the normal case.
  • No system-wide criteria.
  • No defect classes, so a spelling error holds up a payment, or a serious fault is waved through.
  • UAT by the project team alone.
  • Changing criteria during testing without a change request.

When to write them

Before development of each feature begins. In an agile project, that means before the sprint. In a fixed-price project, the main criteria belong in the contract or its annex, because payment milestones depend on them.

Writing criteria takes effort that feels like delay. It is some of the cheapest work in a project: every question it raises is answered in a conversation, not in rework.

We write acceptance criteria with clients as part of every Enterprise Software project and attach them to milestones. If you have requirements and want help turning them into testable criteria, talk to us.

Summary

For each feature, write three to eight observable, specific statements covering the normal case, variations, errors, permissions and limits. Add system-wide criteria for performance, security, migration and recovery. Agree defect classes and a definition of acceptance. Test with real users in a planned UAT and sign the result. The question "is it done?" then has an answer both sides wrote in advance.

Frequently asked questions

Who should write acceptance criteria?

The client and the vendor together. The client knows what the business needs, and the vendor knows what can be tested and where ambiguity hides. Criteria written by one side alone are either untestable or miss what matters. The client must approve the final version.

How many acceptance criteria does a feature need?

Usually three to eight. One for the normal case, several for variations and error cases, and one or two for limits such as permissions. If a feature needs twenty, it is probably several features and should be split.

What is the difference between acceptance criteria and a test case?

Acceptance criteria state what must be true for the feature to be accepted, in business language. Test cases are the detailed steps and data used to check each criterion. One criterion may be covered by several test cases.

Author

Etzal Group Team

Etzal Group Team, helping businesses grow with technology. Contact us.

Related service

Website Development

Fast, SEO-ready websites that turn visitors into customers.