Jira to Jira Sync: How to Synchronize Multiple Jira Instances in 8 Steps

Jira to Jira

In this post, I will be discussing how to integrate multiple Jira instances and projects by way of synchronization.

Jira is hands down one of the best project management and communication tools out there for development teams.

But when you work with outside teams, whether they be service suppliers, clients, or outsourced teams, your collaborative Jira process can get a little sticky.

Every team has their own workflows and pipelines within Jira. If you’ve ever tried onboarding an outside team onto your Jira project – or vice versa – you know how difficult it can get to manage separate workflows.

However, having two completely separate Jira instances or projects is just as much of a hassle. Information gets lost. Issues get confused for other issues.

And manually syncing issues from project to project is not a scalable solution.

What if you’re working with a large number of teams within Jira?

To have teams work together in a more structured manner, we’ll have to integrate multiple Jira instances or projects.

In this guide, I will explain to you exactly how to achieve a Jira to Jira issue sync, step-by-step.

Note: We will be using the Jira sync tool Exalate for this.

Exalate enables teams to efficiently coordinate their work even when tracked in multiple projects or multiple Jira’s. This two-way sync automatically updates issues on both ends when a change is made.

Use Cases For Jira Issue Sync

Okay, so Jira to Jira sync sounds convenient, but how exactly can it help your project?

Here I’ll dive into a few of the several use cases in which Jira issue sync can come in handy.

Outsourcing Quality Assurance For Developers separated by multiple Jira instances

Many software and game developers outsource quality assurance to third-party teams.

These outsourced quality assurance teams have their own workflows within Jira. Especially since they often have to juggle separate clients with multiple workflow styles.

A QA team needs to constantly share issues and bug reports with the development team. But the QA team doesn’t require access to all of the development team’s task-related issues and other development notes.

The traditional solution would be to have the dev team access both Jira instances or projects at the same time: their own project, plus the QA team’s project. The latter only containing bug reports.

However, constantly needing to keep up with two Jira projects (or instances) for the same development project is a waste of time that bogs down developers.

A Synchronization tool enables both teams to stay within their own Jira projects and only sync Jira instances that are relevant to the other team. The workflow could be established as follows:

  • QA tester finds a bug
  • QA tester creates an issue in the QA Jira project
  • The tester’s team lead vets the issue and syncs to dev team’s Jira project
  • An instance of the bug is now created in the dev team’s Jira project
  • Dev team updates QA team on status of bug via their twin issue – all information is synchronized on the QA team’s end

With this workflow, only relevant issues get communicated between both teams for a more streamlined approach to quality assurance.

Setting up a Jira to Jira sync while segregating confidential information from unauthorized access

What if you want to sync Jira issues with an outside team without leaking confidential information?

With the traditional method, two separate issues would be created in two separate Jira instances (or projects).

The issue available to the outside team would only contain non-confidential information. However, this method requires dual work every time the issue is updated.

On the other hand, Exalate enables project administrators to sync only specific fields between two Jira projects.

For example, let’s say a dev team didn’t want to share certain screenshots with the quality assurance team.

But what if they wanted to add these screenshots to the issue to better keep track of the bug on their end?

In this case, the administrator could set it up so that all attachments on the development side do NOT get synchronized to the QA side.

This wouldn’t prevent the QA team from uploading attachments for the dev team, enabling them to share relevant information for bug reproduction.

Jira Service Desk Sync to Multiple Development Projects

Let’s say you have an IT support team reporting issues with a Jira service desk when angry users come to them with problems.

In this use case, you have two Jira projects (or separated Jira instances):

  1. the front-end support project
  2. the back-end development project

The usual method to report bugs would be for IT support agents to forward these Jira issues via email.

Now, even if we set aside the fact that this gets developer’s emails flooded when they’re already busy, email is just not an effective way to share Jira issues. It’s a waste of time and information will inevitably get lost both ways.

Instead, we can set up a Jira to Jira integration.

That way, IT support agents can create issues and sync them so that the development team gets instant access to the issues. This without having to comb through their email first.

This also means that the IT support agent has visibility on the status of the issue when the developers update it, making communication with angry users much simpler.

Note: We’ve covered more use cases on Jira issue synchronization in the following article on: Making The Case For Synchronization Of Issue Trackers

How to Synchronize Multiple Jira Instances

Now that we’ve gone over some use cases together, I’ll show you how easy it is to set up a Jira to Jira integration.

We use our own tool, Exalate, to establish a Jira issue sync. Simply because it offers the most flexibility. And it’s still relatively easy to set up.

Here, I’ll guide you through this process step-by-step. (And if you happen to get stuck, or have any questions, use the live chat widget on this page.)

Step 1: Establish Workflow With Both Teams

The very first step you’ll need to take – before even installing Exalate into your Jira projects – is to establish the workflow you’ll want to be using between both teams.

It’s possible for two teams to sync Jira projects without having the same workflow. For example, you could have one project with a workflow like this:

Sync Jira workflows

And have the second team adopt a workflow like this:

Syncing of Jira workflows

No matter what you decide to establish as your workflow on both sides of the Jira project, it’s important for you to agree what information is exchanged. And how changes on one side need to be applied to twin issues on the other side.

This will avoid communication mistakes between the teams and ensure that the efficiency of the workflows is maximized.

Step 2: Choose an Appropriate Template for your Jira sync project

One of the great features that comes from the Jira synchronization tool Exalate is the ability to pick from pre-existing sync templates when setting up a connection between two projects.

Sync templates establish which issue-information gets synchronized, and which does not, as well as what this translates to on the other side.

For instance, you can sync the summary, description, comment, and attachment between twin Jira issues – right out of the box.

So before you set up a connection, make a list of all the relevant information you want to sync from Jira to Jira.

We’ll go into more depth on how to change this later.

Step 3: Create a New Connection between your Jira instances or projects

Before you can do this step, you need to have Exalate already installed in both Jira projects you want to synchronize.

Once this is done, you’re ready to create a new connection. One team will initiate the connection while the other accepts the invitation. In this example, we’ll have a BLUE Jira project initiating the connection with the RED Jira project.

From the blue project, access the Jira Administration in the top right corner and go to Add-ons:

Install Jira issue sync tool

If you’ve already set up Exalate, the Add-ons menu should give you several options on the left. Open up the Connections menu.

You’ll see any existing connections in this menu if you happen to have any.

If this is your first connection, this area will be empty.

Edit Jira to Jira Sync tool

Click on the green “Initiate Connection” button. From there, you’ll have the choice between three types of connections:

Jira Sync connection type

  • Another instance which is accessible: Because we currently have access to both Jira project instances for this example, this is the option we’ll be using.
  • Another instance which is not accessible: Choose this option if you don’t have direct access to the second Jira project. This is a great option for dev teams and quality assurance teams.
  • Local connection: Use this if you want to synchronize two projects within a single Jira instance.

Once you’ve selected the appropriate connection for your team, click ‘Next’.

Now you’ll fill in the URL for the destination of the project you’re synchronizing to. Exalate will let you know if you’ve made a mistake in the URL or if it cannot find the destination:

Initiate synchronization between multiple Jira instances

A successful connection will look like this:

Succesful Jira to Jira integration

You’ll be given the choice between a Single Project type sync rules and Advanced.

For now we’ll choose Single Project. This will establish a Jira issue sync for the following data:

  • Summary
  • Description
  • Type
  • Assignee
  • Reporter
  • Comments
  • Attachments
  • Labels

Know that you can edit these settings at any time by accessing the Connections menu.

Connection type multiple Jira instances

From the drop-down menu, select the project you want to connect on your end. We’ll choose BLUE:

Singple Project Synchronization Jira to Jira

And now for the final step – name your connection and add a description.

You can also choose to activate or deactivate the connection. When the connection is deactivated, this will pause synchronization. But changes still get queued for later updates. This means that pausing the connection will not make you lose any data.

Jira to Jira integration connection name

Step 4: Invite the other team to connect their Jira project

Once you finish to initiate the connection, Exalate provides you an invitation code and message.

Make sure to send this code to the other team so that they can accept your invitation to connect.

You’ll have the option to copy the entire invitation message to the clipboard, or only copy the invitation link, by clicking on one of the options below the invitation link box:

Jira to Jira Sync invitation

On the second team’s side, you’ll need to go through the same menu. But, this time, click on ‘Accept Invitation’ in the Connections menu.

Connection name Jira to Jira integration

This is where you or your partner – whoever is accepting the invitation – will paste the invitation code generated in the previous step.

Invitation code synchronization multiple Jira instances

Once you click ‘Next’, you’ll get the same choice for sync rules templates.

Keep in mind that while one team can use a certain template, the other team can set things up differently on their end.

However, we’ll keep things simple for now and choose the same option.

Now pick the Jira project you want to synchronize on this end (we’ll choose RED):

Accept invitation Jira to Jira sync

Now confirm the connection, and there you have it! BLUE and RED are connected:

Succesful Jira to Jira sync

That’s it – have a chocolate 🍫.

Step 5: Synchronize a Jira issue

All right, now let’s sync a Jira issue.

Let’s say we’ve created a new Jira issue on the RED project and we want to sync this to the BLUE side.

If you go into ‘MORE’ on your issue, you’ll find the Exalate option:

Jira issue sync

Once you click this, you’ll be asked to choose which connection you want to use from a drop-down menu. Be sure to choose the appropriate one and submit your Exalate form.

You’ll know an issue has been “Exalated” once you see a Sync Status near the bottom right of your issue.

At first, it should look like this:

Jira issue sync in progress

This means your Jira issue is currently being synchronized.

It should only take a few seconds for the synchronization to succeed:

Jira to Jira issue synchronization

If we go back to the BLUE project and search for issues, you’ll find this clone.

So what happens if I write a comment on the BLUE side?

Once we refresh on the RED side, it will look like this:

Jira issue sync on destination

Step 6: Determine the information you need and don’t need to sync across your Jira instances

Let’s go back to some of our use cases.

What if we want to sync attachments to the RED side without giving access to this information to the BLUE side?

We can set this up using simple scripting.

What’s great is that we only need to do this on a single side. So, if we want to block attachments from synchronizing to the BLUE side, we can set this up on the ‘Outgoing Sync’ rules of the RED team.

So for this step, determine which information you want to send out through your outgoing syncs – and which incoming information you want from the other team.

In our case, we’ll set it up so that we can get incoming attachments from the BLUE team. But the BLUE team can’t access the RED attachments.

Step 7: Customize Synchronization Rules Through Scripting

Go to your Connections menu inside the RED project and select the connection you want to edit.

Inside, pick the Sync Rules tab.

This is where you have access to the way issue fields are being synchronized. (Check out the Exalate Documentation for a full overview of these fields.)

In the Outgoing Sync data filter, remove the issue attachments line.

Flexible Jira Issue Sync

Alternatively, you can keep the code snippet intact and add “//” in front of the line to make it into a comment, like so:

Comment out field in Jira synchronization

Don’t forget to apply and update.

Now we’ll add a screenshot on the Jira instance from the BLUE side, and vice versa.

Let’s wait for this Jira issue to sync…

Source issue synchronization

And see what we’ve got:

Destination issue synchronization multiple Jira instances

Success 🎊!

The synchronization rules have blocked the RED screenshot from synchronizing to the BLUE instance, but the RED team still has access to all BLUE screenshots.

Step 8: Handle Sync Errors

So what happens if an error occurs during a Jira issue synchronization?

Because Exalate works with a transaction-based system, any connection errors won’t break the synchronization and cause conflicts between the issue and its clone.

This basically means you don’t need to do any housekeeping in Exalate to fix conflicts if connection errors arise. Because there won’t be conflicts at all.

If an error occurs, you can seek assistance from the Exalate team. Once the issue is resolved, your synchronization will resume in the order the changes were made.

Wrapping it Up

There you have it. 8 steps to achieving a simple Jira to Jira sync.

Here’s a quick recap of the basics:

  • Establish a connection on one end
  • Accept the invitation on the other end
  • “Exalate” your new or existing issues to establish issue synchronization
  • Tweak any sync rules if needed

We used Exalate to set this up.

By synchronizing Jira issues in this way, you’ll avoid losing time and information. And you’ll make your workflow much simpler.

Additionally, if you need separate connections with varying sync rules, you can create multiple connections between two projects with multiple sync rules.

I hope this helped you get an idea of some best practices on how to set up a Jira to Jira integration.

If you have any questions or suggestions, feel free to share your thoughts in the comments below.

And if you have an interest in setting up a sync using Exalate, you can try it completely free.

Finally, if you need some help setting it up, we can schedule a demo on how to use it for your particular use case.


Comments are closed.