How to Sync ServiceNow Requests and Incidents With Jira Cloud

Published: Nov 17, 2026 | Last updated: Nov 17, 2026

Table of Contents

Plenty of companies take requests in ServiceNow and do the work in Jira. When the two systems aren’t connected, someone has to escalate each catalog request or incident as a Jira work item, keep it updated, and then go back to ServiceNow to close the original.

In this particular scenario, a third-party provider runs the company’s domain-separated ServiceNow instance, and the company runs its own Jira Cloud. Both teams use Exalate to connect the two sides with sync rules each party controls, so eligible records become Jira work items and progress flows back to the requester. 

We’ll go through record selection, per-team routing, status return, and how to split ownership with your provider.

Key Takeaways

  • ServiceNow triggers decide which catalog requests and incidents sync, so only eligible records reach Jira.
  • The Jira incoming script pulls the project and work item type from the assignment group and record type, eliminating manual retyping.
  • Each Jira team keeps its own workflow, and a per-project status map translates those statuses into ServiceNow states.
  • Resolving a work item in Jira sets the incident state, resolution code, and resolution notes in ServiceNow, so requesters see progress where they raised the request.
  • The provider owns the ServiceNow-side rules, and the company owns the Jira side, and neither needs admin access to the other’s system.

Discuss your integration setup with our experts

Get free, expert advice on your setup. We’ll reach out via email to discuss your use case.

The Current Setup

ServiceNow is the intake system where employees raise catalog requests, report incidents, and submit a few service requests, and they expect to see updates there.

At the same time, a third-party provider administers that ServiceNow instance, and it’s domain-separated, so the company’s records sit in their own domain. The company has no admin rights there and can’t install or configure an integration on its own.

current setup from servicenow to jira cloud

Jira Cloud is where the work happens, and the company administers it directly. Several teams work in their own projects, each with its own routing rules and workflow. 

The main challenge is that the website team’s statuses don’t match those used by the data team, and neither wants a shared workflow forced on them.

Where the Setup Breaks Down

Under this current setup, every eligible request gets handled twice. First, someone reads the ServiceNow record, creates a Jira work item, copies the details, and later returns to update and close the original.

Other pain points include:

  • Lost product owner capacity: Product owners spend several hours per week transferring and maintaining tickets instead of working on other priorities. 
  • Disconnected requester updates: Jira progress and completion do not automatically flow back to ServiceNow unless someone updates both systems manually.
  • Dependence on an external provider: The organization administers Jira Cloud, but a third party controls its domain-separated ServiceNow environment. So the organization cannot control the integration implementation.
  • Different workflows across teams: Jira teams use different routing and workflow rules. So, the integration must accommodate those differences rather than force everyone into one process.

How Exalate Handles It

Exalate runs on both ServiceNow and Jira Cloud. Each side has an outgoing sync script (what leaves that system), an incoming sync script (how it applies data from the other side), and triggers that decide which records sync. The scripts are written in Groovy, so the rules can change by table, assignment group, and Jira project.

Note

The code snippets have been generated with Aida AI, so make sure to review the output before publishing.

Pick Which ServiceNow Records Sync

Triggers live on the ServiceNow side and use ServiceNow’s filter query syntax. You set one per table, so catalog requests and incidents get separate conditions.

For example, a trigger on the Requested Item (sc_req_item) table could pick up only website change requests:

active=true^cat_item.name=Website Change Request

A trigger on the Incident table could pick up only records assigned to delivery teams that work in Jira:

active=true^assignment_group.nameINWebsite Support,Data Platform

Everything else stays in ServiceNow. Adding a new catalog item or assignment group later means editing a trigger, and the scripts stay untouched.

Send the Right Details Out of ServiceNow

The ServiceNow outgoing script decides what goes into the replica (the payload Exalate sends to the other side). It also passes the table name and assignment group, so the Jira side can route the record:

// ServiceNow outgoing sync

replica.key         = entity.key

replica.summary     = entity.short_description

replica.description = entity.description

replica.priority    = entity.priority

replica.attachments = entity.attachments

replica.customKeys."tableName"       = entity.tableName

replica.customKeys."assignmentGroup" = entity.assignment_group?.display_valueCode language: JavaScript (javascript)

Catalog requests usually carry their details in catalog variables, which sit on related tables. The outgoing script can query them through the ServiceNow REST API and add them to the replica, so the Jira team gets the form answers along with the summary. 

Since this script runs on the provider’s side, the provider decides what leaves the company’s domain. Fields the Jira teams don’t need will never get added to the replica.

Create the Work Item in the Right Jira Project

On the Jira side, the incoming script creates the work item on the first sync and picks the project and work item type:

// Jira incoming sync (from ServiceNow)

if (firstSync) {

    def projectByGroup = [

        "Website Support": "WEB",

        "Data Platform"  : "DATA",

        "Field Apps"     : "APPS"

    ]

    def group = replica.customKeys."assignmentGroup"

    issue.projectKey = projectByGroup[group] ?: "INTAKE"

    issue.typeName   = replica.customKeys."tableName" == "incident" ? "Bug" : "Task"

}

issue.summary     = replica.summary

issue.description = replica.description ?: "No description"

issue.attachments = attachmentHelper.mergeAttachments(issue, replica)

issue.customFields."ServiceNow number".value = replica.keyCode language: JavaScript (javascript)

Note: Project keys, work item types, and the “ServiceNow number” field are placeholders, so swap in your own. The INTAKE fallback catches records from a group that hasn’t been mapped yet, so nothing gets lost while the mapping catches up.

Each team’s project keeps its own workflow, screens, and automation. The sync only creates and updates the work item, and it doesn’t change how the project is configured.

Send Progress and Completion Back to ServiceNow

For requesters, the ServiceNow incoming script reads the Jira status and the project it came from, then sets the matching ServiceNow state:

// ServiceNow incoming sync (from Jira)

def statusByProject = [

    "WEB" : ["In Progress": "In Progress", "Blocked": "On Hold", "Done": "Resolved"],

    "DATA": ["Doing": "In Progress", "Waiting on Requester": "On Hold", "Shipped": "Resolved"]

]

def newState = statusByProject[replica.project?.key]?.get(replica.status?.name)

if (newState && entity.tableName == "incident") {

    entity.state = newState

    if (newState == "Resolved") {

        entity.close_code  = "Solution provided"

        entity.close_notes = replica.comments ? replica.comments.last().body : "Resolved in Jira"

    }

}

if (newState && entity.tableName == "sc_req_item") {

    entity.state = newState == "Resolved" ? "Closed Complete" : "Work in Progress"

}Code language: JavaScript (javascript)

ServiceNow usually requires a resolution code and resolution notes before an incident can move to Resolved, so the script fills both. Here, the notes come from the last Jira comment, which works when the team writes a closing comment before moving the work item to done.

Each Jira project gets its own map, and a team that adds a status only needs one new entry. Statuses that aren’t in the map leave the ServiceNow state as it is.

Jira status (website team)Incident stateRequested item stateWhat the requester sees
In ProgressIn ProgressWork in ProgressSomeone’s working on it
BlockedOn HoldWork in ProgressThe request is paused
DoneResolvedClosed CompleteThe work is finished, with resolution notes

Whether a requested item closes automatically or waits for the requester to confirm is a business decision. Agree on it with the provider before you write the requested item branch, since closing the last requested item on a request can also close the parent request.

Discuss your integration setup with our experts

Get free, expert advice on your setup. We’ll reach out via email to discuss your use case.

Before Syncing ServiceNow Requests and Incidents With Jira

List the exact tables and catalog items that should sync, and the assignment groups behind them. This list drives your triggers and your routing map, so confirm it with each team.

Ask every Jira team to share its workflow statuses and say what each one should mean in ServiceNow. Then decide how resolution works: who writes the resolution notes, which resolution code to use, and whether requested items close automatically.

Next, scope comments and attachments separately. Requesters may need some Jira comments as additional comments, while engineering discussion should stay as work notes or not sync at all.

Settle the operational side with the provider early: ticket volume, their security review, who watches for sync errors, and who fixes them. After that, run the first version between a ServiceNow test instance and a Jira sandbox, and use Test Run to check each script before you publish. 

If your admins don’t want to write Groovy scripts every day, they can use Aida AI, Exalate’s AI scripting and troubleshooting assistant, to create a draft version from a natural language prompt.

When three parties share one integration (you, your ServiceNow provider, and the integration vendor), the commercial setup matters as much as the scripts. Talk to our team to sort out how to set up your connection.

FAQs

Can Exalate sync ServiceNow catalog requests with Jira?

Yes, Exalate syncs requested items from the sc_req_item table, along with incidents, problems, change requests, and other tables. The outgoing script can read catalog variables through the ServiceNow REST API and add them to the sync.

Does Exalate work with domain-separated ServiceNow instances?

Yes, the Exalate proxy user gets access to the domain whose records should sync, and triggers and scripts limit the sync to those records.

Can different Jira teams keep their own workflows?

Yes, teams can keep their own Jira workflows. The incoming script routes each record to the right project, and a per-project status map translates each team’s statuses into ServiceNow states, so no team has to change its workflow.

Do we need to sync every ServiceNow record?

No, you can filter out what syncs using triggered escalation. Exalate triggers use ServiceNow filter queries, so only records that match your conditions reach Jira. On the Jira side, the triggers are configured using JQL.

Who controls the integration when a provider runs ServiceNow?

Each side controls its own scripts. The provider manages the ServiceNow rules and the proxy user’s access, and you manage the Jira rules, so neither party needs admin access to the other’s system.

Recommended Reads

Subscribe to the Newsletter

Join +5.000 companies and get monthly integration content straight into your inbox

Shopping Basket