OBLYTECH Logo
OBLYTECH Logo
ServiceNow Upgrade Readiness Testing and Acceptance Checklist

ServiceNow Upgrade Readiness Testing and Acceptance Checklist

This ServiceNow upgrade checklist helps a team decide what to test before an upgrade reaches production. Regression is the main risk, because the platform code changes under configuration that already worked. It covers test scope, four test layers, preparation, defect triage, the go or no-go decision and the evidence to keep.

Test Scope: What to Test

Lower priority (standard platform): Platform-level features (workflow engine, UI framework, API layer) that have no customer customization. Release changes can still alter them, so they get lighter testing and much of the effort goes to the in-scope items below.

In Scope (you must test): Custom code (scripts, plugins, business rules), custom tables and fields, integrations with external systems, custom reports and dashboards, customized workflows, third-party apps and extensions.

Scope testing by risk: high-risk (custom scripts, integrations, core workflows) get thorough testing. Low-risk (custom field visibility, report formatting) get smoke testing.

Test Layers

Smoke Testing: Quick validation that system is working. Create a record, update it, delete it. Access a few key workflows and reports. Duration depends on how many workflows you check. Done in test environment immediately after upgrade.

Regression Testing: Run previously passing test cases to ensure they still pass. Document any failures. Duration depends on system complexity and the number of test cases.

Integration Testing: Test integrations with external systems. Verify data still flows correctly, API calls still work, error handling works. Duration depends on the number of integrations.

User Acceptance Testing: End-users test their workflows and processes, verify nothing is broken. Duration depends on workflow count.

Pre-Upgrade Preparation

Before upgrade: backup all custom code and configurations. Document existing behavior (how does this workflow work?). Create test data set representative of production volume and mix. Identify high-risk areas that need extra testing. Schedule upgrade in low-volume period if possible. Notify users; set expectations that system may be slower or temporarily unavailable.

ServiceNow upgrade testing checklist

Category Test Item Pass/Fail Notes
Basic Functionality Create, read, update, delete records in all custom tables
Basic Functionality All custom fields display and validate correctly
Workflows Core workflows execute without error
Workflows Approvals route and execute correctly
Workflows Notifications send to correct recipients
Integrations Inbound integration (external system to ServiceNow) works
Integrations Outbound integration (ServiceNow to external system) works
Integrations Error handling works (external system unavailable, timeouts)
Reporting Custom reports run and display correctly
Reporting Dashboards load and update correctly
Performance List views load to an agreed response target
Performance Dashboards load to an agreed response target
Performance API calls respond to an agreed response target
Access Control Role-based access still works correctly
Access Control Data visibility rules still enforced
Third-Party Apps Installed apps still function after upgrade

Defect Triage and Decision

As testing identifies issues, triage by severity: critical (system down, data loss, security breach) must be resolved before production. High (core workflow broken, integration down) should be resolved before production. Medium (feature degraded, UI issue) can be accepted if business agrees to live with issue temporarily. Low (cosmetic, edge case) can wait for next patch.

For each defect: investigate root cause (is this a platform issue or custom code issue?), document workaround if not immediately fixable, estimate effort to fix. Plan resolution: some issues can be fixed before go-live, others must be fixed post-go-live with priority.

Regression testing after an upgrade: traps to avoid

Trap: Script updates. ServiceNow platform changes sometimes require script updates. If your custom scripts were written for previous release, they may break in new release. Check ServiceNow release notes for breaking changes. Test all custom scripts thoroughly.

Trap: Database schema changes. Check whether any release has altered a table your custom code relies on. If your custom code depends on specific schema, it may break. Test data operations (create, query, aggregate) thoroughly.

Trap: Third-party plugin incompatibility. Apps and plugins may not be compatible with new release. Test all installed apps in test environment before production upgrade.

Trap: Timezone and data type issues. A change in how dates or data types are handled is likely to show first in date-dependent workflows and aggregations, so test those first.

Evidence to Preserve

Keep test results: test case, input, expected output, actual output, pass/fail status. Keep logs from testing phase: any errors or warnings in platform logs. Keep screenshots of key workflows and reports. This evidence supports postmortem if issues emerge in production and helps with future upgrades (identify weak areas that tend to break).

Post-Upgrade Support Plan

After production upgrade, have support team on standby for the early period after go-live. Issues often emerge after users start working with system. Keep a rollback plan ready for cutover, though full rollback is risky and should be the last resort. The platform rollback module reverts only patch upgrades and plugin activations, only within 10 days by default, and only one patch step at a time, so it cannot undo a move to a new release. Agree the fallback for a release-level upgrade before cutover. Have escalation path: if issue is found post-upgrade, who do you call?

Capture the baseline before the upgrade starts

An upgrade test only means something when you can compare the result with what the system did before. That sounds obvious, and yet many teams run their checks against the upgraded copy and record whether the outcome looks right. A check that asks “does the approval route work” can pass on a broken route when the approver is the same person who tested it. The comparison that catches regressions is the one that runs the same input against the old release and the new one and asks whether the output changed.

To make that comparison possible, capture a baseline on the current release before the first clone is upgraded. Export a fixed set of records, record the outputs of key reports and scheduled jobs, and save the response times and error counts from the integration logs. Use the same data set on both sides. Without that discipline the team is left comparing a memory of how something used to behave with a fresh observation.

Choosing where testing effort goes

A test plan that gives every item the same weight will spend much of its time on the low-risk items. Weight the effort by how much damage a silent failure would do. A quiet fault in a scheduled job that closes records at night is worse than a visible fault in a dashboard tile, because nobody looks at the job until the damage is done.

Test area What a regression usually looks like How to detect it Evidence to keep
Scheduled jobs and background scripts Job runs without error but writes different values or runs at a shifted time Compare job run history and output records against the baseline Run logs for each job, before and after
Custom business rules Rule stops firing, or fires on records it should skip Replay the baseline data set and diff the changed fields Field-level diff for each replayed record
Inbound and outbound integrations Payload shape changes or a timeout is handled differently Send the same payloads and compare responses and error paths Captured request and response pairs
Reports feeding management decisions Totals move because a default filter or time zone changed Run the report on both releases and reconcile the totals Signed reconciliation sheet per report
Access-controlled views A role sees records outside its scope after a change in list behavior Test each role against a fixed list of records it must not see Role-by-record results matrix

A procedure for turning results into a go or no-go

Results are only useful when they are read in the same way each time. The procedure below gives the test lead a fixed route from raw output to a recommendation.

  1. Freeze the test data set and the list of cases before any upgraded clone is tested, so cases cannot be quietly added after a failure.
  2. Run each case on the baseline release and the target release, and store both outputs side by side.
  3. Diff the outputs automatically where the output is structured, and review the differences by hand where it is not.
  4. Classify each difference as expected by the release notes, caused by custom code, or unexplained.
  5. Mark any case that could not be run as not run, with the reason and the name of the person who accepts that risk.
  6. Issue the recommendation only when every unexplained difference has an owner and a decision.

Patterns that make a passing test meaningless

  • An assertion that checks a record exists but not that its values are right, so a field overwritten with the default still passes.
  • A test environment whose installed plugins differ from production, so a conflict that would appear in production can go unseen.
  • Scheduled jobs that do not fire during testing and are still reported as working because nobody looked at their run history.
  • Cases skipped to meet a date and recorded as passed in the summary sheet.
  • Results rerun until they pass, with the failed runs deleted from the log.

Each of these is easy to avoid when the baseline and the frozen case list exist. Each is hard to spot afterwards when they do not.

Questions about upgrade test evidence

How many cases are enough?

Enough to cover the high-risk areas in the list above with real comparisons, not a count to report. A short set of well-chosen cases, compared against a baseline, tells you more than a long set that only confirms pages load.

What do we do with a failure we cannot reproduce?

Record it, capture the logs and the exact data used, and rerun it on the same environment. If it still cannot be reproduced, classify it as unexplained and keep it open until someone owns the question. Dropping it from the log is not a way to close it.

Should the business run its own tests in parallel?

Yes, for the processes it owns. Business validation catches problems that technical comparisons miss, such as a correct value shown in an unexpected place. Keep those results in the same evidence store as the technical results.

How long should we keep the evidence?

Keep it until the upgrade has been reviewed and the next release cycle has used its lessons. Those records are the best source for knowing which areas tend to break.

Setting the bar a pass has to clear is covered in the note on testing strategy and release evidence. Test roles and the access they need are covered on the access design page.

A phase-by-phase ServiceNow upgrade checklist with owners and exit tests

An upgrade checklist works best as five phases, each with one owner and one condition that must be true before the next phase starts: baseline, rehearsal, business validation, cutover and stabilisation. A flat list of test items tells you what to check; the phases tell you who signs off and when to stop.

Phase Typical owner Exit condition
Baseline Platform owner Exports, report outputs and scheduled job history saved from the current release
Rehearsal Platform team with the test lead Upgrade applied to a fresh clone, regression and integration cases compared with the baseline, defects triaged
Business validation Process owners Named users confirm their top workflows on the rehearsal instance
Cutover Release manager Change freeze in force, rollback decision point agreed, production upgrade run, smoke tests passed
Stabilisation Support lead Early incidents reviewed daily until the agreed exit date, evidence archived

Rehearse on a fresh clone

The rehearsal is where many upgrade surprises should appear, so give it the time and the people it needs rather than treating it as a formality.

Run the rehearsal on a clone taken shortly before the test, not on a test instance that has drifted for months. A drifted instance hides problems that production will show, and it can show problems that production does not have. Take the clone, apply the upgrade, then run the same baseline comparison you saved in phase one.

Freeze configuration movement and agree the rollback point

Stop moving update sets between instances once the rehearsal starts, so the test result describes the code that will go live. Agree before cutover who may call a rollback, by what time, and on which evidence. A rollback call made in the middle of a night cutover tends to come late.

For the surrounding material, see the upgrades and release readiness guides, the notes on update sets and release management, and the platform performance and upgrade readiness service.

The order to run ServiceNow upgrade tests in, from smoke checks to acceptance sign-off

Run the upgrade test window in four stages on a clone that nobody has changed since it was copied: a smoke pass, a baseline comparison for the high-risk areas, regression and integration testing, then user acceptance last. Each stage depends on the one before it. Regression results mean little on a broken clone, and acceptance testers waste time on a build that is still moving. The wider planning sits in the upgrades and release readiness guides covered above.

Stage one is the smoke pass. Create, update and delete a record in each custom table, open the main workflows, and confirm the scheduled jobs your business relies on are present and not in the Permanent Error state. If it fails, stop. Teams that keep testing a broken clone usually end up with many failures that trace back to one fault.

Stage two replays the high-risk areas against the baseline captured before cloning: scheduled jobs, custom business rules and the reports that feed management decisions. Run the same inputs on both releases and diff the outputs. A job that runs cleanly but writes a different value can pass the smoke checks, so this is where silent changes show up. If you have not reviewed the instance recently, a health check and assessment shows which custom areas carry the most risk.

Stage three runs the full regression on custom code, then the integration tests. Use a test endpoint that behaves like production, not a stub that always answers, because a stub cannot show a changed timeout. Record response times and whether the error paths return what the downstream system expects, in the same sheet as the baseline.

Stage four is user acceptance on a frozen build. If a fix lands during acceptance, rerun the smoke pass and the affected regression cases before anyone signs. Skipping this lets a sign-off end up covering a build that no longer exists.

Set stop conditions before the window opens. A failed smoke pass stops the window. An unexplained difference in a scheduled job or a financial report holds the go decision until someone owns it. An integration that misses its agreed response target is a defect to triage.

Build a custom code inventory before the ServiceNow upgrade checklist starts

The custom code inventory is the list of every customised component on the instance, and it should exist before anyone writes a test case. A checklist can only test what someone remembered to list. One practical way to build the list is to filter the instance for records the team created or changed, then check that output with the people who built each area.

Start with components that run without anyone clicking: scheduled jobs, background scripts, business rules and transform logic. They are easy to forget because nobody opens them during a normal review, and they often fail quietly. Then list what users touch, such as client scripts, UI policies, reconfigured forms, custom reports and catalog items. Finish with integration endpoints and their credentials, since a working integration on one side can hide a changed payload on the other.

Record four facts for each entry: the owner, the business process it supports, the date it last changed, and whether any test would notice it failing. Entries without an owner or a test come first. A component nobody can explain needs a decision before the upgrade: retire it, or write a case that shows what it does today. Custom applications need the same four facts. For more on this, see the App Engine and platform engineering approach.

Use the inventory to set the baseline scope. Every item should map to at least one checklist row, and every row should trace back to an entry. A row with no entry tests nothing in particular, and an entry with no row is a gap. Review the mapping with process owners as well as developers, since developers tend to list what they built and miss what the business depends on. Process owners also plan their own checks, which the note on business-owned UAT planning covers.

Freeze the inventory when the baseline is captured, and log later additions as dated changes with a reason. Scope changes after the freeze should go through change governance with clear release control, so the reviewer can see which items were tested and which were accepted as untested, with a named risk owner.

Keep the upgrade checklist as the regression pack for the next release

The checklist should outlive the upgrade it was written for. Each row that has been run records a result the platform passed or broke, so after go-live the rows form the cheapest regression pack the team owns. The next upgrade should start from it.

Give each row a stable identifier that survives rewording. For every run, record the release, the clone, the tester and the result. A row that passed every time tells you less than one that failed last upgrade and was then fixed, so the history matters.

Add rows after go-live, not only before it. Each defect that reaches production should become a case that would have caught it on the clone. That knowledge is easily lost once the incident ticket closes. Integration failures are the exception, since they usually already have a named owner when integration monitoring and error ownership is in place. That owner should approve every new integration row.

  • Stable row identifier, release tested, clone used, tester and result for each run
  • Each production defect added as a case within the same change window
  • Each removed row logged with the date, the owner and the inventory entry it came from

Retire rows carefully. A row can go only when the component it tests has left the inventory and the removal is recorded. A row for a feature that still exists but has gone unexercised is a candidate for review, because a quiet feature is often the one a scheduled job depends on. Store the pack alongside your release management setup, so the rows move with the code they test.

Before each upgrade, run the pack against the frozen clone, starting with the rows that have broken before. Those are often the scheduled jobs and integration error paths, because nobody watches them run. Put them at the top of the smoke pass.

Who owns the regression pack between upgrades?

The platform owner holds the pack and the test lead keeps it current, but each row keeps the name of the process owner who confirmed its expected result. When that person changes role, the row is reassigned in the same review.

Frequently asked questions

How much testing is enough before upgrading to production?

Minimum: smoke testing to verify system is working. Then regression testing of high-risk areas (custom scripts, integrations, core workflows). Full regression duration depends on system complexity. Plan enough time for regression and UAT to finish before cutover.

What if testing finds a critical issue?

Do not proceed to production. Investigate root cause: is it platform issue or custom code issue? If custom code, fix and retest. If platform issue, work with ServiceNow support. If not resolvable before deadline, defer upgrade or apply upgrade and run in degraded mode until issue is fixed.

What should we do if production upgrade breaks something?

Have contingency plan: what is the impact, who is affected, what is the workaround? Work to fix issue ASAP. If issue is critical and no workaround exists, consider rollback (very risky; only as last resort). Have incident response team communicate with users about impact and timeline to fix.

Talk to Oblytech

Planning, running or fixing a ServiceNow programme? Tell us where you are and we will suggest a sensible next step.

Contact us