Hub-and-Spoke Instance Architecture…

advancedTested on Xanadu

The Hub-and-Spoke Instance Architecture Pattern enables large enterprises to manage multiple ServiceNow instances across different business units, regions, or subsidiaries while maintaining centralized oversight and governance. In this pattern, spoke instances handle local operations and data specific to their business units, while a central hub instance aggregates critical data, provides enterprise-wide reporting, and enforces standardized processes.

This pattern solves the challenge of balancing local autonomy with enterprise governance. Business units get the flexibility to customize their ServiceNow instances for local needs while the enterprise maintains visibility into cross-organizational metrics, compliance, and strategic initiatives. The hub instance typically contains master data like employee records, organizational hierarchies, and standardized catalogs that get synchronized to spokes.

Data flows bidirectionally between hub and spokes through REST APIs, scheduled imports, or real-time integrations. The hub aggregates incident volumes, service metrics, and compliance data from all spokes, while pushing out policy updates, catalog items, and organizational changes to maintain consistency across the enterprise.

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 your enterprise has multiple business units requiring ServiceNow customization autonomy but needs centralized reporting, governance, and master data management. This is ideal for large corporations with subsidiaries, global organizations with regional requirements, or companies that have grown through acquisitions and need to consolidate ServiceNow footprints.

Avoid When

Avoid this pattern for smaller organizations where a single instance can meet all needs, as the complexity and licensing costs outweigh benefits. Don't use this approach if your organization lacks the technical resources to maintain multiple instances and complex integrations, or if real-time data consistency across all business units is absolutely critical.

Implementation

Server-side

var HubSpokeDataSync = Class.create();
HubSpokeDataSync.prototype = {
    initialize: function() {
        this.hubURL = gs.getProperty('hub.instance.url', 'https://company-hub.service-now.com');
        this.spokeInstances = this._getSpokeInstances();
    },

    // Aggregate incident metrics from all spoke instances to hub
    aggregateIncidentMetrics: function() {
        var hubMetrics = [];
        
        for (var i = 0; i < this.spokeInstances.length; i++) {
            var spoke = this.spokeInstances[i];
            var spokeData = this._fetchSpokeData(spoke, 'incident');
            
            if (spokeData && spokeData.length > 0) {
                hubMetrics = hubMetrics.concat(this._transformSpokeData(spokeData, spoke.name));
            }
        }
        
        this._updateHubMetrics(hubMetrics);
        gs.info('Hub-Spoke sync completed. Processed ' + hubMetrics.length + ' records');
        return hubMetrics.length;
    },

    // Push master data from hub to spoke instances
    pushMasterDataToSpokes: function(tableName) {
        var gr = new GlideRecord(tableName);
        gr.addQuery('u_sync_to_spokes', true);
        gr.addQuery('sys_updated_on', '>', gs.daysAgoStart(1)); // Only recent changes
        gr.query();
        
        var recordsToSync = [];
        while (gr.next()) {
            recordsToSync.push({
                sys_id: gr.getUniqueValue(),
                data: this._serializeRecord(gr)
            });
        }
        
        for (var j = 0; j < this.spokeInstances.length; j++) {
            this._pushDataToSpoke(this.spokeInstances[j], tableName, recordsToSync);
        }
    },

    _getSpokeInstances: function() {
        var instances = [];
        var gr = new GlideRecord('u_spoke_instances');
        gr.addQuery('u_active', true);
        gr.query();
        
        while (gr.next()) {
            instances.push({
                name: gr.getValue('u_name'),
                url: gr.getValue('u_url'),
                credentials: gr.getValue('u_credentials'),
                businessUnit: gr.getValue('u_business_unit')
            });
        }
        return instances;
    },

    _fetchSpokeData: function(spoke, table) {
        try {
            var rm = new sn_ws.RESTMessageV2();
            rm.setEndpoint(spoke.url + '/api/now/table/' + table);
            rm.setHttpMethod('GET');
            rm.setBasicAuth(spoke.credentials.username, spoke.credentials.password);
            rm.setQueryParameter('sysparm_query', 'sys_updated_onONToday@javascript:gs.daysAgoStart(0)@javascript:gs.daysAgoEnd(0)');
            
            var response = rm.execute();
            if (response.getStatusCode() == 200) {
                var responseBody = response.getBody();
                var jsonData = JSON.parse(responseBody);
                return jsonData.result;
            }
        } catch (ex) {
            gs.error('Failed to fetch data from spoke ' + spoke.name + ': ' + ex.getMessage());
        }
        return null;
    },

    _transformSpokeData: function(data, spokeName) {
        var transformed = [];
        for (var i = 0; i < data.length; i++) {
            var record = data[i];
            transformed.push({
                spoke_instance: spokeName,
                original_sys_id: record.sys_id,
                priority: record.priority,
                state: record.state,
                business_service: record.business_service,
                assignment_group: record.assignment_group,
                opened_at: record.opened_at,
                resolved_at: record.resolved_at
            });
        }
        return transformed;
    },

    _updateHubMetrics: function(metrics) {
        for (var i = 0; i < metrics.length; i++) {
            var metric = metrics[i];
            var gr = new GlideRecord('u_hub_incident_metrics');
            gr.addQuery('spoke_instance', metric.spoke_instance);
            gr.addQuery('original_sys_id', metric.original_sys_id);
            gr.query();
            
            if (!gr.next()) {
                gr.initialize();
            }
            
            // Update all fields from transformed data
            Object.keys(metric).forEach(function(key) {
                if (gr.isValidField(key)) {
                    gr.setValue(key, metric[key]);
                }
            });
            
            gr.update();
        }
    },

    _serializeRecord: function(gr) {
        var data = {};
        var fields = gr.getFields();
        for (var i = 0; i < fields.size(); i++) {
            var field = fields.get(i);
            data[field.getName()] = gr.getValue(field.getName());
        }
        return data;
    },

    _pushDataToSpoke: function(spoke, table, records) {
        try {
            var rm = new sn_ws.RESTMessageV2();
            rm.setEndpoint(spoke.url + '/api/now/import/' + table);
            rm.setHttpMethod('POST');
            rm.setBasicAuth(spoke.credentials.username, spoke.credentials.password);
            rm.setRequestHeader('Content-Type', 'application/json');
            rm.setRequestBody(JSON.stringify({records: records}));
            
            var response = rm.execute();
            gs.info('Pushed ' + records.length + ' records to spoke ' + spoke.name + ', status: ' + response.getStatusCode());
        } catch (ex) {
            gs.error('Failed to push data to spoke ' + spoke.name + ': ' + ex.getMessage());
        }
    },

    type: 'HubSpokeDataSync'
};

This Script Include demonstrates bidirectional data synchronization in a hub-and-spoke architecture. The aggregateIncidentMetrics method pulls operational data from spoke instances via REST API calls and stores aggregated metrics in the hub for enterprise reporting. The pushMasterDataToSpokes method distributes master data changes from the hub to all active spoke instances, ensuring consistency across the enterprise while allowing local customization.

Alternatives

Single Instance with Domain Separation

Use when you need data segregation but can accept shared customizations and configurations. Lower complexity and cost but less flexibility for business unit-specific customizations and potential performance impacts from large shared datasets.

Federated Architecture with Integration Platform

Ideal when you need real-time data synchronization and complex business process orchestration across instances. Provides better data consistency and workflow automation but requires significant integration platform investment and expertise.

Independent Instances with Manual Coordination

Choose this when business units are truly independent and enterprise oversight is minimal. Simplest to implement and maintain but sacrifices enterprise visibility, standardization, and centralized governance capabilities.

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