Update Set Branching Pattern for…

intermediateTested on Xanadu

The Update Set Branching Pattern is a development strategy that enables multiple developers to work on related features simultaneously without conflicts by creating logical branches of update sets that can be independently developed and later merged. This pattern addresses the challenge of coordinating parallel development efforts when multiple teams need to modify the same applications or create interdependent functionality.

This pattern works by establishing a hierarchical naming convention for update sets, implementing automated conflict detection mechanisms, and providing merge utilities that can intelligently combine changes from multiple development tracks. The approach includes creating parent update sets that act as integration points, child update sets for individual features, and merge validation scripts that ensure compatibility before batch commits to production environments.

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 multiple developers working on related features that may affect the same tables, applications, or business processes simultaneously. It's particularly valuable for large development teams working on major releases or when you need to maintain separate development tracks for different versions or customer implementations.

Avoid When

Avoid this pattern for small teams with infrequent changes or when developers are working on completely isolated applications with no shared dependencies. The overhead of managing branching strategies can slow down development velocity when simple sequential update sets would suffice, and the complexity may introduce more problems than it solves for straightforward implementations.

Implementation

Server-side

var UpdateSetBranchManager = Class.create();
UpdateSetBranchManager.prototype = {
    initialize: function() {
        this.BRANCH_SEPARATOR = '_BRANCH_';
        this.MERGE_PREFIX = 'MERGE_';
    },

    createBranch: function(parentUpdateSetId, branchName, assignedTo) {
        var parentUS = new GlideRecord('sys_update_set');
        if (!parentUS.get(parentUpdateSetId)) {
            gs.error('Parent update set not found: ' + parentUpdateSetId);
            return null;
        }

        var branchUS = new GlideRecord('sys_update_set');
        branchUS.initialize();
        branchUS.name = parentUS.name + this.BRANCH_SEPARATOR + branchName;
        branchUS.description = 'Branch: ' + branchName + ' | Parent: ' + parentUS.name;
        branchUS.assigned_to = assignedTo;
        branchUS.state = 'build';
        branchUS.u_parent_update_set = parentUpdateSetId;
        branchUS.u_branch_name = branchName;
        var branchId = branchUS.insert();

        gs.info('Created branch update set: ' + branchUS.name + ' [' + branchId + ']');
        return branchId;
    },

    detectConflicts: function(branchIds) {
        var conflicts = [];
        var updateMap = {};

        // Build map of all updates across branches
        for (var i = 0; i < branchIds.length; i++) {
            var updates = new GlideRecord('sys_update_xml');
            updates.addQuery('update_set', branchIds[i]);
            updates.query();

            while (updates.next()) {
                var key = updates.type + ':' + updates.target_name;
                if (!updateMap[key]) {
                    updateMap[key] = [];
                }
                updateMap[key].push({
                    updateSet: updates.update_set.getDisplayValue(),
                    sys_id: updates.sys_id.toString(),
                    sys_updated_on: updates.sys_updated_on.toString()
                });
            }
        }

        // Identify conflicts (same object modified in multiple branches)
        for (var key in updateMap) {
            if (updateMap[key].length > 1) {
                conflicts.push({
                    target: key,
                    conflictingUpdates: updateMap[key]
                });
            }
        }

        return conflicts;
    },

    createMergeUpdateSet: function(branchIds, mergeName) {
        var conflicts = this.detectConflicts(branchIds);
        if (conflicts.length > 0) {
            gs.warn('Conflicts detected during merge creation. Manual resolution required.');
            this._logConflicts(conflicts);
        }

        var mergeUS = new GlideRecord('sys_update_set');
        mergeUS.initialize();
        mergeUS.name = this.MERGE_PREFIX + mergeName + '_' + gs.nowDateTime().substring(0, 10);
        mergeUS.description = 'Merged branches: ' + branchIds.join(', ');
        mergeUS.state = 'build';
        mergeUS.u_merge_source_branches = branchIds.join(',');
        var mergeId = mergeUS.insert();

        // Copy updates from branches to merge set (latest wins for conflicts)
        this._copyUpdatesToMerge(branchIds, mergeId, conflicts);

        gs.info('Created merge update set: ' + mergeUS.name + ' [' + mergeId + ']');
        return { mergeId: mergeId, conflicts: conflicts };
    },

    _copyUpdatesToMerge: function(branchIds, mergeId, conflicts) {
        var conflictTargets = conflicts.map(function(c) { return c.target; });
        var latestUpdates = {};

        // First pass: identify latest update for each conflicting target
        for (var i = 0; i < branchIds.length; i++) {
            var updates = new GlideRecord('sys_update_xml');
            updates.addQuery('update_set', branchIds[i]);
            updates.orderBy('sys_updated_on');
            updates.query();

            while (updates.next()) {
                var target = updates.type + ':' + updates.target_name;
                if (conflictTargets.indexOf(target) > -1) {
                    if (!latestUpdates[target] || 
                        updates.sys_updated_on > latestUpdates[target].sys_updated_on) {
                        latestUpdates[target] = {
                            sys_id: updates.sys_id.toString(),
                            sys_updated_on: updates.sys_updated_on.toString()
                        };
                    }
                }
            }
        }

        // Second pass: copy non-conflicting updates and latest conflicting updates
        for (var i = 0; i < branchIds.length; i++) {
            var updates = new GlideRecord('sys_update_xml');
            updates.addQuery('update_set', branchIds[i]);
            updates.query();

            while (updates.next()) {
                var target = updates.type + ':' + updates.target_name;
                var shouldCopy = true;

                if (conflictTargets.indexOf(target) > -1) {
                    shouldCopy = (latestUpdates[target].sys_id === updates.sys_id.toString());
                }

                if (shouldCopy) {
                    var newUpdate = new GlideRecord('sys_update_xml');
                    newUpdate.initialize();
                    this._copyUpdateRecord(updates, newUpdate);
                    newUpdate.update_set = mergeId;
                    newUpdate.insert();
                }
            }
        }
    },

    _copyUpdateRecord: function(source, target) {
        var fields = ['action', 'name', 'payload', 'target_name', 'type', 'category'];
        for (var i = 0; i < fields.length; i++) {
            target.setValue(fields[i], source.getValue(fields[i]));
        }
    },

    _logConflicts: function(conflicts) {
        for (var i = 0; i < conflicts.length; i++) {
            gs.warn('CONFLICT: ' + conflicts[i].target + ' modified in ' + 
                   conflicts[i].conflictingUpdates.length + ' branches');
        }
    },

    type: 'UpdateSetBranchManager'
};

This Script Include implements a complete update set branching system with methods for creating branches from parent update sets, detecting conflicts by analyzing sys_update_xml records across multiple branches, and creating merged update sets that automatically resolve conflicts using a 'latest wins' strategy. The key innovation is the systematic approach to conflict detection and the automated copying of non-conflicting updates while flagging conflicts that require manual review.

Alternatives

Sequential Update Set Chains

Creates update sets that explicitly depend on previous ones in a linear chain rather than parallel branches. Simpler to manage but forces developers to work sequentially, reducing parallel development capability and potentially creating bottlenecks.

Application-Based Segregation

Separates development by ServiceNow application scope rather than feature branches, relying on application dependencies to manage integration. Works well for loosely coupled applications but breaks down when multiple teams need to modify shared applications or global resources.

Source Control Integration with External Tools

Uses external source control systems like Git with ServiceNow integration tools to manage branching outside the platform. Provides more sophisticated merge capabilities and familiar workflows for developers but requires additional infrastructure and expertise in both ServiceNow and source control systems.

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