How to Sync Statuses & Custom Fields Between Salesforce and Jira

This article was originally published on the Atlassian Community and the Salesforce Community.

Both Jira and Salesforce support default fields and entities for conveying and displaying data, accessible by referencing the API key. But what if the default fields don’t cover what you need?

In that case, you can create custom fields on both platforms and adjust the mapping to sync them. In this post, I’ll show you how to sync data between custom fields on Jira and Salesforce.

How to Add Custom Fields in Jira

Jira supports different types of custom fields (checkboxes, date pickers, user pickers, radio buttons, select lists, and more). Here are the steps for creating custom Jira fields.

• Open your Jira.
• Select Issues.
• Go to Fields and click Custom Fields.
• Select the custom field type you want to create. Then, add context and a default value.
• You can also change the name and assign the screens on which the field should appear.
• Select Edit Default Value to change the data (for editable custom fields).

To retrieve data from the field, you need to call the custom field ID from the Jira REST API.

How to Add Custom Fields in Salesforce

Salesforce users can create custom fields for standard objects (formula, date, email, phone, picklist, etc). Here are the steps to follow:

• Go to Object Manager.
• Click Contact > Click Fields and Relationships > Click New.
• Choose the data type and click Next.
• Enter the values on separate lines, then click Next.
• Select the Contact page layout and click Save.

The custom field will appear on the layout. To retrieve data from it, write the name without spaces and add “__c” (MyCustomField__c).

Common Custom Field Types You Can Sync Between Jira and Salesforce

Not all field types map 1:1 between the two platforms. Here are some of the most commonly synced custom field types and how they translate:

This table helps when you’re writing your sync rules and need to know what transformations to apply.

Why Sync Jira Custom Fields with a Salesforce Account?

Most organizations integrate custom field data between Jira and Salesforce in order to extend the capabilities of both platforms.

For instance, your organization’s customer success partner can add an Account custom field in Jira to store data coming from the default account field on the sales team’s Salesforce. Doing so will help the customer success partner to exchange data in real time with the corresponding team to make timely, informed sales decisions and close deals faster.

Syncing custom field data also improves communication between connected teams, especially for cross-company collaborations that require constant communication and transparency. You can add up to 50 custom fields to your Jira instance in order to obtain extra data points.

Beyond those internal benefits, here are some real-world scenarios where custom field syncing pays off:

• Bug escalation from sales to dev: A customer reports a bug via Salesforce. The Case automatically creates a Jira work item with custom fields like “Customer Tier” and “SLA Deadline” already populated, so developers have full context from the start.
• Opportunity-to-Epic handoff: When a Salesforce Opportunity reaches “Closed Won,” a Jira Epic is created with deal-specific custom fields (revenue impact, delivery timeline). Delivery teams can plan immediately without waiting for manual handoffs.
• MSP client coordination: Managed service providers can sync custom fields like “Client ID” and “Service Level” between their Salesforce org and multiple client Jira instances, keeping each client’s data isolated while flowing automatically.

What Are the Challenges of Syncing Custom Field Data?

In my experience working with custom fields, here are some challenges I’ve run into:

• Remembering the corresponding field on the other side
• Finding the right API name for scripting the connection
• Getting the data transformation right for accuracy
• Not exceeding the API usage and call limits
• Having an automatic retry mechanism for network failures
• Limiting write access to only authorized users within the project or organization
• Handling data type mismatches (for example, a Jira select list mapping to a Salesforce text field requires explicit value conversion)

These problems are common when you decide to build your Jira Salesforce integration solution from scratch. But it doesn’t have to be this way. You can configure the sync using third-party integration solutions that require little to no extra scripting or coding.

One such solution is Exalate. This Jira Salesforce integration tool comes with a Groovy-based engine that allows you to sync custom fields bidirectionally without the hassle of writing custom transformations for both platforms.

Exalate is a two-way integration solution that works with Jira, Jira Service Management, Salesforce, ServiceNow, Azure DevOps Cloud, Azure DevOps Server, Zendesk, Freshservice, Freshdesk, Asana, GitHub, and custom connectors.

• You can use it to sync Salesforce and Jira custom fields as well as several other entities.
• Exalate’s Groovy scripting engine handles complex use cases with full flexibility.
• Exalate allows you to limit what goes in or comes out of your system.
• Aida (AI-assisted configuration) can help generate sync scripts and troubleshoot errors, reducing the learning curve for Groovy scripting.
• Test Run lets you validate your sync scripts against real data before pushing anything to production.

With a bit of customization, you can sync data from custom fields and map them to existing or newly created default fields.

Get Exalate on the Atlassian Marketplace

Jira to Salesforce Use Case: Custom Field Update and Status Sync

Selecting an account name for a custom drop-down field in a Jira work item triggers a sync with the corresponding Salesforce Case entity. At the same time, changing the status of your Jira work item will also update the status of the corresponding Salesforce Case.

Sounds complicated, right? Let me show you the requirements and challenges.

Primary Requirements

When a team member picks a user from the drop-down list, the selected option appears as a text value on a custom field on the Salesforce side. For this to work, you’d need to establish sync rules to control the incoming and outgoing data in custom fields. These rules are single lines of code. You can also set triggers to update the field on both the Jira and Salesforce instances automatically and bidirectionally.

How to Set Up Exalate for Jira Salesforce Custom Field Sync

To get started, go to the Exalate app. If you already have an account, log in directly. New users can create an account by entering their email or by signing up with Google.

Jira Salesforce Configuration Options

After creating your connection, you have two configuration options: “Quick Sync” and “Edit & Test”.

Quick Sync applies a default sync configuration. You can use it to start syncing right away with standard field mappings.

Edit & Test gives you full control. To start making changes to your sync configuration, click “Create a new version” or select “Open latest draft”. This ensures you don’t accidentally modify the existing configuration. Changes in the draft are saved automatically.

Click the “Edit” button to open the editor and modify the sync rules.

Understanding Sync Rules

Sync rules are based on Groovy scripts. With these scripts, you can add custom data logic and mapping, along with conditional flows, allowing you to adapt for any complex or advanced use case.

The direction of the sync can be changed by clicking the two arrows next to the connection name.

The scripts are divided into incoming and outgoing scripts:

• Outgoing script: If the sync direction is from Jira to Salesforce, the outgoing script holds the values passed from Jira to Salesforce.
• Incoming script: The incoming script defines how the values coming from Jira are mapped in Salesforce.

These scripts are reversed if the direction changes.

The replica works like a message payload and holds the actual data passed between the synced entities. It exists in JSON format.

Under the “Rules” tab, enter the following code snippet into the Jira “Outgoing sync” text box:

replica.customFields."SF Contact" = issue.customFields."SF Contact"

Note: The issue.customFields function points to the custom field name within the Jira work item. The replica works as a payload or a message. It contains the information you want to pass between the two systems.

In the Jira “Incoming sync” text box, enter the following snippet:

def statusMapping = ["New":"To Do", "Working":"In Progress","Escalated":"Done"]

def remoteStatusName = replica.Status.value

issue.setStatus(statusMapping[remoteStatusName] ?: remoteStatusName)Code language: JavaScript (javascript)

Note: The statusMapping variable establishes the relationship between statuses. The remoteStatusName maps to the replica’s status. For example, a “New” case on Salesforce appears as “To Do” in Jira.

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

On the Salesforce side, enter the code in the “Incoming sync” text box:

def statusMap = [

  "New":"To Do",

  "In Progress": "Working",

  "Done": "Escalated",

]

def remoteStatusName = replica.status.name

statusName = statusMap[remoteStatusName] ?: remoteStatusName

entity.Status = statusName

entity."Jira_custom_field__c" = replica.customFields."SF Contact".value.valueCode language: JavaScript (javascript)

Note: The statusMap variable establishes the relationship between statuses. The remoteStatusName maps to the replica’s status name. For example, an “Escalated” case on Salesforce appears as “Done” in Jira. The entity."Jira_custom_field__c" function points to the custom field “Jira custom field” within Salesforce. The replica contains the information you want to pass between the two systems.

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

Using AI-Assisted Configuration

To save time and simplify the scripting process, you can use Exalate’s AI-assisted configuration feature called Aida to generate sync scripts.

Just describe what you want to sync in plain language (for example, “Map the SF Contact custom field from Jira to the Jira_custom_field__c field in Salesforce and sync statuses between both systems”), and Aida will generate a starting script for you. You can then review and adjust it as needed.

Testing with Test Run

Once your sync scripts are ready, you can validate them before going live using the Test Run feature.

• Click “Start Test Run”.
• Select the work items you want to apply the sync to. You can select multiple items.
• Review all the incoming and outgoing replicas for each item in their respective tabs.
• Verify that the field mappings look correct. If needed, go back, adjust the scripts, and test again.

Deploy only when you’re confident everything works correctly. This safety net prevents errors from affecting live data.

Once everything matches your needs, click “Publish Version” to apply the updated configuration to your live synchronization.

All versions for a connection are available in the “Version” dropdown. Versions can be either “Active”, in “Draft” (editable), or “Archived”.

Set Up Automated Triggers

Triggers start your sync automatically based on the conditions you specify.

On the Salesforce side, you need to use SOQL (Salesforce Object Query Language) to configure the trigger, or you can opt for filters. You can choose any entity, whether an Opportunity, Case, or Account.

Configure your trigger to the sync requirements and click “Add”.

On the Jira side, you can configure triggers using Jira Query Language (JQL).

Here are sample triggers and explanations:

You can read more about Exalate triggers here.

Now go back to the Jira work item and choose a user from the “SF Contact” drop-down list. Then change the status to “Done”.

Back on Salesforce, you will see the account name appear in the “Jira custom field” automatically.

You have now set rules to help you update and sync custom Jira fields to Salesforce.

Why Exalate for Jira Salesforce Custom Field Sync

If you’re evaluating tools for this kind of sync, here’s what Exalate brings to the table:

• Unified console: Manage all your Jira and Salesforce connections from a single interface. No need to switch between systems.
• Aida (AI-assisted configuration): Generate and troubleshoot sync scripts faster with AI that understands your integration context.
• Test Run: Validate sync scripts against real data before deploying to production.
• Script versioning: Every script publish creates a new version. Full audit trail of who changed what and when, with rollback capability.
• Groovy scripting engine: Handle any custom workflow. If you can write it in Groovy, Exalate can sync it.
• Security: ISO 27001 certified, role-based access control (RBAC), encryption in transit (TLS 1.2/1.3) and at rest, and decoupled access control. Review full details at the Exalate Trust Center.
• Outcome-based pricing: You pay for active sync pairs (work items currently in sync), not user seats or per-transaction fees. Each integration is billed independently.

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

Recommended Reading:

• How To Map and Sync Statuses and Correlation Details Between Azure DevOps and ServiceNow
• How to Sync Incidents, CMDB, Change Requests, Problems, and Custom Fields Between Jira and ServiceNow
• Advanced Integration Use Cases
• How to Synchronize a Zendesk Ticket to Multiple Jira Cloud Instances
• How to Sync Tempo Worklogs Between Two Jira Cloud Instances