Seamlessly Integrating ServiceNow with Azure DevOps for End-to-End Workflow Automation

Forget juggling multiple platforms independently—discover how syncing ServiceNow with Azure DevOps transforms fragmented workflows into a unified engine that drives faster, smarter IT and software collaboration.

When IT operations and development teams work in silos, communication gaps can delay incident resolution, impede change management, and slow down agile delivery pipelines. Fortunately, connecting ServiceNow—the powerhouse for IT Service Management (ITSM)—with Azure DevOps—the premier suite for Agile development—closes this gap effectively. This integration automates ticket handling, accelerates feedback loops, and gives both teams real-time visibility into work progress.

In this post, I’ll walk you through practical steps to integrate ServiceNow with Azure DevOps. Whether you’re an ITSM manager trying to streamline incident resolution or a DevOps lead aiming at smoother handoffs between operations and development, this guide will help you get started fast.

Why Integrate ServiceNow with Azure DevOps?

Before diving into the how-to, let’s quickly recap why this integration matters:

• Bridge the gap: Automatically push incidents or change requests from ServiceNow straight into Azure DevOps as work items.
• Improve visibility: Development teams get full context upfront; IT ops can track code changes or deployments connected to tickets.
• Reduce manual errors: No more copying and pasting or duplicating effort across platforms.
• Accelerate resolution: Faster turnaround on bugs, changes, and features by closing the feedback loop.

Getting Started: What You Need

1. Active ServiceNow instance with appropriate admin access.
2. Azure DevOps organization/project with sufficient permissions to create work items.
3. API access enabled on both platforms.
4. Some familiarity with REST APIs and basic scripting will help.
5. Optionally a middleware like Microsoft Power Automate or an integration platform such as Zapier or built-in ServiceNow IntegrationHub spokes.

Step 1: Set Up Required Permissions & APIs

On ServiceNow

• Create an Integration User (dedicated account) to push/pull data from ServiceNow securely.
• Enable access to Incident [or your preferred table] via REST API.
• Retrieve the instance URL and credentials (username/password or OAuth tokens).

On Azure DevOps

• Generate a Personal Access Token (PAT) from your user profile under "Security."
• The PAT should have scopes for Work Items read/write.

Step 2: Define Your Workflow Trigger & Events

Typically you want incidents created in ServiceNow to automatically generate corresponding work items (like Bugs) in Azure DevOps.

Example trigger:

• New Incident created in ServiceNow
• Incident updated with specific state (e.g., “In Progress” or “Resolved”)
• Change Requests approved

Step 3: Build Your Integration Logic

You have multiple options here:

Option A: Using Microsoft Power Automate

Power Automate supports connectors for both Azure DevOps and HTTP requests (use ServiceNow API):

1. Create a new automated flow triggered by HTTP Request event configured as a webhook from ServiceNow.

2. When an incident is created/updated in ServiceNow:

   • Use HTTP GET request in Power Automate to extract incident details from ServiceNow API.
   • Use "Create a Work Item" action to create corresponding Bug/Task in Azure DevOps project.
   • Map fields such as Incident number → Work Item Title, Description → Description, Priority → Priority tags.

3. Optionally add update actions so status syncs back from Azure DevOps to ServiceNow once dev starts working or resolves the work item.

Option B: Scripting with REST APIs

If you prefer coding your own integration:

import requests
import json

# ServiceNow credentials & URL
SN_INSTANCE = 'https://yourinstance.service-now.com'
SN_USER = 'integration_user'
SN_PASS = 'your_password'

# Azure DevOps PAT & URL
ADO_ORG = 'yourorg'
ADO_PROJECT = 'yourproject'
ADO_PAT = 'your_pat_token'

def get_new_incidents():
    url = f'{SN_INSTANCE}/api/now/table/incident?sysparm_query=active=true^state=1'  # Example query
    response = requests.get(url, auth=(SN_USER, SN_PASS))
    response.raise_for_status()
    return response.json()['result']

def create_ado_work_item(title, description):
    url = f'https://dev.azure.com/{ADO_ORG}/{ADO_PROJECT}/_apis/wit/workitems/$Bug?api-version=6.0'
    headers = {
        'Content-Type': 'application/json-patch+json',
        'Authorization': f'Basic {ADO_PAT}'
    }
    document = [
        { "op": "add", "path": "/fields/System.Title", "value": title },
        { "op": "add", "path": "/fields/System.Description", "value": description }
    ]
    response = requests.post(url, headers=headers, data=json.dumps(document))
    response.raise_for_status()
    return response.json()

def main():
    incidents = get_new_incidents()
    for inc in incidents:
        title = f"INC {inc['number']}: {inc['short_description']}"
        description = inc['description'] or 'No description provided'
        ado_item = create_ado_work_item(title, description)
        print(f"Created ADO Bug ID: {ado_item['id']} for Incident {inc['number']}")

if __name__ == "__main__":
    main()

This simple example fetches active incidents in state ‘New’ and creates Bugs inside Azure DevOps accordingly.

Step 4: Test Your Integration End-to-End

Once your logic is set up:

1. Create test records in ServiceNow matching your workflow triggers.
2. Confirm that equivalent work items appear correctly in Azure DevOps with mapped data.
3. Verify updates propagate back if bi-directional sync is desired.

Step 5: Optimize & Expand

After establishing basic automation consider:

• Adding link fields so users can jump between incident and work item easily.
• Sync status updates both ways so each side stays current without manual input.
• Handling updates like priority changes or comments addition automatically.
• Including Change Requests or Problem Management objects as well.

Final Thoughts

By integrating ServiceNow’s robust ITSM capabilities directly with Azure DevOps’ agile toolset, you eliminate friction between operations and development teams. The result? Faster incident resolution timelines, clearer alignment on priorities, and improved delivery velocity for business-critical applications.

Start small by automating incident handoffs today — soon you’ll enjoy an end-to-end workflow automation pipeline that empowers seamless collaboration across your entire IT ecosystem.

Happy automating!

If you’d like me to share templates for Power Automate flows or detailed scripts adapted to your environment — just drop a comment below!