This article was originally published on the Atlassian community.
Jira Cloud and Azure DevOps handle dates differently at the API level. Azure DevOps uses the HTML format, while Jira uses Wiki. So when you’re syncing date-time data between the two, there’s no native way to convert between these formats automatically.
That means if your teams use both platforms and rely on date fields like due dates, start dates, or sprint timelines, you need a way to transform the data so it stays coherent on both sides. This is especially true when your Jira and Azure DevOps instances sit in different time zones, and you need to adjust timestamps during the sync.
A third-party integration tool like Exalate bridges this gap. Exalate uses a Groovy-based scripting engine that gives you full control over how data is mapped and transformed between systems, including date-time conversions with timezone offsets.
Why Date-Time Sync Matters for Cross-Platform Teams
When development and operations teams work in Jira and Azure DevOps, respectively, date fields are critical for tracking deadlines, sprint boundaries, and SLA timelines. If those dates get mangled during sync because of format mismatches or timezone differences, it creates confusion around project timelines and milestone tracking.
Common scenarios where date-time sync is essential:
- Sprint planning across Jira and Azure DevOps with teams in different time zones
- SLA tracking where due dates need to reflect the correct local time for each team
- Release management where start and end dates must stay consistent across both platforms
- Cross-company collaboration where partners log work in different tools and time zones
Getting this right means your teams can trust the dates they see in their own tool, without manually checking or adjusting values.
Use Case Requirements
Let’s say your Jira and Azure DevOps instances are in different time zones, and you need the date-time fields to reflect the correct local time on each side. Here’s the scenario:
- The two teams are 5 hours apart
- “Due Date” and “Start Date” are custom date-time fields in Azure DevOps
- “Start date” is a custom date field in Jira
- “Due” is the standard due date field in Jira
The goal: add 5 hours to the Jira timestamp when it arrives in Azure DevOps, and subtract 5 hours from the Azure DevOps timestamp when it arrives in Jira.
How to Sync Date and Time Formats Using Exalate
Exalate’s Groovy scripting engine lets you write custom mapping rules for any connection. You can use it to build the transformation logic for date-time conversion between Jira and Azure DevOps.
Once you have a connection set up between your Jira and Azure DevOps instances, navigate to the connection configuration and open the script editor. You’ll see the sync rules split into two sections:
- Outgoing script: Defines what data leaves the source system.
- Incoming script: Defines how incoming data is mapped into the destination system.
The same structure exists on both the Jira and Azure DevOps sides.
By default, Exalate includes scripts for syncing basic fields like summary, description, comments, and attachments. For custom behaviors like date-time transformation, you’ll add your own script logic.
If you’d rather not write scripts manually, you can use Aida, Exalate’s AI-assisted configuration feature, to generate Groovy scripts based on plain-language descriptions of what you want to sync. Aida understands your platform context and existing scripts to produce working field mappings. You can always review and adjust Aida’s output before applying it.
After writing or generating your scripts, use the Test Run feature to validate them against real data before deploying to production. This lets you preview exactly how the synced work items will look on both sides without affecting live data.
Jira Outgoing Script
replica.customFields."Start date" = issue.customFields."Start date"
replica.due = issue.dueCode language: JavaScript (javascript)This script sends the custom “Start date” field and the standard due date from Jira to Azure DevOps via the replica payload.
Jira Incoming Script
import java.text.SimpleDateFormat
import java.text.DateFormat
import java.util.Calendar
import java.util.Date
def datePattern = "yyyy-MM-dd HH:mm:ss";
DateFormat formatter = new SimpleDateFormat(datePattern);
dateString = replica."start"
dateString = dateString.replaceAll("T"," ").trim();
dateString = dateString.replaceAll("Z"," ").trim();
date = formatter.parse(dateString);
def timestamp = date.time
Calendar calendar = Calendar.getInstance()
calendar.timeInMillis = timestamp
calendar.add(Calendar.HOUR_OF_DAY, -5)
def updatedTimestamp = calendar.timeInMillis
issue.customFields."Start date".value = updatedTimestamp
dateString = replica."duedate"
dateString = dateString.replaceAll("T"," ").trim();
dateString = dateString.replaceAll("Z"," ").trim();
date = formatter.parse(dateString);
timestamp = date.time
calendar.timeInMillis = timestamp
calendar.add(Calendar.HOUR_OF_DAY, -5)
issue.due = calendar.getTime()Code language: JavaScript (javascript)Here’s what this does: it defines a date pattern and parses the incoming timestamp string. It strips the “T” and “Z” characters from the ISO format, converts it to milliseconds, then subtracts 5 hours using calendar.add(Calendar.HOUR_OF_DAY, -5). This ensures the timestamp arriving in Jira is adjusted to the correct local time.
Azure DevOps Outgoing Script
replica."start" = workItem."Microsoft.VSTS.Scheduling.StartDate"
replica."duedate" = workItem."Microsoft.VSTS.Scheduling.DueDate"Code language: JavaScript (javascript)This fetches the start and due dates from the default Azure DevOps scheduling fields and passes them through the replica.
Azure DevOps Incoming Script
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Date
def convertJiraTimeToAdoTime(String dateString){
if(dateString == null) return
String inputFormat = "yyyy-MM-dd HH:mm:ss.S"
String outputFormat = "yyyy-MM-dd'T'HH:mm:ss'Z'"
SimpleDateFormat inputDateFormat = new SimpleDateFormat(inputFormat)
SimpleDateFormat outputDateFormat = new SimpleDateFormat(outputFormat)
Date date = inputDateFormat.parse(dateString)
def timestamp = date.time
Calendar calendar = Calendar.getInstance()
calendar.timeInMillis = timestamp
calendar.add(Calendar.HOUR_OF_DAY, 5)
def updatedTimestamp = calendar.timeInMillis
return outputDateFormat.format(updatedTimestamp)
}
String inputDateString = replica.customFields."Start date"?.value
workItem."Microsoft.VSTS.Scheduling.StartDate" = convertJiraTimeToAdoTime(inputDateString)
inputDateString = replica.due
workItem."Microsoft.VSTS.Scheduling.DueDate" = convertJiraTimeToAdoTime(inputDateString)Code language: JavaScript (javascript)This script does the reverse: it converts the incoming Jira date-time string into the Azure DevOps ISO format, adds 5 hours to offset the timezone difference, and assigns the result to the appropriate scheduling fields.
The convertJiraTimeToAdoTime function includes a null check, so if a date field is empty on the Jira side, it won’t throw an error on the Azure DevOps side.
Tips for Date-Time Sync Between Jira and Azure DevOps
- Adjust the offset to your actual timezone difference. The 5-hour offset in these examples is just that, an example. Replace it with the actual hour difference between your teams. If your Azure DevOps team is in UTC+1 and your Jira team is in UTC-5, the offset would be 6 hours.
- Watch out for daylight saving time. If either team observes DST, the offset changes twice a year. You may want to use Java’s TimeZone class for dynamic timezone handling instead of hardcoding the offset.
- Test with edge cases. Dates near midnight, year boundaries, and leap years can expose parsing issues. Use the Test Run feature to validate your scripts against a range of date values before going live.
- Keep your scripts versioned. Exalate’s script versioning feature creates an audit trail every time you update your sync rules. If a date conversion breaks after an update, you can roll back to a previous version instantly.
- Once everything looks good, publish your changes, and your date-time fields will stay in sync between Azure DevOps and Jira Cloud.
- Script-based integrations can feel complex at first, but they give you the precision you need for scenarios like timezone-aware date syncing. And with features like Aida for script generation and Test Run for validation, the learning curve is a lot more manageable.
Have a specific use case that requires handling different data formats? Ask our integration engineers for a walkthrough of what’s possible.
