Moving to ServiceNow Upgrade Readiness: Migration Considerations
This page helps a team prepare for ServiceNow upgrades by first inventorying its current upgrade process, customizations and integrations. It then covers change impact analysis, phased upgrade sequencing, testing strategy, communication with users, release readiness assessment and rollback planning.
Understanding Your Current Upgrade Approach
Before changing how you run upgrades, inventory your current upgrade process and capability. How frequently do you upgrade ServiceNow? With each new release, or less frequently? Who manages upgrades: a dedicated team, your ServiceNow administrator, or an external partner? What systems and processes are affected by each upgrade? What testing do you currently perform? Do you automate testing or test manually? The answers to these questions show where a managed upgrade practice will improve your process and where you may need new capabilities.
Inventory and Dependency Mapping
Upgrades affect customizations, integrations, and third-party applications. Inventory all of these. For each customization (business rule, script, plugin), assess whether it is compatible with newer ServiceNow releases or if it needs rework. For each integration (REST/SOAP calls to external systems, inbound webhook handlers), verify that ServiceNow API changes in the upgrade do not break integration. For each third-party application connected to ServiceNow, verify that the application supports the target upgrade. This inventory is your compatibility baseline; it drives your upgrade testing plan.
Change Impact Analysis and Assessment
ServiceNow releases include feature updates, bug fixes, and sometimes breaking changes. Some upgrades are routine (patch updates), others are major (major version upgrades). Before each upgrade, assess the impact on your instance. Review the release notes for features that might affect your configuration or customizations. Test in a non-production copy (development or test instance) before touching production. Document breaking changes that require rework or workarounds. Use the Upgrade Monitor and its Upgrade Summary Report on the first non-production instance you upgrade to find conflicts between your customizations and the upgrade. Do not assume your instance will upgrade smoothly; thorough impact analysis prevents surprises.
Upgrade Planning and Sequencing
Plan upgrades in phases: first, upgrade a development instance and test thoroughly. Second, upgrade a test instance and perform integration testing with connected systems. Third, upgrade a staging instance that mimics production as closely as possible; run production-like workloads and measure performance. Finally, upgrade production once you have confidence. Maintain a rollback plan at each stage: if the upgrade breaks something, can you revert to the previous version quickly? Work out in advance how long a rollback from production would take on your own instance.
Testing Strategy for Upgrades
Define a testing strategy that covers the areas most likely to be affected by the upgrade: automated test suites for customizations and integrations (unit tests, integration tests), user acceptance testing (UAT) where key users test their workflows, performance testing to ensure the upgrade does not degrade system speed, and security testing to verify no new vulnerabilities. Allocate adequate time for testing; do not compress testing to save time. Testing failures discovered in production are expensive to fix; failures discovered before production are expected and manageable.
Communication and User Preparation
Upgrades can introduce feature changes visible to users (interface changes, new functionality, deprecated features). Communicate upcoming changes before the upgrade: explain what is changing and why, show how to use new features, address concerns about deprecated features. If significant user-facing changes occur, provide training and documentation. Schedule the upgrade for low-volume periods if possible; avoid upgrading during peak business cycles or critical business events. Give users advance notice and be prepared to support them after the upgrade.
Release Readiness Assessment
Before each ServiceNow release, assess whether you are ready to upgrade. Do you have time allocated for testing and deployment? Are key stakeholders available? Do all your integrations and customizations support the target release? Is your rollback plan documented and tested? Use a comprehensive readiness checklist to ensure nothing is overlooked. If readiness is below your threshold, defer the upgrade to the next release cycle rather than rush into problems.
Post-Upgrade Support and Optimization
Plan support for the first week after upgrade; issues often surface once users interact with upgraded functionality. Have technical staff available to respond quickly. Monitor system performance, error logs, and user feedback. Address all critical issues immediately; log non-critical issues for later optimization. Conduct a post-upgrade review meeting with stakeholders to discuss what went well and what could be improved next time. Use these learnings to refine your upgrade process for future upgrades.
Deciding what the switch actually has to move
A team that has been upgrading informally usually has its knowledge in three places: a person’s memory, a folder of change records and a set of settings nobody has written down. Moving to a managed upgrade practice means relocating all three, and the first job is to list them. Each row in the table below is an asset that the new practice depends on, and the final column names the question to settle before the switch.
| Asset | Where it usually lives today | Where it belongs after the switch | Question to answer first |
|---|---|---|---|
| Record of past windows and their outcomes | Change tickets, email threads and personal notes | One upgrade history with a standard entry for each window | Which past windows had a documented rollback decision? |
| Customization ownership | Whoever built the item last | A named business owner and technical owner per item | Which items have no current owner at all? |
| Integration endpoints and their contacts | A developer’s bookmarks | An integration register that the release lead can read without asking anyone | Which endpoints would fail if their contact left tomorrow? |
| Test scripts | Scripts run from memory or copied between tickets | One versioned script per critical process, reviewed before each window | Which processes have been tested by someone other than their builder? |
| Calendar of releases and freezes | The personal calendar of the admin | A shared calendar that operations and business owners can see | Which business events collide with the next window? |
Running the old and new practice side by side for one cycle
The safest way to change how upgrades are run is to let the new practice shadow the old one for a single release. The old team keeps doing the work, and the new practice records what it would have decided at each point. Where the two disagree, the disagreement is a finding, and it is cheaper to learn it on a shadowed cycle than on a live one.
- Choose the upcoming release as the shadow cycle and name the people who will hold each role in the new practice, even though the old team is still executing.
- Have the new release lead write the readiness criteria before the old team starts testing, and record which criteria the old process would have failed.
- Run the old test scripts and the new ones on the same non-production refresh, and note every case where one passes and the other fails.
- Hold the go or no-go meeting in the new format, with the old team presenting its results, and record the decision the new practice would have made.
- After the window, compare the post-window issues against the decisions made in the shadow meeting, and update the criteria where the shadow missed something.
Turning undocumented history into a usable baseline
Teams often hold a strong sense of what happened in past windows but little evidence. A baseline does not need to reconstruct every past event. It needs to record the current state accurately: which customizations are live, which integrations are active, which scheduled jobs run, and which settings were changed from the vendor default. Start from what the instance shows today, then add a note where a past event explains an oddity. An oddity without an explanation is a risk to list, not a fact to rely on.
Transition risks that come from people rather than the platform
- The person who held the upgrade knowledge is also the person who can approve a rollback, so the new practice has no decision authority until that person is replaced in writing.
- Business owners who were never asked about upgrades are asked for sign-off for the first time during a window, and they refuse, rightly, to approve what they have not seen.
- The old team treats the new practice as a checklist exercise, filling in records after the decisions have already been made informally.
- Support staff hear about the new practice from users rather than from the platform team, and begin answering questions with the old answers.
Choosing a cutover point for the process itself
Do not change the process in the middle of a release window. The cleanest point is directly after a window closes and its post-window review has been held, because at that point the old practice has produced a finished record for the new one to build on. A switch that lands during testing leaves two half-finished records and no one sure which one governs.
The governance model for upgrades describes the approval chain the new practice should adopt, and the roles and responsibilities view shows who holds each part of that chain. Teams with a change process already in place can align the upgrade entries with the change enablement guidance so that a window is governed in the same place as other changes.
Frequently asked questions about moving an informal upgrade practice
Do old upgrade records need to be migrated into the new history?
Only the ones that still explain the current state of the instance. A record of an old window rarely changes a decision today. Keep the old records where they are, and add a short summary entry that points to them for anyone who needs the detail.
Can the upgrade calendar be held by an outside partner?
It can, provided the business owners can read it and the platform owner remains the person who decides. Outsourcing the calendar without outsourcing the decision is a common source of confusion when a window moves.
What if the last upgrade has no written record at all?
Write a record now, marked as reconstructed, and list the points where the reconstruction relies on memory. A marked gap is far more useful to the next team than a silent one.
The best practice notes for upgrades give a set of principles the new process can be measured against.
When to move to a managed ServiceNow upgrade practice, and the minimum to have in place
Move to a managed upgrade practice when the next release is far enough away to run a shadow cycle, and when you can name one person who may call a rollback. If either is missing, fix that first, because many other migration steps depend on it.
A perfect inventory is rarely needed first. The new practice needs only a small base on day one.
The minimum entry list
- One named decision owner for go and no-go, written down and known to the business owners.
- A list of the customizations and integrations you already know about, even if it is incomplete, with the gaps marked as gaps.
- A non-production copy that is recent enough to test against, and a note of how old it is.
- A date for the next window agreed with the people who run the busiest business periods.
A simple decision rule
Count how many of those four items you can honestly tick. With all four, start at the next window. With two or three, start, and use the shadow cycle described above for the first window. With one or none, spend the time before the next window closing the gaps, and keep the existing approach for that release.
What not to move yet
Move only what the next window will actually use. Old upgrade records are covered in the questions above.
Business sign-off is the part that usually stalls. Agree early who validates what, and how that validation is done, using a plan such as the one in ServiceNow UAT planning for business-owned validation. Put the dates in terms the whole organisation understands, as described in what a change window is.
If your team is stretched, it is worth weighing whether to build this practice in house or bring in outside help for part of it. The trade-offs are set out in consulting or managed support.
How do we know the move has worked?
After the first full window, ask whether the go decision was taken by the named owner, whether business owners saw the test results before it, and whether a rollback would have been possible if needed. Three yes answers are a good sign that the practice is working, whatever the size of the issues found.
What each upgrade history entry must record so a rollback decision stays traceable
Each upgrade window needs one history entry that records what changed, who made the go decision, what evidence they relied on, and whether a rollback was possible. Without those four answers, the next release lead has to rebuild the decision from email, and the rollback option is lost before anyone needs it.
Write the entry when the window closes, not weeks later from memory. The fields below are the minimum.
| Field | What to write | Why the next team needs it |
|---|---|---|
| Versions | The release moved from and to, with the patch level | Shows which release notes apply to this window |
| Go or no-go | The named owner, the date and the decision taken | Confirms the person entitled to decide actually did |
| Test evidence | Where the results sit and which business owner reviewed them | Shows what was checked and by whom |
| Accepted issues | Each open defect, its owner and the business decision to carry it | Stops an accepted risk being rediscovered as a new fault |
| Rollback | Whether a rollback was prepared, roughly how long it would take and who could call it | Shows whether the window could have been reversed |
| Post-window issues | Issues raised in the first week, with the fix or log entry they led to | Feeds the readiness criteria for the next window |
Keep the entry short. One page per window is enough, and it should point to the detailed test evidence rather than copy it. If a field is unknown, write unknown and the reason, so the gap stays visible. A blank field looks as if a decision was made and then forgotten.
Use the entries to build the readiness checklist for the next window. An issue that appears twice in the post-window column should become a readiness criterion, and a field left empty in two windows should become a required field. The testing and acceptance checklist shows how the evidence is gathered, and the update set and release management guides cover the change control around each window. Teams that want outside help with the readiness work can look at the platform performance and upgrade readiness service.
Frequently asked questions
How frequently should we upgrade ServiceNow?
ServiceNow ships two major family releases a year, so most organizations plan around two upgrade windows. Most organizations upgrade at least twice per year to stay current and receive critical security patches. Upgrading quarterly with each release is ideal but requires significant testing resources. Consider your risk tolerance and available resources when choosing upgrade frequency.
What is the biggest risk in upgrading?
Breaking changes that you did not anticipate: customisations that no longer work, integrations that fail, or features that behave differently. Mitigation: thorough testing in non-production environments before production upgrade, maintenance of a detailed inventory of customisations and integrations, and regular review of ServiceNow release notes and upgrade guides.
How long should an upgrade take from start to production?
Planning and testing length depends on release scope and number of customisations. Actual upgrade execution takes relatively little time. Phases typically cover planning, testing, staging and final verification, then production upgrade. Fast-track upgrades with less testing can be quicker but carry higher risk.
Related guides
Related Oblytech services
Where this topic turns into delivery work, these are the Oblytech services that cover it.
Planning, running or fixing a ServiceNow programme? Tell us where you are and we will suggest a sensible next step.
Contact us