ServiceNow Salesforce Integration Guide

Architecture Overview

Implementation Steps

// Transform script for Priority mapping in Flow Designer
(function transform(source) {
    var priorityMap = {
        '1': 'High',
        '2': 'Medium', 
        '3': 'Low',
        '4': 'Planning',
        '5': 'Planning'
    };
    return priorityMap[source] || 'Medium';
})(fd_data.current.priority);

// Duplicate check logic in Flow Designer script
var gr = new GlideRecord('core_company');
gr.addQuery('name', fd_data.salesforce_account.Name);
gr.query();
if (gr.next()) {
    fd_data.company_sys_id = gr.getUniqueValue();
    fd_data.update_existing = true;
} else {
    fd_data.update_existing = false;
}

(function process(request, response) {
    var payload = request.body.data;
    var caseId = payload.Id;
    var caseStatus = payload.Status;
    
    // Find corresponding incident by external reference
    var incident = new GlideRecord('incident');
    incident.addQuery('u_salesforce_case_id', caseId);
    incident.query();
    
    if (incident.next()) {
        incident.setValue('state', mapSalesforceStatusToIncidentState(caseStatus));
        incident.update();
        response.setStatus(200);
        response.getStreamWriter().writeString('Success');
    } else {
        response.setStatus(404);
        response.getStreamWriter().writeString('Incident not found');
    }
})(request, response);

// Test script to validate sync status
var testIncident = new GlideRecord('incident');
testIncident.addQuery('u_salesforce_case_id', '!=', '');
testIncident.addQuery('sys_created_on', '>', gs.daysAgoStart(1));
testIncident.query();
gs.info('Found ' + testIncident.getRowCount() + ' synced incidents in last 24 hours');

while (testIncident.next()) {
    gs.info('Incident: ' + testIncident.number + ' synced with Salesforce Case: ' + testIncident.u_salesforce_case_id);
}

Common Use Cases

Troubleshooting

Pro Tips

• →Implement correlation ID fields (like u_salesforce_case_id, u_salesforce_account_id) in your ServiceNow tables to maintain permanent links between synchronized records, preventing duplicate creation and enabling efficient updates. Use these fields as indexed database columns for faster lookup performance and include them in all sync flows for reliable record matching.
• →Configure Integration Hub retry policies and error handling workflows to automatically handle transient API failures, network timeouts, and rate limiting scenarios without manual intervention. Set up email notifications for integration administrators when critical sync failures occur, but avoid alerting for temporary issues that resolve automatically through retry logic.
• →Use Salesforce Platform Events instead of Outbound Messages for real-time notifications when possible, as they provide better scalability, retry capabilities, and detailed delivery tracking compared to traditional workflow-based outbound messages. Platform Events also support event replay functionality for better reliability during ServiceNow maintenance windows.
• →Implement field-level change detection in your Flow Designer flows to sync only modified data rather than full record updates, reducing API call consumption and improving performance. Store hash values or last-modified timestamps to compare against incoming data and skip unnecessary updates when no changes have occurred.
• →Create comprehensive logging and monitoring dashboards that track sync success rates, API usage trends, and data quality metrics across your Salesforce integration. Use ServiceNow's Integration Hub dashboard widgets and custom Performance Analytics datasets to provide visibility into integration health and identify optimization opportunities.
• →Schedule bulk synchronization jobs during off-peak hours and implement incremental sync patterns that process only records modified within specific time windows rather than full dataset refreshes. This approach minimizes impact on system performance while ensuring data consistency between platforms.

Known Limitations

• —Salesforce API rate limits vary significantly by edition and can impact sync frequency, with Enterprise edition providing 15,000 API calls per 24 hours while Unlimited provides 100,000 calls, requiring careful planning for high-volume synchronization scenarios. Integration Hub doesn't automatically queue failed requests beyond basic retry attempts, so sustained rate limiting can cause data sync delays requiring manual intervention.
• —Real-time bidirectional synchronization can create infinite loops if not properly designed with loop prevention logic, particularly when both systems trigger updates simultaneously on the same record. ServiceNow's Integration Hub lacks built-in loop detection, requiring custom correlation tracking and synchronization state management to prevent circular update scenarios.
• —Large dataset synchronizations (over 10,000 records) may exceed ServiceNow's transaction timeout limits or Salesforce's single API call result size restrictions, requiring complex pagination and batch processing logic that increases implementation complexity. The Integration Hub Salesforce spoke doesn't automatically handle bulk API operations, limiting throughput for initial data migration scenarios.
• —Field-level security and sharing rules in Salesforce are enforced during API operations, potentially causing sync failures for records that the connected user cannot access or modify based on their profile and permission sets. This requires careful planning of the integration user's permissions and may necessitate separate integration users for different types of data access.

Frequently Asked Questions