High Availability Design Pattern for…

advancedTested on Xanadu

The High Availability Design Pattern ensures ServiceNow implementations remain operational during system failures, network outages, and disaster scenarios. This pattern leverages ServiceNow's built-in clustering capabilities, implements redundant integration paths, and designs resilient MID Server architectures to eliminate single points of failure.

This pattern addresses the critical need for enterprise systems to maintain uptime and data consistency across distributed components. It encompasses database clustering, load balancing, geographic distribution of MID Servers, and failover mechanisms for external integrations. The pattern also includes monitoring and alerting strategies to detect failures before they impact end users.

At its core, this pattern treats failure as inevitable and designs around it rather than trying to prevent it. By implementing multiple layers of redundancy, graceful degradation strategies, and automated recovery mechanisms, organizations can achieve near-zero downtime while maintaining data integrity and user experience quality.

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 for mission-critical ServiceNow implementations where downtime directly impacts business operations, revenue, or regulatory compliance. It's essential for organizations with strict SLA requirements, global operations requiring 24/7 availability, or systems that serve as single sources of truth for critical business processes.

Avoid When

Avoid this pattern for development environments, proof-of-concept implementations, or organizations where the cost of high availability infrastructure exceeds the business impact of temporary outages. The complexity and ongoing maintenance overhead may not be justified for smaller deployments with flexible uptime requirements.

Implementation

Server-side

var HighAvailabilityIntegration = Class.create();
HighAvailabilityIntegration.prototype = {
    initialize: function() {
        this.endpoints = [
            'https://primary-api.company.com/api/v1',
            'https://secondary-api.company.com/api/v1',
            'https://tertiary-api.company.com/api/v1'
        ];
        this.timeout = 10000; // 10 second timeout
        this.retryAttempts = 3;
    },
    
    makeResilientRequest: function(path, payload) {
        var response = null;
        var lastError = null;
        
        // Try each endpoint in order until success
        for (var i = 0; i < this.endpoints.length; i++) {
            var endpoint = this.endpoints[i];
            gs.info('HA Integration: Attempting request to ' + endpoint);
            
            try {
                response = this._executeWithRetry(endpoint + path, payload);
                if (response && response.getStatusCode() == 200) {
                    gs.info('HA Integration: Success with endpoint ' + endpoint);
                    // Update endpoint priority for future requests
                    this._promoteEndpoint(i);
                    return response;
                }
            } catch (e) {
                lastError = e;
                gs.warn('HA Integration: Endpoint failed ' + endpoint + ': ' + e.message);
                // Record failure for monitoring
                this._recordEndpointFailure(endpoint, e.message);
            }
        }
        
        // All endpoints failed
        gs.error('HA Integration: All endpoints failed. Last error: ' + lastError);
        this._triggerFailoverAlert();
        throw new Error('All integration endpoints unavailable');
    },
    
    _executeWithRetry: function(url, payload) {
        var rm = new RESTMessageV2();
        rm.setEndpoint(url);
        rm.setHttpMethod('POST');
        rm.setRequestHeader('Content-Type', 'application/json');
        rm.setRequestBody(JSON.stringify(payload));
        rm.setHttpTimeout(this.timeout);
        
        var response = null;
        var attempt = 0;
        
        while (attempt < this.retryAttempts) {
            try {
                response = rm.execute();
                if (response.getStatusCode() == 200) {
                    return response;
                }
                attempt++;
                // Exponential backoff
                gs.sleep(Math.pow(2, attempt) * 1000);
            } catch (e) {
                attempt++;
                if (attempt >= this.retryAttempts) {
                    throw e;
                }
                gs.sleep(Math.pow(2, attempt) * 1000);
            }
        }
        
        throw new Error('Request failed after ' + this.retryAttempts + ' attempts');
    },
    
    _promoteEndpoint: function(index) {
        // Move successful endpoint to front of array for faster future access
        if (index > 0) {
            var endpoint = this.endpoints.splice(index, 1)[0];
            this.endpoints.unshift(endpoint);
        }
    },
    
    _recordEndpointFailure: function(endpoint, error) {
        var gr = new GlideRecord('u_integration_health');
        gr.initialize();
        gr.u_endpoint = endpoint;
        gr.u_status = 'failed';
        gr.u_error_message = error;
        gr.u_timestamp = new GlideDateTime();
        gr.insert();
    },
    
    _triggerFailoverAlert: function() {
        gs.eventQueue('integration.failover.alert', null, 'All integration endpoints failed', 'System requires immediate attention');
    },
    
    type: 'HighAvailabilityIntegration'
};

Client-side

// MID Server health monitoring client script
function checkMidServerHealth() {
    var ga = new GlideAjax('HighAvailabilityMonitor');
    ga.addParam('sysparm_name', 'getMidServerStatus');
    ga.addParam('sysparm_cluster', g_form.getValue('u_cluster_name'));
    
    ga.getXMLAnswer(function(response) {
        var status = JSON.parse(response);
        
        if (status.healthy_servers < 2) {
            // Show warning when less than 2 MID Servers available
            g_form.addWarningMessage('Warning: Only ' + status.healthy_servers + ' MID Server(s) available in cluster. Redundancy compromised.');
            g_form.setValue('u_ha_status', 'degraded');
        } else {
            g_form.clearMessages();
            g_form.setValue('u_ha_status', 'healthy');
        }
        
        // Update server list display
        var serverList = status.servers.map(function(server) {
            return server.name + ' (' + server.status + ')';
        }).join(', ');
        
        g_form.setValue('u_server_status', serverList);
    });
}

The server code demonstrates a resilient integration pattern that automatically fails over between multiple API endpoints with exponential backoff retry logic and endpoint health tracking. The client code shows real-time MID Server cluster health monitoring that alerts users when redundancy is compromised. Both components work together to provide visibility into system health and automatically handle failures without user intervention.

Alternatives

Load Balancer Delegation

Relies on external load balancers to handle endpoint failover, reducing ServiceNow code complexity but requiring additional infrastructure and losing application-level retry intelligence.

Message Queue Pattern

Uses asynchronous message queuing for integration resilience, providing better decoupling and guaranteed delivery but adding complexity and potential latency for real-time operations.

Circuit Breaker Pattern

Implements fast-fail behavior to prevent cascading failures, offering better performance under load but potentially causing more immediate service interruptions during transient issues.

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