Async Processing Pattern for…

advancedTested on Xanadu

The Async Processing Pattern defers resource-intensive operations from synchronous business rules to asynchronous execution contexts to prevent transaction timeouts and improve user experience. When users perform actions that trigger complex calculations, bulk record updates, or external API calls, executing these operations synchronously can cause database transaction timeouts and poor performance.

This pattern works by capturing the necessary context in the synchronous transaction, then triggering asynchronous processing through events, scheduled jobs, or Flow Designer. The heavy lifting happens in the background while users can continue working immediately. Progress can be tracked through status fields or notifications.

The pattern maintains data integrity by clearly separating the triggering action from the processing logic, allowing the system to handle failures gracefully and provide appropriate feedback to users about the status of their requested operations.

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 business rules perform operations that take more than a few seconds, such as bulk record updates, complex calculations across large datasets, or multiple external API calls. It's essential when users report slow form saves, transaction timeout errors, or when operations involve processing hundreds or thousands of records.

Avoid When

Avoid this pattern for simple operations that complete quickly or when immediate synchronous results are required for business logic validation. Don't use it for operations that must complete before the user can continue their workflow, or when the complexity of async coordination outweighs the performance benefits.

Implementation

Server-side

// Business Rule (Before/After Insert/Update) - Triggers async processing
(function executeRule(current, previous) {
    // Only process if specific conditions are met
    if (current.state.changesTo('approved') && current.impact == 'high') {
        // Capture context for async processing
        var eventRecord = new GlideRecord('sysevent_register');
        eventRecord.initialize();
        eventRecord.event_name = 'custom.bulk_processing';
        eventRecord.instance = gs.getProperty('instance_name');
        eventRecord.table = current.getTableName();
        eventRecord.sys_id = current.getUniqueValue();
        
        // Pass additional parameters as JSON
        var params = {
            record_id: current.getUniqueValue(),
            processing_type: 'approval_cascade',
            user_id: gs.getUserID(),
            timestamp: gs.nowDateTime()
        };
        eventRecord.parm1 = JSON.stringify(params);
        eventRecord.insert();
        
        gs.info('Queued async processing for record: ' + current.number);
    }
})(current, previous);

// Script Include - Handles the async processing
var AsyncProcessor = Class.create();
AsyncProcessor.prototype = {
    initialize: function() {
        this.BATCH_SIZE = 100;
        this.MAX_PROCESSING_TIME = 300000; // 5 minutes
    },
    
    processEvent: function(eventRecord) {
        var startTime = new Date().getTime();
        
        try {
            var params = JSON.parse(eventRecord.parm1 || '{}');
            var sourceRecord = new GlideRecord(eventRecord.table);
            
            if (!sourceRecord.get(params.record_id)) {
                gs.error('Source record not found: ' + params.record_id);
                return;
            }
            
            // Update status to indicate processing started
            sourceRecord.u_processing_status = 'in_progress';
            sourceRecord.u_processing_started = gs.nowDateTime();
            sourceRecord.update();
            
            // Perform the heavy processing in batches
            this._performBulkProcessing(params, startTime);
            
            // Update completion status
            sourceRecord.initialize();
            sourceRecord.get(params.record_id);
            sourceRecord.u_processing_status = 'completed';
            sourceRecord.u_processing_completed = gs.nowDateTime();
            sourceRecord.update();
            
            gs.info('Async processing completed for: ' + params.record_id);
            
        } catch (ex) {
            gs.error('Async processing failed: ' + ex.message);
            this._updateErrorStatus(eventRecord.table, params.record_id, ex.message);
        }
    },
    
    _performBulkProcessing: function(params, startTime) {
        var relatedRecords = new GlideRecord('task');
        relatedRecords.addQuery('parent', params.record_id);
        relatedRecords.query();
        
        var processedCount = 0;
        while (relatedRecords.next()) {
            // Check if we're approaching time limit
            if (new Date().getTime() - startTime > this.MAX_PROCESSING_TIME) {
                gs.warn('Processing timeout reached, stopping batch');
                break;
            }
            
            // Perform the actual processing
            relatedRecords.u_cascade_approval = 'approved';
            relatedRecords.u_approved_by = params.user_id;
            relatedRecords.update();
            
            processedCount++;
            
            // Yield periodically to prevent monopolizing resources
            if (processedCount % this.BATCH_SIZE === 0) {
                gs.sleep(100);
            }
        }
        
        gs.info('Processed ' + processedCount + ' related records');
    },
    
    _updateErrorStatus: function(table, recordId, errorMessage) {
        var record = new GlideRecord(table);
        if (record.get(recordId)) {
            record.u_processing_status = 'error';
            record.u_processing_error = errorMessage;
            record.update();
        }
    },
    
    type: 'AsyncProcessor'
};

// Scheduled Job Script - Processes queued events
var processor = new AsyncProcessor();
var events = new GlideRecord('sysevent_register');
events.addQuery('event_name', 'custom.bulk_processing');
events.addQuery('state', 'ready');
events.orderBy('sys_created_on');
events.setLimit(10); // Process max 10 events per run
events.query();

while (events.next()) {
    processor.processEvent(events);
    events.state = 'processed';
    events.update();
}

Client-side

// Catalog Client Script or Form Client Script - Shows processing status
function onLoad() {
    // Monitor async processing status
    if (g_form.getValue('u_processing_status') == 'in_progress') {
        // Show processing indicator
        g_form.addInfoMessage('Your request is being processed in the background. You will receive a notification when complete.');
        
        // Disable form while processing
        g_form.setReadOnly(true);
        
        // Poll for status updates every 30 seconds
        setTimeout(function() {
            checkProcessingStatus();
        }, 30000);
    }
}

function checkProcessingStatus() {
    var ga = new GlideAjax('AsyncStatusChecker');
    ga.addParam('sysparm_name', 'getProcessingStatus');
    ga.addParam('sysparm_record_id', g_form.getUniqueValue());
    ga.getXML(function(response) {
        var answer = response.responseXML.documentElement.getAttribute('answer');
        var status = JSON.parse(answer);
        
        if (status.processing_status == 'completed') {
            g_form.addInfoMessage('Processing completed successfully!');
            g_form.setReadOnly(false);
            g_form.reload();
        } else if (status.processing_status == 'error') {
            g_form.addErrorMessage('Processing failed: ' + status.error_message);
            g_form.setReadOnly(false);
        } else if (status.processing_status == 'in_progress') {
            // Continue polling
            setTimeout(function() {
                checkProcessingStatus();
            }, 30000);
        }
    });
}

The business rule captures the triggering context and queues an event rather than performing heavy processing directly. The Script Include handles the actual processing with batching, timeout protection, and error handling to prevent resource monopolization. The client code provides user feedback and status polling to maintain a responsive user experience during background processing.

Alternatives

Flow Designer with Subflows

Better for non-technical administrators and provides visual process modeling, but may have less flexibility for complex error handling and doesn't offer the same level of performance control as custom scripting.

Direct Scheduled Job Approach

Simpler implementation by writing records to a custom processing table and having scheduled jobs poll that table, but lacks the event-driven responsiveness and may result in longer processing delays.

REST API with External Processing

Offloads processing entirely from ServiceNow to external systems which can handle very large workloads, but introduces network dependencies, security complexity, and requires additional infrastructure management.

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