Creatio UAT: A Practical User Acceptance Testing Checklist
UAT is where the business accepts the system, not where it demos it. A practical checklist for Creatio: scope, testers, realistic data, scenarios, defect triage and sign-off.
User acceptance testing is the point where the business says, with evidence, that the system supports the way it actually works. It is not a second round of quality assurance, and it is not a demo with a sign-off at the end. When UAT is run as a screen-by-screen walkthrough, the sign-off is real but the confidence behind it is not — and the gaps usually surface in the first week after go-live.
This checklist is for Creatio implementations and major releases where the configuration has been built and system-tested, and the question is now whether the business can accept it.
Key takeaways
- UAT proves a real role can complete real work with realistic data, not that a screen exists.
- Build the acceptance pack from signed-off requirements, and write each scenario as a sentence from the business.
- Test with the named people who do the work, on the build that is actually scheduled for production.
- Define severity and exit criteria before the first test, and keep the scenario pack as your regression suite.
What UAT is, and what it is not
System testing asks whether the configuration behaves as specified. UAT asks whether the configured system lets a real role complete real work, with realistic data, from trigger to outcome.
That difference changes what you test. UAT does not need to re-check every field on every form. It needs to prove the end-to-end scenarios the business will depend on, including the branches that are awkward: the rejection, the duplicate, the credit hold, the missing approval.
A defect found during UAT is evidence, not a failure of the exercise. The failure is a UAT that never had a chance to find one.
Start the scope from signed-off requirements
Build the acceptance pack from the requirements and process maps that were signed off, not from a list of screens. For each business process, define a small number of scenarios, and write down for each one:
- the role that performs the work
- the trigger that starts it
- the data that must exist before the test begins
- the steps the tester follows
- the expected outcome at each hand-off: record status, owner, related records, notifications, approvals and any report that should change
- the evidence the tester captures (record ID, screenshot, exported report)
A useful scenario reads like a sentence from the business, not a menu path. For example: "A regional sales manager creates an opportunity for an existing account, applies a 15 percent discount, and the deal routes to the sales director for approval before the quote can be sent." That single scenario exercises permissions, pricing rules, the approval process, notifications and the quote template at once.
Choose testers who do the work
UAT is only as good as the people running it. Nominate:
- a process owner for each area, accountable for acceptance and sign-off
- one or two day-in-the-life testers per role, drawn from the people who will use the system after go-live
- a UAT coordinator who schedules sessions, keeps the defect log current and chases decisions
- an administrator or implementation partner on standby to fix the environment and triage defects
Do not let the business analyst who wrote the requirements drive the tests. They know where the happy path is, and they will unconsciously avoid the awkward route a real user takes. Testers should be trying to do their job, not confirming that a feature exists.
Prepare the data before testers arrive
Data is the most common reason a UAT round produces no usable evidence. If the test environment contains five perfect sample accounts, every scenario passes and tells you nothing.
Prepare a data set that resembles production in shape and variety:
- accounts and contacts at realistic volume, including duplicates and incomplete records
- customers on credit hold, inactive customers, and records with missing mandatory fields carried over from the old system
- multi-currency or multi-entity records if the business uses them
- historic records deep enough to test list views, reports and search
- named test users with the correct roles and business units — never an administrator account
- a reset plan so round two starts from a known state
If you use masked production data, confirm that relationships between records survive the masking. Broken lookups produce false defects and waste a day of triage.
Test the build that will actually go live
UAT belongs in the test environment, against the configuration package that is scheduled for production. Record the package version, the deployment date and the environment name on every test log. When a defect is fixed, redeploy the package and re-test — do not accept "fixed in development" as evidence.
Freeze configuration during the round except for defect fixes. A UAT that runs while the system is still being changed produces results nobody can reproduce, and testers stop trusting the exercise.
Scenarios to include beyond the happy path
Every process needs its end-to-end path. The risk usually sits around it. Make sure the pack covers:
- Permissions by role. What each role can see and change, including field-level restrictions on confidential data and team-based visibility. Test with ordinary users.
- Approvals. Approve, reject, return for revision and reassign. Test the boundary value on the threshold, not just a value comfortably inside it.
- Automation. Triggers, reminders, timers and escalations that should fire — and the cases where they should not.
- Integrations in both directions. A record created in the ERP arrives once, with the right owner. A change in the CRM reaches the downstream system. Failures are visible and retry works.
- Reporting. Dashboard and report totals reconcile with the underlying records, and filters by period, owner and business unit return sensible results.
- Data quality. Duplicate detection and merge, required fields, lookup values and the consequences of changing a shared reference record.
- Documents. A quote, contract or proposal generates with the correct merge fields and the correct approval history attached.
- Mobile and portal users. The few things field staff or external customers do, tested on the device or access route they will really use.
- Volume. Open a busy list view and a report at realistic record counts. A configuration that is fine with 50 records can be unusable with 50,000.
Run defect triage daily
Agree the severity definitions before testing starts, and apply them consistently:
- Blocker — the scenario cannot complete, data is corrupted, or a permission exposes something it should not. Fixed before go-live.
- Major — the outcome is wrong but a workaround exists. Fixed, or accepted with a documented workaround and an owner.
- Minor — cosmetic or low-impact. Logged and scheduled after go-live.
- Change request — behaviour that was never in scope. It goes to a separate backlog; it is not a UAT defect and should not silently expand the build.
Keep one defect log with one owner and a target date per item. The business process owner — not the implementation team — decides whether a workaround is acceptable. Short daily triage beats a long review at the end, when there is no time left to fix anything.
Define exit criteria before the first test
Sign-off is a decision, so define the basis for it in advance:
- all blockers closed
- all majors closed, or formally accepted with a workaround, owner and date
- the agreed proportion of scenarios passed — choose the target at the start, not after seeing the results
- each process owner has signed for their area, naming the build and the date
- training and quick-reference material delivered to each role
- the open-defects list attached to the sign-off
Store the sign-off, the scenario pack and the defect log together. They are the evidence that the system was accepted on a specific build, and they double as the regression set for future releases and upgrades.
Common ways UAT goes wrong
- The analyst drives and the users watch, so nobody has actually used the system.
- Testing happens in development, against a build that is not the release candidate.
- Only the happy path is covered, because the awkward cases are hard to set up.
- The data is too clean, so duplicates, exceptions and volume never appear.
- Sign-off arrives by email with no log, no build reference and no record of what was tested.
- Configuration keeps changing during the round, so results cannot be reproduced.
- Fixes are not re-tested, and the go-live decision rests on an unverified change.
A realistic shape
For a mid-sized Creatio implementation, plan two rounds. Round one covers the full scenario pack broadly and surfaces the defects. Round two re-tests fixes and works through the branches that were deferred. Keep a buffer between the last fix and the go-live decision; a UAT that ends the day before go-live is not a decision, it is a formality.
Keep the scenario pack afterwards. It becomes the regression suite for the next release, and the fastest way to verify an upgrade did not break the work the business signed off.
UAT is not a demonstration. It is the moment the business proves it can run on the system, on a known build, with data that looks like its own — and records exactly what it accepted and what remains open.
Frequently asked questions
What is the difference between system testing and UAT?
System testing asks whether the configuration behaves as specified. UAT asks whether a real role can complete real work with realistic data, from trigger to outcome. A system that passes technical tests can still fail acceptance because the awkward branches were never exercised.
Who should sign off user acceptance testing?
The business process owner for each area, not the implementation team. They decide whether a documented workaround is acceptable and whether the tested behaviour supports the way the work actually runs.
How much test data does UAT need?
Enough to resemble production in shape and variety: duplicates, incomplete records, records on credit hold, realistic volume and historic records deep enough to exercise list views and reports. Five perfect sample accounts will pass every scenario and prove nothing.
What happens to the scenarios after go-live?
Keep them. The scenario pack, the defect log and the sign-off together become the regression suite for the next release and the fastest way to check that an upgrade did not break the work the business signed off.
Facing this in your CRM?
Bring the requirement you are least sure was tested, and the scenario your users keep getting wrong. A free 30-minute call is usually enough to agree what acceptance should prove.
Let's talk for 30 minutes, free More articles