Jira Integrations

The service desk team receives a new incident in ServiceNow. After checking the issue, they see that the problem results from a software bug. Therefore, the development team should handle it.

With our integration platform, the service desk team doesn’t need to open Jira and log the issue manually. ZigiOps provides easy, no-code integration between Jira and ServiceNow.

The communication between the service desk and the developer working on the bug is easy. It doesn’t require any additional applications. Instead, everything is taking place in the comments. Log files, traces, or other attachments sync automatically. This streamlines defect tracking and resolution, improves change request management, and prevents communication and information bottlenecks.

Once the developer fixes the issue, ZigiOps instantly updates the ServiceNow incident. The end customer receives a notification about it, as well.

This use case is similar to the ServiceNow Jira integration. The helpdesk team gets a new incident in their BMC Remedy queue. After investigating it, they find out the underlying problem is a software bug, which means they need to forward it to the development team.

With ZigiOps, they can do that automatically, without even needing to open Jira. The integration logs an issue in Jira and updates it in real time. This improves performance and speed, and enhances defect tracking and resolution.

The helpdesk team and the developer can communicate very easily with the help of ZigiOps. This doesn’t require any additional tools, because communication simply takes place in the comments. ZigiOps instantly syncs log files, traces, and all other attachments. This eliminates bottlenecks and silos.

Once the developer fixes the issue, ZigiOps updates the incident in Remedy. The end-customer receives a notification that the issue is resolved.

The service desk receives a new incident in their Cherwell queue. They investigate the issue and find out that the problem is the result of a software bug, i.e. they need to forward it to the development team. For this, they need to log it into Jira.

With ZigiOps, everything is automated: they don’t need to open Jira and log the issue themselves: the integration platform does everything. ZigiOps logs a new issue in Jira Software and syncs the two in real time. As a result, you get to improve the efficiency of your application lifecycle management (ALM).

The service desk and the developer working on the issue can now communicate effortlessly, thanks to ZigiOps. To do that, they don’t need any additional tools: communication on the bug takes place in the comments. ZigiOps immediately synchronizes all log files, traces, issue links or other attachments. Because of that, both root cause analysis and change request management become easier. This means that you can easily eliminate communication bottlenecks and duplicate work.

Once the developer fixes the issue, ZigiOps automatically updates the incident in Cherwell. The end customer receives a notification that your team has resolved their problem.

If your main ITSM/CRM system is Salesforce and you want to synchronize Cases with teams that use Jira, you can use ZigiOps’ integration between the two applications. The opposite is also possible.

When a Case is created in Salesforce, the integration platform will retrieve it based on a scheduled interval (every minute) and it will create a related Issue in Jira. You have a high degree of data filtering control, so the platform collects only the required Salesforce Cases. You also have full control over data field mapping to define how ZigiOps reports data to Jira. Regular fields, custom fields, lifecycle fields, issue links, comments and attachments are all synchronized.

Updates in Salesforce for Cases already transferred to Jira are extracted on a scheduled interval (every minute) and synchronized with the related Issue in Jira for regular fields, custom fields, lifecycle fields, issue links, comments and attachments.

Similarly, updates in Jira for Issues that were initially created in Salesforce are collected on a scheduled interval (every minute). The integration platform synchronizes them with the related Case in Salesforce for regular fields, custom fields, lifecycle fields, issue links, comments and attachments.

If one of your teams is using Jira, and another one is using Azure DevOps to manage their projects, you can plan, track, and transfer work across your teams easily by integrating both systems.

For example, when a Task is created in Azure DevOps, the development team might find out it is related to a project another team is handling. They will need to forward it to the Jira instance the other team is using. When a ZigiOps Jira Azure DevOps integration is in place, this will happen automatically. No one needs to manually enter the information in Jira, since a Jira task is created in real time by the integration platform. You can easily set correlation and mapping in ZigiOps, so all the necessary fields (like title, description, urgency, issue links, comments, etc.) are automatically populated once the new task is created. When there is some progress in the Jira task, the integration will update all changes in Azure DevOps, too.

On the other hand, if there are any changes or information added in Azure DevOps, they will also be synced in real time with Jira. This way you can build, test and deploy projects without any manual transfer of data between systems.

Development teams across companies often use both GitHub and Jira to manage and track their projects. When the two systems are integrated team members can get quick access to pull requests, commits and branches from GitHub in Jira, and details from Jira tasks, bugs and stories in GitHub. Here is one of the most common use cases of GitHub Jira integration.

If there is a new task in Jira and the developers need to track it in GitHub, ZigiOps will automatically create a GitHub issue and will populate the extracted information from Jira in it.

The integration provides bi-directional updates, so if there are any changes in GitHub, ZigiOps will reflect them in the corresponding Jira task in real time, and any updates in Jira will be reflected in GitHub accordingly. ZigiOps will also close the task in Jira once the GitHub issue is closed.