Microservices Integration Pattern…

advancedTested on Xanadu

The ServiceNow Microservices Integration Pattern treats ServiceNow as a service participant in a distributed microservices architecture rather than a monolithic system. This pattern leverages ServiceNow's Table API for data operations, event-driven integration through message queues, and Integration Hub for orchestrating external service communications while maintaining loose coupling between systems.

This architectural approach solves the challenge of integrating ServiceNow with cloud-native applications and containerized services that expect REST-based, stateless interactions. Instead of building point-to-point integrations, this pattern creates a service mesh where ServiceNow can consume and publish events, expose domain-specific APIs, and participate in distributed transactions without becoming a bottleneck.

The pattern works by exposing ServiceNow capabilities through well-defined REST endpoints, implementing event handlers that respond to external system changes, and using Integration Hub spokes to abstract complex integration logic into reusable components that can be called by external orchestrators.

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 ServiceNow needs to integrate with cloud-native applications, containerized microservices, or when you're implementing event-driven architecture across multiple systems. This is ideal for organizations adopting DevOps practices where ServiceNow participates in CI/CD pipelines or when you need to maintain data consistency across distributed systems without tight coupling.

Avoid When

Avoid this pattern for simple point-to-point integrations or when you have legacy systems that cannot support REST APIs or event-driven communication. This approach adds complexity and may be overkill for small implementations with fewer than five integrated systems or when real-time synchronous processing is absolutely required.

Implementation

Server-side

// Script Include: MicroserviceEventHandler
var MicroserviceEventHandler = Class.create();
MicroserviceEventHandler.prototype = {
    initialize: function() {
        this.queueName = 'servicenow.events';
        this.maxRetries = 3;
    },
    
    // Handle incoming events from external microservices
    processIncomingEvent: function(eventType, payload) {
        try {
            gs.info('Processing microservice event: ' + eventType);
            
            switch(eventType) {
                case 'user.created':
                    return this._createUserRecord(payload);
                case 'asset.updated':
                    return this._updateAssetRecord(payload);
                case 'incident.external':
                    return this._createIncidentFromExternal(payload);
                default:
                    gs.warn('Unknown event type: ' + eventType);
                    return false;
            }
        } catch(ex) {
            gs.error('Error processing event: ' + ex.getMessage());
            return false;
        }
    },
    
    // Publish events to external microservices via Integration Hub
    publishEvent: function(eventType, recordSysId, tableName) {
        var eventPayload = {
            eventId: gs.generateGUID(),
            timestamp: new GlideDateTime().getDisplayValue(),
            source: 'servicenow',
            type: eventType,
            data: this._buildEventData(recordSysId, tableName)
        };
        
        // Use Integration Hub Action to publish to message queue
        var action = new sn_ih.IntegrationAction();
        action.setName('Publish Microservice Event');
        action.setInput('queue_name', this.queueName);
        action.setInput('event_payload', JSON.stringify(eventPayload));
        
        var result = action.execute();
        if (!result.success) {
            gs.error('Failed to publish event: ' + result.error);
        }
        
        return result.success;
    },
    
    // Create ServiceNow user from external service event
    _createUserRecord: function(userData) {
        var userGR = new GlideRecord('sys_user');
        userGR.initialize();
        userGR.user_name = userData.username;
        userGR.email = userData.email;
        userGR.first_name = userData.firstName;
        userGR.last_name = userData.lastName;
        userGR.external_id = userData.externalId; // Track external system ID
        
        var sysId = userGR.insert();
        
        if (sysId) {
            gs.info('Created user record: ' + sysId);
            // Publish confirmation event back to microservices
            this.publishEvent('user.created.confirmed', sysId, 'sys_user');
            return sysId;
        }
        
        return null;
    },
    
    // Build event data payload for external consumption
    _buildEventData: function(recordSysId, tableName) {
        var gr = new GlideRecord(tableName);
        if (!gr.get(recordSysId)) {
            return null;
        }
        
        var eventData = {
            sys_id: recordSysId,
            table: tableName,
            number: gr.getValue('number') || '',
            state: gr.getDisplayValue('state') || '',
            updated_on: gr.sys_updated_on.getDisplayValue(),
            updated_by: gr.sys_updated_by.getDisplayValue()
        };
        
        return eventData;
    },
    
    type: 'MicroserviceEventHandler'
};

// Business Rule: Microservice Event Publisher
// Table: Incident, When: after, Insert/Update/Delete
(function executeRule(current, previous) {
    var eventHandler = new MicroserviceEventHandler();
    var eventType = '';
    
    if (current.operation() == 'insert') {
        eventType = 'incident.created';
    } else if (current.operation() == 'update') {
        eventType = 'incident.updated';
    } else if (current.operation() == 'delete') {
        eventType = 'incident.deleted';
    }
    
    if (eventType) {
        eventHandler.publishEvent(eventType, current.sys_id, 'incident');
    }
})(current, previous);

Client-side

// Service Portal Widget Client Script for microservice status
function($scope, $http) {
    var c = this;
    
    c.checkMicroserviceHealth = function() {
        var ga = new GlideAjax('MicroserviceHealthCheck');
        ga.addParam('sysparm_name', 'getServiceStatus');
        ga.getXMLAnswer(function(response) {
            var status = JSON.parse(response);
            c.serviceStatus = status;
            $scope.$apply();
        });
    };
    
    c.retryFailedEvents = function() {
        c.server.get({action: 'retryEvents'}).then(function(response) {
            c.eventRetryResult = response.data.result;
            c.checkMicroserviceHealth();
        });
    };
    
    // Initialize health check on load
    c.checkMicroserviceHealth();
    
    // Refresh status every 30 seconds
    setInterval(c.checkMicroserviceHealth, 30000);
}

The code demonstrates a complete microservices integration pattern with a Script Include handling bidirectional events, a Business Rule automatically publishing ServiceNow record changes, and Integration Hub actions for queue-based messaging. The pattern maintains loose coupling by using event-driven communication and provides error handling with retry mechanisms for resilient distributed system behavior.

Alternatives

Direct REST API Integration

Simpler to implement for point-to-point connections but creates tight coupling between systems and doesn't scale well as the number of integrated services grows.

Import Set with Transform Maps

Better for batch data synchronization and provides built-in data transformation capabilities, but lacks real-time event processing and doesn't support bidirectional communication patterns.

MID Server Integration

Ideal for on-premises systems and provides secure connectivity through firewalls, but adds infrastructure complexity and may introduce latency for cloud-native microservices.

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