Multi-Tenant ServiceNow Architecture…

advancedTested on Xanadu

Multi-tenant ServiceNow architecture enables serving multiple customers or business units from shared or isolated ServiceNow instances while maintaining data security, performance, and customization requirements. This pattern addresses the fundamental challenge of balancing resource efficiency with tenant isolation in enterprise ServiceNow deployments.

The core problem solved is how to architect ServiceNow to serve multiple tenants while ensuring data privacy, customization flexibility, and operational efficiency. Different organizations require different levels of isolation based on regulatory requirements, customization needs, and resource constraints.

This pattern encompasses three main approaches: domain separation for logical isolation within a single instance, dedicated instances for complete isolation, and hybrid models that combine both strategies. The implementation involves tenant identification mechanisms, data access controls, and automated provisioning processes that ensure proper isolation while maintaining operational efficiency.

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 serving multiple distinct customer organizations, business units with different compliance requirements, or when offering ServiceNow as a managed service. It's essential when tenants require different customizations, have varying security requirements, or when regulatory compliance demands data isolation.

Avoid When

Avoid this pattern for simple departmental separations within a single organization where basic ACLs suffice, or when all users share identical processes and security requirements. The complexity and overhead aren't justified for scenarios where standard ServiceNow role-based access controls can provide adequate separation.

Implementation

Server-side

// Multi-Tenant Manager Script Include
var MultiTenantManager = Class.create();
MultiTenantManager.prototype = {
    initialize: function() {
        this.TENANT_TABLE = 'u_tenant_config';
        this.DEFAULT_DOMAIN = 'global';
    },

    // Get tenant configuration based on current user context
    getCurrentTenant: function() {
        var user = gs.getUser();
        var tenantGr = new GlideRecord(this.TENANT_TABLE);
        tenantGr.addQuery('active', true);
        
        // Check if user belongs to a specific tenant domain
        if (user.getDomainID() && user.getDomainID() != this.DEFAULT_DOMAIN) {
            tenantGr.addQuery('domain', user.getDomainID());
            tenantGr.query();
            if (tenantGr.next()) {
                return {
                    id: tenantGr.getUniqueValue(),
                    name: tenantGr.getValue('name'),
                    domain: tenantGr.getValue('domain'),
                    config: this._parseConfig(tenantGr.getValue('configuration'))
                };
            }
        }
        
        // Fallback to default tenant
        return this._getDefaultTenant();
    },

    // Create isolated query for tenant-specific data
    getTenantQuery: function(tableName, tenantId) {
        var gr = new GlideRecord(tableName);
        var tenant = this._getTenantById(tenantId);
        
        if (tenant && tenant.domain != this.DEFAULT_DOMAIN) {
            // Apply domain separation
            gr.addDomainQuery(tenant.domain);
        }
        
        // Add additional tenant-specific filters
        if (this._requiresTenantFilter(tableName)) {
            gr.addQuery('u_tenant', tenantId);
        }
        
        return gr;
    },

    // Provision new tenant with domain separation
    provisionTenant: function(tenantData) {
        var tenantId = gs.generateGUID();
        
        // Create domain if using domain separation
        if (tenantData.isolation_level == 'domain') {
            var domainId = this._createDomain(tenantData.name, tenantId);
            tenantData.domain = domainId;
        }
        
        // Create tenant configuration record
        var tenantGr = new GlideRecord(this.TENANT_TABLE);
        tenantGr.initialize();
        tenantGr.setValue('sys_id', tenantId);
        tenantGr.setValue('name', tenantData.name);
        tenantGr.setValue('domain', tenantData.domain || this.DEFAULT_DOMAIN);
        tenantGr.setValue('isolation_level', tenantData.isolation_level);
        tenantGr.setValue('configuration', JSON.stringify(tenantData.config || {}));
        tenantGr.setValue('active', true);
        tenantGr.insert();
        
        // Initialize tenant-specific data and permissions
        this._initializeTenantData(tenantId, tenantData);
        
        gs.info('Tenant provisioned: ' + tenantData.name + ' (' + tenantId + ')');
        return tenantId;
    },

    // Helper methods
    _getTenantById: function(tenantId) {
        var tenantGr = new GlideRecord(this.TENANT_TABLE);
        if (tenantGr.get(tenantId)) {
            return {
                id: tenantGr.getUniqueValue(),
                name: tenantGr.getValue('name'),
                domain: tenantGr.getValue('domain'),
                config: this._parseConfig(tenantGr.getValue('configuration'))
            };
        }
        return null;
    },

    _createDomain: function(tenantName, tenantId) {
        var domainGr = new GlideRecord('domain');
        domainGr.initialize();
        domainGr.setValue('name', 'Tenant: ' + tenantName);
        domainGr.setValue('value', 'tenant_' + tenantId);
        domainGr.setValue('active', true);
        return domainGr.insert();
    },

    _parseConfig: function(configStr) {
        try {
            return JSON.parse(configStr || '{}');
        } catch (e) {
            gs.error('Invalid tenant configuration JSON: ' + e.message);
            return {};
        }
    },

    _getDefaultTenant: function() {
        return {
            id: 'default',
            name: 'Default Tenant',
            domain: this.DEFAULT_DOMAIN,
            config: {}
        };
    },

    _requiresTenantFilter: function(tableName) {
        var tenantTables = ['incident', 'sc_request', 'u_custom_app_data'];
        return tenantTables.indexOf(tableName) >= 0;
    },

    _initializeTenantData: function(tenantId, tenantData) {
        // Create tenant-specific groups, roles, and initial data
        // This would include creating tenant admin groups, default categories, etc.
        gs.info('Initializing data structures for tenant: ' + tenantId);
    },

    type: 'MultiTenantManager'
};

Client-side

// Client-side tenant context helper
function getTenantContext(callback) {
    var ga = new GlideAjax('MultiTenantManager');
    ga.addParam('sysparm_name', 'getCurrentTenant');
    ga.getXML(function(response) {
        var answer = response.responseXML.documentElement.getAttribute('answer');
        if (answer) {
            try {
                var tenantInfo = JSON.parse(answer);
                callback(tenantInfo);
            } catch (e) {
                console.error('Failed to parse tenant context: ' + e.message);
                callback(null);
            }
        }
    });
}

// Apply tenant-specific UI customizations
function applyTenantBranding() {
    getTenantContext(function(tenant) {
        if (tenant && tenant.config.branding) {
            var headerDiv = document.querySelector('#header');
            if (headerDiv && tenant.config.branding.logo) {
                var logoImg = document.createElement('img');
                logoImg.src = tenant.config.branding.logo;
                logoImg.style.height = '30px';
                logoImg.style.marginRight = '10px';
                headerDiv.insertBefore(logoImg, headerDiv.firstChild);
            }
            
            if (tenant.config.branding.primaryColor) {
                document.documentElement.style.setProperty('--tenant-primary-color', tenant.config.branding.primaryColor);
            }
        }
    });
}

The code demonstrates a comprehensive multi-tenant architecture using domain separation as the primary isolation mechanism. The MultiTenantManager Script Include handles tenant identification, domain-based data isolation, and automated tenant provisioning with proper domain creation. The client-side code shows how to retrieve tenant context and apply tenant-specific UI customizations, enabling a complete multi-tenant experience with both data isolation and visual differentiation.

Alternatives

Dedicated Instance Per Tenant

Provides complete isolation and unlimited customization flexibility but significantly increases infrastructure costs, maintenance overhead, and complexity of cross-tenant reporting or shared services.

ACL-Based Soft Separation

Lower complexity and maintenance overhead using only Access Control Lists and user roles for separation, but provides weaker isolation and limited customization capabilities per tenant compared to domain separation.

Hybrid Multi-Instance with Shared Services

Combines dedicated instances for high-isolation tenants with shared instances for standard tenants, optimizing costs while meeting diverse security requirements, but requires sophisticated orchestration and management tooling.

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