ServiceNow Jira Integration Guide

Architecture Overview

Implementation Steps

// Custom field mapping function
function mapServiceNowToJira(changeRecord) {
    var jiraPayload = {
        fields: {
            project: { key: gs.getProperty('jira.default.project', 'SNOW') },
            summary: changeRecord.short_description.toString(),
            description: changeRecord.description.toString(),
            issuetype: { name: 'Task' },
            priority: { name: mapPriority(changeRecord.priority.toString()) },
            labels: ['servicenow', 'change-' + changeRecord.number.toString()]
        }
    };
    return jiraPayload;
}

// Flow script step for updating ServiceNow record with Jira key
(function execute(inputs, outputs) {
    var gr = new GlideRecord('change_request');
    if (gr.get(inputs.change_sys_id)) {
        gr.u_jira_issue_key = inputs.jira_key;
        gr.u_jira_url = 'https://yourcompany.atlassian.net/browse/' + inputs.jira_key;
        gr.update();
        outputs.success = true;
    } else {
        outputs.success = false;
        outputs.error_message = 'Change request not found: ' + inputs.change_sys_id;
    }
})(inputs, outputs);

(function process(request, response) {
    var payload = JSON.parse(request.body.data);
    var jiraKey = payload.issue.key;
    var newStatus = payload.issue.fields.status.name;
    
    var gr = new GlideRecord('change_request');
    gr.addQuery('u_jira_issue_key', jiraKey);
    if (gr.next()) {
        gr.state = mapJiraStatusToServiceNow(newStatus);
        gr.work_notes = 'Updated from Jira: Status changed to ' + newStatus;
        gr.update();
        response.setStatus(200);
        response.getStreamWriter().writeString('Success');
    } else {
        response.setStatus(404);
        response.getStreamWriter().writeString('Record not found');
    }
})(request, response);

// Sync conflict detection and resolution
function shouldSyncField(tableName, fieldName, sourceSystem) {
    var syncRule = new GlideRecord('u_integration_sync_rules');
    syncRule.addQuery('table_name', tableName);
    syncRule.addQuery('field_name', fieldName);
    syncRule.addQuery('source_system', sourceSystem);
    syncRule.addQuery('active', true);
    if (syncRule.next()) {
        return syncRule.sync_enabled == true;
    }
    return false; // Default to no sync if rule not found
}

// Integration health check script
var integrationHealth = new GlideRecord('u_integration_health_check');
integrationHealth.initialize();
integrationHealth.system_name = 'Jira';
integrationHealth.last_sync_time = new GlideDateTime();
integrationHealth.sync_status = testJiraConnection() ? 'Success' : 'Failed';
integrationHealth.records_synced_today = getRecordsSyncedCount('today');
integrationHealth.insert();

Common Use Cases

Troubleshooting

Pro Tips

• →Implement custom Transform Maps for bulk data synchronization scenarios where Flow Designer's real-time processing would be inefficient, using scheduled import jobs with the Jira REST API to handle large volumes of historical data migration. Create reusable subflows in Flow Designer for common Jira operations like field mapping and error handling, which can be shared across multiple integration workflows and maintained centrally as business rules evolve.
• →Use ServiceNow's Integration Hub Connection testing capabilities proactively by setting up scheduled business rules that test Jira connectivity and create ServiceNow events when failures are detected, enabling proactive issue resolution before users are affected. Configure separate Connection Aliases for different environments (development, staging, production) to enable proper testing workflows and prevent accidental cross-environment data synchronization during development activities.
• →Leverage Jira's JQL filtering capabilities in webhook configurations to minimize unnecessary webhook calls to ServiceNow, improving performance and reducing the risk of hitting API rate limits during high-activity periods. Implement webhook signature validation using Jira's webhook security features to prevent unauthorized parties from triggering integration workflows and potentially corrupting data or causing performance issues.
• →Create custom ServiceNow reports and dashboards to monitor integration health metrics like sync success rates, average processing times, and common error patterns, enabling data-driven optimization of field mappings and processing logic. Use ServiceNow's Table API and GlideAggregate to build integration analytics that help identify patterns in sync failures and optimize retry strategies based on actual usage patterns.
• →Implement intelligent conflict resolution by storing integration metadata like last sync timestamps and field-level change tracking, enabling sophisticated conflict detection and resolution strategies that consider business context rather than just technical timing. Design your field mappings to be configuration-driven rather than hard-coded, using custom tables or system properties to store mapping rules that business users can adjust without requiring code changes.
• →Consider implementing asynchronous processing patterns using ServiceNow events for complex synchronization scenarios involving multiple related records, preventing timeout issues and improving user experience by decoupling user actions from integration processing time. Use Flow Designer's error handling capabilities to implement sophisticated retry logic with exponential backoff and circuit breaker patterns to gracefully handle temporary Jira outages or performance issues.

Known Limitations

• —Jira Cloud enforces API rate limits of 10,000 requests per hour per connected app, which can be restrictive for organizations with high-volume synchronization requirements or multiple ServiceNow instances connecting to the same Jira instance. The Integration Hub Jira spoke does not include built-in bulk operations, requiring custom REST message implementations for scenarios involving synchronization of hundreds or thousands of records within short time windows.
• —File attachments cannot be synchronized bidirectionally through the standard Jira spoke actions, requiring custom REST API implementations using GlideHTTPRequest or RESTMessageV2 to handle attachment upload and download between systems. The spoke's field mapping capabilities are limited to standard Jira fields and cannot automatically handle custom field synchronization without additional scripting and configuration work.
• —Real-time bidirectional synchronization introduces complexity around conflict resolution when both systems are updated simultaneously, and the spoke does not provide built-in mechanisms for detecting or resolving such conflicts automatically. Webhook reliability depends on network connectivity and Jira Cloud's delivery guarantees, with no built-in message queuing or guaranteed delivery mechanisms for critical updates that must not be lost.
• —The integration requires careful management of user context and permissions, as Jira API operations are performed under a single service account, potentially limiting visibility into who actually made changes in the originating system. Large text fields and complex formatting may not translate properly between ServiceNow's rich text capabilities and Jira's markup syntax, requiring custom transformation logic for proper rendering in both systems.

Frequently Asked Questions