Salesforce Integration: A Developer's Roadmap

Overview of Salesforce Integration

Building robust integrations requires a strong foundation in both Salesforce platform limits and industry-standard communication protocols. Whether you are consuming external services or exposing Salesforce data, the architecture must prioritize security, scalability, and idempotency.

Core Integration Patterns

Before writing code, identify the integration pattern that fits your requirements:

• Request-Reply: Synchronous communication where the client waits for a response (e.g., standard REST/SOAP calls).
• Fire-and-Forget: Asynchronous communication using Platform Events or Change Data Capture (CDC).
• Batch Data Sync: Moving large volumes of data using Bulk API 2.0 or ETL/middleware tools.
• Remote Call-in: External systems querying Salesforce via the Force.com REST or SOAP APIs.

Technical Implementation Steps

1. Master Authentication

Security is paramount. Never hardcode credentials. Use OAuth 2.0 flows, specifically:

• JWT Bearer Token Flow: Recommended for server-to-server communication.
• Client Credentials Flow: Ideal for non-user-interactive background processes.

2. Standardize API Usage

When building callouts from Apex, leverage HttpRequest and HttpResponse classes. Always implement robust error handling for HTTP status codes.

Http h = new Http();
HttpRequest req = new HttpRequest();
req.setEndpoint('callout:My_Named_Credential/services/data/v59.0/query?q=SELECT+Id+FROM+Account');
req.setMethod('GET');

HttpResponse res = h.send(req);
if (res.getStatusCode() == 200) {
    System.debug(res.getBody());
} else {
    // Log error and handle exceptions
}

3. Handle Governor Limits

Salesforce imposes strict limits on callouts (e.g., 100 callouts per transaction). Use the @future(callout=true) annotation or Queueable Apex to move long-running operations outside the main transaction.

Best Practices for Architects

• Use Named Credentials: Decouple endpoints and authentication settings from your code.
• Implement Idempotency: Ensure that processing the same message twice does not result in duplicate records.
• Monitoring: Always log integration failures to a dedicated object or platform event for auditing.

Key Takeaways

• Protocols: Prioritize REST for modern integrations; use SOAP only for legacy systems or specific enterprise requirements.
• Security: Use Named Credentials and OAuth flows rather than storing tokens in custom settings.
• Async First: Always consider if a process can be handled asynchronously to avoid hitting synchronous governor limits.
• Tooling: Become proficient with Salesforce CLI for testing and Postman for exploring APIs.