Dashboard Report Performance Pattern for…

intermediateTested on Xanadu

The Dashboard and Report Performance Pattern addresses slow-loading dashboards and reports that can significantly impact user experience and system performance in ServiceNow. This pattern focuses on optimizing data retrieval, reducing database load, and implementing smart caching strategies to ensure dashboards render quickly even with large datasets.

The pattern works by replacing expensive list-based queries with aggregate functions, implementing intelligent caching mechanisms for dashboard widgets, scheduling resource-intensive reports during off-peak hours, and leveraging Performance Analytics (PA) targets for pre-calculated metrics. This approach transforms slow, real-time calculations into fast retrievals of pre-processed data.

By implementing this pattern, organizations can maintain responsive dashboards while handling enterprise-scale data volumes, improve overall system performance, and provide users with fast access to critical business intelligence without overwhelming the ServiceNow instance.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Use This When

Use this pattern when dashboards take more than 3-5 seconds to load, when reports frequently time out or cause performance issues, or when you have widgets that perform complex calculations on large datasets. This pattern is particularly valuable for executive dashboards, operational reports that refresh frequently, and any reporting that aggregates data across multiple tables with thousands of records.

Avoid When

Avoid this pattern for simple reports with small datasets (under 1000 records) where real-time data is critical and performance is already acceptable. Don't implement complex caching for reports that are rarely accessed or for data that changes so frequently that cache invalidation becomes more expensive than direct queries. This pattern adds complexity that isn't justified for basic list reports or one-time ad-hoc reporting needs.

Implementation

Server-side

// Script Include: DashboardPerformanceUtil
var DashboardPerformanceUtil = Class.create();
DashboardPerformanceUtil.prototype = {
    initialize: function() {
        this.CACHE_DURATION = 300; // 5 minutes in seconds
    },

    // Get cached widget data or calculate if expired
    getCachedWidgetData: function(widgetId, calculationFunction) {
        var cacheKey = 'widget_' + widgetId;
        var cached = gs.getProperty('sys.cache.' + cacheKey);
        var cacheTime = gs.getProperty('sys.cache.' + cacheKey + '.timestamp');
        
        var now = new GlideDateTime().getNumericValue();
        var cacheExpiry = parseInt(cacheTime) + (this.CACHE_DURATION * 1000);
        
        if (cached && now < cacheExpiry) {
            gs.info('DashboardPerformance: Cache hit for widget ' + widgetId);
            return JSON.parse(cached);
        }
        
        // Cache miss or expired - recalculate
        gs.info('DashboardPerformance: Cache miss for widget ' + widgetId + ', recalculating');
        var data = calculationFunction();
        
        // Store in cache with timestamp
        gs.setProperty('sys.cache.' + cacheKey, JSON.stringify(data));
        gs.setProperty('sys.cache.' + cacheKey + '.timestamp', now.toString());
        
        return data;
    },

    // Optimized incident summary using aggregates instead of multiple queries
    getIncidentSummaryOptimized: function() {
        var summary = {
            total: 0,
            byPriority: {},
            byState: {},
            avgResolutionTime: 0
        };
        
        // Single aggregate query instead of multiple GlideRecord loops
        var gr = new GlideAggregate('incident');
        gr.addAggregate('COUNT');
        gr.groupBy('priority');
        gr.groupBy('state');
        gr.query();
        
        while (gr.next()) {
            var priority = gr.getValue('priority');
            var state = gr.getValue('state');
            var count = parseInt(gr.getAggregate('COUNT'));
            
            summary.total += count;
            summary.byPriority[priority] = (summary.byPriority[priority] || 0) + count;
            summary.byState[state] = (summary.byState[state] || 0) + count;
        }
        
        // Calculate average resolution time using aggregate
        var avgGr = new GlideAggregate('incident');
        avgGr.addQuery('state', '6'); // Resolved state
        avgGr.addNotNullQuery('resolved_at');
        avgGr.addAggregate('AVG', 'calendar_duration');
        avgGr.query();
        
        if (avgGr.next()) {
            summary.avgResolutionTime = parseFloat(avgGr.getAggregate('AVG', 'calendar_duration')) || 0;
        }
        
        return summary;
    },

    // Schedule heavy report execution during off-peak hours
    scheduleHeavyReport: function(reportName, reportSysId) {
        var scheduledJob = new GlideRecord('sysauto_script');
        scheduledJob.initialize();
        scheduledJob.name = 'Heavy Report: ' + reportName;
        scheduledJob.run_time = '2023-01-01 02:00:00'; // 2 AM daily
        scheduledJob.run_period = 'daily';
        scheduledJob.active = true;
        
        // Script to execute the report and cache results
        scheduledJob.script = 
            "var reportRunner = new DashboardPerformanceUtil();\n" +
            "var reportData = reportRunner.executeHeavyReport('" + reportSysId + "');\n" +
            "gs.setProperty('report.cache." + reportSysId + "', JSON.stringify(reportData));\n" +
            "gs.setProperty('report.cache." + reportSysId + ".timestamp', new GlideDateTime().getNumericValue().toString());";
        
        var jobSysId = scheduledJob.insert();
        gs.info('DashboardPerformance: Scheduled heavy report ' + reportName + ' with job ID: ' + jobSysId);
        
        return jobSysId;
    },

    type: 'DashboardPerformanceUtil'
};

Client-side

// Dashboard widget client-side code for loading cached data
function loadDashboardWidget(widgetId, containerId) {
    // Show loading indicator
    var container = document.getElementById(containerId);
    container.innerHTML = '<div class="loading-spinner">Loading...</div>';
    
    // Use GlideAjax to get cached widget data
    var ga = new GlideAjax('DashboardPerformanceUtil');
    ga.addParam('sysparm_name', 'getCachedWidgetData');
    ga.addParam('sysparm_widget_id', widgetId);
    ga.getXMLAnswer(function(response) {
        try {
            var data = JSON.parse(response);
            renderWidget(data, containerId);
        } catch (e) {
            console.error('Error parsing widget data:', e);
            container.innerHTML = '<div class="error">Error loading widget data</div>';
        }
    });
}

function renderWidget(data, containerId) {
    var container = document.getElementById(containerId);
    var html = '<div class="widget-content">';
    
    // Render cached data without additional server calls
    if (data.total !== undefined) {
        html += '<div class="metric">Total: ' + data.total + '</div>';
    }
    
    if (data.byPriority) {
        html += '<div class="priority-breakdown">';
        for (var priority in data.byPriority) {
            html += '<span class="priority-' + priority + '">P' + priority + ': ' + data.byPriority[priority] + '</span>';
        }
        html += '</div>';
    }
    
    html += '</div>';
    container.innerHTML = html;
}

The code demonstrates three key performance optimization techniques: intelligent caching with expiration timestamps to avoid redundant calculations, aggregate queries that replace multiple individual database calls with single efficient operations, and scheduled execution of heavy reports during off-peak hours. The client-side component shows how to load cached data asynchronously without blocking the dashboard rendering process.

Alternatives

Performance Analytics (PA) Integration

Use PA when you need historical trending and complex KPIs with automated data collection. PA provides more sophisticated analytics capabilities but requires additional licensing and setup complexity compared to custom caching solutions.

Real-time Data Streaming

Implement WebSocket or Server-Sent Events for truly real-time dashboards when data freshness is more critical than performance. This approach provides instant updates but increases server load and complexity, making it suitable only for mission-critical monitoring scenarios.

Database View Optimization

Create database views for complex join operations and frequently accessed data combinations. This approach offers better performance for read-heavy workloads but requires database administrator access and may impact system upgrades or migrations.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue