Automated Assignment Rules Pattern…

intermediateTested on Xanadu

The Automated Assignment Rules Pattern provides a systematic approach to intelligently route work items to the most appropriate agents or groups based on configurable criteria. This pattern goes beyond simple group assignment by incorporating skills matching, workload balancing, availability checking, and escalation fallbacks to ensure work is distributed efficiently and fairly across teams.

This pattern addresses the common problem of manual assignment overhead and uneven work distribution that occurs in service desk environments. By automating the assignment process with intelligent rules, organizations can reduce response times, improve agent utilization, and ensure consistent service delivery. The pattern typically combines multiple assignment strategies in a hierarchical fallback approach, starting with the most specific matching criteria and falling back to broader distribution methods when needed.

The implementation uses a combination of Business Rules for real-time assignment, Script Includes for reusable assignment logic, and scheduled jobs for handling unassigned record escalation. The pattern maintains assignment history and provides audit trails while being flexible enough to accommodate different assignment strategies for various record types and business scenarios.

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 you have high-volume work items that require consistent, fair distribution across team members and when assignment criteria are complex enough to benefit from automation. This is particularly valuable in service desk environments with multiple skill sets, varying workloads, or time-sensitive SLA requirements.

Avoid When

Avoid this pattern for low-volume environments where manual assignment is manageable or when assignment rules are highly dynamic and change frequently based on business context that cannot be easily codified. The complexity overhead may not be justified for simple group-based assignment scenarios or when specialized human judgment is critical for proper routing.

Implementation

Server-side

var AssignmentRuleEngine = Class.create();
AssignmentRuleEngine.prototype = {
    initialize: function() {
        this.MAX_WORKLOAD = 10; // Maximum active assignments per user
        this.ASSIGNMENT_TIMEOUT = 30; // Minutes before escalation
    },

    assignRecord: function(recordGr, assignmentType) {
        // Try assignment strategies in order of preference
        var assignedTo = this._trySkillsBasedAssignment(recordGr) ||
                        this._tryRoundRobinAssignment(recordGr) ||
                        this._tryFallbackAssignment(recordGr);
        
        if (assignedTo) {
            recordGr.setValue('assigned_to', assignedTo);
            recordGr.setValue('assignment_group', this._getUserGroup(assignedTo));
            recordGr.setValue('u_assignment_method', assignmentType);
            recordGr.setValue('u_assigned_date', new GlideDateTime());
            this._logAssignment(recordGr, assignedTo, assignmentType);
            return true;
        }
        
        // No assignment possible, escalate
        this._escalateUnassigned(recordGr);
        return false;
    },

    _trySkillsBasedAssignment: function(recordGr) {
        var category = recordGr.getValue('category');
        var subcategory = recordGr.getValue('subcategory');
        var priority = recordGr.getValue('priority');
        
        // Query for users with required skills and availability
        var userGr = new GlideRecord('sys_user');
        userGr.addActiveQuery();
        userGr.addQuery('u_available_for_assignment', true);
        
        // Join to skills table to find matching expertise
        userGr.addJoinQuery('u_user_skills', 'sys_id', 'user')
               .addQuery('skill.name', category);
        
        userGr.query();
        
        var candidates = [];
        while (userGr.next()) {
            var workload = this._getCurrentWorkload(userGr.getUniqueValue());
            if (workload < this.MAX_WORKLOAD) {
                candidates.push({
                    userId: userGr.getUniqueValue(),
                    workload: workload,
                    skillLevel: this._getSkillLevel(userGr.getUniqueValue(), category)
                });
            }
        }
        
        if (candidates.length > 0) {
            // Sort by skill level descending, then workload ascending
            candidates.sort(function(a, b) {
                if (a.skillLevel !== b.skillLevel) {
                    return b.skillLevel - a.skillLevel;
                }
                return a.workload - b.workload;
            });
            
            return candidates[0].userId;
        }
        
        return null;
    },

    _tryRoundRobinAssignment: function(recordGr) {
        var groupId = this._getTargetGroup(recordGr);
        if (!groupId) return null;
        
        // Get group members ordered by last assignment date
        var userGr = new GlideRecord('sys_user_grmember');
        userGr.addQuery('group', groupId);
        userGr.addQuery('user.active', true);
        userGr.addQuery('user.u_available_for_assignment', true);
        userGr.query();
        
        var candidates = [];
        while (userGr.next()) {
            var userId = userGr.user.sys_id.toString();
            var workload = this._getCurrentWorkload(userId);
            var lastAssigned = this._getLastAssignmentDate(userId);
            
            if (workload < this.MAX_WORKLOAD) {
                candidates.push({
                    userId: userId,
                    lastAssigned: lastAssigned,
                    workload: workload
                });
            }
        }
        
        if (candidates.length > 0) {
            // Sort by last assignment date (oldest first), then by workload
            candidates.sort(function(a, b) {
                var dateCompare = new GlideDateTime(a.lastAssigned).compareTo(new GlideDateTime(b.lastAssigned));
                if (dateCompare !== 0) return dateCompare;
                return a.workload - b.workload;
            });
            
            return candidates[0].userId;
        }
        
        return null;
    },

    _tryFallbackAssignment: function(recordGr) {
        // Assign to group manager or designated backup
        var groupId = this._getTargetGroup(recordGr);
        if (!groupId) return null;
        
        var groupGr = new GlideRecord('sys_user_group');
        if (groupGr.get(groupId) && groupGr.manager) {
            var managerId = groupGr.manager.toString();
            if (this._isUserAvailable(managerId)) {
                return managerId;
            }
        }
        
        return null;
    },

    _getCurrentWorkload: function(userId) {
        var incidentGr = new GlideAggregate('incident');
        incidentGr.addQuery('assigned_to', userId);
        incidentGr.addQuery('state', 'NOT IN', '6,7,8'); // Not resolved/closed/cancelled
        incidentGr.addAggregate('COUNT');
        incidentGr.query();
        
        if (incidentGr.next()) {
            return parseInt(incidentGr.getAggregate('COUNT')) || 0;
        }
        return 0;
    },

    _escalateUnassigned: function(recordGr) {
        recordGr.setValue('u_assignment_failed', true);
        recordGr.setValue('u_escalation_date', new GlideDateTime());
        
        // Create assignment failure event for notifications
        gs.eventQueue('assignment.failed', recordGr, recordGr.getUniqueValue(), 'Assignment rules could not find suitable assignee');
        gs.log('Assignment failed for record: ' + recordGr.getUniqueValue(), 'AssignmentRuleEngine');
    },

    _getTargetGroup: function(recordGr) {
        // Logic to determine target group based on record attributes
        var category = recordGr.getValue('category');
        var mappingGr = new GlideRecord('u_category_group_mapping');
        mappingGr.addQuery('category', category);
        mappingGr.query();
        
        if (mappingGr.next()) {
            return mappingGr.group.toString();
        }
        
        return null;
    },

    _logAssignment: function(recordGr, assignedTo, method) {
        var logGr = new GlideRecord('u_assignment_log');
        logGr.initialize();
        logGr.setValue('record_id', recordGr.getUniqueValue());
        logGr.setValue('record_table', recordGr.getTableName());
        logGr.setValue('assigned_to', assignedTo);
        logGr.setValue('assignment_method', method);
        logGr.setValue('assigned_date', new GlideDateTime());
        logGr.insert();
    },

    type: 'AssignmentRuleEngine'
};

// Business Rule implementation (onChange, after, Incident table)
(function executeRule(current, previous) {
    // Only run on insert or when assignment_group changes
    if (!current.isNewRecord() && !current.assignment_group.changes()) {
        return;
    }
    
    // Don't auto-assign if already assigned
    if (!gs.nil(current.assigned_to)) {
        return;
    }
    
    var assignmentEngine = new AssignmentRuleEngine();
    assignmentEngine.assignRecord(current, 'automatic');
})(current, previous);

The code implements a hierarchical assignment engine that tries skills-based matching first, then round-robin distribution, and finally fallback assignment to managers. The engine tracks workload limits, maintains assignment history in a custom log table, and includes escalation handling for unassigned records. The Business Rule triggers the assignment automatically when records are created or when assignment groups change.

Alternatives

Flow Designer Assignment

Better for non-developers with drag-and-drop configuration and easier maintenance, but less flexible for complex assignment logic and may have performance limitations with high-volume scenarios compared to server-side JavaScript.

Assignment Rules (OOB)

ServiceNow's out-of-box assignment rules are simpler to configure and maintain but lack advanced features like skills-based routing, workload balancing, and complex fallback logic that custom implementations provide.

Workflow-based Assignment

Traditional workflows offer visual process modeling and are familiar to many administrators but are being deprecated in favor of Flow Designer and lack the real-time performance of Business Rule-based assignment for high-volume scenarios.

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