The Ultimate Guide to ServiceNow GitHub Integration For Independent Teams in 2024

ServiceNow GitHub integration

If you use platforms like ServiceNow and GitHub to organize your teams, you may want to consider a ServiceNow GitHub integration at some point along the way. 

Connecting these two platforms means easier and more accurate data sharing, especially with automated connectors.

Automatically filtering and sorting the many issues and tickets you use sounds like a difficult challenge. The right integration solution can make it much easier. 

So in this article, I’ll show you how to set up a ServiceNow integration with GitHub with the least fuss possible.

Here’s what we’re going to cover in this blog post:

Why Integrate ServiceNow and GitHub

ServiceNow is a workflow platform that handles everything from service management to help desk support. 

With a focus on large teams and organizations, ServiceNow provides the right tools for tracking large amounts of information and handling complex business relationships.

On the other hand, GitHub is a code storage platform that enables developers to handle version control and code distribution easily.

GitHub supports open-source projects and is a great way to build a community of coders working together to help improve products.

Since both platforms are vital to operations, integrating them can help teams share data and manage workflows collectively without jeopardizing either side’s autonomy or security.

Choosing the Right ServiceNow GitHub Integration

Your teams need a solution that is reliable enough to handle outages and errors, flexible enough to adapt to their changing needs, and customizable enough to allow them to choose how to share information with the other side. 

The tool we’ve chosen for this guide is Exalate because it meets the above criteria above. It also allows you to sync the following entities:

  • Assignee
  • Reporter
  • Summary
  • Description
  • Labels
  • Comments
  • Attachments
  • Priority
  • ParentId
  • Resolution
  • Status
  • Projects (versions and components).

Let’s see how to use it in practice.

How to Set up a ServiceNow GitHub Integration in Six Steps 

Step 1 – Install Exalate on ServiceNow

You can install Exalate on your ServiceNow instance with Docker, or you can reach out to Exalate to set up a separate node for you. I’ll use the second option in this tutorial.

To learn more about both options, take a look at this documentation.

Click below to request a free trial for ServiceNow GitHub integration.

Follow the steps, enter your details, and click “Submit”.

The Exalate team will reach out to you to help you with the next steps.

You also need to create a ServiceNow account with the appropriate permissions.

Once you’ve created the right user accounts, go to your Exalate node and click “general settings”. Put in the URL of your ServiceNow instance, along with the username and password of your proxy user.

Now you should be able to access the Exalate console. You’ll need to use an account with administrator permissions to do so.

Step 2 – Install Exalate on GitHub

To install Exalate on GitHub, you should first request your free trial.

Note: Exalate is also available for GitHub Enterprise. For installing Exalate on GitHub Enterprise Cloud, check this article.

Once you’re set, Exalate needs access to your projects, and you can choose whether to give it access to specific repositories or to all of them. The system needs both read and write access to issues and pull requests.

If you are happy with that, click the green “Install” button.

Now, Exalate will automatically create a node for you. The system will redirect you to it, and you will have to enter your details. After that, click the “Agree and submit” button.

verify exalate instance for ServiceNow GitHub integration

You’ll get a confirmation email in your intray. Click the button in the email to verify your account. Then, click continue.

exalate for github access token

Next, you need to create an access token for use in Exalate. To do that, go back to GitHub. Open the top-right menu and click “settings”. On the next screen, look at the menu on the left and click “Developer settings”.

Then on the next screen, click “Personal access tokens”.

personal access token for ServiceNow GitHub integration

Click the “Generate new token” button toward the top right. A detailed set of options will appear. You can optionally add a note to help remind you what your token is for later. 

create an exalate access token

The only option you need to select is “repo”, which should also automatically select all the other tick boxes in its group. 

After that, click the green button at the bottom to generate the token. Copy the token and stash it somewhere safe because you’ll need it every time you log in.

Next, go back to the Exalate node page and paste it into the “Token” box. Click the login button and if all goes well, the system should take you to the main Exalate menu.

All right! You now have Exalate on both sides, so let’s set up the connection.

Step 3 – Connect Your ServiceNow and GitHub Instances

Exalate allows you to initiate the connection from ServiceNow or GitHub. For this guide, I’ll initiate the connection from GitHub and then accept it in ServiceNow. Exalate uses a common interface across platforms, so the process is much the same either way.

Exalate connections screen

In your GitHub node, go to the Exalate menu and click “Connections”.

Click “Initiate connection”.

initiate connection between github and servicenow

Next, enter the destination URL, i.e., the ServiceNow URL. After checking if Exalate is on the destination side, you will need to choose the configuration type. 

Exalate comes in 2 configuration modes: the Basic mode and the Script mode.

  • The Basic mode already has GitHub and ServiceNow entities mapped with each other. You get up to 1000 free syncs per month.
  • The Script mode allows you to control what information to send or receive with the help of sync rules. It works best for complex and advanced integration use cases.

Let us see how they both work.

Connections With The Basic Mode

To continue using the Basic mode, click “Basic” on the screen shown above and then hit “Next”.

Select repository in Github for syncing

Proceed to select the repository on the GitHub side. This will be the repository in which Incidents from ServiceNow will be synced. Select the one you want from the drop-down list and click “Next”.

Note: By default, the Basic Mode supports syncing the summary, description, comments, attachments, and issue types.

Service now connects with Github

You then need to verify if you have admin access to the destination instance, i.e., ServiceNow in our case. Proceed with the verification by clicking “Yes, I have admin access.” Then click “Initiate”.

In case you don’t have access, you will be required to copy an invitation code on the GitHub side and manually paste it on the ServiceNow side. We will see how to do this in detail in the Script mode. 

Incident from ServiceNow to sync

After verification, you will be redirected to the ServiceNow instance. Here, you need to enter the incident number you want to synchronize on the GitHub side. 

Clicking “Exalate” creates a new GitHub issue and syncs information with the ServiceNow incident. A similar screen on the GitHub side will require you to give an issue key. Follow the same procedure to set up your connection.

incident synchronized between Github and ServiceNow

You can create automatic synchronization triggers for syncing issues and incidents, or you can sync existing entities using the “Bulk Connect” option.

Connections With The Script Mode

To continue with this mode, click “Next” when you select “Script”.

enter connection name

You then need to enter a name for your local instance (ServiceNow in this case), and the destination instance (GitHub). Add a description for the connection.

When you’re ready, click “Next”.

Exalate will now generate a code that you should copy and paste into ServiceNow to complete the connection. Click the “Copy invitation code” button, and paste the code somewhere safe. 

Then open ServiceNow. You can do this by clicking “Go to remote”, or you can navigate there directly. If you’re using your own instance, you can find the Exalate console by typing “Exalate” into the search field above the left-hand menu.

In the Exalate console, click “Connections”. Then click the “Accept invitation” button.

Paste the invitation code in ServiceNow

You’ll see a large text field. Paste the invitation code you got from GitHub here and click “Next”.

Then select the target GitHub repo and click “Confirm”.

Click through the next confirmation screen and the connection will be established.

sync mode connection successful

Now you’ve set up your connection. If you click the “Configure Sync” button, the system will take you straight to the “Edit connection” screen.

Step 4 – Configure Your Connection

To edit a connection, find its listing in the connections screen. You’ll see four icons on the right. Click the furthest left to edit your connection.

You’ll now see a screen with four tabbed areas. These are “Rules”, “Triggers”, “Statistics” and “Info”. For now, make sure you select “Rules” and have a look at the boxes below.

Github servicenow sync rules

You’ll see two large text fields containing outgoing and incoming sync rules for controlling the connection.

Let’s take a closer look at the outgoing sync section. The rules here copy items from the issue to the replica that will go over to the other side. If you don’t want all the information sent over, you can comment or delete any line you like. 

Commenting by adding two slashes (//) at the start of the line helps you enable and disable items quickly. That’s useful if you want to restrict the information you send out, and then add it back later.

By default, the mappings use the same suffix for every item, so replica.assignee is mapped to issue.assignee

You could map the GitHub assignee to a label in ServiceNow by removing the assignee line and changing the label line to read: replica.label = issue.assignee.

Also, you can use specific values. For example, changing that line to replica.label = “from GitHub” would add that label to synced ServiceNow items. That way, your team can see which items came from the synchronization.

After configuring the mappings, click “Publish” at the top right to save your changes. Don’t forget to check with both of your teams to make sure items are being exchanged correctly.

To read more about sync rules, check out this documentation.

Step 5 – Set Up Automated Synchronization Triggers

Synchronization triggers define the conditions for information exchange and also control the syncs. 

You can edit triggers from the “Edit connection” screen used in the previous step, or you can click the “Triggers” tab. 

Snow Github triggers

The triggers screen shows your existing triggers but is blank the first time you look at them. To start, click the “Create trigger” button on the right.

add trigger to your sync

At the top is a dropdown box to select what type of entity the trigger applies to. Next, in the “If” section, you write a query that picks out the issues you want to synchronize. You can read more about the query syntax here

On the ServiceNow side, you can use the ServiceNow search syntax to specify the filter query.

There’s a space to leave notes describing the purpose of these triggers. 

Toggle the “Active?” switch to activate the trigger. When you’ve finished, click the “Add” button.

Step 6 – Start Synchronizing Tasks

Now that you’ve set everything up, all you have to do is wait for Exalate to synchronize your items. If it doesn’t start straight away, don’t panic! 

For performance reasons, Exalate doesn’t check continually. So go grab yourself a copy while Exalate does its magic. 
Self-starters can also use AIDA, the Exalate virtual assistant, to set up and troubleshoot connections without waiting for engineers.

Common Use Cases 

There are many scenarios where you might want to integrate ServiceNow and GitHub. Here are some examples.

Connecting Developers and Support Team

The right ServiceNow GitHub integration can automatically filter issues from the support team and copy them into the developers’ issue tracking system on GitHub. 

When the developers resolve the issue, the integration passes the updates back to ServiceNow, alerting the support team to inform the customer that the issue has been resolved.

Merging Product Development and Quality Control

Implementing ServiceNow integration with GitHub allows teams to see information that is relevant to them and provide further feedback if needed.

If the quality control team is tracking their work in ServiceNow, they can monitor how the issues they raise are implemented in GitHub. 

Uniting the Efforts of Project Managers and Sales Reps

Project managers (and product managers) can rely on GitHub ServiceNow integration to monitor the progress of products and features.

At the same time, sales reps can combine data from both platforms to understand the financial impact of outages and other performance metrics.

Connecting Managed Services Providers With Clients

Managed services providers (MSPs and MSSPs) can use GitHub integration with ServiceNow to connect with clients. This type of cross-company collaboration is coming in outsourcing.

For instance, an MSP providing web development services can connect with their client’s ServiceNow to gain access to customer feedback faster.


Integrating software platforms is easy with the right solution. In just a few steps, you can get your teams (and even companies) to share information and work together seamlessly. 

Once the ServiceNow GitHub integration is ready, it can exchange items between your teams without creating extra work for anyone.

Making changes and evolving your integration allows you to control when and how data is shared without worrying that everything will come crashing down.

With a flexible ServiceNow and GitHub integration, your teams can focus on their own tasks in their own familiar environment while enjoying easy and secure collaboration.

Frequently Asked Questions

Can GitHub integrate with ServiceNow?

Zendesk can integrate with ServiceNow using native solutions like IntegrationHub as well as third-party integration tools like Exalate, which are available in the marketplace of both platforms. Dev teams using GitHub can connect with customer support agents working with ServiceNow.

How do I connect GitHub with ServiceNow?

To connect GitHub with ServiceNow, you’ll need to find a third-party integration solution from the marketplace. This solution (Exalate, Skyvia, etc.) fetches data from one platform’s API and sends it across to the other. 

Can I use a no-code tool to integrate GitHub with ServiceNow?

Yes, you can use no-code tools to integrate GitHub with ServiceNow. No-code integration solutions provide you with pre-built connectors, eliminating the need to write lines of code for mapping syncs. Some no-code integration tools include Zapier, Exalate (Basic Mode), and SnapLogic.

Recommended Reads:

Comments are closed.