Majid

The aim of syncing Zendesk and Jira is to get both systems to share data about updates automatically. But when more than one Jira instance is involved, you need to find a way to keep some comments private from the purview of the other Jira instance.

I’ll show you how to sync these side conversations using Exalate.

Use Case Description

A customer support team (Zendesk) is in contact with a team of developers (Jira D) and a QA team (Jira Q). 

When a comment is made on the Zendesk ticket, the admin can apply macros, and configuration will determine whether it is meant for Jira D or Jira Q. 

The macros action contains the name of the group, the subject, and the message body. You can label them respectively:

• Jira D (“Send to Developers”)
• Jira Q (“Send to QA”)

Therefore, the comment will appear only in the Jira instance to which the macros have been applied, with a comment specifying the source.

What are Side Conversations?

Side conversations are spaces in a Zendesk ticket where agents can discuss an issue or a resolution with a specific group of people. Admins use them to organize and channel information about a ticket.

Your team can also use it to segregate information when your system is in sync with multiple platforms at the same time.

Why Sync Side Conversations?

Implementing and curating side conversations can be a headache, but they can actually make things easier for your organization.

Integrating side conversations provides the following advantages:

• It allows you to organize and manage information based on specific issues or concerns.
• It ensures that only authorized users get access to specific pieces of information.
• It makes it easier for users in the system to filter information only to essentials.
• It declutters the system and makes it easy for teams to become more productive. 

Usually, you can configure the system to send side conversations via email or Slack messages. But with Exalate, you can convert the side conversations to Jira comments or information tables.

In addition to Jira, Exalate can create side conversations for other systems, such as Salesforce, Zendesk, ServiceNow, etc.

How to Sync Side Conversations with Jira Issues Using Exalate

1. Install Exalate from the Atlassian and Zendesk Marketplaces.
2. Set up an Exalate script mode connection between Zendesk and Jira D.
3. Set up another Exalate Script mode connection between Zendesk and Jira Q.
4. Create a macro called "Send to Developers", and include the following in the Action:
   
5. Create another macro called "Send to QA", and include the following in the Action:
   
6. Now create Zendesk triggers to add a custom tag if a new ticket is created in one of the Groups assigned in steps 3 and 4:
7. The final piece is to create Exalate triggers based on the tags added via Zendesk triggers, i.e. in the respective connections. 
   tags:dev
   tags:qa

Now support agents are able to run macros and create side conversations to talk to the Development and QA teams on separate threads, and no one ever has to leave their favored work system.

Zendesk Jira: Using side conversations to address a one-to-many use case 

To watch a detailed explanation of how to set up macros and sync side conversations from Zendesk to two Jira instances, check out the video above. 

Need help to sync side conversations or have some other use case in mind? Book a call with our solution engineers.

Syncing data between Zendesk and Salesforce allows organizations to unify both sales and support data without context-switching or manual request processing.

Since neither platform can share data natively, you’d need native or third-party solutions to get the exchange to work. These integration solutions bridge the communication gap and handle data transformation across platforms.

Without wasting much time, let me show you how to map and sync Zendesk and Salesforce custom fields and statuses using Exalate, a bidirectional third-party solution. 

Status and Custom Field Update: Zendesk to Salesforce Use Case

You can create a custom field in your Salesforce Case to reflect data from a custom field in a Zendesk ticket.

Why is this necessary?

• Syncing user data from Zendesk to Salesforce can give more context and information about user accounts.
• You can share Zendesk ticket status with teams monitoring a Salesforce Case.
• Customer service teams can use this case configuration to obtain customer account data from a custom field created in a Salesforce Case.

For this illustration, I want to fetch the day of the week from a “Weekday” picklist on Salesforce and have it reflect as a text in the custom “Weekday” field in Zendesk. 

Then, we also want to change the status of a Salesforce case and have it reflected on the corresponding Zendesk ticket.

Here are the requirements:

Primary Requirements

• Fetching the right API name from fields and entities on both sides.
• Mapping the correct statuses and custom fields on both Salesforce and Zendesk.
• Establishing sync rules for the incoming and outgoing data in custom fields. 
• Setting triggers to update the field on the Salesforce side automatically.

If you prefer watching a video demonstrating the use case, it’s all here: 

https://bit.ly/48qkoSQ

How Exalate Can Map and Sync Statuses and Custom Fields Between Zendesk and Salesforce

Exalate is a two-way integration solution that works with Zendesk, Azure DevOps, ServiceNow, Jira, Salesforce, GitHub, etc. 

Why Exalate? 

• It supports trigger-based integration and bulk operations.
• It’s built with security at its core. 
• It provides an integration as a service (IaaS) option for MSPs.
• It supports the synchronization of all the available Salesforce and Zendesk default and custom fields.
• You can use its Groovy scripting engine for complex Salesforce Zendesk integration use cases.

How to Implement Exalate for Data Updates

First, install Exalate on both the Salesforce and Zendesk sides. Follow this step-by-step Getting Started guide to connect both of them. 

To set a connection between Zendesk and Salesforce that supports advanced integration, choose the Script Mode.

Once done, open a Case in Salesforce. Add the description and populate the required fields. These changes won’t reflect on the other side because the mapping rules have not been set. 

To configure the sync, open Exalate in your Zendesk dashboard, go to the connection you want to edit, and click on the “Edit connection” icon. 

You have two options: 

• Outgoing sync (on the Zendesk side) refers to the data being sent over to Salesforce. 
• Incoming sync (on the Salesforce side) refers to the data to be received from the issue on Zendesk.

Under the “Rules” tab, enter the following code snippet into the “Outgoing sync” text area. 

replica.Weekday__c = entity.Weekday__c

The entity.Weekday__c function points to the custom field name in the Zendesk ticket. The replica works as a payload or a message containing information you want to pass between the two systems. 

For the status mapping between custom fields on Zendesk and Salesforce, enter the following code snippet.

def statusMap = [
          "open"   : "New",
          "pending": "Working",
          "Solved" : "Escalated"
        ]

 

def remoteStatusName  = replica.status.name
      statusName      = statusMap[remoteStatusName]
      entity.Status   = statusName
}

The statusMap variable maps different statuses by fetching the replica.status.name and mapping it to the statusName variable of the corresponding entity.Status. Make sure the names match the corresponding statuses.

Once done, click “Publish” to save and implement changes.

Now head to the Zendesk “Incoming sync” text area and add the following line of code.

issue.customFields."Weekday".value = replica.Weekday__c.value

The issue.customFields."Weekday".value fetches the string value of the field based on the name. The replica saves the value from the Salesforce Case.

Once done, click “Publish” to save the changes.

Now, it’s time to set event triggers to control the sync. 

Salesforce uses Salesforce Object Query Language (SOQL), while Zendesk uses the Zendesk search syntax.

To set an event trigger for the sync, go to “Triggers” and click “Create trigger”. 

Status = "Working"

Enter the following code to dictate when the exchange should be triggered. Say, when the admin sets the Case status to “Working”.

Click “Add” to complete the trigger configuration.

Back in Salesforce, select a day from the “Weekday” picklist and change the status to “Working”.

Now, back in Zendesk, you’ll see that the status has changed to “Pending”, which corresponds with the rules established earlier. You can also see that the “Weekday” field has been populated by the same value selected from the Picklist. 

Congratulations! You have now set rules and triggers to help you update statuses and sync custom Salesforce case fields with Zendesk tickets. 

Start monitoring things in order to adjust the rules according to the demands of specific projects and issues.

If you still have questions or want to see how Exalate is tailored to your specific use case, book a demo with one of our experts right away.

Many template-based integration tools are available to solve the needs of the most common use cases. On the other hand, script-based solutions like Exalate are perfect for setting up deep integrations between tools like Zendesk, Jira, Salesforce, etc. 

However, such tools might seem overwhelming to non-technical users. To prioritize giving users the means to implement any kind of integration easily and accurately, at Exalate, we introduced AI Assist, an integration co-pilot. 

Now scripting for integrations no longer consumes enormous amounts of time and resources. 

Let’s check out how it works. 

Introducing AI Assist by Exalate

What is AI Assist?

AI Assist is an AI-powered integration script builder that complements Exalate’s Script mode capabilities.

It acts as a copilot, helping you steer your integration scripts in the desired direction—whether it is internal connections or cross-company collaborations.

AI Assist provides the following:

• Dynamic sync rules generation for simple and advanced integration scenarios based on user inputs. The AI feature relies on human input and refinement to fetch the correct fields and entities and suggests sync scripts based on these inputs, always putting the human in the driving seat. 
• Embedded UI that is integrated within the Exalate incoming and outgoing sync rules interface.
• Color-coded change tracking to highlight what code fragment or snippet needs to change or go.

All these features are available without any extra charge to Exalate’s Script mode users.

Despite being an excellent copilot and scripting assistant, AI Assist, like every other AI-powered solution, is still evolving. It needs clear and precise human prompts to improve the output. So, it’s important you review (and test) the generated script or code snippets before publishing any changes.

Why Do You Need AI Assist?

This is how you can benefit from AI Assist:

• It reduces the time spent on writing code from scratch or searching for the relevant script.
• It helps you explore several advanced and complex integration scenarios.
• It increases the accuracy of mappings by reducing the need for manual input.
• It bridges the skill gap between tech-savvy users and non-technical integration admins.

If you’re not familiar with Groovy scripting, then AI Assist is your perfect partner for scripting connections.

How Does AI Assist Work

Here’s how to set up and use Exalate’s AI Assist:

1. Install Exalate on the systems you want to integrate.  
2. Set up a Script mode connection. 
3. Click on the Edit Connection icon and go to the Rules tab. 
4. Go to the AI chat panel under the text boxes (for Incoming and Outgoing sync) and enter a detailed prompt containing the sync requirements. For instance, I want to sync internal comments from Zendesk to Jira. Or map and sync statuses between Jira and Zendesk. 
5. AI Assist generates sync scripts automatically, taking into account your existing configurations and Exalate’s scripting API. 
6. You can either discard or accept the AI suggestions. 
7. Make slight adjustments and publish refined output.

If you have a specific use case in mind and are wondering how AI Assist can help you set it up faster and easier, reach out to us for a free demo. 

To sync statuses between Jira and Zendesk, you need a third-party integration solution.

I’ll show you how to implement this use case with Exalate.

Jira Zendesk Integration Use Case: Issue Status Sync

Changing the status of your Jira issue will also update the status of the corresponding Zendesk ticket. 

Let me show you the requirements and challenges:

Primary Requirements

Every time a user changes the status of the Jira issue, the linked Zendesk ticket also reflects the status change. 

For this to work, you’d need to establish sync rules to control the incoming and outgoing data and map the right status to each system.

You can also set triggers to update the status of all tickets linked to the connection automatically and bi-directionally.

Potential Challenges

• Mapping the right statuses using the correct field name.
• Writing the correct sync rules.
• Setting up the right triggers to control the synchronization.

How Exalate Can Solve the Problem

Exalate is a bidirectional integration solution that works with Zendesk, Azure DevOps, ServiceNow, Jira, Salesforce, etc. With the Exalate app, you can:

• Sync Zendesk and Jira custom fields as well as other entities.
• Create a trigger for syncing existing issues using the Bulk Exalate feature.
• Configure complex use cases using Exalate’s Groovy scripting engine.

How to Implement Exalate for Data Updates

First, install Exalate on both the Zendesk and Jira sides. Next, follow the instructions in this comprehensive guide to establish a connection between them.

For advanced use cases such as this, you must set up a connection using Exalate’s Script Mode. After that, you can commence with the sync.

Go to your Jira dashboard and create a new issue.

Then, open the Exalate console in Jira. Go to the connection you want to edit and click on the “Edit connection” icon. 

Then change the sync rules under the “Rules” tab. 

You have two text boxes: 

• Outgoing sync (on the Jira side) refers to the data to be sent over to the Zendesk side. 
• Incoming sync (on the Zendesk side) refers to the data to be received from the issue on Jira.

On the Zendesk side, add the following code:

def statusMap = [
    "To Do":"pending",
          "New":"open",
          "Done":"solved"
        ]
def remoteStatusName = replica.status.name      
issue.setStatus(statusMap[remoteStatusName] ?: remoteStatusName)

Note: The statusMap variable establishes the relationship between statuses. The remoteStatusName maps to the replica’s status. Eg., A “pending” case on Zendesk appears as “To Do” in Jira.

Once done, click “Publish” to save the changes.
On the Jira side, enter the code in the “Incoming sync” text box.

def statusMap = [
      "pending":"To Do",
      "open":"In Progress",
      "solved":Done"
      ]
def remoteStatusName = replica.status.name
issue.setStatus(statusMap[remoteStatusName] ?: remoteStatusName)

Note: The statusMap variable establishes the relationship between statuses. The remoteStatusName maps to the replica’s status name. Eg., An “open” ticket on Zendesk appears as “In Progress” in Jira. 

Once done, click “Publish” to save the changes.

Now go back to the Zendesk ticket and set the status as “Open”.

Back on Jira, you will see the status appear as “In Progress” automatically.

Congratulations! You have now set rules to help you update the status of Jira issues with Zendesk tickets. 

If you still have questions or want to see how Exalate is tailored to your specific use case, book a demo with one of our experts right away.

Watch the Jira Zendesk integration tutorial:

https://bit.ly/49EHIen

A Jira Zendesk integration can help teams using JSM (Jira Service Management) to connect with those using Zendesk. 

To get this done, you can always find native integration tools in the Zendesk marketplace but there are limitations on how much you can configure these tools and you can sync only a limited number of entities. 

To set up an advanced fully bi-directional Jira Zendesk integration, the tool I’ll cover today is Exalate. It has a scripting engine for mapping the incoming and outgoing data on both sides. 

4 simple steps to set up your Jira to Zendesk integration

Step 1: Install Exalate on both Jira and Zendesk

The Exalate app is available for installation via the Atlassian and Zendesk marketplaces, respectively, or through our integrations page. You can also watch the Jira and Zendesk installation videos. 

You can always discuss your use case with our team and understand if Exalate is the right fit for your needs. 

Step 2: Connect Jira to Zendesk

First, you need to outline the requirements from the integration for both sides to help you create mappings for projects, fields, and entities.

To create a connection, open the Jira instance. Then enter the URL for the Zendesk instance.

To set up a connection, choose the available configuration options. 

Exalate has three modes: Basic, Visual (Beta), and Script. 

The Basic mode supports basic entity mappings. The Visual mode combines low-code scripting with drag-and-drop mappings. The Script mode supports advanced configuration and scripting. 

To find out how to script your Exalate connections, check out the detailed configuration guide. 

Step 3: Write the sync rules

The Exalate console supports the Groovy scripting language for configuring one-way and two-way syncs.

You can map data from labels, summaries, descriptions, assignees, reporters, comments, attachments, and much more. 

The Outgoing sync textbox decides what goes out to the other side, while the Incoming sync textbox decides how (and where) the information coming from the remote side appears. 

Here is a sample line of code for syncing Jira custom fields.

issue.customFields."Jira custom field name".value = replica.customFields."Jira custom field name".value

The above code snippet populates the custom field in Jira with value coming from the Zendesk side and vice versa. In the other instance’s incoming sync, make sure to map the value received from Zendesk in the correct issue field. 

Step 4: Automate your sync with triggers

Triggers are conditions that control how your sync works. They automatically carry out the sync once the condition is fulfilled. 

You can configure triggers using Jira Query Language (JQL) and Zendesk search syntax.

Here are sample JQL triggers: 

• project = XProject and assignee = JDoe
• project = FIR and labels = sync
• worklogDate > startOfWeek()

Here are sample Zendesk triggers: 

• type:ticket ticket_type:incident priority:urgent
• type:ticket status:open
• has_attachment:true

You can now sync your data automatically based on the rules and triggers you have set.  

Advanced Jira to Zendesk integration use cases

• Sync multiple Zendesk tickets to one Jira instance.
• Sync one Zendesk ticket to multiple Jira instances.
• Sync issue priority. 
• Sync only public comments between Jira and Zendesk.
• Sync user fields and statuses between Jira and Zendesk.
• Sync Elements connect fields with different key values in Zendesk. 
• Display the remote Jira issue link in a Zendesk custom field. 

To learn more about syncing Jira and Zendesk, reach out to us to discuss your use case.

If you use Zendesk and Jira Cloud, you may want to synchronize tickets between the two platforms. This synchronization can help you keep track of customer issues and ensure they are promptly addressed.

To synchronize a ticket to multiple Jira Cloud instances, you can use the Exalate integration. Exalate is a third-party tool that allows you to connect different software applications and sync data between them.

The Use Case

When a customer ticket arrives in Zendesk, it is automatically synced to multiple Jira Cloud instances. 

For the purpose of this use case, we consider one Zendesk instance and two Jira Cloud instances, the yellow (Y) Jira and the Blue (B) Jira. We will sync the ticket from Zendesk to instance Y in two different projects, project A and project B. We will also sync the ticket with instance B.  

We need an advanced integration solution to achieve this kind of flexibility of syncing a single entity to multiple locations. 

The solution we will use here is called Exalate. 

Exalate: A Customizable Integration Solution

Exalate is a unique integration solution that supports synchronization between multiple platforms like Jira, Zendesk, Azure DevOps, Salesforce, ServiceNow, etc. 

It has some features that make it an ideal solution for implementing complicated integrations: 

• It uses an advanced scripting engine based on low-code Groovy scripts. This lets users implement custom configurations. 
• It has a decentralized integration architecture. This allows you to control the source and destination information independently. 
• It has security features like single-tenant architecture, JWT tokens, encrypted data, etc. This makes it secure by design. 
• It has an embedded retry mechanism. This helps you resume your synchronization from the point at which it was interrupted. 

Let’s implement the use case with a step-by-step process using Exalate. 

Note: You can watch the video here. 

How to Connect a Single Zendesk Ticket To Multiple Jira Cloud Instances Using Exalate?

Step 1: Install Exalate on Zendesk and All Jira Cloud Instances. 

To use Exalate to sync a single ticket to multiple Jira Cloud instances, you must install it on your Zendesk and all Jira Cloud (Y and B) instances. Exalate is a decentralized integration solution that requires all integration parties to install the application on their platforms. 

You can install Exalate for Zendesk from the Zendesk marketplace and Exalate for Jira from the Atlassian Marketplace. 

Step 2: Create Connections Between the Zendesk and Jira Instances

Now, you must connect all the instances together. Connect the Zendesk instance to the Jira Y instance (project A and project B) and also to the Jira B instance. 

The following connections must exist: 

• Connection Zendesk - Jira Y (project A)
• Connection Zendesk -Jira Y (project B)
• Connection Zendesk -Jira B

This way, there can be any number of Jira instances you can connect to. 

The process to set up a connection using Exalate is simple and straightforward. One side initiates the connection, and the other side accepts the connection invitation. It doesn’t matter which side starts initiating the connection; the interface remains the same. 

We’ll start all the connections from the Zendesk instance.  

Head to the “Connections” tab in the Zendesk Exalate admin console and click “Initiate connection”.

Enter the destination Jira instance Y URL. 

You’ll be prompted to choose between three Exalate modes. The Basic and the Visual Mode are no-code modes, whereas the Script mode is a low-code mode based on Groovy scripts for simple to complex use cases. 

Select the “Script mode” and click “Next”.

Enter the connection details. We are keeping the connection names as per the list above. In this case, the connection name is Zendesk - Jira Y. 

An invitation code is generated. Copy it. Click “Done”.

Open the Jira Y instance’s Exalate console, and this time, click “Accept invitation” under the “Connections” tab. 

Paste the invitation code in the text box. 

Select project A, the project in which the Zendesk ticket must arrive. 

That’s it. You have connected your Zendesk instance to Jira Y (project A). 

Proceed to create the remaining connections in a similar manner. 

Step 3: Set the Sync Rules for Information Exchange

Once all your instances are connected, you can configure the sync under the “Rules” and “Triggers” tab. These tabs appear when you click “Configure sync” after the connection is established or when you edit the connection.  

Sync rules govern the information flow. You can specify the fields you want to sync under this tab. You can choose to sync all fields or select only specific ones. You can also choose the direction of the sync. 

After making changes to the sync rules, click the “Publish” button to save them. 

Upon specifying the entity fields you want to sync, proceed to the next important step. 

Step 4: Create Triggers for Syncing Zendesk Tickets to Jira

After the initial groundwork, it’s now time to sync a single Zendesk ticket to multiple Jira instances. 

You must create “Triggers” in Exalate to implement such conditions of information exchange. 

Click the “Triggers” tab. Then, click “+ Create trigger”. 

Note: You can also create triggers from the Exalate admin console’s left-side menu. 

The “Add trigger” modal pops up. 

Note that this modal is present for the Zendesk and all the Jira instances, so you can control the sync from any direction in any way you want. 

The triggers are created in the platform-native query language. For instance, you need to use Jira Query Language (JQL) for Jira and Zendesk search syntax for Zendesk. 

We want the ticket to go from Zendesk to Jira, so click the trigger screen shown below for Zendesk. 

Enter the search query. Here, we are syncing the tickets that have been assigned the label = “sync”. You can create all kinds of conditions depending on your requirements. For example, sync an “Open” ticket assigned to a specific user, having a label = “sync”. 

Note: If you’re creating triggers from the left-hand Exalate console, you need to select the connections we have created in Step 2 and activate the trigger.

Do this for the remaining connections too. 

You’re all set for now.  You can keep configuring the sync rules and the triggers as your demands change with time. 

Step 5: View the Status of Your Sync

Exalate will start synchronizing all the tickets based on the trigger conditions you’ve set in Zendesk over to the Jira cloud instances. Comments, attachments, labels, etc. will synchronize according to the sync rules configured in Step 3. 

You can create a ticket in Zendesk and assign Tags = sync to it. 

Exalate will pick this up automatically and start syncing the ticket to all the Jira instances. Appropriate status messages will be displayed when the ticket is being transferred to Jira.  

You can view the sync status in the Exalate panel present under the ticket view in Zendesk and the issue view in Jira. 

Conclusion

Syncing a single Zendesk ticket to multiple Jira cloud instances is a relatively straightforward, albeit tricky process. By following the steps outlined in this article, you can ensure that your tickets are always up-to-date and your teams have the information they need to resolve issues quickly and efficiently.

If you have a specific use case in mind and are wondering if you can implement it with Exalate, book a demo with an integration engineer and figure it out.

Integrating Jira and Zendesk combines the strengths of Jira’s project management capabilities with Zendesk’s comprehensive customer support features. 

We’ll discuss a commonly encountered scenario: when an issue is resolved in Jira, a private comment containing the associated Jira issue key is automatically appended to the relevant Zendesk ticket. 

In the following sections, we’ll discuss the use case requirements and the step-by-step configuration to set it up using an integration tool called Exalate. 

The Use Case

Customer support teams need visibility on the ticket status once the dev team starts working on it. Stemming from this need, we had a customer with the following requirements: 

• Ticket summary, description, status, tags, and public comments must be synced from Zendesk to Jira. 
• Jira issue status should be mapped to the ticket status in Zendesk. When the issue is in “In Progress” in Jira, it must be changed to “Open” in Zendesk. 
• When the issue is marked “Done” in Jira, a comment saying: “Fix has been released by the Dev team for UD-386” must be added to the private comments in Zendesk. Here, UD-386 is the Jira issue key. 

The Challenge

It’s easy to sync the ticket summary, description, tags, etc, since they are out-of-the-box sync configurations for most of the integration providers in the market. 

The real challenge lies in appending a fixed comment to the public comments in Zendesk with the actual Jira issue key that resolves the ticket. 

We’ll also need to use code-based solutions to implement this use case since it’s challenging with ready-made integration templates. We’ll need to ensure that the code written is error-free. 

In an integration setup, network timeout errors also need to be taken into account. 

Keeping in mind all these considerations, we’ll use Exalate to implement the use case. 

Why Choose Exalate to Implement This Use Case? 

Exalate is a synchronization solution that facilitates the exchange of data between work management systems and online repositories in both directions. It supports various platforms like Zendesk, Azure DevOps, ServiceNow, Jira, Salesforce, GitHub, and more.

What are the advantages of using Exalate?

1. It provides a seamless synchronization process for Jira issues and Zendesk tickets, requiring only a few clicks.
2. With Exalate's Groovy scripting engine, you can create customized rules to address advanced use cases.
3. The Bulk Exalate and Bulk Connect features enable the synchronization of multiple issues and tickets simultaneously.
4. Exalate ensures the security of your data by safeguarding sensitive information during sharing.

How to Append the Jira Issue Key to a Private Comment in Zendesk When the Issue is Closed?

You need to install Exalate on both the Jira Cloud and Zendesk instances. Next, create a connection in the Script mode. 

Note: You can check out the Exalate Academy or the Getting Started Guide for more information. 

With Exalate's Script mode, you get the flexibility to write your own Groovy scripts, allowing you to control the data transferred to the other side. 

Proceed to click on the edit icon in the “Connections” tab in front of the connection name. You can also click the “Configure Sync” button to edit the connection. 

Navigate to the “Rules” tab in the Zendesk Exalate node and locate the “Incoming sync”. 

Insert the following code: 

issue.labels = replica.labels
issue.summary      = replica.summary
issue.description  = replica.description ?: "No description"
issue.attachments  = attachmentHelper.mergeAttachments(issue, replica)
issue.comments     += replica.addedComments

def statusMapping = ["Done":"open", "In Progress":"open"]
def remoteStatusName = replica.status.name
issue.setStatus(statusMapping[remoteStatusName] ?: "open")

if(remoteStatusName == "Done")
    issue.comments += commentHelper.addComment("Fix has been released by the Dev team for: "+replica.key, issue.comments)

The code maps the Zendesk status with the Jira status. For instance, when the engineering team in Jira starts working on the issue (status: “In Progress”), the ticket in Zendesk is marked “Open”. 

Once the issue is marked “Done” in Jira, we use the commentHelper’s addComment method to add a comment on the Zendesk instance that consists of the appended Jira issue key. 

Click “Publish” to save the changes you’ve made. 

The Output

To see if the use case is working, go to your Zendesk instance and open the ticket you want to sync. Click on the “Apps” icon on the right side and click on the “Exalate” button. Select the connection you’ve just created from the list. 

The ticket will now be synced to Jira as an issue. The ticket summary, description, and other details will also be copied to the Jira issue. 

Note: We’re manually syncing the ticket here, but you can also set up automatic sync triggers in JQL (Jira Query Language) for Jira and Zendesk search syntax for Zendesk.  

Let’s mark the issue as “Done” in Jira now. 

Exalate automatically picks this update and leaves a comment appended with the Jira issue key in the Zendesk instance. 

Conclusion

Exalate enables the synchronization between Jira and Zendesk. Additionally, it allows you to configure personalized rules and triggers for automating the sync process. These data synchronization capabilities streamline your daily operations and enhance customer service delivery. 

If you have any queries or wish to witness how Exalate can be tailored to your unique requirements, we encourage you to schedule a demo session with one of our experts.