How to Set up a ServiceNow Jira Integration: the Comprehensive 2023 Guide

stefaan@idalko.comUncategorized

Jira ServiceNow integration

As companies grow, the need to integrate data between different platforms becomes more inevitable. For instance, if you’re working in ServiceNow and you have a partner or a client who uses Jira, then a ServiceNow Jira integration seems to be the best solution for seamless collaboration.

So in this guide, we will discuss the need to integrate ServiceNow Incidents with Jira Issues. (Note that this process can also be applied to other entities like Problems, Cases, Change Requests, etc.) We will cover why you would set up a ServiceNow Jira integration in the first place, and how to choose the right technology to configure the integration. Then, we will cover the step-by-step process of how to set it up.

Note: In this tutorial, we will be using an integration solution called Exalate to set up the integration. You will learn more about this, as well as other integration options, throughout this guide.

Here is an overview of what we will cover:

ServiceNow Jira Integration Guide

Learn how to achieve a seamless Jira ServiceNow integration, step-by-step.

Why Integrate ServiceNow with Jira

Thinking of IT Service Management, ServiceNow has become a mainstream choice for CIOs & the head of IT departments to consider. Started as an innovative niche cloud platform to manage ITSM processes based on ITIL best practices, ServiceNow has gained enormous traction in recent years. They currently have more than 20.000 customers worldwide and are growing rapidly.

On the other hand, when thinking of Agile Software development, Jira springs to mind immediately. As part of the Atlassian product offering, Jira manages issues and projects for Software teams. And it integrates nicely with other software development tools of Atlassian.

In short, for many software teams, Jira is the natural choice for issue/project management. This is especially true when other Atlassian products are used for software development too. With the above positioning of ServiceNow and Jira in the IT Service Management and software development space in mind, the need for integration becomes obvious.

 Information exchanged with such an integration can bring visibility and transparency within teams and help everyone be on the same page. 

Common Use Cases for a Jira ServiceNow Integration

Here I’ve summed up 2 possible scenarios for a Jira ServiceNow integration: 

  1. A company’s IT department uses ServiceNow to provide users with a One-Stop-Shop portal for all IT services. This includes reporting issues on software. In-house Software teams use Jira to manage issues/projects. They generally prefer the Atlassian suite because it is used for Coding/Collaboration.

    * Incidents reported by a user on ServiceNow need to be forwarded to Jira as an issue to be solved by the development team.

    * When the development team encounters infrastructure issues, they need to be forwarded to ServiceNow as an Incident

  2. A company uses ServiceNow for ITSM and one or several software packages are provided by an external software vendor. The software vendor tracks issues on the software from all customers with Jira. Then the incident in ServiceNow needs to create an issue on Jira and get status updates.

How to Choose the Right Technology for Setting up your Integration

When designing an integration between 2 platforms, three aspects always need to be considered:

  • Decentralized Integration (Autonomy): The platforms at each end of the integration have the means to independently control what information is sent to the other side and how incoming information is interpreted. Changes in the platforms, like modifying the information to be exchanged, shouldn’t break the integration. Rather they should be easily reflected in the integration.
  • Reliability: A reliable integration is one that always works for the user – even when the other side is not available for whatever reason (such as maintenance). Operational maintenance capability is important to ensure always-on integration.
  • Flexibility in the configuration: The integration is able to bridge the differences between the two systems. To be able to effectively attribute mapping is the first mandatory step. Having the flexibility to align the process differences between the teams/organizations.  

For this guide, we’ll set up the integration using Exalate. Precisely because Exalate was built to fulfill the above requirements. And it meets the criteria for the described ServiceNow Jira integration scenarios.

In the chapters below I will show you how Exalate addresses the above aspects in more detail. But first, let’s go through the step-by-step process of how to set up the integration!

How to Set up a ServiceNow Jira Integration (a Step-by-Step Process)

We’ll get to the step-by-step process of the ServiceNow Jira integration, but if you don’t like reading, you can go ahead and watch this tutorial instead.

Note: You can also refer to the Getting started guide on Exalate documentation for a step-by-step process of setting up a ServiceNow Jira integration. 

Step 1: Install the Exalate app on your ServiceNow Instance

To install Exalate on your ServiceNow instance, you’ll have to use an “update set”.

You can find the step-by-step instructions for the Exalate agent installation for ServiceNow on the following Exalatedocumentation page: Installing the Exalate app on your ServiceNow instance

or you can watch how to install Exalate on ServiceNow

Step 2: Install the Exalate app on your Jira Instance

In order for Exalate to work, it needs to be installed on both sides of the integration. This means you’ll also have to install Exalate on Jira. This will be a straightforward process like installing a Jira app.

You can find the step-by-step instructions for installing the Exalate agent on your Jira instance here:

Step 3: Have a Quick Look at the Exalate Console

The Exalate console provides a user interface for system administrators to configure & maintain the integration. After installing, the Exalate console should be directly accessible as an Application on the ServiceNow instance:

exalate console in ServiceNow

                   Exalate console  On the Jira side, similar configuration options are provided as an Application as well:

exalate console for jira servicenow integration With the Exalate console you can, on the one hand, create/maintain your configuration. On the other hand, you can also view Sync Queues and check/resolve errors. These capabilities will help to maintain the integration efficiently.

But, let’s move on to setting up a connection between your Jira and ServiceNow instance.

Step 4: Establish a Connection between Jira and ServiceNow

Once the Exalate agent is installed on both ServiceNow and Jira, you need to set up connections between the two Exalate agents. Either side can initiate the Connection or else accept the Connection invitation from the other side.

Below you have step-by-step instructions to set up the connection between the 2 systems:

But here’s a recap of what it boils down to. You’ll first have to “Initiate connection” in the Connections tab in the Exalate console.

initiate a jira servicenow sync

If there are connections that already exist, they will be displayed in the Connections tab. 

You will then be prompted to enter the URL of the destination instance. Assuming we have initiated the connection from the ServiceNow side, the destination URL will be that of Jira.

Configuration modes for integrationExalate then performs a quick check to see if it is installed on the Jira side. If yes, then more fields appear. Next, you have to select the configuration mode for your connection.

Exalate supports 2 configuration modes: Basic and Script.

The Basic mode allows you to establish a connection with pre-existing sync rules. These cannot be configured or changed. It is suitable for simple integration use cases. You can only sync issues and incidents with this mode. Exalate offers a Free Plan so that you can experience it firsthand. The Free plan only supports the Basic mode.

To use the full functionality of Exalate with advanced features and configurations, we recommend that you use the Script mode. You can configure it to suit your unique integration case. You can even upgrade from the Free Plan to the Premium Plan in Jira and in ServiceNow anytime you want!

Let’s now have a look at both the Basic and the Script mode one by one.

Continue with the Basic Mode

Click “Next” when you select “Basic” on the screen above. You will be required to verify admin access to the destination side, Jira in our case. Click “Yes, I have admin access” since we have access already, and click “Initiate”.

If you don’t have access, an invitation code will be generated. You need to manually copy and paste it on the destination side to establish a connection.

Verification for Jira ServiceNow basic integrationExalate then performs a quick check to verify the access. Once the verification is successful, it will automatically redirect you to the destination side (Jira). Here select the project on the Jira side that you want the Incidents to synchronize into. After selecting the appropriate one from the drop-down list, click “Confirm”.

Select the project for Jira ServiceNow syncEnter the issue key to start your first synchronization.

jira issue key in Exalate If you navigate to the ServiceNow side right now, you will be asked to enter the Incident number for synchronization. In either case, press the “Exalate” button. Wait for some time for successful synchronization.

Jira ServiceNow integrationYou can go to the synchronized Issue or Incident by clicking the respective links shown in the image above. Appropriate status messages will be displayed till the synchronization happens.

The Basic mode connection just created can be viewed in the “Connections” tab. If you click the edit connection icon in front of its name, you can see the default mappings. You can choose to upgrade the connection if you want.

Exalate basic mode mapping Connections created using the Basic mode are simple and you can sync issues or incidents as shown above. You can even create triggers to start automatic synchronization or choose to sync in bulk using the “Bulk Connect” option. Let us now have a look at the Script mode.

Continue with the Script Mode

In this mode, one side sends an invitation code and the other side accepts it. Let us see how it works.

1. Send an invitation code

We are sending an invitation from the ServiceNow side and accepting it on the Jira side. For this, choose “Script” on the screen shown below and click “Next”.

Exalate Script modeEnter the connection details. For this, provide the local instance name (ServiceNow in our case) and also the remote instance name (Jira). Exalate automatically generates a name for you, but you can change it if you want to. Don’t forget to add a description to the connection. This will help you identify the connection when you have a lot of them. Click “Initiate” when you are ready.

sync Jira and ServiceNowThis will generate an invitation code. You’ll have to copy this so the other side (Jira) can accept the invitation.

Invitation code for integration

2. Accept the invitation code

That code you’ve just generated is what you will use to accept the invitation on the other side. So, move over to your Jira instance or by navigating to “Connections” in the Exalate console in Jira and clicking “Accept Invitation”.

Go ahead and paste the code there:

Exalate invitation code The code will validate automatically once you’ve clicked Next. Your connection type will be set automatically based on the invitation. Choose the project on the Jira side, just like you did for the Basic mode. Click “Confirm” after choosing.

Select integration projectYou’ll be able to configure the sync rules for each side separately, from the other side. This has been done on purpose, so each side will remain autonomous.

successful Jira ServiceNow syncYou can choose to configure it immediately by clicking on “Configure Sync” or you can configure this later in Step 6.

After you’ve accepted the invitation and a connection has been established, we can move on to setting up a rule that will trigger the synchronization.

Step 5: Configure your Synchronization Triggers to Determine When to Sync

Once a connection between ServiceNow and Jira is established, the main work of integration can start.

How to Create Automated Synchronization Triggers

At this stage, close cooperation between the Incident/Issue manager is needed to determine when an Incident on the ServiceNow side needs to create an issue on the Jira side or vice versa. The agreement can be defined on ServiceNow Exalate and Jira Exalate independently, allowing all possible scenarios.

However, it’s also possible that you’re an admin on both sides.

To create triggers, click the “Triggers” tab in the left-hand Exalate console. If there are any existing triggers, they will be listed here, but the first time you use them, they will be blank.

Note: You can also create Triggers by clicking on the “Configure Sync” button when the connection is established and choosing the Triggers tab.

Click the “Create trigger” button to get started. On the “Add trigger” pop-up that appears, there are several fields you can interact with. The entities you want to apply triggers to can also be selected now.

The entity selection will differ from platform to platform. You can then set the conditions that cause the trigger to activate. In Jira, triggers are written using the JQL query language. You can read more about that here. ServiceNow search syntax is used for the ServiceNow side.

Click the “Active” button to activate the trigger and then click “Add”.

Note: Incidents, Problems, ChangeRequests, RITM, Cases, and CatalogTasks are the popular ServiceNow entities that are synced with Exalate. But you can sync any entity in ServiceNow using Exalate’s intuitive scripting engine. 

Set up your First Trigger

If the process managers have determined that whenever an Incident is assigned to an Assignment group called Application Development, an issue needs to be created on the Jira side.

The Trigger defined in Exalate ServiceNow looks like the following:

exalate trigger on ServiceNowIf, at the same time, they also agree that whenever an Issue in Jira has a label equal to ServiceNow, it will create an Incident in ServiceNow for teams on ServiceNow to solve.

The Trigger defined in Exalate Jira looks like the following:

Exalate trigger in Jira

Step 6: Configure your Connection to Determine the Information to Send

Once an Incident on ServiceNow fulfills the conditions defined by the Trigger, the ServiceNow Exalate will receive access to the Incident through the REST API. The same applies to Jira issues that fulfill the condition defined by the Trigger as well.

Configure the outgoing sync

What information is sent to the Jira Exalate is defined in the Connection Sync Rules -> “Outgoing sync”.

Note: The same Outgoing sync on the Jira side will determine what information is sent to ServiceNow.

Here’s what it looks like:

Jira ServiceNow sync rules

  • replica.<attributes> represents the message attributes. In our case, it represents Jira Exalate.
  • entity.<attribute> represents the local record attributes. In our case, it represents Servicenow Incidents.

The above example is an out-of-box, straightforward mapping. However, more complex mapping can be defined using Groovy scripts.

Exalate provides a number of Script Helpers to reduce the effort to script yourself.

Configure the Incoming Sync

The incoming sync will determine how to interpret the information received. The rules for interpreting the incoming data are configured in the Connection Sync Rules as well.

On the ServiceNow Exalate’s “incoming sync”, there is a distinction for when an Incident is created or updated. In the example shown below, an incident will be created if it’s the first sync. Otherwise, details like summary, description, attachments, and comments of an Incident already present will be updated.

Note: The Incoming sync on the Jira side represents how to interpret information received from the ServiceNow side.

Configure jira servicenow incoming sync Just like with outgoing sync rules, more complex mappings can be scripted. Below is an example of mapping the ServiceNow Incident States with the Jira Issue Status. (Again Exalate Script Helpers can help reduce the scripting effort.)

Example Jira Servicenow Integration

Additional Information on Exalate as an Integration Solution

Since we used Exalate to set up the Jira ServiceNow integration, you might have some questions about this solution. Here I’ll explain a bit more about Exalate’s architecture and security.

On Autonomy in Architecture (Decentralized Integration)

The basic architectural setup of Exalate as an integration enabler between two systems is depicted below:

Exalate Architecture for Jira ServiceNow integrationIn our scenario Tracker (Blue) would be your ServiceNow instance, and Tracker (Red) would be the Jira Server or Cloud instance. Tracker(Blue) and Tracker(Red) have a separate Exalate Agent dedicated to your ServiceNow/Jira.

  • Letters A -F depicts the information flow between the systems. ServiceNow and Jira communicate with each other through the dedicated Exalate agent, keeping the autonomy of your system
  • Your (ServiceNow connected) Exalate Agent controls what information is sent and how incoming information is mapped.
  • Exalate agent is available for ServiceNow instance, Jira Cloud, Jira On-Premise, Salesforce, HP ALM/QC, Github, Zendesk, and more to come

On Security

Exalate is an intelligent middleware that transports data between ServiceNow & Jira. The Security consideration is described in great detail in the following whitepaper, free for download: “Exalate Security and Architecture Whitepaper”. The below image explains the different deployment models Exalate is supporting. Exalate for ServiceNow can be deployed either in the cloud or on-premise.

Integration deployment models Jira and ServiceNow

Comparison between Exalate and the IntegrationHub with the Jira Spoke

ServiceNow itself has a capability called IntegrationHub that allows reusable integrations with third-party systems and calls them from anywhere in the ServiceNow platform.

Using IntegrationHub requires you to get a separate subscription. The Standard package of IntegrationHub includes a Jira Spoke with a (limited) number of Actions that allow ServiceNow to manage issues, users, stories, and groups in Jira. And it retrieves Jira data to use in a flow. Jira spoke V3.0.5 uses bi-directional webhooks and subscribes to Jira with a ServiceNow callback URL.

Note: You can also have a look at a detailed comparison between IntegrationHub and Exalate

So, why use a third-party tool, like Exalate, to set up the integration? Below I’ve added some considerations:

  1. Use Exalate when
    • The integration is bi-directional. Then both sides will be able to trigger the integration and decide on the information to be exchanged.
    • The integration is point-to-point between the 2 systems. 
  2. Use IntegrationHub when
    • ServiceNow has the orchestration role to create an automated flow, involving several systems.
    • ServiceNow controls the trigger of integration, remote system (in our case Jira) is the receiver of the commands

Conclusion

Many ITSM teams adopt ServiceNow as a best-in-class solution. While development and project management teams still widely consider Jira as the ideal solution. As efficient collaboration is crucial for any effective organization, integrations between these systems are increasingly common. 

When considering the right technology to set up the integration, it’s important to keep into account the following three aspects:

  • Does each side have autonomy over outgoing and incoming information and how it is interpreted?
  • Is the solution reliable enough to continue working, independently from changes to the other side of the integration?
  • Is the solution flexible enough to cover a wide variety of use cases and evolve with your way of working?

In this guide, we set up the integration using Exalate. And we described the step-by-step process of how to complete this integration.

Recommended reads: