Approval Chain Design Pattern - Flow &…

intermediateTested on Xanadu

The Approval Chain Design Pattern provides a structured approach to implementing complex approval workflows in ServiceNow that can dynamically determine approvers, handle parallel and sequential approval stages, and manage timeout escalations. This pattern combines Flow Designer capabilities with server-side scripting to create maintainable and flexible approval processes.

This pattern solves the challenge of building approval workflows that need to adapt to different organizational structures, approval requirements, and business rules without hardcoding approver logic. It enables dynamic approver calculation based on record attributes, supports both parallel approvals within stages and sequential progression through approval levels, and provides built-in escalation and delegation capabilities.

The pattern works by separating approval logic into reusable components: a Script Include that calculates approvers dynamically, Flow Designer subflows that handle the approval mechanics, and configuration tables that define approval chains without code changes. This separation allows for easy maintenance and modification of approval processes as business requirements evolve.

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 need approval workflows that vary based on record attributes like amount, department, or category, when you require multiple approval stages with different logic for each stage, or when you need to support complex approval scenarios like parallel approvals within a stage followed by sequential escalation. This pattern is ideal for purchase requisitions, change requests, or any process where approval requirements are dynamic and business rules are complex.

Avoid When

Avoid this pattern for simple, static approval workflows where approvers are always the same and don't change based on record attributes, as the overhead of dynamic calculation adds unnecessary complexity. Don't use this pattern if your approval requirements are likely to remain very simple long-term, as the Flow Designer native approval activities may be sufficient and easier to maintain.

Implementation

Server-side

var ApprovalChainCalculator = Class.create();
ApprovalChainCalculator.prototype = {
    initialize: function() {
        this.debug = true;
    },

    // Calculate approval chain for a given record
    calculateApprovalChain: function(tableName, recordSysId) {
        var approvalChain = [];
        var record = new GlideRecord(tableName);
        
        if (!record.get(recordSysId)) {
            gs.error('ApprovalChainCalculator: Record not found - ' + tableName + ':' + recordSysId);
            return approvalChain;
        }

        // Example: Purchase Request approval chain based on amount
        if (tableName == 'sc_req_item') {
            approvalChain = this._calculatePurchaseApprovalChain(record);
        } else if (tableName == 'change_request') {
            approvalChain = this._calculateChangeApprovalChain(record);
        } else {
            // Generic approval chain based on configuration
            approvalChain = this._calculateGenericApprovalChain(record);
        }

        if (this.debug) {
            gs.info('ApprovalChainCalculator: Calculated chain for ' + recordSysId + ': ' + JSON.stringify(approvalChain));
        }

        return approvalChain;
    },

    _calculatePurchaseApprovalChain: function(record) {
        var chain = [];
        var amount = parseFloat(record.getValue('price')) || 0;
        var department = record.requested_for.department.toString();
        
        // Stage 1: Manager approval (always required)
        var managerStage = {
            stage: 1,
            name: 'Manager Approval',
            type: 'sequential', // or 'parallel'
            approvers: [],
            required: true,
            timeout_hours: 24,
            escalation_approvers: []
        };
        
        // Get requesting user's manager
        var requestedFor = record.requested_for.toString();
        var manager = this._getManagerForUser(requestedFor);
        if (manager) {
            managerStage.approvers.push(manager);
            // Add manager's manager as escalation
            var seniorManager = this._getManagerForUser(manager);
            if (seniorManager) {
                managerStage.escalation_approvers.push(seniorManager);
            }
        }
        
        chain.push(managerStage);
        
        // Stage 2: Department head approval (if amount > $1000)
        if (amount > 1000) {
            var deptStage = {
                stage: 2,
                name: 'Department Head Approval',
                type: 'sequential',
                approvers: [],
                required: true,
                timeout_hours: 48,
                escalation_approvers: []
            };
            
            var deptHead = this._getDepartmentHead(department);
            if (deptHead) {
                deptStage.approvers.push(deptHead);
            }
            
            chain.push(deptStage);
        }
        
        // Stage 3: Finance approval (if amount > $5000)
        if (amount > 5000) {
            var financeStage = {
                stage: 3,
                name: 'Finance Approval',
                type: 'parallel', // Multiple finance approvers can approve in parallel
                approvers: this._getFinanceApprovers(),
                required: true,
                timeout_hours: 72,
                escalation_approvers: [this._getFinanceDirector()]
            };
            
            chain.push(financeStage);
        }
        
        return chain;
    },

    _calculateChangeApprovalChain: function(record) {
        var chain = [];
        var risk = record.getValue('risk');
        var category = record.getValue('category');
        
        // Always require CAB approval for high risk changes
        if (risk == '1' || risk == '2') { // High or Medium risk
            chain.push({
                stage: 1,
                name: 'CAB Approval',
                type: 'sequential',
                approvers: this._getCABMembers(),
                required: true,
                timeout_hours: 168, // 1 week
                escalation_approvers: [this._getChangeManager()]
            });
        }
        
        return chain;
    },

    _calculateGenericApprovalChain: function(record) {
        // Fallback to simple manager approval
        var requestedBy = record.getValue('sys_created_by');
        var manager = this._getManagerForUser(requestedBy);
        
        return [{
            stage: 1,
            name: 'Manager Approval',
            type: 'sequential',
            approvers: manager ? [manager] : [],
            required: true,
            timeout_hours: 48,
            escalation_approvers: []
        }];
    },

    _getManagerForUser: function(userSysId) {
        var user = new GlideRecord('sys_user');
        if (user.get(userSysId) && user.manager) {
            return user.manager.toString();
        }
        return null;
    },

    _getDepartmentHead: function(departmentSysId) {
        var dept = new GlideRecord('cmn_department');
        if (dept.get(departmentSysId) && dept.dept_head) {
            return dept.dept_head.toString();
        }
        return null;
    },

    _getFinanceApprovers: function() {
        var approvers = [];
        var gr = new GlideRecord('sys_user');
        gr.addQuery('department.name', 'Finance');
        gr.addQuery('u_finance_approver', true);
        gr.addQuery('active', true);
        gr.query();
        
        while (gr.next()) {
            approvers.push(gr.sys_id.toString());
        }
        
        return approvers;
    },

    _getFinanceDirector: function() {
        var gr = new GlideRecord('sys_user');
        gr.addQuery('title', 'CONTAINS', 'Finance Director');
        gr.addQuery('active', true);
        gr.query();
        
        if (gr.next()) {
            return gr.sys_id.toString();
        }
        
        return null;
    },

    _getCABMembers: function() {
        var members = [];
        var gr = new GlideRecord('sys_user');
        gr.addQuery('u_cab_member', true);
        gr.addQuery('active', true);
        gr.query();
        
        while (gr.next()) {
            members.push(gr.sys_id.toString());
        }
        
        return members;
    },

    _getChangeManager: function() {
        var gr = new GlideRecord('sys_user');
        gr.addQuery('title', 'CONTAINS', 'Change Manager');
        gr.addQuery('active', true);
        gr.query();
        
        if (gr.next()) {
            return gr.sys_id.toString();
        }
        
        return null;
    },

    type: 'ApprovalChainCalculator'
};

This Script Include demonstrates dynamic approval chain calculation with configurable stages supporting both parallel and sequential approvals. The calculateApprovalChain method returns a structured array defining approval stages with approvers, timeouts, and escalation rules that Flow Designer can consume. Each stage specifies whether approvals should be processed in parallel or sequentially, includes timeout periods for escalation, and provides fallback approvers when primary approvers don't respond.

Alternatives

Configuration Table Driven Approvals

Uses custom tables to store approval rules and stages rather than hardcoded logic, making it more configurable for administrators but requiring additional setup and maintenance of configuration records.

Native ServiceNow Approval Engine

Leverages the built-in approval_approver table and workflow activities for simpler implementation, but provides less flexibility for complex approval logic and dynamic approver calculation.

Scripted Approval Policies

Uses approval policies with advanced scripting for highly customized approval logic, offering maximum flexibility but requiring more complex debugging and maintenance compared to Flow Designer approaches.

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