Jira ServiceNow Integration [2026]: How to Connect Jira and ServiceNow

A Jira ServiceNow integration keeps incidents, changes, and requests in ServiceNow linked to the Jira work items your developers fix. When one side changes a status or adds a comment, the other side sees it without anyone copying it over.

You can build it three ways: ServiceNow’s Integration Hub with the Jira Spoke, custom REST code, or a third-party sync tool like Exalate. Each method handles routing, field mapping, and two-way updates differently.

This guide covers all three methods, how ServiceNow’s structures map to Jira projects, the use cases teams actually run, and a step-by-step setup with Exalate.

Key Takeaways

• A Jira ServiceNow integration syncs records like incidents, RITMs, catalog tasks, change requests, problems & more with Jira work items, in one or both directions.
• ServiceNow’s ITSM side has no project container. Assignment groups usually decide which Jira project or space a record lands in.
• ServiceNow’s native option to connect ServiceNow with other tools is Integration Hub, which comes with different spokes, one of them being the Jira Spoke.
• Custom REST builds can sync data between tools, but their maintenance depends on the person who writes the sync scripts, and they are often a good option for companies with dedicated engineering teams.
• Third-party tools like Exalate add two-way sync, field-level control on each side, and cross-company connections.
• Map ServiceNow urgency to Jira priority (for example, 1 – Critical to Highest) so both teams triage the same way.

Common use cases: incident escalation to developers, ServiceNow intake to Jira delivery, Agile Development 2.0 sync, change request management, MSP client coordination.

Why Integrate Jira and ServiceNow

Teams usually use ServiceNow to run intakes, their service desk, and change governance. Jira runs development.

There is data sitting individually between Jira and ServiceNow that can be valuable to the other teams.

But when this work needs to cross between them, without having an automated mechanism to do so, a team member copies it by hand and sends it over. This manual way of working is prone to mistakes and makes it even more difficult for the teams to get real-time status updates on critical information raised in either instance.

Without a sync, teams often rely on one person to relay updates between Jira and ServiceNow by hand. Outside the person’s working hours, these updates didn’t reach the team in Jira, so active P1 incidents sat with no updates.

Fast changes are another weak spot: status changes made less than a minute apart can fail to reach ServiceNow.

The example below follows one incident escalated from Jira Service Management to ServiceNow, first without an integration and then with one, so you can see which manual steps the sync removes.

Use Case Example:

A customer logs an incident in Jira Service Management (JSM) (e.g., “System Outage”) with Summary, Description, Priority, and Attachments, with correct transformations applied (e.g., JSM’s “High” Priority maps to ServiceNow’s “Critical” Urgency, and so on). The support team needs to escalate this to IT operations in ServiceNow for resolution.

Without Integration: Manual copying of work item details from Jira to ServiceNow, which is time-consuming and error-prone.

With Integration:

• An incident is automatically created in ServiceNow with all fields mapped correctly.
• Any updates, such as a status change in JSM to “In Progress”, sync to ServiceNow as “Work in Progress.” Similarly, updates in ServiceNow sync back to JSM with proper field mappings.
• Comments sync bidirectionally, but visibility rules ensure customer-facing comments in JSM remain internal work notes in ServiceNow.
• If the incident is marked “Critical,” additional fields like Service Owner and Resolution SLA synchronize in real time.
• Once the incident is resolved in JSM, the resolution code and resolution notes are automatically assigned to the incident based on the selection the agent 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: both teams see the same status, comments, and attachments without asking each other.
• Less manual work: nobody re-types tickets or relays updates between tools.
• Better collaboration: development and IT teams keep their own workflows and still share the same record.
• Faster resolution: escalations reach developers with the full context, so less time goes into back-and-forth questions.

Those benefits depend on what the integration actually moves between the two systems and how. The next section covers the sync flow and the data you can share. If you don’t find your scenario here, you can always set up a call with our integration engineers.

What Does Jira ServiceNow Integration Do

A Jira ServiceNow integration links records in both platforms and updates each side automatically based on mappings or triggers you define, for instance, when a status, comment, or field changes on the other. You can control the mapping and the data flow at a granular level to match your team’s workflows.

How It Works

When you integrate Jira and ServiceNow:

1. Automatic sync: ServiceNow incidents create corresponding Jira work items (or vice versa) based on triggers you define
2. One-way or two-way sync: choose the direction per connection, or even per field. A one-way sync pushes ServiceNow incidents into Jira for developers to track. A two-way sync also sends Jira updates, like status changes and resolution notes, back to ServiceNow
3. Real-time updates: comments added in ServiceNow appear in Jira in real-time after they’re saved. Attachments, status changes, and field updates follow the same path
4. Field mapping: ServiceNow “Priority 1 – Critical” automatically becomes Jira “High Priority” based on the transformation rules you configure
5. Context preservation: SLA timelines, work history, escalation notes, and other details transfer between systems without information loss
6. Workflow autonomy: IT operations continues using ServiceNow, development teams stay in Jira, but everyone sees synchronized data

What Data Is Typically Synced Between Jira and ServiceNow

Standard fields:

• Entities: ServiceNow incidents, change requests, RITMs, catalog tasks, problems, and other entities available in tables → Jira stories, bugs, tasks, epics → work items (previously called issues)
• Comments and notes: Work notes, internal comments, customer-facing comments
• Attachments (even inline): Files, images, documents (transferred or linked)
• Status and workflow: Open → In Progress → 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) → Jira priority (Highest to Lowest). Map according to your needs

Advanced synchronization:

• Custom fields: Sync any custom field available via REST API between Jira 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
• CMDB data: Configuration items from the ServiceNow asset database
• Agile records: Agile Development 2.0 stories, epics, and defects
• Any data available via REST APIs

How ServiceNow Records Map to Jira Projects

Knowing what to sync between systems is just half the setup. The other half is deciding where and how each ServiceNow record lands in Jira.

Jira organizes work into projects (now called spaces in Jira Cloud). ServiceNow doesn’t have one equivalent, so the first design decision is what decides where a record lands in Jira.

It depends on which part of ServiceNow the work comes from:

Most setups combine two or more of these.

Most integrations start with “routing by teams”, so the next part covers how assignment groups decide which Jira project gets each record.

ServiceNow Assignment Groups Decide Routing Rules for ITSM Records

For ServiceNow incidents, catalog tasks, and changes, the unit that maps to a Jira project is the assignment group. ServiceNow has no project on those records. The integration reads the assignment group that owns each ticket and uses it to decide which Jira team gets it.

A common setup we’ve observed routes selected ServiceNow records by assignment group into the matching Jira space. Each one becomes a story under an existing epic, and it keeps syncing even when someone moves the story to a different epic.

This also keeps the setup small.

A company with 276 Jira projects might ask how many connections it needs. The answer is often 4 to 6 logical connection groups, with routing rules inside each one.

Agile Records

If your ServiceNow team runs Agile Development 2.0, you do have backlogs on the ServiceNow side as well. Those map more directly: an agile group to a Jira project, and stories, epics, and defects to their Jira equivalents. The use cases below cover this case.

Real-World Use Cases for Jira ServiceNow Integration

These are the patterns teams run most often, from IT escalations to agile delivery and MSP operations.

1. Customer Support to Development Incident Escalation with SLA Tracking

Scenario: A critical item (Urgency=1) occurs in your IT infrastructure.

Workflow:

1. The incident is logged in ServiceNow with urgency, assignment group, and SLA details, and support investigates.
2. Support finds the root cause needs a code fix.
3. A Jira work item is created automatically with the incident history, SLA timeline, mapped priority, and work notes as Jira comments.
4. The development team fixes the issue in Jira while IT operations keeps working the incident in ServiceNow.
5. Status updates, comments, and attachments sync both ways, and SLA breach alerts reach both teams.
6. Resolution notes sync back to ServiceNow, and the incident closes with the right resolution code.

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

Jira ServiceNow Integration Use Cases: Learn how to implement some advanced technical use cases.

Read more

2. ServiceNow Agile Development and Jira

Scenario: Product requirements start in ServiceNow, but developers track the work in Jira.

ServiceNow has its own connector for this. It enables bidirectional synchronization of records between Atlassian Jira and ServiceNow Agile Development, and epics and stories come across into Agile Development.

It has 2 limits worth looking into:

• One Jira project, one agile group: The connector maps each Jira project to a single agile group, and all its work items land in that group, whichever board they sit on. Teams that split one Jira project across several boards lose that split in ServiceNow.
• No Jira Data Center: Integration with Jira Data Center, Jira Align, and other Atlassian products isn’t available.

Exalate syncs the same records (stories, epics, and defects) with Jira, and the sync rules decide which agile group or Jira project each record goes to.

A common version of this: user stories in ServiceNow in sync with requirements in Jira, and defects in Jira in sync with defects in ServiceNow.

3. ServiceNow Intake to Jira Delivery

Scenario: ServiceNow is the employee-facing portal. Jira is where IT and development teams run projects, technical debt, and the backlog.

Without a sync, people update a change request in ServiceNow, switch to Jira to update the related story, and come back once the change closes. This setup is common in public sector agencies: ServiceNow stays the intake platform, application developers keep stories and bugs in Jira, and neither team moves to the other tool.

Workflow:

1. A request, catalog task, or change request is created in ServiceNow.
2. Its assignment group routes it to the right Jira project as a story, often under an existing epic.
3. Statuses map between the two workflows, so neither team changes its process.
4. Comments and agreed fields stay aligned, and the ServiceNow record shows the Jira key for traceability.

Not every record should cross. Most teams don’t want every incident or request forced into Jira, only the ones a team chooses to track there. Triggers handle that.

4. MSP Multi-Tenant Operations

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

Solution:

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

Why not a free app from the ServiceNow Store? For an MSP, each free app is something you maintain: its API calls, its configuration, and its upgrades, usually with no vendor support. With 10 clients on 10 different apps, you run 10 integration setups. With one integration platform, every client connection sits in the same console, with the same rules and one support contract. MSPs and MSSPs often sell this as part of the managed service (for example, an add-on to a SOC service, like the MSSP in this case study that integrates 500+ tickets monthly) instead of a separate product.

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

– Ms. TEO
TEAM LEAD, LF LOGISTICS

Outcome: Transparency, simplified reporting, trust across organizations.

5. Change Request Management

Scenario: Your e-commerce platform requires an upgrade.

Workflow:

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

Advanced Mapping:

• ServiceNow Change Request → Jira Epic
• ServiceNow Change Tasks → Jira Stories/Sub-tasks
• Time tracking aggregated from Jira stories returned to the ServiceNow custom field

What are the Best Ways to Connect Jira and ServiceNow?

There are 3 main routes: ServiceNow’s Integration Hub, custom code, and third-party sync tools.

ServiceNow and Atlassian also offer narrower connectors for specific jobs, like on-call alerts or license tracking, covered below.

ServiceNow Integration Hub with the Jira Spoke (Native Method)

ServiceNow’s Integration Hub connects to Jira through the Jira Spoke. The spoke gives you actions to manage Jira work items, users, stories, and groups, and to pull Jira data into a Flow Designer flow. You can also subscribe to Jira webhooks with a ServiceNow callback URL, so changes in Jira can start flows in ServiceNow.

That makes two-way sync possible, but you build it. Each direction, field mapping, and error path is a flow your ServiceNow team designs and maintains.

• Two-way sync means building and maintaining flows for each direction
• Requires an Integration Hub subscription on top of your ServiceNow license
• ServiceNow-centric control, with no configuration on the Jira side
• Works well for simple, one-way pushes

Best For: ServiceNow teams that already own Integration Hub and have flow designers available. For the trade-offs of native connectors in general, read our native integration guide.

ServiceNow also ships a narrower Jira connector for Agile Development 2.0, limited to Jira Cloud. Use case 2 above covers it.

Jira Service Management’s ServiceNow Integration (Alerts)

Atlassian’s own integration links ServiceNow to JSM’s alerting features, not to Jira work items. When an incident is created in ServiceNow, an alert is created in JSM, and resolving the incident closes the alert. JSM then notifies whoever is on call.

Use it for on-call alerting. It doesn’t sync tickets, comments, or custom fields, and Atlassian doesn’t support multiple ServiceNow integrations for different JSM teams without code changes. Bidirectional integrations also aren’t available on JSM’s Free and Standard plans.

Custom Code Development

Many ServiceNow teams start by building. Larger ServiceNow teams sometimes have their own integration framework and weigh whether to extend it to Jira. In-house builds also tend to start narrow, for example covering only problem tasks and catalog tasks in one direction. When a team later asks for incident-level visibility, the build can’t give it without more development.

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

• Full customization capability
• No licensing fees (initially)
• Development time for every record type, field, and direction you add
• Ongoing maintenance as both APIs change
• Knowledge sits with the people who built it
• 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

Teams that start with a custom build often move to a third-party tool once the maintenance load grows.

Many third-party tools for Jira and ServiceNow are no-code and template-based. They work for simple use cases but struggle with conditional routing, custom tables, and cross-company setups.

Compare them on deployment model, which records and fields they support, who controls the configuration on each side, and how pricing works.

What to Consider When Choosing an Integration Solution

The approach you pick decides who maintains the integration, how much context survives an escalation, and what happens when you add the next team. Check these capabilities before you commit, or use our guide to evaluating integration tools.

Security

Your integration handles sensitive operational data like incident details, customer information, SLA commitments, and internal work notes.

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, Basic Auth, API keys, Personal Access Tokens (no shared credentials)
• Audit trails: Complete logs of configuration changes and data transfers for compliance
• Data filtering: the ability to strip fields like PHI or personal data before the payload leaves your system, not after it lands

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. Exalate’s security and architecture whitepaper explains its own approach.

Real-Time Synchronization

Delays between systems create confusion. If a ServiceNow incident shows “In Progress” while Jira shows “Resolved,” which is correct? Real-time sync removes 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.

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 support conditional logic and advanced data mappings by default. The solution must also support historical data exchange or legacy system integration.

Ask specifically how it handles users who don’t exist on the other side. A common example: a team needs ServiceNow’s “Requested For” person set as the Jira Reporter when that person has a Jira account, and saved in a custom Caller field when they don’t. Without that fallback, agents keep going back to ServiceNow to find out who raised the ticket.

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 usually requires developers who understand both platforms’ APIs, data models, and scripting languages. AI assistants like Aida cut part of that work.

What to look for:

• Natural language script generation: Describe what you want (“sync all high-priority incidents to Jira 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: Admins who aren’t Groovy developers can write and fix sync rules, and troubleshooting goes faster when errors come with a plain explanation.

Scalability

You might start with one Jira project syncing to one ServiceNow assignment group. A few months later, you need five Jira instances connected to ServiceNow, plus Azure DevOps and Salesforce 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 platform that scales from the start avoids this.

Reliability

Downtime hurts. Look for a built-in retry mechanism that doesn’t need manual intervention. The two-way synchronization should also resume from the point of interruption, so no data is 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.

Change History and Access Control

Integrations get edited by several people and change owners over time. Look for two features that keep that safe:

• Change history: Exalate’s Activities tab logs every change to a connection, such as published script versions, edited triggers, added collaborators, and sync actions, with who made each one and when. The log is read-only, kept for 90 days, and exportable for audits, so a new owner can see what changed before they took over.
• Delegated authentication: the person setting up a connection doesn’t need credentials for both systems. They can delegate authentication to whoever holds them, such as the ServiceNow admin, and the connection stays in draft until that person authenticates their side. Nobody shares passwords to get the integration running.

Cost & Pricing Model

Integration pricing varies widely. 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 Jira 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 (Jira ↔ 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.

Look for transparency in pricing. You should be able to estimate costs before committing. An ROI calculator helps quantify benefits (time saved, errors reduced) against costs.

Budget owners will ask what the manual process costs today. Before you request budget, count how many records cross between the teams each week and how long each handoff takes. Without that number, a budget request can’t show a return.

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

Who Should Be Part of the Evaluation

Jira ServiceNow integrations rarely have one buyer. Plan for these people early:

The security review usually runs as a separate step after the technical evaluation, so send the documentation early.

Why Use Exalate to Integrate Jira and ServiceNow

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

• Script-based engine: Groovy scripting for any custom Jira ServiceNow workflow
• Side-by-side view: Manage all integrations and connections from one interface. Form 2-tier or multi-tier Jira 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 publish creates a new version you can roll back to. You can also work on drafts without touching production data.
• Activities: A read-only log of changes on each connection, such as published script versions, edited triggers, added collaborators, and forced unlinks. Each entry names who made the change and when, and both sides of a cross-company connection see the same history.
• Real-time sync: Complete queue visibility and work item or incident history
• Security-first: ISO 27001 certified, RBAC, encryption at rest and in transit. Visit Exalate Trust Center.
• Any ServiceNow table: incidents, RITMs, catalog tasks, change requests, problems, customer cases, Agile Development 2.0 records, and custom tables
• Supported Integrations: Jira, Jira Service Management, Jira Product Discovery, 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, so costs scale with actual usage, not team size. You pay once per integration pair (Jira ServiceNow, in this case), not once per system, and you can create as many connections and users as you want within it. The cost per item decreases as items under sync increase.
• Sync panel: Exalate also offers a Chrome extension, Sync Panel, for checking sync status, catching errors, kicking off manual syncs, and unlinking sync pairs from the browser without ever opening the console.

View pricing details → | Exalate Plan Calculator

Bring 3 real ServiceNow records to a demo (an incident, a catalog task, and a change request), and the team maps them to your Jira projects live.

Before You Start: Jira ServiceNow Implementation Checklist

Most setup problems trace back to a decision nobody made before the first sync. Settle these first:

1. Scope the record types. List which ServiceNow tables cross (incidents, RITMs, catalog tasks, changes, problems, agile records) and what each becomes in Jira.
2. Decide the routing. Map assignment groups (or agile groups) to Jira projects. Group them into a few connections instead of one per project.
3. Set field ownership and conflict resolution. For each synced field, decide which side wins when both teams edit it at the same time.
4. Map statuses and priorities. Write the status table for each Jira workflow, since different teams often use different ones.
5. Plan user mapping. Decide what happens when the requester or assignee doesn’t exist on the other side, and use a service account for defaults.
6. Filter sensitive data. Strip fields like PHI or internal notes in the outgoing rules, before data leaves the system.
7. Test with real records. Run a few existing incidents through a test run and compare both sides field by field.
8. Pilot with one team. Start with one assignment group and one Jira project, then add teams once the mappings hold.

Matching historical records is a separate step. If you have open ServiceNow records that already have Jira counterparts, link them before you turn on triggers so they don’t get duplicated.

How to Integrate Jira and ServiceNow: A Step-by-Step Guide

This tutorial demonstrates how to integrate Jira 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.

If you’re a video person, we also have a step-by-step tutorial.

Creating Your First Connection

Once you log in, you can start creating connections between Jira and ServiceNow. You can view all your connections under the “Connections” tab, where you can edit connection settings and view other connection details.

Note: You need an active Exalate account to create a connection. If you don’t have credentials for Jira or ServiceNow, you can delegate authentication to someone who does, and the connection stays in draft until they authenticate their side.

Jira ServiceNow Connection Setup Steps

You can also speed up the process by using Aida – Quick Assist at the top right of the dashboard.

• Click “+ Add connections” > “Create new connection“.
• Enter the name for your first system (System A). You can name either Jira 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.
• For new systems, you’ll need to enter your authentication details. ServiceNow uses Basic authentication and OAuth, and Jira uses OAuth.
• Complete the same setup process for the Jira 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 a Jira project you want to use for synchronization.

Then click “Continue”.

If you’re working with local connections in Jira, syncing work items between different Jira projects (or spaces) within one instance is also possible (see our Jira to Jira integration guide). Then click “Build & continue“

Example: a Jira site like exalate.atlassian.net could hold 2 Jira projects (or spaces) with two related work items. You can sync both work items via local connections in Exalate.

Jira ServiceNow Configuration Options

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

Quick Sync: Publish & Quick Sync

This option allows you to sync one item between Jira 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 key in Jira 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 issues 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 “+ 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 Script” 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 Jira to ServiceNow, the outgoing script will hold the values passed from Jira to ServiceNow.
• Incoming script: The incoming script defines how the values coming from Jira are mapped in ServiceNow.

These scripts will be reversed if the direction changes.

The replica is the message payload. It holds the actual data passed between the synced entities, 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 Jira to ServiceNow), simply remove that script line from the corresponding 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 issues.”
• 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.

TestRun: 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 Jira work items that have a label “dev”, 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 Jira: You can use Jira Query Language (JQL) to specify conditions for work items or sprints.
• For ServiceNow: You can use the advanced search syntax to apply the trigger to incidents, problems, change requests, etc.

Save your changes by publishing them.

Deploy and Monitor

Your first synchronization starts automatically based on the sync rules and triggers you’ve set.

Once it’s live, errors will come up, especially when someone changes a workflow or a field on either side. Exalate gives you 4 ways to catch and fix them.

Troubleshooting with Aida

Aida 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 to view it. 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.

Sync Panel

Exalate also comes with a Chrome extension called Sync Panel that lets users check sync status, spot errors, trigger manual syncs, and unlink sync pairs straight from the browser, without opening the console.

1. Open the Exalate Sync Panel listing in the Chrome Web Store.
2. Click Add to Chrome
3. When prompted, click Add extension to confirm.
4. The Exalate icon appears in your browser toolbar. Pin it for easy access.

Note: The extension works on Chrome. Other browsers are not supported at this time.

It’s useful for two groups: admins who want to keep an eye on sync status without switching tabs and end users who want to confirm that the remote side received their update.

You can access this feature via the browser. But if you want to check the sync queue status or configure your sync, you still need to log in to the Exalate console.

Dashboard

The Dashboard lets you track the number of items under sync over time. You can monitor all the connections you have access to or focus on a specific integration or connection.

1. Log in to the Exalate Console.
2. Select Dashboard from the left menu.

You can also open the Dashboard for a specific connection:

1. Go to the Connections list.
2. Open the Action Menu for the connection.
3. Select View Dashboard.

Dashboard data is displayed as cumulative snapshots and refreshed daily. You can display everything or choose a specific integration or connection to be shown, as well as a time range.

Activities

Once the sync is live, people keep changing it. Someone publishes a new script version, someone else deactivates a trigger, and the priority mapping starts behaving differently.

The Activities tab records each of those changes. Click Activities in the left menu to see all your connections, or open a connection’s three-dot menu to see only its history. Entries appear newest first, grouped by day, and you can filter by connection or time range.

Each entry shows who made the change, what changed, and whether it worked. Nobody can edit or delete an entry, and Exalate keeps them for 90 days.

You can export the log when an auditor asks for change-management evidence. The Jira and ServiceNow teams also get one shared record to check when they disagree about what changed. Activities is available on the Trial, Pro, and Enterprise plans. Read how it works.

Advanced Jira ServiceNow Integration Options Using Exalate

Exalate gives you the flexibility to adapt and adjust your synchronization to handle different kinds of Jira 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 Jira and ServiceNow instances simultaneously. For example, a central ServiceNow environment can integrate with several departmental Jira instances, or multiple vendor-managed ServiceNow instances can link into a single MSP Jira environment.

All of these connections are administered through a unified console, which shows every integration as a network view. Administrators can update several connections at once and apply the same script templates across similar integrations.

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 Jira, 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 Jira field using a Groovy script such as:

def ciField = issue.customFields."Configuration Item"
if (ciField) {
    ciField.value = replica.customKeys.cmdb_ci
}Code language: JavaScript (javascript)

This keeps the same configuration item context on both sides, so developers see which service is affected without opening ServiceNow.

Correlation Fields

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

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

A typical approach uses a script like:

// Store Jira work item key in ServiceNow correlation field
entity.correlation_id = replica.key
entity.u_issue_key = replica.key
entity.correlation_display = issueUrlCode language: JavaScript (javascript)

Users in either system can open the linked item from the other side, which helps with audits, reporting, and troubleshooting.

Epic and Story Time Tracking

ServiceNow incidents can be converted into Jira 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:

// ServiceNow → Jira Epic with time aggregation
def ced = new CollectEpicData(issue.key)
replica.customKeys.totalTimeSpent = ced.storyTotalTimeSpent
replica.customKeys.totalOriginalEstimate = ced.storyTotalOriginalEstimate
replica.customKeys.totalEstimate = ced.storyTotalRemainingEstimateCode language: JavaScript (javascript)

These aggregated values can then be returned to a ServiceNow custom field, so teams on both platforms see the same 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 Jira and ServiceNow to ensure critical incidents are always handled with priority and within their SLAs.

Example: a priority 1 incident comes in, and the support agent identifies it as development work for the team in Jira. If the SLA, time fields, and incident status sync along with it, agents can see progress at any time, and developers know the deadline before they start.

When the work is marked resolved in Jira, 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 Jira, 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 Jira, so the dev team has all the required information handy.

Sync Anything between Jira and ServiceNow

You can also sync different entities or work types between Jira and ServiceNow.

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

Exalate also connects ServiceNow’s Agile Development backlogs, defects, and incidents with Jira, so updates on one side show up on the other without anyone re-entering them. Support agents stay in ServiceNow and keep working tickets instead of switching between systems.

Automate Incident Creation in ServiceNow from Jira Labels

With Exalate, you can create ServiceNow incidents from Jira work items that carry a specific label. Teams with contractual obligations use this so required incidents always exist in ServiceNow, without anyone creating them by hand.

You can also automate change request workflows between ServiceNow and Jira: syncing statuses, updating records, or creating tasks on the other side.

Exalate can also send email notifications when a change completes, and show the change details on the related Jira work item.

Exalate Review for Jira ServiceNow Integration

Watch Deepak’s take on setting up a Jira ServiceNow integration using Exalate. You can set up advanced JQL triggers or automate your sync using ServiceNow’s advanced search syntax. Sync attachments, comments, priorities, and much more. For a written walkthrough, read our Exalate review.

What to Do Next

Start a free trial and configure a working sync without calling sales. Connect both ends, configure your rules with Aida or a Groovy engineer, and records start flowing.

If you’re building the business case first, count how many records cross between your ServiceNow and Jira teams each week, and run that number through the ROI calculator.

Want to see it handle your own records first? Book a demo with an incident, a catalog task, and a change request from your instance, and the Exalate team maps them to your Jira projects with you.

Frequently Asked Questions

Why should I integrate Jira and ServiceNow?

Integrating Jira 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.

Can Jira replace ServiceNow?

For some teams, yes. Jira Service Management covers incident, problem, change, and service request management, and smaller IT teams run their whole service desk on it.

Larger enterprises usually keep ServiceNow because it runs more than the service desk: the CMDB, asset management, HR and facilities workflows, and change governance across the company. In those organizations, the practical question is how to connect the two, so ServiceNow stays the system of record while developers keep working in Jira.

If you do decide to move from ServiceNow to Jira Service Management, or the other way around, Exalate also supports migration. It moves historical data and keeps both systems in sync during the transition, so teams keep working in either tool until you’re ready to cut over. Not sure which fits? Read ServiceNow and Jira: migrate or sync.

What are the key differences between Jira and ServiceNow?

Many companies use both: ServiceNow for intake and IT operations, Jira for building and fixing.

Can Jira be used for ITSM?

Yes. Jira Service Management is Atlassian’s ITSM product. It handles service requests, incidents, problems, changes, and on-call alerting, with a customer portal and SLA tracking.

Teams that already use Jira for development often pick it because the service desk and the engineering backlog live in the same platform. Teams that also run ServiceNow can sync JSM with it, so each side keeps its own tool.

Does ServiceNow have projects like Jira?

Only in some modules. Strategic Portfolio Management has projects and project tasks, and Agile Development 2.0 has agile groups with epics and stories. Incidents, catalog tasks, and change requests have no project. They’re owned by assignment groups, which is what most integrations use to decide which Jira project a record goes to.

What is the ServiceNow Jira Spoke?

The Jira Spoke is ServiceNow’s Integration Hub connector for Jira. It gives Flow Designer actions to create and update Jira work items, users, and groups, and it can subscribe to Jira webhooks so Jira events start flows in ServiceNow. Your ServiceNow team builds and maintains the flows for each direction.

What’s the difference between Exalate and ServiceNow Integration Hub?

Integration Hub is ServiceNow’s native integration platform. With the Jira Spoke:

• Control sits on the ServiceNow side; the Jira team doesn’t configure anything
• You pay for an Integration Hub subscription on top of ServiceNow
• Two-way sync means building and maintaining flows for each direction
• It works best for simple, one-way 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 TestRun for safe deployment

You can read the detailed comparison between Exalate and Integration Hub here.

Can I connect multiple Jira and ServiceNow instances?

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

Connect:

• Multiple Jira instances to one ServiceNow
• One Jira instance to multiple ServiceNow instances
• Complex mesh networks across departments or MSP client environments

All managed from a single unified console with network visualization.

What fields can I sync between Jira and ServiceNow?

Any field accessible via REST API:

Standard Fields: Work items, comments, attachments, status, priority, assignee, description

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

ServiceNow: Any table (Incident, Change Request, Problem, RITM, Catalog Task, Customer Case, Agile Development 2.0 stories and defects, etc.)

Jira: Jira Software, Service Management (Cloud, Data Center)

View the detailed documentation for fields supported here.

Can I sync work items bidirectionally in real-time?

Yes. Exalate syncs both ways in near real time. When a work item updates in Jira, the change is queued and applied in ServiceNow shortly after (and vice versa).

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

Use platform-native triggers for granular control:

Jira: JQL (Jira Query Language) Example: project = SUPPORT AND priority in (High, Highest)

ServiceNow: Filter queries Example: assignment_group=IT Operations^priority<=2

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

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

Yes. Exalate’s Groovy scripting engine supports any transformation:

• Map ServiceNow “Critical” to Jira “High”
• 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:

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

Scripts give you granular control over what crosses system boundaries.

Can I see who changed my Jira ServiceNow sync configuration?

Yes. The Activities tab in Exalate logs script and trigger changes, user and invitation changes, and sync actions like bulk sync or force unlink. Each entry shows who did it and when.

The log is read-only, kept for 90 days, and can be exported for audits. Owners and collaborators on the connection see the same entries. View the Activities documentation.

How does Exalate pricing work?

Exalate offers a 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 →

→ Start Free Trial

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 Jira instances. Clients work in their tools, you manage from the unified console.

Features for MSPs:

• Delegated authentication: each client authenticates their own Jira, so nobody shares credentials during setup
• Single-stop integration visualization of all client connections
• Bulk operations across connections

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

New 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 new connector development →

Ready to Connect Jira and ServiceNow?

With Exalate, you get:

• Unified visibility: A single place to view and manage all your integrations
• Safe deployment: TestRun validates before production, and script versioning enables rollback
• Change history: Activities shows who edited a connection and when
• Outcome-based pricing: Pay for active sync pairs, not user seats

Start a free trial or book a demo.

Recommended Reads:

• ServiceNow to ServiceNow Integration: The Step-by-Step Guide to Setting up a Two-Way Sync
• How to set up a Jira Salesforce Integration
• How to Set Up an Azure DevOps ServiceNow Integration
• Jira ServiceNow integration connector
• How to Integrate Jira and ServiceNow: 14 Real-World Enterprise ITSM Use Cases
• 10 Best Tools for Jira to ServiceNow Integration
• ServiceNow and Jira: Migrate or Sync? How to Decide
• How to Know If Your ServiceNow ITSM Setup Is Working