How to Set Up a ServiceNow Azure DevOps Integration: The 2026 Step-by-Step Guide

Teams within your organization usually use different platforms (let’s say Azure DevOps and ServiceNow) to handle business-critical or user-centered information. You might also want to share some data with other companies you do business with. To this end, you’ll need an Azure DevOps ServiceNow integration to connect internal and external teams.

With the integration in place, you’ll be able to boost your productivity and save yourself time if you understand how to set up an Azure DevOps ServiceNow integration with the least fuss possible.

So in this step-by-step guide, you’ll learn how to integrate Azure DevOps with ServiceNow.

Key Takeaways

Integrating Azure DevOps and ServiceNow lets you:

• Automatically sync work items between platforms such that incidents in ServiceNow become trackable bugs or tasks in Azure DevOps without manual data entry
• Keep teams aligned with real-time updates to comments, attachments, statuses, and priorities across both systems
• Map ServiceNow urgency levels to Azure DevOps priorities (Critical → High, Moderate → Medium) so both teams see consistent prioritization
• Escalate incidents from IT operations to development teams with complete context, including SLA timelines, work notes, and history intact
• Enable cross-company collaboration where partners, suppliers, or MSPs can work in their preferred tool while staying synchronized
• Reduce resolution time by eliminating context switching where developers work in Azure DevOps, operations in ServiceNow, and data flows automatically
• Connect Azure DevOps Cloud or Azure DevOps Server (on-premises) with ServiceNow instances

Common use cases: Incident escalation, change request management, MSP client coordination, multi-team collaboration

Why Integrate Azure DevOps and ServiceNow

Teams using Azure DevOps and ServiceNow can benefit by collecting, organizing, and exchanging data between these platforms.

Use Case Example

A customer logs an incident in ServiceNow (e.g., “Application Performance Degradation”) with Summary, Description, Urgency, and Attachments, with correct transformations applied (e.g., ServiceNow’s “High” Urgency maps to Azure DevOps’s “Priority 1”, and so on). The support team needs to escalate this to development in Azure DevOps for resolution.

Without Integration: Manual copying of incident details from ServiceNow to Azure DevOps, which is time-consuming and error-prone.

With Integration:

• A work item is automatically created in Azure DevOps with all fields mapped correctly
• Any updates, such as a status change in ServiceNow to “In Progress”, sync to Azure DevOps as “Active.” Similarly, updates in Azure DevOps sync back to ServiceNow with proper field mappings
• Comments sync bidirectionally, but visibility rules ensure customer-facing comments in ServiceNow remain internal work notes in Azure DevOps
• If the incident is marked “Critical,” additional fields like Assignment Group and Resolution SLA synchronize in real time
• Once the work item is resolved in Azure DevOps, the resolution code and resolution notes are automatically assigned to the incident based on the selection the developer makes
• This triggers the status change in the ServiceNow instance. The resolution code and resolution notes for the incident are automatically filled. The incident is now “Resolved”
• Both teams work in their preferred tool while maintaining complete visibility

Key Benefits

• Real-Time Visibility: Track synchronization progress and keep all team members up-to-date through the Activity Dashboard
• Reduced Manual Work: Automation eliminates duplicate data entry, saving hours per week
• Better Collaboration: Development and IT teams stay aligned without constant context switching
• Faster Resolution: Improve incident resolution time by eliminating handoff delays

But before that, let’s see a few practical use cases. If you don’t find what you’re looking for here, you can always set up a call with our integration engineers to discuss further.

What Does an Azure DevOps ServiceNow Integration Do

An Azure DevOps ServiceNow integration creates a bidirectional data bridge between the two platforms, automatically synchronizing information without manual copying.

How It Works

When you integrate Azure DevOps and ServiceNow:

1. Automatic sync: ServiceNow incidents create corresponding Azure DevOps work items (or vice versa) based on triggers you define
2. Real-time updates: Comments added in ServiceNow appear in Azure DevOps within seconds. Attachments, status changes, and field updates flow automatically
3. Field mapping: ServiceNow “Urgency 1 – High” automatically becomes Azure DevOps “Priority 1” based on the transformation rules you configure
4. Context preservation: SLA timelines, work history, escalation notes, and other details transfer between systems without information loss
5. Workflow autonomy: IT operations continues using ServiceNow, development teams stay in Azure DevOps, but everyone sees synchronized data

What Data Is Typically Synced Between Azure DevOps and ServiceNow

Standard fields:

• Entities: ServiceNow incidents, change requests, RITMs, problems, and other entities available in tables → Azure DevOps bugs, tasks, user stories, features, epics, test cases
• Comments and notes: Work notes, internal comments, customer-facing comments
• Attachments: Files, images, documents (transferred or linked)
• Status and workflow: New → Active → Resolved → Closed (with custom mapping), any status transition based on your workflows
• People: Assignee, reporter, watchers (with user mapping between systems)
• Dates and times: Created date, due date, resolution date, SLA breach times
• Priorities and urgency: ServiceNow urgency (1-5) → Azure DevOps priority (1-4). Map according to your needs

Advanced synchronization:

• Custom fields: Sync any custom field available via REST API between Azure DevOps and ServiceNow
• SLA information: Breach times, SLA status
• Related work items: Parent-child relationships, linked incidents, blocked by/blocks
• Time tracking: Work logs, time spent, original estimates
• Any data available via REST APIs

Real-World Use Cases for Azure DevOps ServiceNow Integration

A ServiceNow Azure DevOps integration will ensure all the daily tasks are synced between different teams using these systems, increasing transparency and trust. It will also simplify reporting by keeping both teams aligned.

Let’s see a few practical use cases of integrating Azure DevOps and ServiceNow.

Customer Support to Development Incident Escalation with SLA Tracking

Scenario: A critical incident (Urgency=1) occurs affecting your application.

Workflow:

1. Incident logged in ServiceNow with urgency, assignment group, and SLA details. Incident investigated by support
2. Root cause identified: requires code fix
3. Automatically creates a corresponding Azure DevOps work item with:
   • Complete incident history
   • SLA timeline information
   • Priority mapping (Critical → Priority 1, etc.)
   • Work notes transformed to Azure DevOps comments
4. The development team fixes the issue in Azure DevOps
5. Resolution notes sync back to ServiceNow
6. Incident closed with proper resolution code
7. The IT operations team handles incidents in ServiceNow
8. The development team tracks progress simultaneously in Azure DevOps
9. Status updates, comments, and attachments sync bidirectionally in real-time
10. SLA breach alerts notify both teams automatically

Outcome: Collaboration without context switching, complete visibility, faster resolution.

MSP Multi-Tenant Operations

Challenge: Clients use Azure DevOps; MSP uses ServiceNow for centralized operations. Setting up an Azure DevOps ServiceNow integration for ITSM workflows will help solve this challenge.

Solution:

• MSP connects its single ServiceNow instance to 5+ client Azure DevOps instances
• Work items sync automatically when clients log requests
• Comments, attachments flow bidirectionally
• Integration visualization in a unified console shows all connections and how they connect
• Different sync rules per client (connection) based on workflow needs
• Clients work in their preferred tools without ServiceNow access

Security Features:

• Role-based access control (RBAC) ensures proper permissions
• Data encryption in transit (TLS 1.2/1.3) and at rest

“The moment the ticket enters the help desk in ServiceNow, Exalate routes it to my team working in Azure DevOps. My team then provides feedback, which is immediately reflected in ServiceNow.”

– Operations Manager, Enterprise MSP

Outcome: Transparency, simplified reporting, trust across organizations.

Change Request Management

Scenario: Your fintech platform requires upgrading, and you follow ITIL change management practices.

Workflow:

1. Change request created in ServiceNow with approval workflow
2. Once approved, it automatically syncs to Azure DevOps as an Epic or a User Story
3. Development team breaks down into tasks, tracks time
4. Azure DevOps triggers require ServiceNow change approval before deployment
5. Progress updates flow back to ServiceNow in real-time
6. Completion triggers change request closure in ServiceNow

Advanced Mapping:

• ServiceNow Change Request → Azure DevOps Epic
• ServiceNow Change Tasks → Azure DevOps User Stories/Tasks
• Time tracking aggregated from Azure DevOps tasks returned to the ServiceNow custom field

QA and Development Coordination

Scenario: QA team uses ServiceNow to track defects discovered during testing. Development team works in Azure DevOps.

Workflow:

1. QA logs defect in ServiceNow with reproduction steps, severity, environment details, attachments
2. Defect automatically syncs to Azure DevOps as a Bug work item
3. Developer picks up the bug, begins investigation
4. Status changes in Azure DevOps reflect immediately in ServiceNow
5. Developer adds comments with technical findings that are synced to ServiceNow
6. Fix completed, code reviewed, merged
7. Resolution details sync back to ServiceNow
8. QA verifies fix in ServiceNow, closes the defect

Outcome: QA and development stay synchronized without leaving their respective platforms.

What Are the Best Ways to Connect Azure DevOps and ServiceNow?

Before you jump right into the integration, it’s important to understand the ways in which you can integrate Azure DevOps and ServiceNow.

ServiceNow IntegrationHub (Native Method)

ServiceNow’s IntegrationHub provides native connectivity options for Azure DevOps in the form of different spokes.

While native, it has limitations:

• Limited bidirectional sync functionality
• Longer onboarding journey
• Additional package costs
• ServiceNow-centric control (limited Azure DevOps-side autonomy)
• Works for simple, unidirectional use cases
• Focused primarily on CI/CD pipeline integration rather than comprehensive work item sync

Best For: Basic, one-way data pushes when cost isn’t a constraint and you only need simple integration.

Azure DevOps ServiceNow Extension

Microsoft provides a ServiceNow Change Management extension for Azure DevOps Pipelines.

Capabilities:

• Create change requests from Azure Pipelines
• Gate deployments until change approval
• Update change request status after deployment

Limitations:

• Pipeline-focused, not general work item sync
• Limited field mapping options
• No comprehensive bidirectional sync for incidents, problems, etc.

Best For: Teams primarily needing pipeline gating with ServiceNow change management.

Custom Code Development

I have often observed that teams prefer to build their integration from scratch. Honestly, the REST APIs for both platforms do make the task possible, but this option isn’t always cost-effective. It also leads to significant maintenance costs and difficulty scaling your integration requirements.

Building with ServiceNow and Azure DevOps APIs gives complete control but requires ongoing investment:

• Full customization capability
• No licensing fees (initially)
• High development costs (50-200+ hours)
• Significant ongoing maintenance
• Scaling difficulties as requirements grow
• No built-in error handling, security, or monitoring. Has to be handled by the dev team

Best For: Organizations with dedicated integration teams and stable requirements.

Read our detailed guide: Build vs. Buy Integration Solutions, or try our build vs. buy calculator.

Third-Party Integration Solutions

From my experience, I have observed that companies try to build their own solution initially, but then eventually switch to a third-party integration solution.

Also, when it comes to third-party solutions, you will see a lot of no-code, template-based tools to integrate Azure DevOps with ServiceNow. They may work for simple use cases, but cannot be used to implement advanced integration scenarios, for which script-based solutions are a good alternative.

There are a lot of third-party Azure DevOps ServiceNow integration solutions available in the market with flexible license plans, various deployment models, extensive documentation, and other custom-made features. With such solutions, you can get your integration project up and running in no time.

However, it’s a good practice to consider some factors while choosing the solution.

What to Consider When Choosing an Integration Solution

Sharing data between Azure DevOps and ServiceNow sounds straightforward, but the approach you choose determines whether your integration becomes a productivity multiplier or a maintenance headache. The right solution keeps teams aligned, preserves data context during escalations, and scales as your organization grows.

When evaluating integration options, focus on these critical capabilities.

Security

Your integration handles sensitive operational data like incident details, customer information, SLA commitments, and internal work notes, so it’s important to ensure the solution you choose is secure.

What to look for:

• Compliance certifications: ISO 27001, GDPR compatibility
• Data encryption: In transit (TLS 1.2/1.3) and at rest
• Access control: Role-based permissions that separate integration management from system access
• Authentication options: OAuth 2.0, API keys, Personal Access Tokens (no shared credentials)
• Audit trails: Complete logs of configuration changes and data transfers for compliance
• Independent sync control: Full operational control over your sync side, where you decide exactly what data leaves your system

Why it matters: A security breach through your integration could expose customer data, violate compliance requirements, and damage trust. Choosing a certified platform reduces risk and satisfies audit requirements.

Look for platforms with public Trust Centers where you can review security documentation, penetration test results, and compliance certificates.

Real-Time Synchronization

Delays between systems create confusion. If a ServiceNow incident shows “In Progress” while Azure DevOps shows “Resolved,” which is correct? Real-time sync eliminates this ambiguity.

Why it matters: IT operations and development teams make decisions based on current data. Stale information leads to duplicate work, missed SLAs, and frustrated customers. Real-time sync means both teams always see the same truth.

Flexibility

Many companies look for integration solutions that can support complex or advanced use cases. Using predefined integration templates doesn’t always work. Look for solutions that offer support for complex integration use scenarios with minimum hassle. Adding conditional logic, advanced data mappings should be included as a default.

The solution must also support historical data exchange or legacy system integration.

Why it matters: Your business processes have evolved over the years. Forcing them into rigid integration templates means either changing your workflows (expensive, disruptive) or accepting incomplete data sync (defeats the purpose).

AI-Assisted Configuration

Setting up integrations traditionally requires developers who understand both platforms’ APIs, data models, and scripting languages. AI changes this equation.

What to look for:

• Natural language script generation: Describe what you want (“sync all high-urgency incidents to Azure DevOps as bugs”), get working code
• Context-aware suggestions: AI understands your existing configuration and recommends improvements
• Error explanations: When sync fails, AI translates technical errors into plain language with fix suggestions

Why it matters: Reduces implementation time from days to hours. Non-developers can configure complex sync rules. Troubleshooting becomes faster when errors are explained clearly instead of cryptic API messages.

Scalability

You might start with one Azure DevOps project syncing to one ServiceNow assignment group. Six months later, you need five Azure DevOps organizations connected to ServiceNow, plus Jira, Salesforce, and Zendesk in the mix.

Why it matters: Starting with a solution that can’t scale means migration later: re-implementing integrations, retraining teams, and disrupting workflows. Choosing a scalable platform from the start avoids this pain.

Reliability

Downtimes are hard-hitting. It’s important to consider solutions that offer an integrated retry mechanism that doesn’t need manual intervention. Also, the two-way synchronization must resume from the point of interruption without having to worry about data being lost during system failures.

What to look for:

• Automatic retry logic: Failed sync attempts retry automatically with exponential backoff
• Rollback capability: If a configuration change breaks sync, revert to the previous working version
• Uptime guarantees: SLA commitments for platform availability
• Safe testing: Validate configuration changes before production deployment

Why it matters: A broken integration is worse than no integration—teams see outdated data, make decisions on false information, and lose trust in the system. Reliability features minimize downtime and provide safety nets.

Cost & Pricing Model

Integration pricing varies wildly. Some charge per user, some per transaction, some per connection. Understanding the model prevents budget surprises.

Pricing models explained:

• Per-user licensing: You pay based on how many people have access to Azure DevOps or ServiceNow
• Flat pricing: Charged a flat rate for the entire integration or per system
• Per-transaction (usage-based): You pay per API call or sync event
• Per-connection: You pay per integration pair (Azure DevOps ↔ ServiceNow)
• Outcome-based (sync pairs): You pay for the number of work items actively synchronized at any given time
• Cost per item decreases as scale increases: The more work items you sync, the lower the per-item cost. This aligns incentives—the platform wants you to get more value, not artificially limit your usage.

Look for transparency in pricing. You should be able to estimate costs before committing.

Why Use Exalate to Integrate Azure DevOps and ServiceNow

Exalate combines flexibility with operational simplicity through a unified management console:

• Script-based engine: Groovy scripting for any custom Azure DevOps ServiceNow workflow
• Side-by-side view: Manage all integrations and connections from one interface. Form 2-tier or multi-tier Azure DevOps ServiceNow integration networks
• AI-assisted configuration: Aida (Exalate AI) helps generate and troubleshoot sync scripts
• TestRun functionality: Test your sync scripts before production deployment
• Script versioning: Every script publish creates a new version. Full audit trail of who changed what and when, with rollback capability. This also allows you to work on drafts without affecting production data
• Real-time sync: Complete queue visibility and work item or incident history
• Activity Dashboard: Monitor sync health, queue depth, and error rates across all connections from a single view
• Network visualization: See all your connections and integrations in one place for quick understanding of integration architecture
• Security-first: ISO 27001 certified, RBAC, encryption at rest and in transit. Visit Exalate Trust Center
• Supported Integrations: Jira, Jira Service Management, ServiceNow, Azure DevOps Cloud and Server, Salesforce, Zendesk, Freshservice, Freshdesk, Asana, GitHub, and more. View All Supported Connectors
• Outcome-based pricing: Exalate uses sync-based (outcome-based) pricing, i.e., you pay for active work items in sync, not user seats, ensuring costs scale with actual usage, not team size. With every integration pair (Azure DevOps ServiceNow, in this case), you can create as many connections and users as you want. Also, the cost decreases as items under sync increase.

View pricing details → | Exalate Plan Calculator

Note: You can also have a look at the complete comparison between IntegrationHub and Exalate if you prefer.

Now that you understand what makes an effective integration and why this guide uses Exalate, let’s walk through the actual setup process.

How to Integrate Azure DevOps and ServiceNow: A Step-by-Step Guide

This tutorial demonstrates how to integrate Azure DevOps and ServiceNow using Exalate.

Go to the Exalate app. If you already have an account, you can log in directly.

New users can create an account by manually entering their email and verifying it, or by signing up using Google.

Creating a Workspace

Workspaces help you organize and manage your integrations and connections in a single place. You can find all your existing workspaces under the “Workspaces” tab.

To create your first workspace:

• Click the “+ Create Workspace” button
• Enter a name and description for your workspace
• Click “Create workspace” to confirm

Creating Your First Connection

Once you have a workspace, you can start creating connections between Azure DevOps and ServiceNow.

If you already have an existing workspace, you can view all your connections under the “Connections” tab, where you can edit connection settings and view other connection details.

Note: To create a connection, you’ll need an active Exalate account with at least one workspace and the access credentials for the systems you want to connect.

Azure DevOps ServiceNow Connection Setup Steps

• Click “+ Add connections” > “Create new connection”
• Enter the name for your first system (System A). You can name either Azure DevOps or ServiceNow as System A, it doesn’t matter which one goes first
• Enter the URL of your system. For example, if you start with ServiceNow, enter your ServiceNow instance URL

• Once you enter the URL, a validation check occurs. If your system is already part of the existing workspace, authentication happens automatically. If the system is part of a different workspace, it will be imported into your current workspace
• For new systems, you’ll need to enter your authentication details:
  • ServiceNow: Uses Basic authentication (username/password)
  • Azure DevOps: Uses API tokens
• Complete the same setup process for the Azure DevOps side
• Give your connection a name and description

• Click “Next”
• Review the details to ensure they are correct, then click “Create connection”

When the process is complete, select “Continue to configuration” and choose an Azure DevOps project you want to use for synchronization.

Then click “Build & continue”.

Azure DevOps ServiceNow Configuration Options

After creating your connection, you have two configuration options: “Quick Sync” and “Edit & Test”.

Let’s explore both.

Quick Sync: Publish & Quick Sync

This option allows you to sync one item between Azure DevOps and ServiceNow to verify that your connection works properly. This is an optional step, but recommended for initial testing.

Under the “Item sync monitor,” enter the work item ID in Azure DevOps or the incident number in ServiceNow.

To sync the first item, click “Sync Now”. To link two existing items, click “Link with existing”.

You’ll receive status updates while the items sync, and once the sync is complete, you can view both synced items by opening them in a new window.

You can also compare how the synced items will look and how the changes will be applied.

Edit & Test: Open Draft Editor

To start making changes to your sync configuration, click “Create a new version” or select “Open latest draft”.

This ensures you don’t accidentally modify the existing configuration. Changes in the draft are saved automatically.

Click the “Edit” button to open the editor and modify the sync rules.

Understanding Sync Rules

Sync rules are based on Groovy scripts. With these scripts, you can add custom data logic and mapping, along with conditional flows, allowing you to adapt for any complex or advanced use cases and workflows.

The direction of the sync can be changed by clicking the two arrows next to the connection name.

The scripts are divided into incoming and outgoing scripts:

• Outgoing script: If the sync direction is from Azure DevOps to ServiceNow, the outgoing script will hold the values passed from Azure DevOps to ServiceNow
• Incoming script: The incoming script defines how the values coming from Azure DevOps are mapped in ServiceNow

These scripts will be reversed if the direction changes.

Replica works like a message payload and holds the actual data passed between the synced entities. It exists in JSON format.

To sync new values, you can enter the sync script yourself if you are familiar with Groovy.

To stop something from syncing (for instance, attachments from Azure DevOps to ServiceNow), simply remove that script line from the outgoing Azure DevOps script.

AI-Assisted Configuration

To save time and simplify the scripting process, you can use Exalate’s AI-assisted configuration feature called Aida to generate sync scripts.

Aida is available in both incoming and outgoing script sections, so choose the appropriate side accordingly.

Aida helps you in two ways:

• For Outgoing scripts: Describe what data should leave your system. For example, “Exclude attachments” or “Only sync high-priority work items.”
• For Incoming scripts: Describe how incoming data should be applied to your system. For example, “Map statuses” or “Set a default assignee if the user can’t be found.”

Based on Exalate’s scripting API and your existing scripts, Aida generates working Groovy scripts with proper field mappings for you.

Once Aida finishes drafting your script, review the suggested changes. Green highlights indicate new lines that will be added, while red highlights show lines that will be removed from your script. You can choose to “Insert” or “Discard” Aida’s suggestions.

The outgoing and incoming scripts work independently, as does Aida, so maintain separate context and direction for each prompt.

Note: While Aida is helpful, like any AI tool, please review the generated code before applying it.

Test Run: Validate Before Production

Once your sync scripts are ready, you can choose to “Save script” or proceed to test them using the “Start Test Run” option.

To test the configuration, select the items you want to apply the sync to. You can select multiple items. Once selected, click “Start Test Run”. You can now view all the incoming and outgoing replicas for each item you selected in their respective tabs.

Review how the sync configuration will be applied to your items, preview the replica, and verify that the field mappings look correct. If needed, go back, adjust the scripts, and test again. Deploy only when you’re confident everything works correctly.

This safety net prevents errors from affecting live data.

Once everything matches your needs, click “Publish Version” to apply the updated configuration to your live synchronization.

All versions for a connection are available in the “Version” dropdown. Versions can be either “Active”, in “Draft” (editable), or “Archived”.

Adding Triggers

To start your sync automatically, it’s important to add triggers, which are conditions or filters you apply to specific items. For instance, you can sync all Azure DevOps work items that have a tag “escalate”, or sync all incidents in ServiceNow that belong to a specific assignment group.

Click the “+ Add trigger” button to start creating triggers. These triggers are platform-specific:

• For Azure DevOps: You can use Work Item Query Language (WIQL) to specify conditions for work items
• For ServiceNow: You can use the advanced search syntax to apply the trigger to incidents, problems, change requests, etc.

Azure DevOps trigger examples:

[System.WorkItemType] = 'Bug' AND [System.State] = 'Active'
Code language: JavaScript (javascript)

[System.TeamProject] = 'MyProject' AND [System.Tags] CONTAINS 'escalate'
Code language: JavaScript (javascript)

ServiceNow trigger examples:

assignment_group=IT Operations^urgency<=2

category=Software^active=true^state!=6
Code language: JavaScript (javascript)

Save your changes by publishing them.

Deploy and Monitor

That’s it! Your first synchronization will start automatically based on the sync rules and triggers you have set. Happy syncing!

Unfortunately, troubleshooting errors is a significant part of synchronization, especially in script-based tools like Exalate, which allow the flexibility of setting up complex workflows.

Troubleshooting with Aida

Aida AI helps you troubleshoot errors faster by offering clear and context-aware suggestions to resolve errors right where you see them.

If there’s an error, go to the “Troubleshooting” tab of your workspace. Hover over the error you want to diagnose and click on the Aida icon that appears next to the error. You will see the AI-generated suggestion in the modal window. This includes a short explanation of the error and a proposed solution for it.

You can also “View Full Analysis” to get more context.

Additionally, you can view “Error details” to copy the stack trace and “Replicas” to view the JSON format, if required.

Choose to “Resolve” and retry errors as needed.

Advanced Azure DevOps ServiceNow Integration Options Using Exalate

Exalate gives you the flexibility to adapt and adjust your synchronization to handle different kinds of Azure DevOps ServiceNow integration use cases. We’ll discuss a few integration scenarios that are commonly implemented using Exalate.

Multi-Instance Connections

A hub-and-spoke architecture makes it possible to connect multiple Azure DevOps and ServiceNow instances simultaneously. For example, a central ServiceNow environment can integrate with several departmental Azure DevOps organizations, or multiple vendor-managed ServiceNow instances can link into a single enterprise Azure DevOps organization.

All of these connections are administered through a unified console, which provides a network-style visualization of every integration. Administrators can perform bulk operations, such as updating multiple connections at once, and apply consistent script templates across similar integrations to streamline maintenance and configuration.

Custom Field Mapping

The platform supports syncing virtually any field accessible through the REST API. In ServiceNow, this includes fields across tables such as Incident, Change Request, Problem, and others. In Azure DevOps, you can map standard fields, custom fields, and even multi-select fields.

For example, the ServiceNow Configuration Item value can be synchronized into a custom Azure DevOps field using a Groovy script such as:

def ciField = workItem.customFields."Custom.ConfigurationItem"
if (ciField) {
    ciField.value = replica.customKeys.cmdb_ci
}
Code language: JavaScript (javascript)

This allows teams to maintain consistent contextual data across both systems, ensuring that critical attributes move seamlessly with the work items.

Correlation Fields

Correlation fields make it possible to define and preserve relationships between local and remote work items.

By storing identifiers from Azure DevOps inside ServiceNow, teams retain traceability even if titles or descriptions change over time.

A typical approach uses a script like:

// Store Azure DevOps work item ID in ServiceNow correlation field
entity.correlation_id = replica.id
entity.u_azure_workitem_id = replica.id
entity.correlation_display = workItemUrl
Code language: JavaScript (javascript)

This method allows users in either system to navigate quickly back to the originating item, creating a stable linkage that supports long-term auditing, reporting, and troubleshooting.

Epic and Story Time Tracking

ServiceNow incidents can be converted into Azure DevOps Epics while preserving detailed time-tracking information. A common pattern is to aggregate story-level estimates and time spent, then push those values back into ServiceNow for increased visibility. For example:

// Azure DevOps → ServiceNow with time aggregation
def childWorkItems = workItemHelper.getChildren(workItem.id)
replica.customKeys.totalTimeSpent = childWorkItems.sum { it.completedWork ?: 0 }
replica.customKeys.totalOriginalEstimate = childWorkItems.sum { it.originalEstimate ?: 0 }
replica.customKeys.totalRemainingWork = childWorkItems.sum { it.remainingWork ?: 0 }
Code language: JavaScript (javascript)

These aggregated values can then be returned to a ServiceNow custom field, ensuring teams on both platforms share a unified view of progress and effort across related stories.

Maintain Updates between SLA and the Attached Account

You can sync the SLA records and maintain state updates between Azure DevOps and ServiceNow to ensure critical incidents are always handled with priority and within their SLAs.

Imagine a priority 1 incident is raised, and the customer support agent identifies it as a development work item to be passed to the dev team working in Azure DevOps. Along with the SLA and time-related information, if the incident status is also synced, the agents would always have visibility over it at all times, and the dev team would know the SLAs and time constraints they must adhere to beforehand.

So, when the work is marked resolved in Azure DevOps, the corresponding state is updated in ServiceNow with specific comments left as resolution notes.

Keep Internal Comms Private

Sometimes, internal teams working on specific problems or incidents must pass important information from ServiceNow to Azure DevOps, for instance, leaving notes for the dev team to help them with the work item.

In such a case, private comments must be kept private and synced between the two systems. It’s possible to do that with simple code. Share only ServiceNow work notes to Azure DevOps, such that the dev team has all the required information handy.

// Only sync comments that don't contain [INTERNAL]
workItem.comments = replica.comments.findAll { comment ->
    !comment.body.contains("[INTERNAL]")
}
Code language: JavaScript (javascript)

Sync Anything between Azure DevOps and ServiceNow

You can also sync different entities or work types between Azure DevOps and ServiceNow for better visibility and streamlined business operations.

For instance, sync a ServiceNow customer case to an Azure DevOps epic. You can also sync incidents, CMDB, change requests, problems, custom fields, and almost any field available via REST APIs.

Exalate also allows you to integrate ServiceNow’s Agile backlogs, defects, and incidents with Azure DevOps, allowing your teams to keep everything updated in real time. No more redundant data entry or siloed information.

Automate Incident Creation in ServiceNow from Azure DevOps Tags

With Exalate, you can automatically create ServiceNow incidents directly from Azure DevOps work items using predefined tags. This ensures that your critical issues, required by contractual obligations, are created in ServiceNow without manual intervention, saving time and reducing errors.

Frequently Asked Questions

Why should I integrate Azure DevOps and ServiceNow?

Integrating Azure DevOps and ServiceNow can help teams reduce information silos. It reduces manual errors like misplaced statuses, wrong escalations, etc. You can ensure data is exchanged automatically and is accessible to the right stakeholders when they need it. You can also control exactly how much data to share using script-based sync rules.

What’s the difference between Exalate and ServiceNow IntegrationHub?

IntegrationHub is ServiceNow’s native solution with limitations:

• ServiceNow-centric control (limited autonomy for the Azure DevOps side)
• Higher costs (additional package fees)
• Limited bidirectional functionality
• Best for simple, unidirectional use cases

Exalate provides:

• Unified console with operational control for both sides
• Full bidirectional sync with unlimited customization
• AI-assisted configuration (Aida)
• Outcome-based pricing (active sync pairs, not user seats)
• Script versioning and Test Run for safe deployment
• Activity Dashboard for monitoring sync health

Can I connect multiple Azure DevOps and ServiceNow instances?

Yes. Exalate supports multi-instance hub-and-spoke architectures.

Connect:

• Multiple Azure DevOps organizations to one ServiceNow
• One Azure DevOps organization to multiple ServiceNow instances
• Complex mesh networks across departments or MSP client environments
• Azure DevOps Cloud and Azure DevOps Server (on-premises) instances

All managed from a single unified console with network visualization.

What fields can I sync between Azure DevOps and ServiceNow?

Any field accessible via REST API:

Standard Fields: Work items (bugs, tasks, user stories, features, epics), comments, attachments, status, priority, assignee, description

Advanced: Custom fields, SLA information, time tracking, correlation fields, CMDB configuration items, approval workflows, pipeline status

ServiceNow: Any table (Incident, Change Request, Problem, RITM, Customer Case, etc.)

Azure DevOps: All work item types in Azure DevOps Cloud and Server

View the detailed documentation for fields supported here.

Can I sync work items bidirectionally in real-time?

Yes. Exalate provides real-time bidirectional synchronization. When a work item updates in Azure DevOps, it syncs to ServiceNow within seconds (and vice versa). The Activity Dashboard lets you monitor sync queue status across all connections.

What if I only want certain work items or incidents to sync?

Use platform-native triggers for granular control:

Azure DevOps: WIQL (Work Item Query Language) Example: [System.WorkItemType] = 'Bug' AND [System.State] = 'Active' AND [System.Tags] CONTAINS 'escalate'

ServiceNow: Encoded query syntax Example: assignment_group=IT Operations^urgency<=2^active=true

Triggers ensure only matching work items or incidents enter the sync.

Can I transform data during sync (e.g., priority mapping)?

Yes. The Groovy scripting engine supports any transformation:

• Map ServiceNow “Critical” urgency to Azure DevOps “Priority 1”
• Convert timestamps between time zones
• Concatenate multiple fields
• Apply conditional logic (e.g., sync comments only if they don’t contain “CONFIDENTIAL”)

Aida helps generate transformation scripts from natural language prompts.

Can I control what data is shared between teams?

Yes. Full operational control through scripting:

Scenario: Share work item summary and status with external partner, but keep internal comments private.

Script Logic:

workItem.comments = replica.comments.findAll { comment ->
    !comment.body.contains("[INTERNAL]")
}
Code language: JavaScript (javascript)

Scripts give you granular control over what crosses system boundaries.

How does Exalate pricing work?

Exalate offers a 30-day free trial with full functionality.

Outcome-based pricing: You pay for active sync pairs (work items currently synchronized) at any given time.

Each integration is billed independently. You can mix plan tiers (Starter for one integration, Pro for another).

View detailed pricing →

Can I use Exalate as an MSP connecting to client systems?

Yes. Exalate is designed for cross-company integration:

MSP Scenario: Connect your ServiceNow instance to multiple client Azure DevOps instances. Clients work in their tools, you manage from the unified console.

Features for MSPs:

• Decoupled authentication (clients don’t need ServiceNow access)
• Role-based access control
• Network visualization of all client connections
• Bulk operations across connections

Can I connect Azure DevOps to ServiceNow Change Management?

Yes, you can connect Azure DevOps with ServiceNow change management and sync all necessary details like change type, reason, priority, assignment group, planned dates, approval status, etc.

Does Exalate support Azure DevOps Server (on-premises)?

Yes. Exalate supports both Azure DevOps Services (Cloud) and Azure DevOps Server (on-premises, formerly TFS). Configuration is similar, though on-premises installations require network connectivity between your Exalate node and both platforms.

What if I need a connector that’s not currently supported?

Custom connector development is available for Enterprise customers, MSPs, or MSSPs.

We’ve built connectors for:

• Proprietary in-house systems
• Exotic tools
• Industry-specific tools (healthcare, manufacturing, etc.)
• Legacy platforms

Inquire about custom connector development →

Ready to Connect Azure DevOps and ServiceNow?

With Exalate, you get:

• Unified visibility: A single place to view and manage all your integrations
• Operational Control: Full Groovy scripting flexibility with unified management
• AI-Assisted Setup: Aida generates scripts from natural language prompts
• Safe Deployment: Test Run validates before production, and script versioning enables rollback
• Real-Time Visibility: Activity Dashboard monitors sync status across all connections
• Enterprise Security: ISO 27001 certified, RBAC, encryption at rest and in transit
• Outcome-Based Pricing: Pay for active sync pairs, not user seats

Integrating Azure DevOps and ServiceNow eliminates manual data entry, keeps development and IT operations aligned, and accelerates incident resolution.

Recommended Reads:

• Jira ServiceNow Integration: How to Set up an Integration in 6 Steps
• Jira Azure DevOps Integration: The Complete Step-by-Step Guide
• How to Set up a Salesforce ServiceNow Integration
• How to Set up an Azure DevOps Salesforce Integration
• Zendesk ServiceNow Integration: The Complete Guide
• How to Set up a Zendesk Azure DevOps Integration
• ServiceNow Integrations: Integrate ServiceNow and Other Systems Bidirectionally