OBLYTECH Logo
OBLYTECH Logo

OBLYTECH / ServiceNow

Troubleshooting ServiceNow Performance Issues: Enhance Your System’s Efficiency 

Performance issues with ServiceNow can reduce the effectiveness of your organization's efficiency. Here is the guide on improving the performance of your system and troubleshooting it. When troubleshooting with ServiceNow, you can maximize the efficiency of your system by checking connectivity, cache behavior and the metrics below.

For readers evaluating this topic and deciding what to review next.

ServiceNow performance optimizationServiceNowpractical guide

Guide map

A practical framework for servicenow performance optimization.

Define the question and scope

A slow instance is easier to fix once the team agrees which users, pages and hours the complaint covers.

Make decisions and ownership visible

Write down who can approve each change to a performance-related setting, so a slowdown has a named person to ask first.

Review evidence and next actions

Write down what each check showed, who owns the follow-up, and the date it will be reviewed, so the next meeting starts from facts.

The practical framework

Performance issues with ServiceNow can reduce the effectiveness of your organization's efficiency. Here is the guide on improving the performance of your system and troubleshooting it. When troubleshooting with ServiceNow, you can maximize the efficiency of your system by checking connectivity, cache behavior and the metrics below.

  1. Network Connectivity Tests
    To confirm connectivity between you and your instance works, run thorough testing. By handling connectivity difficulties well, you can quickly resolve any network concerns. 
  2. Monitor Memory and Performance Figures 
    Keep an eye on the performance figures your instance makes available to administrators, such as the Stats modules under System Diagnostics, to catch problems early. It's important for you to recognize and handle instances of unusual memory use because they can impair performance. 

  3. Inspect Parallel Transaction Load  
    To avoid performance snags, watch how many transactions run at the same time, since bursts of parallel work from users, jobs and integrations can cause slowdowns. Spreading that work more evenly can help system performance. 

  4. Assess Disk I/O
    Prevent misuse or saturation of the disk I/O, which might hinder system performance. You need to identify and manage high disk I/O for the database server to operate at its best. 

  5. Monitor CPU Utilization
    Keep an eye on CPU resources, especially in busy hours, so the instance can meet its load. Reducing sustained high CPU utilization on the server can make performance steadier.

    Should problems with performance continue, you should consider taking these steps:

    • Clearly state what the problem or question is. 

    • Check the instance logs and recent changes for likely causes before you escalate. 

    • Bring in a specialist with platform performance experience if the cause is still unclear. 

    Additionally, make sure that you achieve continuous system optimization by means of thorough diagnostics and performance monitoring. Monitor the following metrics on a regular basis: browser rendering, network latency and throughput, instance cache impact on performance, and application server response time.  

    To avoid performance deterioration, steer clear of actions that cause the instance cache to be rebuilt and purged during peak business hours. Changes such as translations, update sets, dictionary entries and system properties can have this effect, so confirm the exact triggers for your release. These checks help narrow down the cause of a ServiceNow slowdown and show when to escalate it. 

Common questions

Questions teams ask about servicenow performance optimization

What should a review establish first?

Start with the question, scope, decision boundary, ownership, and evidence that the reader needs to carry into the next action.

How should the next action be chosen?

Use the article framework to identify the unresolved decision, the responsible group, and the record that will show what happened.

The documented boundary

This article is presented as a practical reference. Apply its recommendations against the specific systems, responsibilities, and evidence available in the organization being reviewed.

Build a symptom record before anyone changes a setting

Performance tickets often arrive as a single sentence: the system is slow today. That sentence cannot be tested, and the first engineer to pick it up will start with whichever check they know best. A symptom record turns the complaint into something another person can reproduce. It needs the screen or action, the approximate time, the user’s location and browser, whether the slowness is constant or intermittent, and whether it affects one person or a group. Ask for one example of a record that was slow and one that was fine, because the difference between them is usually where the cause sits.

Keep the record in the ticket rather than in someone’s memory. The same symptom often returns, and a record from the first occurrence saves the team from rediscovering the same dead ends.

Matching the symptom to the first check

Different symptoms point to different first moves. The table is a way to pick the starting point, not a conclusion, and it should be revised once the evidence comes back.

Symptom in the recordMost likely areaFirst check
Slow only for users in one office or on one networkConnectivity between the user and the instanceCompare the same action from another location on the same account
A single form is slow to load for everyoneClient scripts or a heavy related list on that formCheck which client scripts and related lists load on the form
Reports or list views degrade over a few weeksData volume growing without matching filters or indexesCompare the filters on the slow list with the table’s size
Slowness starts right after a deploymentA changed script, workflow or update setReview what changed in the window before the first complaint

What to send when the problem goes beyond the team

When an internal fix does not hold, the escalation package decides how quickly the next engineer makes progress. Include the following, in this order:

  1. The symptom record and the example of a slow and a fast occurrence.
  2. The changes made in the period before the first complaint, with dates and the people who made them.
  3. The steps already tried and the result of each one, including the changes that were reverted.
  4. Any patterns in the timing, such as a daily peak or a scheduled job that overlaps the slowdown.
  5. The exact outcome the business needs back, so the next engineer knows what success looks like.

Item three is often the one missing. A reviewer who does not know that a change was tried and reverted may repeat it, and the second attempt can look like a new cause.

Mistakes that stretch the timeline

A common mistake is treating the browser as the instance. Developer tools on a user’s machine can show a slow response, but that does not say whether the delay sits in the instance, in an integration or in the browser’s own rendering. Compare a fast and a slow session with the same account before deciding where the problem lives.

Another mistake is closing the ticket on a restart. A restart can clear a temporary state and make the symptom disappear for a while. If the record shows the problem coming back, the restart was a pause, not a fix, and the ticket should stay open until the reproduction passes.

A third mistake is letting the people who built a feature be the only ones to judge it. The builder knows what the feature was meant to do, but a second reviewer is more likely to notice the query that reads far more rows than the screen displays.

Deciding when the fix is a design change

Some slowness cannot be cleared by tuning. When the same screen is slow because it was designed to show too much at once, the fix is a design decision: fewer columns, a default filter, a summary view or a separate report. Raise these as design questions with the business owner, rather than asking the platform team to make the screen faster by changing its internals. The guide to monitoring dashboard design looks at designing dashboards so a defined audience can recognize a condition and choose the next action, and the note on platform health checks looks at preparing evidence for a health check that can cover areas such as performance and supportability.

Questions to answer after the first fix

How do we know the fix worked and did not just move the problem?

Repeat the original reproduction and then check the neighboring screens and the scheduled jobs that run in the same window. A fix that speeds one screen while slowing a report that shares its data has moved the problem.

Should the symptom record be shared with users?

Share the outcome, not the internal detail. Users need to know what changed and whether they should expect it to recur. The technical record stays with the engineers who need it.

What if different users see different speeds on the same screen?

Compare their roles, their default filters and their saved views. Personal settings and large personal lists can be a common cause of uneven performance that looks random from the outside.

Is it worth keeping a standing list of slow screens?

Yes. Keep it short and review it on a regular cycle, so that a screen moves from the list only when its reproduction passes. A standing list also shows which problems keep returning, which is more useful than any single fix.

A practical next step

If your team has a recurring slowdown that no one can reproduce consistently, assemble the escalation package described above before making further changes. The platform performance and upgrade readiness page describes a review that connects customizations, integrations, data, workflows and users, and the proactive monitoring and maintenance page describes a service aimed at keeping a ServiceNow instance healthy.

Use the contact page to set out the recurring symptoms and the changes already tried.

Why a ServiceNow instance freezes and how to find the cause

A frozen or slow ServiceNow instance usually has one of a handful of causes: a heavy scheduled job or integration holding the available worker capacity, a slow database query, a business rule that runs more work than the form needs, or a cache rebuild during busy hours. The fastest route to the cause is to decide first whether the problem hits everyone, one module or one person, and then read the transaction and slow query logs for that window.

Narrow the scope before you open any log

If every user is affected at once, look at the node and its queue: long-running jobs, an integration burst or a large import. If only one list or form is slow, the cause is usually that page: too many columns, a heavy related list or a client script waiting on a server call. If one person is affected, suspect the browser, the network path or a personal filter.

What you seeTypical causeFirst check
Whole instance stalls at a set timeScheduled job, import or integration burstJob schedule and transaction log for that hour
One form or list opens slowlyBusiness rules, related lists, unbounded queriesSlow query log and the rules running on that table
Slow right after a release or update setCache rebuild, new rule on a large tableWhat was committed and when
Slow for one user onlyBrowser, network or a very broad personal filterSame action from another account and browser

Fix in this order

Stop the cause that is running now, such as a runaway job, before you tune anything. Then bring the offending query or rule back to a filtered, indexed lookup. Then move work that does not need to finish while the user waits into an asynchronous or scheduled path. Only after those steps is it worth asking whether the instance needs more capacity, and that decision belongs with the platform owner, supported by the same logs.

If the pattern repeats, the ServiceNow platform performance guides set out what to measure routinely, and a health check and assessment reviews the whole platform against that evidence. For fixes that need hands on the code, see performance tuning and upgrades.

How do I improve ServiceNow performance without adding capacity?

Remove the work first: retire unused scheduled jobs, narrow list filters, trim columns on busy lists and replace unbounded queries with filtered ones. In many cases the larger gains come from doing less per request rather than adding hardware.

Set a performance baseline before you judge a ServiceNow slowdown

A slowdown only means something against a known normal. Before anyone changes a setting, time a short set of reference actions at the same hours on the same days for one to two weeks, and record the results in the ticket. Without that record, most complaints get compared with memory, and memory of fast usually describes the last good morning.

Choose five to eight actions that people do every day and that matter to the business. Good candidates in most implementations are these:

  • The agent home page, loaded cold after a fresh sign-in
  • The main incident form, opened from its list view
  • The busiest list view, with its default filter in place
  • A global search for a common record number
  • A record save that runs the usual business rules
  • A report that people open at the start of the day

Keep the list short enough to run by hand in a few minutes, because a baseline nobody repeats is of little use.

Measure from the same kind of connection each time. A reading from the office network and one from a home laptop differ for reasons unrelated to the instance, so label every reading with its network and browser. Repeat the run twice a day, once at a quiet hour and once in the busy window, so one unusual reading does not decide the matter. If the readings show a pattern you cannot explain, the platform performance guides explain which measures to track on a regular basis.

Thresholds should come from the users, not from a rule of thumb. Agree the acceptable time for each action with the people who work in it and who raise the complaints, and write that agreement beside the readings. When a complaint arrives later, the team can then see which action moved, by how much, and whether it now sits outside the agreed range. For the fixes themselves, see performance tuning and upgrades.

How to triage a ServiceNow instance that freezes during working hours

When a ServiceNow instance freezes during working hours, the first hour is about deciding what to stop, not what to fix. Establish whether every session is stuck or only one page, then find the scheduled job, import or integration that began just before the freeze.

Keep the first checks small and reversible. Ask a colleague on a different account to load a simple page while someone watches the busy node’s queue. If their session is stuck too, the cause is shared across the instance. If it loads, suspect one heavy page or one personal filter and narrow the work to that page.

Before anyone changes a setting, write down the time of the first report, the last change anyone made, and who was running reports, imports or bulk updates at that moment. A freeze that starts at the top of the hour often lines up with a job scheduled for that hour.

Decide between waiting and stopping

If responses are recovering on their own, wait while you capture the logs. If they are not, stop the job that began the problem, ideally with its owner making the call, because a load stopped halfway can leave records that someone must reconcile later.

  • Stop a job only when you can name its owner and the records it touches.
  • Capture the transaction and slow query logs before any restart.

The common error is cancelling the report on screen, which is often not the heavy work. The freeze tends to return when the background process runs again.

When the same window produces a freeze again, treat it as a scheduling question. Move the work out of business hours or split it into smaller batches, and record the change in the ticket. If an integration feed is the trigger, the ownership question is covered in who owns integration errors when a feed misbehaves.

If the freezes began within a day or two of a release, check what moved using our troubleshooting update sets and release problems guide before assuming the platform is undersized. Where freezes keep returning in the same window, a ServiceNow health check can review the evidence across the whole platform.

Clear old records before you tune a slow list that keeps growing

If a list, report or search has slowed steadily over several months, the fix is often to reduce the number of rows it reads rather than to rewrite its query. A filter helps for a while, but a table that keeps gaining closed tasks, finished approvals and old logs can eventually outgrow even a narrow filter. Check the table size and its growth rate before you change the query.

Start with the question the list answers. A service desk queue needs open work and recently closed work, not every task closed since the instance was first set up. A report that averages several years of closed records can often be narrowed to a fixed period without changing the decision it supports. Agree the period with the report owner and write it in the ticket.

Retention is a governance decision, not a tuning one. Archiving or deleting records can remove audit evidence, so the platform owner and the business owner of the records should agree which tables may be trimmed, how long records are kept, and who approves each purge. Look at the archive and deletion options under Data Management before writing any rule. Test any archive or deletion rule on a copy of the instance first, and check the exact steps on your own instance and release, because the available options differ between versions.

Use this rule to choose the first move:

  • The row count grows every month and the filter is already narrow: agree a retention rule first.
  • The row count is flat but one query reads far more rows than the screen shows: fix the query or the columns.
  • The list slowed right after a data load: review the load before touching the list.

Before and after, run the same checks as the platform health-check readiness review. Measure the result on the same list, at the same hours, as your baseline. A purge that cuts the row count but leaves the list slow points to a different cause, and the next step is the query. Keep a record of what was removed, when, and who approved it, so the next reviewer does not reopen the question from scratch.

A practical next step

Need a clearer operating model?

OBLYTECH can discuss the questions raised by this guide and the next review step. Use the OBLYTECH contact route to start the conversation.

Useful starting pointBring the current question, scope, ownership concerns, and evidence needs into the first review conversation.

ServiceNow guides on this topic

Guides from the Oblytech ServiceNow library that explain the practice behind this page.

More from the blog