Skip to main content
Free 20-minute marketing audit
Limited spots available

Have a question?

We usually reply within 5 minutes.

WWhatsApp TTelegram

ERP user acceptance testing (UAT) in Uzbekistan: scenarios, roles, defect severity and go-live criteria

How to accept an ERP from a developer in Uzbekistan: UAT scenarios, test data, who tests, defect severity, acceptance criteria, parallel run and sign-off.

ERP user acceptance testing (UAT) in Uzbekistan: scenarios, roles, defect severity and go-live criteria

Short answer: ERP user acceptance testing (UAT) means the system is checked by its future users on real business processes, not by the developer. The outcome is either a signed acceptance certificate or a list of defects to fix. If the criteria are not written down in advance, acceptance turns into a feeling that "it seems to work". The defects then appear after go-live, on real money and real stock.

How a custom system is built is covered in the guide to custom ERP development. This article is about the riskiest moment in the project: the developer says "done", and you have to say "accepted". It is written for foreign companies setting up or acquiring operations in Uzbekistan, where the local team, local tax documents and local contract practice all shape how sign-off works.

What UAT is and how it differs from developer testing

In its own testing, the developer checks that pressing a button does the right thing. UAT asks a different question: can the company run a full working day in this system, start to finish?

  • Who runs it — Developer testing: Programmers, QA; User acceptance testing (UAT): Company staff
  • What it checks — Developer testing: Whether a function works technically; User acceptance testing (UAT): Whether a business process runs end to end
  • Basis — Developer testing: Items in the specification; User acceptance testing (UAT): Real work situations and acceptance criteria
  • Output — Developer testing: Internal defect list; User acceptance testing (UAT): Decision: accept or send back

The developer should finish its own testing before UAT starts. The entry condition is simple: the test server works, users and roles exist, and test data is loaded.

Who tests: roles and responsibilities

Handing UAT to whoever in the department is least busy is a mistake. A tester must know the process well and be willing to say "that is not how we do it".

Also read Your Customer Calls Twice and Still Has to Spell Their Name: Connecting IP Telephony to ERP in Uzbekistan Technology · 10 min
  • Acceptance owner — the project lead on the company side. Writes the plan, keeps the defect log and makes the final call with the business owner or country manager.
  • Key users — one per department: storekeeper, cashier, sales manager, accountant. They run the scenarios.
  • Chief accountant — checks every money and stock report separately. In Uzbekistan this person also knows the local tax documents best.
  • Owner or general director — opens 2–3 key reports personally and signs the certificate.
  • Developer representative — stays close, answers questions, logs defects.

If head office staff take part, agree on a working language early. Scenarios written in English and run by a Russian- or Uzbek-speaking team will be misread. Write each scenario in the language of the person who executes it.

Cut testers' regular workload during UAT. Without 2–3 hours a day set aside, testing stays "for spare time" and drags on.

Test scenarios: processes, not functions

A scenario is not "test the create-order button". A scenario is a real work situation from beginning to end. It is built from the requirements in the specification and the process map. How to write requirements is covered in the article on the ERP technical specification. If processes are documented as procedures, scenarios are far easier to write; see the article on business process procedures (SOPs).

Every scenario has five parts: starting state, steps, who performs them, expected result and actual result.

  • Partial shipment — Steps: Customer ordered 10 units, 6 in stock, 4 ship tomorrow; Expected result: Two shipments, receivable correct on both
  • Return — Steps: Customer returned 1 defective unit; Expected result: Stock, receivable and cost corrected
  • Credit limit exceeded — Steps: Sales manager entered an order above the limit; Expected result: System blocked it and sent it for approval
  • Month-end close — Steps: All documents entered, report run; Expected result: Stock and profit match a manual calculation
  • Access rights — Steps: Cashier tried to change a price; Expected result: Access denied

Do not test only the happy path. Most defects live in exceptions: returns, cancellations, partial payments, backdated documents, two users opening the same document at once. Write at least one such "awkward" scenario for every key process. Add local ones too: an electronic invoice (ESF) that the buyer rejects, or a refund at the till, where stock in the system and the cash register report must change by the same amount.

Foreman reads test steps aloud in a Samarkand furniture workshop as a key user enters data on a tablet

Test data: realistic but safe

Testing on two or three invented products hides a lot. The test database should hold a volume close to real life: the actual product list, actual price types, part of the customer base and last month's balances.

If real data is copied into the test database, mask the personal data of customers and staff: phone numbers, passport details, addresses. Uzbekistan has its own personal data law, so check with local counsel what applies, especially if the test server sits outside the country. Restrict who can access the test server.

It is convenient to prepare test data together with one of the trial migrations. That checks two things at once: whether the system works and whether the data moved correctly. The migration itself is covered in the article on ERP data migration.

Before every round, reset the database to the same starting state, or round two cannot be compared with round one.

Logging defects and severity levels

Defects go into one log, not a chat: a spreadsheet or a bug tracker. Each entry holds the scenario number, steps, expected and actual result, a screenshot, who found it and the severity.

  • Critical — Definition: A key process stops, or money or stock is calculated wrongly; Example: Stock does not decrease after a sale; Effect on acceptance: Cannot be accepted
  • High — Definition: An important function fails, a workaround exists; Example: Returns only go through the accountant; Effect on acceptance: Allowed with a fix date
  • Medium — Definition: Slows work, does not affect results; Example: Filter is not saved; Effect on acceptance: Logged, fixed under warranty
  • Low — Definition: Appearance, wording, convenience; Example: Wrong column name; Effect on acceptance: Next update

Agree in advance who sets the severity. Usually the tester proposes it and the acceptance owner confirms. If the developer disagrees, the dispute goes to the managers of both sides.

Add a separate column: defect or new requirement. If the system works as written in the specification but you need it to work differently, that is a new requirement. It does not block acceptance and is estimated separately.

Acceptance criteria: when you can say "yes"

The criteria are written before UAT starts and signed by both sides. An illustrative example:

  • every scenario has been run at least once;
  • at least 95% of scenarios have passed;
  • critical defects — 0;
  • high defects — no more than 3, each with a written workaround and fix date;
  • the month-end report matches a manually calculated control total.

Worked example: 114 of 120 scenarios passed. 114 / 120 = 95%. The remaining 6 relate to medium and low defects. There are no critical defects and 2 high ones. The criteria are met and the system can be accepted. If even one of the remaining six is critical, the system is not accepted, even though the percentage is high enough.

Tune the numbers to your business: a rule written in advance decides, not an impression.

Parallel run: the final check in real conditions

A test database does not show everything. So during the first period after go-live, especially for money and stock, a short parallel run takes place. Work is recorded in the new system, while the old method is kept for control.

The length of the parallel run and the condition for ending it are written down in advance. For example: "2 weeks. Every day the cash, daily sales and stock of 20 key items are reconciled. If there are no differences for 5 days in a row, or every difference is explained, the old method is switched off".

If a difference appears, find the cause first. Do not stretch the parallel run: keeping the same records in two places wears people out and multiplies errors.

Acceptance certificate and warranty period

The acceptance certificate (often called an "akt" locally) is the formal document confirming the system was accepted. It states:

  1. which modules were accepted and against which version of the specification;
  2. UAT results: how many scenarios, how many passed;
  3. an annex listing open defects with severity and fix date;
  4. what was handed over: source code, documentation, access credentials, user guide;
  5. the date the warranty period starts.

The certificate is often tied to payment, so it makes sense to hold the final payment until the system is stable. Illustrative example: a contract worth 300 million sums with a 20% final payment. 300 × 0.2 = 60 million sums are paid after the parallel run ends and the remaining high defects are closed.

The Civil Code of Uzbekistan sets out how the result of work is accepted under a work contract (pudrat). A software development agreement, however, may be structured as a work contract, a services contract or a copyright agreement. Have local counsel confirm which rules apply and what form of certificate to use. The certificate date also matters for local accounting and for the electronic invoice (ESF), so agree it with the chief accountant.

During the warranty period, defects where the system does not meet the agreed requirements are fixed free of charge. The term, response times and exclusions belong in the contract. How to organise support once the warranty ends is covered in the article on ERP support and SLAs.

Bakery owner in Bukhara signs the acceptance document as the chief accountant checks the second copy

Common mistakes

  • Writing acceptance criteria after UAT, with the results in front of you.
  • Watching the developer's demo and saying "it works".
  • Not giving testers time.
  • Testing only the happy path, without returns or cancellations.
  • Logging defects in chats and voice messages.
  • Treating a new requirement as a defect and blocking acceptance.
  • Trusting "fixed" without a second round.
  • Leaving the list of open defects out of the certificate.
  • Paying the full amount at the moment of acceptance.

UAT checklist

  • ☐ The UAT plan, timeline and owners are written down.
  • ☐ Acceptance criteria were signed by both sides before UAT.
  • ☐ Every key process has a scenario, including exceptions and local cases.
  • ☐ Every scenario has an expected result written in advance.
  • ☐ The test database has realistic volume and masked personal data.
  • ☐ Testers have working time set aside for UAT.
  • ☐ Defects are in one log, with severity and a "defect or new requirement" flag.
  • ☐ At least two rounds were run and fixes were retested.
  • ☐ The parallel run length and exit condition are defined.
  • ☐ The certificate lists open defects, handed-over items and the warranty start date.
  • ☐ The final payment is tied to stabilisation.

10–11 ticks: you are ready for acceptance. 6–9: close the gaps before UAT starts. 5 or fewer: write the scenarios and acceptance criteria first.

Conclusion

Accepting a system is a check, not a signature. It is carried out by the people who will use the system, on real processes, not by the developers. Write the criteria in advance, log defects with their severity and attach the open ones to the certificate. Do one thing today: for the process that moves the most money, write three scenarios with expected results.

Frequently asked questions

Can the developer run UAT?

No. The developer runs its own testing and hands over a system that is ready for UAT. Acceptance testing is done by the client's staff: the storekeeper, cashier and accountant who will use the system every day. The developer stays close, answers questions and logs defects, but does not judge the result.

How long does UAT take?

It depends on the number of modules and how complex the processes are. You usually need at least two rounds: the first finds defects, the second checks the fixes. Leave the developer time to fix between rounds. Plan the timeline from the number of scenarios and the time your testers actually have.

Can the system be accepted with open defects?

Yes, if the remaining defects fit criteria agreed in advance. Typically no critical defects may remain, while high ones are allowed with a workaround and a written fix date. The list of open defects is attached to the acceptance certificate.

What is fixed free of charge during the warranty period?

That depends on the contract. Usually defects where the system does not meet the agreed requirements are covered, while new requirements and changes are not. Write the warranty term, response times and exclusions into the contract and have local counsel review it.

Preparing to sign off an ERP in Uzbekistan?

A consultation can cover your test scenarios, acceptance criteria and certificate terms: what to test, who signs, and which open defects make a go-live risky.

Book a consultation →

Let's work out where to start

Free consultation with a DORA specialist

Message on Telegram

Let's discuss your project

Leave your number and a specialist will get in touch.

Send a request via Telegram

Your details are used only to contact you.