Most failed integrations didn’t fail because someone picked the wrong API. They failed because someone made a batch job behave like a real-time call, or let a user wait on a system that sometimes takes 40 seconds to answer.
Salesforce publishes 6 integration patterns to prevent exactly that. This guide explains each one with a real example, shows how to choose, and covers the error handling and limits the pattern docs mention only briefly.
Start with 3 questions
Salesforce’s Integration Patterns guide on the Architects site sorts every integration by direction, type and timing. Answer these before you pick a tool.
Which direction? Is Salesforce calling another system, or is another system calling Salesforce?
What type? Process (kick off work somewhere else), data (keep records in sync) or virtual (show external data without storing it).
What timing? Synchronous, where someone waits for the answer, or asynchronous, where the answer can come later.
Once you know those, the pattern mostly picks itself.
The 6 patterns, with examples
1. Request and reply
Salesforce calls a remote system, waits, and uses the response straight away.
Example: a rep clicks “Check credit” on an account, Salesforce calls the finance system, and the credit limit appears on the screen 2 seconds later.
Use it when a person is waiting and the payload is small. The architect guide advises against it for batch payloads. If the remote system can take more than a few seconds, this pattern will make your users miserable.
2. Fire and forget
Salesforce sends a message and moves on once the other side acknowledges it. The actual work finishes later.
Example: an opportunity closes, Salesforce publishes an event, and the ERP creates a sales order a minute later. The rep doesn’t wait.
This is the right default for most process integrations. It survives a slow or briefly unavailable remote system, as long as you design retries (more on that below).
3. Batch data synchronization
Data moves in bulk on a schedule, in either direction.
Example: every night, product prices and stock levels from the ERP update 50,000 product records in Salesforce.
Use it when freshness of a few hours is fine and volumes are large. Bulk API is built for this. Our ERP integration patterns post goes deeper on SAP and NetSuite specifically.
4. Remote call-in
Another system creates, reads, updates or deletes Salesforce data.
Example: your website’s sign-up form creates a lead in Salesforce through the REST API, or a billing system updates an account’s payment status.
The external system needs its own integration user, scoped permissions, and a plan for what happens when Salesforce rejects a record because of a validation rule.
5. UI update based on data changes
The Salesforce screen refreshes when the underlying data changes, without the user reloading.
Example: a service agent has a case open. A field technician’s mobile app updates the case status, and the agent’s screen shows the change immediately.
This usually runs on platform events or Change Data Capture with a Lightning component listening for them.
6. Data virtualization
Salesforce shows external data in real time without copying it.
Example: a service agent sees a customer’s last 20 orders, which live in an order database, as a related list on the account. Nothing is stored in Salesforce.
It avoids sync and reconciliation work. The trade-off is dependency: if the order database is down, the related list is empty.
Which pattern fits which job
Job | Pattern | Typical Salesforce tools
|
|---|---|---|
Rep needs an answer on screen now | Request and reply | Apex callout, External Services, Named Credentials |
Closed deal must create an order elsewhere | Fire and forget | Platform events, Flow, middleware |
Nightly price or inventory refresh | Batch data synchronization | Bulk API 2.0, middleware, ETL tools |
Website or app writes leads, orders or payments into Salesforce | Remote call-in | REST API, Composite API |
Screens refresh when other systems change records | UI update based on data changes | Change Data Capture, platform events, Lightning components |
Show external records without storing them | Data virtualization | Salesforce Connect, external objects |
For a plain-language rundown of the APIs in the right-hand column, see our guide to Salesforce integration APIs.
Events: the modern way to do asynchronous work
Most asynchronous integrations now run on 2 Salesforce features.
Change Data Capture publishes an event whenever a record is created, edited, deleted or restored, so external systems can mirror the change almost instantly. Platform events let you define your own business events, such as “Order Approved.”
External systems usually consume those events through the Pub/Sub API, which runs on gRPC and HTTP/2 and sends compact binary messages. The architect guide treats Pub/Sub API as the recommended approach and labels CometD long polling and outbound messaging as legacy. If a vendor proposes outbound messaging for a new build in 2026, ask why.
Do the API limit math before you build

Every remote call-in and batch job uses API requests, and they’re capped per 24 hours. Salesforce’s developer limits reference gives Enterprise Edition a base of 100,000 requests plus 1,000 per Salesforce license. Unlimited and Performance get 5,000 per license.
So a 200-user Enterprise org has about 300,000 calls a day. That sounds like a lot until a website pushes every page view as a separate call, or a sync job updates 50,000 records 1 at a time instead of in batches.
The same reference caps long-running requests (20 seconds or more) at 25 at once for production orgs. A slow external system called synchronously can hit that ceiling during a busy hour and start returning errors to everyone.
What the pattern docs don’t cover enough
Picking the pattern is half the design. These 4 decisions decide whether it survives its first bad day.
Retries. Every asynchronous integration needs a retry policy: how many attempts, how far apart, and where failed messages go after the last try. Without one, a 10-minute ERP outage silently loses every order created during those 10 minutes.
Idempotency. A retry can deliver the same message twice. Each message needs a unique key (an external ID or event ID) so the receiving system can ignore duplicates. We’ve seen an ERP create 2 sales orders for 1 deal because the design skipped this step.
Error ownership. When Salesforce rejects a record from another system, who gets told? Route errors to a queue or a channel that a named person watches, not a shared inbox that goes unread.
Monitoring. Track message counts, failures and lag per integration, and alert when any drifts. Our post on why Salesforce integrations fail covers the failure modes we see most often.
When to add middleware
The architect guide recommends middleware for complex orchestration, transactions across several systems, heavy transformation and aggregation. That keeps the work away from Salesforce governor limits and timeouts.
Our rule of thumb: once more than 3 systems exchange the same business object (customer, order, product), put a middleware layer in the middle. Point-to-point connections multiply fast. Connect 5 systems directly and you can end up maintaining 10 separate integrations.
A worked example: one company, 4 patterns
Picture a B2B distributor with Salesforce, an ERP, a website and a support desk.
- Credit check on the account page: request and reply, because the rep waits for it.
- Closed-won deal creates an ERP sales order: fire and forget through a platform event, with retries and the opportunity ID as the idempotency key.
- Nightly price and stock refresh: batch data synchronization through Bulk API 2.0.
- Website quote requests create leads: remote call-in through the REST API, with a dedicated integration user.
None of these 4 jobs share a pattern, and forcing them into one would break at least 2. In our prospecting tools case study, 3 enrichment providers were combined into a single request-and-reply action with waterfall logic, because the rep needed the result on screen.
Design integrations that hold up
HyphenX designs Salesforce integrations around the right pattern for each job, with retries, idempotency and monitoring built in from day 1. Talk to our Salesforce integration services team, or see our API integration services for custom builds.
Frequently asked questions
What are the main Salesforce integration patterns?
Salesforce’s architect guide lists 6: request and reply, fire and forget, batch data synchronization, remote call-in, UI update based on data changes, and data virtualization. They’re grouped by direction (into or out of Salesforce), type (process, data or virtual) and timing (synchronous or asynchronous). Most real projects use 2 or 3 of them for different jobs.
What’s the difference between request and reply and fire and forget?
With request and reply, Salesforce waits for the remote system to finish and uses the answer immediately, so it suits small, real-time requests where a user is waiting. With fire and forget, Salesforce hands off the message and continues once receipt is acknowledged. The work finishes later, so it suits processes like order creation where the user doesn’t need to wait.
How many API calls does a Salesforce org get per day?
Enterprise and Professional Edition orgs with API access get a base of 100,000 requests per 24 hours plus 1,000 per Salesforce license. Unlimited and Performance get 5,000 per license instead. Salesforce’s developer limits reference has the full table, including community and platform licenses, and you can buy API call add-ons if you need more.
When should I use middleware such as MuleSoft?
Use middleware when an integration involves several systems, multi-step orchestration, heavy data transformation or aggregation, which Salesforce’s architect guide recommends keeping out of Salesforce to avoid governor limits and timeouts. Simple point-to-point connections between 2 systems often don’t need it. Once 3 or more systems share the same business object, middleware usually pays for itself.