Introduction
Salesforce offers a rich set of integration options to connect with external systems, middleware, and data sources. Knowing the right integration approach depends on use-case factors such as data volume, latency, direction (inbound/outbound), security, and transformation needs.
Integration Patterns & Use Cases
Common integration patterns in Salesforce include:
- Request & Reply (synchronous) — REST/SOAP callouts.
- Fire & Forget (asynchronous) — Outbound Messages, Platform Events.
- Batch Data Synchronization — Bulk API, ETL tools.
- Remote Call-In (external systems call Salesforce) — REST/SOAP APIs, Apex REST, Apex SOAP.
- Data Virtualization — Salesforce Connect (OData), External Objects.
Key Salesforce Integration Options
Below are the integration technologies and how they’re commonly used.
1. REST API (SOAP alternative for lightweight integrations)
Use when you need simple, stateless, JSON-based communication. Ideal for mobile and single-page apps.
GET /services/data/vXX.X/sobjects/Account/001xx000003DGbYAAW
2. SOAP API
Use when you need a formal WSDL, strict contracts, or mature enterprise clients.
3. Bulk API / Bulk API 2.0
Designed for high-volume data loads, asynchronous processing of millions of records. Common for nightly ETL and migrations.
4. Streaming API & PushTopics
Server-sent events for near-real-time notifications when records change. Good for live dashboards and sync use-cases.
5. Change Data Capture (CDC)
Publish detailed record change events (create, update, delete, undelete). Preferred for reliable event-driven architectures.
6. Platform Events
Custom event-driven architecture for decoupled integrations between Salesforce and external systems or internal apps.
7. Outbound Messages (Workflow/Flows)
Declarative option to push SOAP messages to an external endpoint when records meet workflow/flow conditions. Good for legacy systems and simple push workflows.
8. Apex Callouts (HTTP)
Use Apex to call external REST/SOAP services. Combine with Named Credentials for secure authentication and easier endpoint management.
HttpRequest req = new HttpRequest();
req.setEndpoint('callout:My_Named_Credential/services/api');
req.setMethod('POST');
req.setBody(jsonBody);
Http http = new Http();
HTTPResponse res = http.send(req);
9. Apex REST / Apex SOAP
Expose custom REST or SOAP endpoints on Salesforce when you need custom behavior or business logic executed by external systems calling into Salesforce.
10. Salesforce Connect (External Objects & OData)
Virtualize external data in Salesforce without copying it. Works well with OData 2.0/4.0 providers and real-time data access scenarios.
11. External Services & Schema-First Integrations
Register external API schema (OpenAPI) and invoke it directly from Flows via declarative actions. Great for citizen developers and low-code automation.
12. Heroku & Heroku Connect
Use Heroku for custom apps and Heroku Connect to sync data between Heroku Postgres and Salesforce for near real-time, bi-directional synchronization.
13. Middleware & iPaaS (MuleSoft, Informatica, Dell Boomi, etc.)
Enterprise-grade integration platforms provide mapping, transformation, orchestration, retry/monitoring, and connectors to many systems. MuleSoft is Salesforce’s integration partner for robust enterprise scenarios.
14. AppExchange Connectors
Pre-built connectors available on AppExchange for popular systems (SAP, Workday, AWS, Google, Microsoft). Fastest time-to-value for common integrations.
15. Files & Content Integration (Content Connectors, External File Storage)
Integrate external file storage (Box, SharePoint) with Salesforce Files or use content connectors for centralized document management.
Authentication Options
Secure integrations with standard authentication flows:
- OAuth 2.0 (Web Server Flow, JWT Bearer, Username-Password — use carefully)
- Session ID (not recommended for new apps)
- Named Credentials (recommended for Apex callouts — manages authentication centrally)
- Mutual TLS / Certificate-based authentication for SOAP or certain enterprise endpoints
How to choose the right option
Consider the following when selecting an integration approach:
- Latency: real-time vs batch
- Volume: single record vs millions
- Direction: inbound (external → Salesforce) vs outbound (Salesforce → external)
- Governance & Security: OAuth, named credentials, IP allowlists
- Error handling & monitoring: retry policies, dead-letter queues
- Complexity & Cost: custom code vs middleware vs AppExchange connector
Best Practices
- Prefer declarative features when possible (Flows, Outbound Messages, External Services).
- Use Named Credentials to manage secrets and auth centrally.
- Design for idempotency when processing retries.
- Use Bulk API for high-volume loads and change data capture for event-driven sync.
- Monitor integrations with proper logging, alerts, and dashboards.
Sample Apex HTTP Callout (simple JSON)
HttpRequest req = new HttpRequest();
req.setEndpoint('callout:My_Named_Credential/v1/accounts');
req.setMethod('POST');
req.setHeader('Content-Type', 'application/json');
req.setBody('{"Name":"Acme"}');
Http http = new Http();
HTTPResponse res = http.send(req);
System.debug(res.getBody());
Conclusion
Salesforce provides flexible integration options for nearly every scenario — from lightweight REST calls to enterprise-scale middleware and event-driven architectures. The right approach depends on performance, volume, security, and maintenance trade-offs.