Salesforce documents 5 canonical patterns. Understanding them helps choose the right one.
1. Request-Reply (Synchronous)
- Salesforce calls external (or vice versa); waits for response.
- Use case: real-time data lookup ("get current inventory").
- Tooling: REST/SOAP callouts, External Services for declarative.
- Trade-off: blocking; failure mode is ambiguous.
2. Fire-and-Forget
- Salesforce sends data; doesn't wait for response.
- Use case: notifications, audit logging.
- Tooling: Outbound Messages, Platform Events.
- Trade-off: no confirmation of receipt; need separate retry mechanism.
3. Batch Data Synchronization
- Periodic bulk sync of large datasets.
- Use case: nightly reload of inventory, weekly sync of price lists.
- Tooling: Bulk API 2.0, Heroku Connect, ETL tools.
- Trade-off: not real-time; data drift between syncs.
4. Remote Process Invocation (Request-Reply with Process)
- Salesforce kicks off a long-running process in external; gets ID; checks status later.
- Use case: complex computation, AI inference, long workflows.
- Tooling: Heroku/Functions with async pattern; webhook callback when done.
5. UI Update Based on Data Changes
- Salesforce displays data from external system; UI must refresh when source changes.
- Use case: real-time inventory in a sales app.
- Tooling: Salesforce Connect (External Objects), Streaming API for push.
Modern additions:
6. Pub/Sub Eventing
- Decouple via events. Publishers don't know subscribers; subscribers react.
- Use case: distributed system architecture.
- Tooling: Platform Events, Change Data Capture, Pub/Sub API.
Anti-patterns:
- Polling externally every 5 minutes instead of subscribing to events.
- Synchronous chatty calls — multiple round trips per page load.
- Caching for too long — stale data confuses users.
- No retry / error handling — transient failures lose data permanently.
Decision drivers:
- Latency requirement (real-time vs hourly vs daily).
- Volume (10/day vs 10M/day).
- Reliability requirement (best-effort vs guaranteed delivery).
- Cost (synchronous calls hit API limits; bulk is cheaper per-record).
Senior consultants pick the integration pattern from the user-experience requirement backwards, not from "what's available".