How Companies Benefit from AI-Powered Jira Azure DevOps Integration

How-to-Sync-and-Maintain-Issue-links-Relations-Sub-task-Mappings-between-Jira-and-Azure-DevOps.png
Published on 
Updated on 
by
Integration KnowledgeUncategorized

AI is becoming part of everything, including collaborations with other teams and organizations. In the integration context, AI acts as a partner or assistant to help make sure every system is connected correctly. This assistance is more relevant in script-based integrations.

So, suppose you have a Jira Service management instance and want to integrate with your Azure DevOps instance. In that case, an AI-powered integration can triple the scripting and implementation speed and reduce human errors.

We’ll be focusing on the role AI plays in specific integration use cases between Jira and Azure DevOps.

Here are the topics covered:

What is AI-Powered Jira Azure DevOps Integration?

AI-powered Jira Azure DevOps integration involves using AI solutions to map fields, generate codes, and automate triggers for any connection between both systems. This allows you to implement any kind of use case.

This applies explicitly to script-based integration solutions that allow admins to customize syncs with their custom script or code. AI-powered integration tools level the playing field so both experienced developers and non-technical users can rely on them.

For instance, the QA team might want to send information from a Jira bug as a work item in Azure DevOps. With an AI-powered Jira to Azure DevOps integration tool, the admins in charge can generate the script using user-created natural language prompts.

Of course, the process is not straightforward, but the applications of this technology are quite extensive.

What are the Use Cases for AI-powered Integration?

System admins and developers can use AI-driven Jira to Azure DevOps integration solutions for the following use cases:

#1 – Map Jira Issues to Azure DevOps Work Items

When a user creates a Task, Epic, or Feature on the Azure DevOps side, it should be mapped to a Story, Task, or Bug on the Jira on-premise side. You can also replicate a 3-level hierarchy between all 3 work items.

For this use case, here is a sample prompt:

“I want to create a mapping so that when a user creates a task in Jira, it is mapped as a feature in Azure DevOps, when a user creates a story, it is mapped as an Epic in Azure DevOps, and when a Jira bug is created, it is mapped as an Azure DevOps task.”

The resulting code could contain something like this: 

def issueMap = [
        "Epic" :"Story",
        "Feature" :"Task",
        "Task" :"Bug"
        ]
    issue.typeName  = issueMap[replica.type?.name]

#2 – Maintaining Issue links, Relations, and Sub-task Mappings 

In this use case, both sides try to maintain a link between work items and entities in order to make them easier to trace.

Maintain parent child hierarchy between Jira and Azure DevOps

So, stories in Jira should arrive as user stories (work items) in Azure DevOps that show links to tasks and bugs. This relationship should be replicated for stories, bugs, tasks, and sub-tasks in a coherent hierarchy that makes sense to first-time users.

You can prompt the AI on the Azure DevOps incoming side using this example:

“I want Jira stories to come in as User Stories (work items) in Azure DevOps, showing links to tasks and bugs. This relationship should be replicated for stories, bugs, tasks, and sub-tasks in a hierarchy.”

The output could contain this fragment:

…
workItem.parentId = null
if (replica.parentId) {
  def localParent = syncHelper.getLocalIssueKeyFromRemoteId(replica.parentId.toLong())
  if (localParent)
  workItem.parentId = localParent.id
}
… 

#3 – Syncing Epics from Azure DevOps to Jira Cloud

Let’s say you want to transfer an Epic from Azure DevOps and make some of the content from its custom fields appear on the related Jira Cloud Epic. The AI prompt for scripting this connection could look like this:

And the generated output for the outgoing sync rules:

“I want to transfer an Epic from an Azure DevOps project named “Project X” and make some of the content from custom fields named “User Info” and “Contact Name” appear on the related Jira Cloud Epic.”

The generated results will contain this snippet:

if (firstSync) {
  issue.projectKey = nodeHelper.getProject(replica.project?.key)?.key?: "ProjectX"
  if (replica.type?.name == "Epic") {
    issue.typeName = "Epic"
    issue.customFields."Epic Name".value = replica.summary 
  } else {
        issue.typeName = nodeHelper.getIssueType(replica.typeName)?.name
  }
}

#4 – Aligning CreatedDate Field between Jira and Azure DevOps

The CreatedDate field in Jira is read-only since it tells the day the issue was created. So, how do you get it to appear in Azure DevOps? Use the integration solution to write mapping rules in order to link it to a custom field.

The prompt for generating sync rules:

“I want to sync the created date of a Jira issue to a custom field named “Original Created Date” in my Azure DevOps work item.”

The final output:

issue.customFields."Original Created Date" = replica.created

Note: As every platform environment and architecture is different, the code snippets might not be perfectly suited to your specific use case and might need to be adjusted.

What are the Benefits of AI-powered Integration?

Companies looking to explore AI-powered Azure DevOps Jira integration can benefit in the following ways:

  • Improve the speed of configurations: Instead of unnecessary back-and-forth and countless iterations to get a snippet for your use case, the AI can scour multiple sources to provide you with a relevant solution within minutes.
  • Increase the accuracy or mappings: AI-driven integrations for Jira and Azure DevOps limit human input to only prompting. It all comes down to how detailed, clear, and concise your prompt is.
  • Speed up data extraction: Instead of manually sifting through multiple lines of code and fields, the AI can fetch the data from the fields or through interactions with the API.
  • Improve error handling: AI-powered integration solutions can also find errors in your script by running quick scans to locate the bug or typo, refine it, and suggest improvements.

What are the Challenges of Using AI for Jira and Azure DevOps Integration?

AI-driven solutions can save your organization a lot of time and effort, but they also come with a unique set of challenges.

For instance, AI-generated scripts could contain errors and hallucinations. So you should always review every suggestion and test it rigorously before implementing it to your core environment.

Also, vague prompts can affect the quality of the output. Which means you have to dedicate enough energy to fine-tune the prompt. A prompt engineer might be the only solution to this issue.

AI models usually need internet connectivity to work. So, if the model goes online, it will become unusable and inaccessible, which could be a nightmare for time-sensitive syncs.

When you add AI features, you also introduce privacy and compliance issues. This is clear in cross-company collaborations, where one side has a “no-AI” policy.

Considering these challenges will help you understand how to implement AI-powered Jira Azure DevOps integration for your team.

How Exalate Handles Jira and Azure DevOps Integrations

Exalate is an AI-powered integration solution that connects Jira and Azure DevOps instances. It also supports integrations with systems such as ServiceNow, GitHub, Zendesk, Salesforce, etc.

Exalate has two AI features:

  • Aida is a standalone AI documentation assistant that you can use to fetch vital information from the Exalate documentation.
  • AI Assist is a dedicated AI script builder intrinsically embedded in the configuration console.

Both features accept user prompts and process them in order to generate code snippets for scripting connections and mappings.

Aida cannot embed the script in the UI or generate sync scripts for you, but AI Assist is directly embedded in the scripting console and takes your existing sync rules into consideration while suggesting scripts. 

How to Set Up a Jira Azure DevOps Integration Using Exalate AI Assist

Here are the steps to follow according to our documentation:

  1. Install Exalate on both Jira and Azure DevOps from the respective marketplaces. You can also get them from our integrations page.
  2. Set up a Script mode connection between both instances.

    Exalate supports three configuration modes: the Basic mode, the Visual mode (BETA), and the Script mode.

    The Basic mode is for simple Jira Azure DevOps integration use cases and cannot be configured.

    The Visual mode is a drag-and-drop interface and is available as a BETA version.

    The Script mode unlocks the full potential of Exalate where you can generate sync rules based on Groovy scripts. You can set up advanced use cases to integrate Jira and Azure DevOps using this mode.

    Since the AI Assist feature is only available for Script mode, we will discuss that mode.

    Note: To learn the steps for configuring the connection in Visual mode, refer to this guide.

    While setting up a connection, one side initiates the connection and the other side accepts the connection invitation.

    Start setting up the connection from the “Connections” tab in the Exalate admin console and click “Initiate connection”. You can start from any side. Then enter the destination instance URL. Choose your mode and follow the steps in the wizard.

    For accepting the connection on the other side, click “Accept invitation” and follow the steps from that point.
Configuration modes in Exalate
  1. Once the connection is set up, you need to configure it. For this, click the “Configure sync” button that is displayed when Step 2 is successful or edit the connection.

    You can explicitly edit the connection in the “Connections” tab.
    successful jira azure devops sync
  2. Go to the “Rules” tab. You can define your sync rules here. The rules are divided into incoming and outgoing sections. Both these sections have an AI chat feature.

    You can edit the sync rules yourself by following the steps in this guide or using the AI feature to enter a detailed prompt.

    For instance, enter a prompt describing the sync requirements, such as “I want to map the state of Azure DevOps work item to the status of a Jira issue to reflect “New” as “To Do”, “Resolved” as “Done” in the Jira incoming configuration.”

    AI Assist prompt in Azure DevOps
  3. The AI will generate an output in the incoming and outgoing sync rules depending on how you want to map the information.  

  1. The green highlights are suggested additions, while the red highlights are the suggested deletions. 
  2. If the output is to your satisfaction, click Insert Changes. 
  3. If the output is incorrect, click Discard.
  4. You can also set up triggers to automate your sync. For instance, sync all Jira issues that have the label “todev” and are assigned to “James”.

    These triggers are platform-specific. So, you can use Jira Query Language (JQL) to set them up in Jira and use Work Item Query Language (WIQL) to set them up in Azure DevOps.

    Once, issues or work items that satisfy the condition are created, they are automatically synced based on the rules you have set.
  5. Once done, publish the changes. 

Now, the established connection is ready to start syncing data between Jira and Azure DevOps. 

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 our solutions engineers for a free demo. 

Conclusion

So, how do you integrate Jira and Azure DevOps using AI?

Follow these simple steps:

  • Install Exalate on Jira and Azure DevOps
  • Set up a script mode connection. The script mode connection helps you set up advanced Jira Azure DevOps integration use cases with the help of Groovy scripts.
  • Configure the sync rules in the Script mode with the help of AI Assist. Enter what you wish to sync and AI Assist will generate the output.
  • Automate the sync with the help of triggers.
  • Publish the changes.
  • Happy syncing!

Recommended Reading:

Comments are closed.