ServiceNow Integration with Azure DevOps

Overview

ServiceNow is the IT Service Management (ITSM) platform that most enterprises use for incident management, change requests, and service catalogs. Azure DevOps is where development teams plan, build, and deploy software. When these systems do not talk to each other, you get manual handoffs -- developers create a work item in Azure DevOps, then manually create a matching change request in ServiceNow before deploying. Operations creates an incident in ServiceNow, then sends an email to the development team who manually creates a bug in Azure DevOps. Every manual handoff is a delay, an error opportunity, and a compliance gap.

I have built ServiceNow-to-Azure DevOps integrations for organizations ranging from 50 developers to 5,000. The patterns are consistent: automate change request creation from deployment pipelines, synchronize incidents to bugs bidirectionally, and use service hooks to trigger workflows across systems. The technical integration is straightforward -- both platforms have mature REST APIs. The challenge is mapping the data models and workflows between the two systems. This article covers both the technical implementation and the workflow design.

Prerequisites

• An Azure DevOps organization with Azure Pipelines
• A ServiceNow instance (developer instance or production) with admin or integration user access
• ServiceNow REST API enabled (Table API and Import Set API)
• A Personal Access Token for Azure DevOps with appropriate scopes
• Node.js 18+ for the integration scripts
• Basic familiarity with ServiceNow tables (incident, change_request, cmdb_ci)
• Understanding of Azure DevOps service hooks

Change Request Automation from Pipelines

The most common integration requirement: every production deployment must have an approved change request in ServiceNow before it proceeds. Without automation, this means a developer fills out a change request form, waits for CAB approval, and then manually triggers the deployment. With automation, the pipeline creates the change request, waits for approval, deploys, and closes the request.

Creating Change Requests via REST API

// servicenow/create-change-request.js
var https = require("https");

var SN_INSTANCE = process.env.SERVICENOW_INSTANCE; // e.g., "dev12345.service-now.com"
var SN_USER = process.env.SERVICENOW_USER;
var SN_PASSWORD = process.env.SERVICENOW_PASSWORD;
var AUTH = "Basic " + Buffer.from(SN_USER + ":" + SN_PASSWORD).toString("base64");

function snRequest(method, table, data, sysId) {
  return new Promise(function (resolve, reject) {
    var path = "/api/now/table/" + table;
    if (sysId) { path += "/" + sysId; }

    var options = {
      hostname: SN_INSTANCE,
      path: path,
      method: method,
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
        Authorization: AUTH,
      },
    };

    var req = https.request(options, function (res) {
      var body = "";
      res.on("data", function (chunk) { body += chunk; });
      res.on("end", function () {
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve(body ? JSON.parse(body) : null);
        } else {
          reject(new Error("ServiceNow " + method + " " + table + ": " + res.statusCode + " " + body));
        }
      });
    });

    req.on("error", reject);
    if (data) { req.write(JSON.stringify(data)); }
    req.end();
  });
}

function createChangeRequest(details) {
  var changeData = {
    type: details.type || "normal",
    category: details.category || "Software",
    short_description: details.shortDescription,
    description: details.description,
    assignment_group: details.assignmentGroup,
    cmdb_ci: details.configurationItem,
    priority: details.priority || "3",
    risk: details.risk || "moderate",
    impact: details.impact || "2",
    start_date: details.startDate || new Date().toISOString(),
    end_date: details.endDate || new Date(Date.now() + 3600000).toISOString(),
    u_azure_devops_build: details.buildNumber || "",
    u_azure_devops_release: details.releaseName || "",
  };

  return snRequest("POST", "change_request", changeData).then(function (response) {
    var cr = response.result;
    console.log("Change request created: " + cr.number);
    console.log("  Sys ID: " + cr.sys_id);
    console.log("  State: " + cr.state);
    return cr;
  });
}

function getChangeRequestState(sysId) {
  return snRequest("GET", "change_request", null, sysId).then(function (response) {
    return response.result;
  });
}

function waitForApproval(sysId, timeoutMinutes) {
  var timeout = (timeoutMinutes || 60) * 60 * 1000;
  var interval = 30000; // Check every 30 seconds
  var startTime = Date.now();

  return new Promise(function (resolve, reject) {
    function check() {
      getChangeRequestState(sysId).then(function (cr) {
        var state = cr.state;
        var approval = cr.approval;

        console.log("  CR " + cr.number + " - State: " + state + ", Approval: " + approval);

        // State values: -5=New, -4=Assess, -3=Authorize, -2=Scheduled, -1=Implement, 0=Review, 3=Closed
        // Approval values: not requested, requested, approved, rejected
        if (approval === "approved" || state === "-1") {
          console.log("Change request approved. Proceeding with deployment.");
          resolve(cr);
        } else if (approval === "rejected") {
          reject(new Error("Change request " + cr.number + " was rejected"));
        } else if (Date.now() - startTime > timeout) {
          reject(new Error("Timeout waiting for approval on " + cr.number));
        } else {
          setTimeout(check, interval);
        }
      }).catch(reject);
    }

    check();
  });
}

function closeChangeRequest(sysId, success) {
  var updateData = {
    state: "3", // Closed
    close_code: success ? "successful" : "unsuccessful",
    close_notes: success
      ? "Deployment completed successfully via Azure DevOps pipeline"
      : "Deployment failed. See Azure DevOps build logs for details.",
  };

  return snRequest("PATCH", "change_request", updateData, sysId).then(function (response) {
    console.log("Change request closed: " + response.result.number);
    return response.result;
  });
}

// Pipeline integration
var action = process.argv[2];
var BUILD_NUMBER = process.env.BUILD_BUILDNUMBER || "local-build";
var RELEASE_NAME = process.env.RELEASE_RELEASENAME || "local-release";

if (action === "create") {
  createChangeRequest({
    shortDescription: "Production deployment: " + BUILD_NUMBER,
    description: "Automated change request for Azure DevOps deployment.\n\n" +
      "Build: " + BUILD_NUMBER + "\n" +
      "Release: " + RELEASE_NAME + "\n" +
      "Pipeline: " + (process.env.BUILD_DEFINITIONNAME || "unknown") + "\n" +
      "Requested by: " + (process.env.BUILD_REQUESTEDFOR || "automation"),
    assignmentGroup: process.env.SN_ASSIGNMENT_GROUP || "Software Engineering",
    configurationItem: process.env.SN_CONFIG_ITEM || "",
    type: "standard",
    priority: "3",
    risk: "moderate",
    buildNumber: BUILD_NUMBER,
    releaseName: RELEASE_NAME,
  }).then(function (cr) {
    // Output for pipeline variable consumption
    console.log("##vso[task.setvariable variable=CR_SYS_ID]" + cr.sys_id);
    console.log("##vso[task.setvariable variable=CR_NUMBER]" + cr.number);
  }).catch(function (err) {
    console.error("Failed to create change request: " + err.message);
    process.exit(1);
  });
} else if (action === "wait") {
  var sysId = process.env.CR_SYS_ID || process.argv[3];
  if (!sysId) {
    console.error("CR_SYS_ID required");
    process.exit(1);
  }
  waitForApproval(sysId, 120).catch(function (err) {
    console.error(err.message);
    process.exit(1);
  });
} else if (action === "close") {
  var closeSysId = process.env.CR_SYS_ID || process.argv[3];
  var success = process.argv[4] !== "failed";
  closeChangeRequest(closeSysId, success).catch(function (err) {
    console.error("Failed to close CR: " + err.message);
    process.exit(1);
  });
} else {
  console.log("Usage:");
  console.log("  node create-change-request.js create");
  console.log("  node create-change-request.js wait <sysId>");
  console.log("  node create-change-request.js close <sysId> [success|failed]");
}

Pipeline Integration

stages:
  - stage: ChangeManagement
    displayName: Create Change Request
    jobs:
      - job: CreateCR
        steps:
          - script: node servicenow/create-change-request.js create
            displayName: Create ServiceNow change request
            env:
              SERVICENOW_INSTANCE: $(SN_INSTANCE)
              SERVICENOW_USER: $(SN_USER)
              SERVICENOW_PASSWORD: $(SN_PASSWORD)
              SN_ASSIGNMENT_GROUP: $(SN_ASSIGNMENT_GROUP)
              SN_CONFIG_ITEM: $(SN_CONFIG_ITEM)

          - script: node servicenow/create-change-request.js wait $(CR_SYS_ID)
            displayName: Wait for change request approval
            timeoutInMinutes: 120
            env:
              SERVICENOW_INSTANCE: $(SN_INSTANCE)
              SERVICENOW_USER: $(SN_USER)
              SERVICENOW_PASSWORD: $(SN_PASSWORD)

  - stage: Deploy
    dependsOn: ChangeManagement
    jobs:
      - deployment: Production
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - script: echo "Deploying to production..."

            on:
              success:
                steps:
                  - script: node servicenow/create-change-request.js close $(CR_SYS_ID) success
                    env:
                      SERVICENOW_INSTANCE: $(SN_INSTANCE)
                      SERVICENOW_USER: $(SN_USER)
                      SERVICENOW_PASSWORD: $(SN_PASSWORD)

              failure:
                steps:
                  - script: node servicenow/create-change-request.js close $(CR_SYS_ID) failed
                    env:
                      SERVICENOW_INSTANCE: $(SN_INSTANCE)
                      SERVICENOW_USER: $(SN_USER)
                      SERVICENOW_PASSWORD: $(SN_PASSWORD)

Incident-to-Bug Synchronization

When an incident is created in ServiceNow, automatically create a corresponding bug in Azure DevOps. When the bug is resolved, update the incident.

ServiceNow Business Rule for Outbound Integration

In ServiceNow, create a Business Rule on the incident table that fires on insert:

// ServiceNow Business Rule: "Sync Incident to Azure DevOps"
// Table: incident
// When: after insert
// Condition: current.category == 'Software'

(function executeRule(current, previous) {
  var request = new sn_ws.RESTMessageV2();
  request.setEndpoint("https://dev.azure.com/" + gs.getProperty("azure.devops.org") +
    "/" + gs.getProperty("azure.devops.project") + "/_apis/wit/workitems/$Bug?api-version=7.1");
  request.setHttpMethod("POST");
  request.setRequestHeader("Content-Type", "application/json-patch+json");
  request.setRequestHeader("Authorization", "Basic " +
    GlideStringUtil.base64Encode(":" + gs.getProperty("azure.devops.pat")));

  var patchDoc = [
    { op: "add", path: "/fields/System.Title", value: "[INC] " + current.short_description },
    { op: "add", path: "/fields/System.Description", value: current.description.toString() },
    { op: "add", path: "/fields/Microsoft.VSTS.Common.Priority", value: mapPriority(current.priority) },
    { op: "add", path: "/fields/Microsoft.VSTS.Common.Severity", value: mapSeverity(current.impact) },
    { op: "add", path: "/fields/System.Tags", value: "servicenow;incident;" + current.number },
    { op: "add", path: "/fields/Custom.ServiceNowIncident", value: current.number.toString() },
  ];

  request.setRequestBody(JSON.stringify(patchDoc));

  var response = request.execute();
  if (response.getStatusCode() == 200 || response.getStatusCode() == 201) {
    var result = JSON.parse(response.getBody());
    current.u_azure_devops_id = result.id;
    current.work_notes = "Azure DevOps bug created: #" + result.id;
    current.update();
  } else {
    gs.error("Azure DevOps sync failed: " + response.getStatusCode());
  }

  function mapPriority(snPriority) {
    var map = { "1": 1, "2": 1, "3": 2, "4": 3, "5": 4 };
    return map[snPriority.toString()] || 2;
  }

  function mapSeverity(snImpact) {
    var map = { "1": "1 - Critical", "2": "2 - High", "3": "3 - Medium" };
    return map[snImpact.toString()] || "3 - Medium";
  }
})(current, previous);

Azure DevOps Service Hook for Inbound Updates

Configure a service hook in Azure DevOps to notify ServiceNow when a bug is resolved:

1. Navigate to Project Settings > Service Hooks
2. Click "Create subscription"
3. Select "Web Hooks" as the service
4. Select "Work item updated" as the trigger
5. Filter: Work item type = Bug, State changed to = Resolved
6. Set the URL to your ServiceNow inbound endpoint

Node.js Middleware for Bidirectional Sync

// servicenow/sync-middleware.js
var http = require("http");
var https = require("https");

var PORT = process.env.SYNC_PORT || 8090;
var SN_INSTANCE = process.env.SERVICENOW_INSTANCE;
var SN_USER = process.env.SERVICENOW_USER;
var SN_PASSWORD = process.env.SERVICENOW_PASSWORD;
var SN_AUTH = "Basic " + Buffer.from(SN_USER + ":" + SN_PASSWORD).toString("base64");

function updateServiceNowIncident(incidentNumber, updateData) {
  return new Promise(function (resolve, reject) {
    // First, find the incident sys_id by number
    var queryPath = "/api/now/table/incident?sysparm_query=number=" +
      encodeURIComponent(incidentNumber) + "&sysparm_limit=1";

    var options = {
      hostname: SN_INSTANCE,
      path: queryPath,
      method: "GET",
      headers: {
        Accept: "application/json",
        Authorization: SN_AUTH,
      },
    };

    var req = https.request(options, function (res) {
      var data = "";
      res.on("data", function (chunk) { data += chunk; });
      res.on("end", function () {
        var result = JSON.parse(data);
        if (!result.result || result.result.length === 0) {
          reject(new Error("Incident not found: " + incidentNumber));
          return;
        }

        var sysId = result.result[0].sys_id;

        // Update the incident
        var updateOptions = {
          hostname: SN_INSTANCE,
          path: "/api/now/table/incident/" + sysId,
          method: "PATCH",
          headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
            Authorization: SN_AUTH,
          },
        };

        var updateReq = https.request(updateOptions, function (updateRes) {
          var updateBody = "";
          updateRes.on("data", function (chunk) { updateBody += chunk; });
          updateRes.on("end", function () {
            if (updateRes.statusCode >= 200 && updateRes.statusCode < 300) {
              resolve(JSON.parse(updateBody).result);
            } else {
              reject(new Error("Update failed: " + updateRes.statusCode));
            }
          });
        });

        updateReq.write(JSON.stringify(updateData));
        updateReq.end();
      });
    });

    req.on("error", reject);
    req.end();
  });
}

// HTTP server to receive Azure DevOps webhooks
var server = http.createServer(function (req, res) {
  if (req.method !== "POST" || req.url !== "/webhook/azure-devops") {
    res.writeHead(404);
    res.end("Not found");
    return;
  }

  var body = "";
  req.on("data", function (chunk) { body += chunk; });
  req.on("end", function () {
    try {
      var payload = JSON.parse(body);
      var eventType = payload.eventType;

      console.log("Received webhook: " + eventType);

      if (eventType === "workitem.updated") {
        var workItem = payload.resource;
        var fields = workItem.fields || {};
        var tags = fields["System.Tags"] || "";

        // Find ServiceNow incident number from tags
        var incidentMatch = tags.match(/INC\d+/);
        if (!incidentMatch) {
          console.log("No incident tag found, skipping");
          res.writeHead(200);
          res.end("OK");
          return;
        }

        var incidentNumber = incidentMatch[0];
        var state = fields["System.State"];

        console.log("Bug state changed to: " + state + " for " + incidentNumber);

        if (state === "Resolved" || state === "Closed") {
          updateServiceNowIncident(incidentNumber, {
            state: "6", // Resolved
            resolution_code: "Solved (Permanently)",
            resolution_notes: "Fixed in Azure DevOps. Bug #" + workItem.id +
              " resolved by " + (fields["System.ChangedBy"] || "automation"),
          }).then(function (incident) {
            console.log("ServiceNow incident updated: " + incident.number);
          }).catch(function (err) {
            console.error("Failed to update incident: " + err.message);
          });
        }
      }

      res.writeHead(200);
      res.end("OK");
    } catch (err) {
      console.error("Webhook processing error: " + err.message);
      res.writeHead(500);
      res.end("Error");
    }
  });
});

server.listen(PORT, function () {
  console.log("Sync middleware listening on port " + PORT);
});

Service Hook Configuration

Azure DevOps service hooks send real-time notifications to external systems when events occur.

Available Events for ServiceNow

• Work item created: Create a corresponding record in ServiceNow
• Work item updated: Sync state changes back to ServiceNow
• Build completed: Update change request with build results
• Release deployment completed: Close the change request
• Pull request merged: Trigger change request workflow

Configuring a Service Hook

// servicenow/setup-service-hooks.js
var https = require("https");
var url = require("url");

var ORG = "my-organization";
var PROJECT = "my-project";
var PAT = process.env.AZURE_DEVOPS_PAT;
var API_VERSION = "7.1";
var AUTH = "Basic " + Buffer.from(":" + PAT).toString("base64");

function createServiceHook(eventType, webhookUrl, filters) {
  var subscription = {
    publisherId: "tfs",
    eventType: eventType,
    consumerId: "webHooks",
    consumerActionId: "httpRequest",
    publisherInputs: filters,
    consumerInputs: {
      url: webhookUrl,
      httpHeaders: "X-Source:azure-devops",
      resourceDetailsToSend: "all",
      messagesToSend: "all",
    },
  };

  return new Promise(function (resolve, reject) {
    var apiUrl = "https://dev.azure.com/" + ORG + "/_apis/hooks/subscriptions?api-version=" + API_VERSION;
    var parsed = url.parse(apiUrl);

    var options = {
      hostname: parsed.hostname,
      path: parsed.path,
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: AUTH,
      },
    };

    var req = https.request(options, function (res) {
      var data = "";
      res.on("data", function (chunk) { data += chunk; });
      res.on("end", function () {
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve(JSON.parse(data));
        } else {
          reject(new Error("Failed to create hook: " + res.statusCode + " " + data));
        }
      });
    });

    req.on("error", reject);
    req.write(JSON.stringify(subscription));
    req.end();
  });
}

// Create hooks for ServiceNow integration
var WEBHOOK_BASE = process.env.WEBHOOK_BASE_URL || "https://middleware.example.com";

Promise.all([
  createServiceHook("workitem.updated", WEBHOOK_BASE + "/webhook/azure-devops", {
    projectId: PROJECT,
    areaPath: "",
    workItemType: "Bug",
  }),
  createServiceHook("build.complete", WEBHOOK_BASE + "/webhook/build-complete", {
    projectId: PROJECT,
    definitionName: "",
    buildStatus: "",
  }),
]).then(function (hooks) {
  console.log("Service hooks created:");
  hooks.forEach(function (hook) {
    console.log("  " + hook.eventType + " -> " + hook.consumerInputs.url);
  });
}).catch(function (err) {
  console.error("Error: " + err.message);
});

Data Mapping Between Systems

Work Item Field Mapping

Azure DevOps Field	ServiceNow Field	Notes
System.Title	short_description	Prefix with [INC] for incidents
System.Description	description	HTML to plain text conversion needed
Microsoft.VSTS.Common.Priority	priority	ADO 1-4 maps to SN 1-5
Microsoft.VSTS.Common.Severity	impact	ADO 1-4 maps to SN 1-3
System.State	state	Custom mapping per workflow
System.AssignedTo	assigned_to	Requires user mapping table
System.AreaPath	assignment_group	Maps to SN groups
System.Tags	u_tags	Comma-separated to multi-value

State Mapping

var STATE_MAP_ADO_TO_SN = {
  "New": "1",         // New
  "Active": "2",      // In Progress
  "Resolved": "6",    // Resolved
  "Closed": "7",      // Closed
};

var STATE_MAP_SN_TO_ADO = {
  "1": "New",
  "2": "Active",
  "3": "Active",      // On Hold -> Active (no ADO equivalent)
  "6": "Resolved",
  "7": "Closed",
};

Complete Working Example

A comprehensive integration service that handles bidirectional synchronization between ServiceNow and Azure DevOps, including change request lifecycle management and incident sync:

// servicenow/integration-service.js
var http = require("http");
var https = require("https");
var url = require("url");

var config = {
  sn: {
    instance: process.env.SERVICENOW_INSTANCE,
    user: process.env.SERVICENOW_USER,
    password: process.env.SERVICENOW_PASSWORD,
  },
  ado: {
    org: process.env.AZURE_ORG,
    project: process.env.AZURE_PROJECT,
    pat: process.env.AZURE_DEVOPS_PAT,
  },
  port: parseInt(process.env.PORT) || 8090,
};

var snAuth = "Basic " + Buffer.from(config.sn.user + ":" + config.sn.password).toString("base64");
var adoAuth = "Basic " + Buffer.from(":" + config.ado.pat).toString("base64");

function snRequest(method, table, data, sysId, query) {
  return new Promise(function (resolve, reject) {
    var path = "/api/now/table/" + table;
    if (sysId) { path += "/" + sysId; }
    if (query) { path += "?sysparm_query=" + encodeURIComponent(query); }

    var options = {
      hostname: config.sn.instance,
      path: path,
      method: method,
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
        Authorization: snAuth,
      },
    };

    var req = https.request(options, function (res) {
      var body = "";
      res.on("data", function (chunk) { body += chunk; });
      res.on("end", function () {
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve(body ? JSON.parse(body) : null);
        } else {
          reject(new Error("SN " + method + " " + table + ": " + res.statusCode));
        }
      });
    });

    req.on("error", reject);
    if (data) { req.write(JSON.stringify(data)); }
    req.end();
  });
}

function adoRequest(method, path, data) {
  return new Promise(function (resolve, reject) {
    var apiUrl = "https://dev.azure.com/" + config.ado.org + "/" + config.ado.project + path;
    var parsed = url.parse(apiUrl);

    var options = {
      hostname: parsed.hostname,
      path: parsed.path,
      method: method,
      headers: {
        "Content-Type": "application/json-patch+json",
        Authorization: adoAuth,
      },
    };

    var req = https.request(options, function (res) {
      var body = "";
      res.on("data", function (chunk) { body += chunk; });
      res.on("end", function () {
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve(body ? JSON.parse(body) : null);
        } else {
          reject(new Error("ADO " + method + " " + path + ": " + res.statusCode));
        }
      });
    });

    req.on("error", reject);
    if (data) { req.write(JSON.stringify(data)); }
    req.end();
  });
}

function handleIncidentWebhook(payload) {
  var incident = payload;
  console.log("Processing incident: " + incident.number);

  var patchDoc = [
    { op: "add", path: "/fields/System.Title", value: "[" + incident.number + "] " + incident.short_description },
    { op: "add", path: "/fields/System.Description", value: incident.description || "No description" },
    { op: "add", path: "/fields/Microsoft.VSTS.Common.Priority", value: mapPriority(incident.priority) },
    { op: "add", path: "/fields/System.Tags", value: "servicenow;incident;" + incident.number },
  ];

  return adoRequest("POST", "/_apis/wit/workitems/$Bug?api-version=7.1", patchDoc)
    .then(function (bug) {
      console.log("Created ADO bug #" + bug.id + " from " + incident.number);
      return bug;
    });
}

function handleBugUpdate(payload) {
  var workItem = payload.resource;
  var tags = (workItem.fields["System.Tags"] || "").toString();
  var incidentMatch = tags.match(/INC\d+/);

  if (!incidentMatch) { return Promise.resolve(); }

  var incidentNumber = incidentMatch[0];
  var state = workItem.fields["System.State"];
  console.log("Bug updated: state=" + state + ", incident=" + incidentNumber);

  if (state === "Resolved" || state === "Closed") {
    return snRequest("GET", "incident", null, null, "number=" + incidentNumber)
      .then(function (response) {
        if (!response.result || response.result.length === 0) { return; }
        var sysId = response.result[0].sys_id;
        return snRequest("PATCH", "incident", {
          state: state === "Resolved" ? "6" : "7",
          resolution_notes: "Resolved via Azure DevOps Bug #" + workItem.id,
          work_notes: "Azure DevOps bug #" + workItem.id + " " + state.toLowerCase(),
        }, sysId);
      })
      .then(function () {
        console.log("Incident " + incidentNumber + " updated to " + state);
      });
  }

  return Promise.resolve();
}

function mapPriority(snPriority) {
  var map = { "1": 1, "2": 1, "3": 2, "4": 3, "5": 4 };
  return map[String(snPriority)] || 2;
}

// Webhook server
var server = http.createServer(function (req, res) {
  var body = "";
  req.on("data", function (chunk) { body += chunk; });
  req.on("end", function () {
    var payload;
    try { payload = JSON.parse(body); } catch (e) {
      res.writeHead(400);
      res.end("Invalid JSON");
      return;
    }

    var handler;
    if (req.url === "/webhook/incident") {
      handler = handleIncidentWebhook(payload);
    } else if (req.url === "/webhook/azure-devops") {
      handler = handleBugUpdate(payload);
    } else {
      res.writeHead(404);
      res.end("Unknown endpoint");
      return;
    }

    handler
      .then(function () { res.writeHead(200); res.end("OK"); })
      .catch(function (err) {
        console.error("Handler error: " + err.message);
        res.writeHead(500);
        res.end("Error");
      });
  });
});

server.listen(config.port, function () {
  console.log("ServiceNow integration service running on port " + config.port);
  console.log("Endpoints:");
  console.log("  POST /webhook/incident        (ServiceNow -> Azure DevOps)");
  console.log("  POST /webhook/azure-devops     (Azure DevOps -> ServiceNow)");
});

Common Issues and Troubleshooting

ServiceNow REST API Returns 401 Unauthorized

The integration user needs the rest_api_explorer and web_service_admin roles in ServiceNow. Without these roles, the Table API returns 401 even with correct credentials. Also verify that the instance allows basic authentication -- some organizations enforce OAuth or mutual TLS for API access. Check System Properties > glide.basicauth.required.only_from to see if IP restrictions are in place.

Change Request Stuck in "New" State

ServiceNow change request workflows vary by organization. Standard change requests may require additional fields (risk assessment, test plan, backout plan) before advancing to the approval state. Check the change request form for required fields and populate them in your automation. Work with your ServiceNow admin to identify the minimum required fields for automated change requests.

Azure DevOps Webhook Delivery Failures

Service hooks retry failed deliveries 3 times with exponential backoff. If your middleware is behind a firewall, Azure DevOps cannot reach it. Options: (a) expose the middleware via a public URL with IP filtering, (b) use Azure Functions as an intermediary, (c) use Azure Service Bus with a queue consumer inside the firewall. Check the service hook subscription's delivery history in Project Settings > Service Hooks for error details.

Duplicate Work Items Created on Rapid Updates

When ServiceNow fires multiple business rules in quick succession for the same incident, the integration can create duplicate bugs in Azure DevOps. Implement deduplication: before creating a bug, query Azure DevOps for existing bugs with the incident number in the tags. If a match exists, update instead of creating.

Field Mapping Mismatches

ServiceNow custom fields (prefixed with u_) vary between organizations. The field mappings in this article use common patterns but may not match your instance. Use the ServiceNow Table API Explorer (/api/now/table/incident?sysparm_limit=1) to discover available fields and their data types. Map custom fields in a configuration file rather than hard-coding them.

Best Practices

• Use a dedicated integration user in both systems. Do not use a personal account. Create a service account with the minimum necessary permissions in both Azure DevOps and ServiceNow. This prevents disruption when employees leave and provides clear audit trails.

• Implement idempotent operations. Every sync operation should be safe to retry. Before creating a work item, check if one already exists for the source record. Before updating a record, verify the current state has not already been updated. Idempotency prevents duplicate records from retry logic and webhook redelivery.

• Log all sync operations. Every record created, updated, or failed should be logged with timestamps, source record IDs, and target record IDs. When something goes wrong, the log is the only way to diagnose the issue without manual investigation in both systems.

• Map only the fields you need. Start with title, description, priority, and state. Add additional field mappings as needed. Every mapped field is a potential failure point when field values change, custom fields are renamed, or validation rules are updated.

• Use standard change requests for automated deployments. Standard changes have pre-approved workflows that do not require CAB review. Work with your change management team to define standard change templates for common deployment types. This eliminates the approval wait time for routine deployments.

• Handle sync failures gracefully. When a sync operation fails, log the error and continue. Do not fail the deployment pipeline because ServiceNow is temporarily unreachable. Queue failed operations for retry and alert the integration team.

• Test with a ServiceNow developer instance. ServiceNow provides free developer instances at developer.servicenow.com. Use these for integration development and testing before connecting to production.

• Version your field mappings. Store field mappings in a configuration file in source control. When ServiceNow or Azure DevOps workflows change, update the mapping file and deploy the integration service. This provides an audit trail of mapping changes.

References

• ServiceNow Table API
• Azure DevOps Service Hooks
• Azure DevOps Work Items REST API
• ServiceNow Business Rules
• ServiceNow Developer Instances
• Azure DevOps Webhooks