What are the core Salesforce Integration Patterns?

The core patterns include Request & Reply, Fire & Forget, Batch Data Sync, UI Update Based on Data Changes, Remote Call-In, and Virtual Integration patterns like Salesforce Connect and External Objects.

How do I choose the right integration pattern for Salesforce?

Choose based on your need: data movement, real-time process execution, or virtual access to external data.

What is the difference between Data Integration and Process Integration?

Data Integration focuses on syncing records, whereas Process Integration focuses on triggering actions across systems in real time.

When should I use Virtual Integration?

Use Virtual Integration when you want real-time access to external data without importing or storing it in Salesforce.

Guide to Salesforce Integration Patterns

1. What Are Salesforce Integration Patterns?

Integration Patterns are standardized, reusable architectural approaches that help enterprises connect Salesforce with external applications in a scalable, reliable, and predictable way.

These patterns guide how data should flow, how processes should be triggered, and how systems should communicate to maintain performance, consistency, and governance in enterprise environments.

Salesforce classifies integration needs into three primary categories:

UData Integration – Moving or synchronizing data across systems
Process Integration – Triggering business processes across systems in real time
Virtual Integration – Accessing external data without storing it in Salesforce

These categories ensure architects and enterprise IT teams choose the correct pattern for performance, reliability, and maintainability.

Patterns of Salesforce integration are templates for your integration architecture. They offer established, repeatable patterns for common use cases, e.g., data synchronization, API interactions, and event-driven updates, to avoid having to reinvent the wheel each time. These patterns introduce consistency, scalability, and reliability in integration design.

Practically, these patterns guarantee that your integrations are more stable, maintainable, and faster to deploy. Indeed, as Salesforce itself emphasizes, it is possible to capitalize on such patterns to ensure teams deliver to production within the shortest possible time with the most stable, scalable, and maintenance-free applications.

2. Salesforce Integration Patterns Explained

Salesforce outlines various patterns of core integration that are used to establish an efficient, scalable, and maintainable integration. Such patterns are founded on years of practice and are applied by architects all over the world to resolve the most frequent integration issues. Every pattern addresses a particular business and technical need: do you need real-time synchronization, asynchronous processing, moving large amounts of data, or updating a user interface?

Below are the five classic Salesforce integration patterns, each offering a distinct approach to ensuring seamless connectivity between Salesforce and external systems.

Infographic illustrating the 5 core software architecture patterns: Request and Reply, Fire and Forget, Batch Data Synchronization, Remote Call-In, and UI Update Based on Data Changes, shown with colorful icons and a modern tech design.

Request and Reply

Request and Reply pattern allows Salesforce to make a call to another system and wait till it will respond. This is a synchronous model of communication that is suitable in real-time data retrieval and decision-making.

Example : When a sales representative makes a sales order and checks the availability of products in an ERP system, Salesforce makes an API call to the ERP synchronously, retrieves the most recent inventory data, and confirms the order immediately.

Key Characteristics:
- Interaction in real time, synchronously.
- Provides accuracy of data when undertaking crucial business transactions.
- Most appropriate in situations where immediate validation is needed (e.g. pricing, credit check, or inventory validation).
Fire and Forget

Fire and Forget pattern enables Salesforce to call a process on a third-party system without the need to wait to get a response. This is an asynchronous method that enhances user experience and efficiency of the system since it does not block Salesforce UI or slow down other processes.

Example : Once a contract has been signed in Salesforce, it sends a call to a billing system to create an invoice. The request is made; Salesforce does not wait to be confirmed but just continues, which makes the process quicker and more decoupled.

Key Characteristics:
- One way, asynchronous communication.
- Best suited to event-driven integrations which do not need live feedback.
- Ordinarily applied in notifications, triggers, and background updates.
Batch Data Synchronization

The Batch Data Synchronization pattern is adopted when a large amount of data has to be shared between Salesforce and another system on a regular basis. Data synchronization is not done in real time but in bulk batches at specified times.

Example : Thousands of customer or order records are synchronized between Salesforce and an on-premises ERP every night. These two systems can be synchronized by moving data in a batch at off-peak times without putting a strain on their APIs or performance.

Key Characteristics:
- Periodic, bulk data transfer.
- Good at the processing of large datasets and reduction of API calls.
- Usually done with Salesforce Bulk API, Data Loader, or ETL software, such as MuleSoft or Informatica.
Remote Call-In (Inbound to Salesforce)

In this pattern, the external systems will start communicating with Salesforce, usually by calling its open APIs like REST, SOAP, or custom Apex endpoints. This inbound integration enables external applications to create, update, or query Salesforce records in real time.

Example : A Salesforce e-commerce site automatically sends the new orders to Salesforce as soon as the customer checks out. The information is sent and processed by Salesforce, and the records of opportunities or orders are automatically updated.

Key Characteristics:
- The caller is the external system; the receiver is Salesforce.
- Allows real-time incoming data into Salesforce.
- Maintains Salesforce as the sole source of customer and transaction information.
UI Update Based on Data Changes

This pattern allows the Salesforce user interface to dynamically reflect changes in other systems in close real time. It is perfect to improve the user experience by ensuring Salesforce data is always updated without manual updates.

Example : A logistics organization combines its warehouse system with Salesforce Service Cloud. When the shipment status is altered (e.g. In Transit to Delivered), the change is reflected in Salesforce immediately. The latest delivery information is immediately available to support agents and customers.

Key Characteristics:
- Synchronization in real time or near real time.
- Consumes Streaming API, Change Data Capture (CDC), or Platform Events.
- Best suited to dashboards, live data feeds, and interactive customer portals.

Choosing the Right Pattern

Every pattern of integration fits a different business and technical requirement. The choice of the appropriate one is based on the objectives of your system:

Real-time data requirements: Request and Reply.
Asynchronous updates of events: Fire and Forget.
Large-scale data transfer: Batch Data Synchronization.
Inbound system communication: Remote Call-In.
Real-time synchronization of UI: Use UI Update Based on Data Changes.

With the knowledge and practical use of these patterns, architects are able to create Salesforce integrations that are efficient, secure, and scalable, forming the foundation of a connected enterprise ecosystem.

3. Real-World Use Cases of Salesforce Integration Patterns

It is one thing to know integration patterns conceptually; it is another thing to see how they actually apply to business in real-world situations and see their worth. All patterns have their merits based on the usage, volume of data required, and performance requirements.

Following are some of the real-life examples of how these patterns are applied in organizations in different industries:

Live Business Transactions and Data Checking

The Request and Reply pattern is frequently used in enterprises that require the accuracy of data in real-time, like retail, finance, and healthcare. It allows Salesforce to synchronously call external systems and obtain the most up-to-date information on demand, including checking inventory availability, verifying the credit limit of a customer, or substantiating insurance eligibility.

This guarantees that users will always be dealing with current data when making important business decisions. It eliminates the possibility of inconsistencies and enhances the reliability of transactions.
Event-Based Notifications and Process Automation

Companies use the Fire and Forget pattern to run processes that do not need real-time responses, such as sending notifications, starting billing processes, or automating workflows. In this case, Salesforce transmits information or event notifications to a different system and proceeds to execute additional processes without receiving a response.

This asynchronous design is more scalable and places less load on the system. It provides faster transaction speed, particularly in customer engagement processes, automated invoicing, and marketing triggers.
Massive Data Transfer and System Reconciliation

The Batch Data Synchronization pattern is required in enterprises that handle large amounts of customer, order, or financial data, e.g., manufacturing or telecom organizations. Bulk data exchange between ETL tools or Salesforce Bulk APIs is performed on a scheduled basis.

This is suitable in the case of nightly account and transaction record synchronization, massive migrations, or periodic Salesforce-to-ERP system updates. It maintains the consistency of data and reduces overhead on performance during business hours.
Inbound Data and System-to-Salesforce Integrations

The Remote Call-In pattern is very common where external systems are required to push data into Salesforce in real-time (e.g., e-commerce platforms or partner portals). Salesforce provides these systems with the ability to create or update records by exposing REST or SOAP endpoints.

The most common applications are the automatic pushing of online orders, customer registrations, or service requests into Salesforce. This real-time inbound integration ensures that manual data entry is removed and that real-time updates are made in sales, service, and fulfillment processes.

Note: In this pattern, Salesforce does not call the external system. Instead, Salesforce exposes REST/SOAP/Apex APIs, and external applications initiate communication. Remote Call-In is a process integration pattern, enabling real-time inbound interactions.
Live Visibility and Interactive User Interfaces

The contemporary business needs real-time information about operations, whether it is delivery tracking, financial figures, or viewing live services. The UI Update Based on Data Changes pattern allows Salesforce to show external system updates in real-time in its user interface.

With the help of such technologies as Streaming API and Change Data Capture (CDC), Salesforce can automatically update dashboards, cases, or records when data is updated outside of Salesforce. This leads to a customer and internal user-friendly, interactive experience, which improves the decision-making process and operational transparency.

4. Best Practices for Implementing Salesforce Integration Patterns

When creating Salesforce integrations, it is necessary to design integrations that are both scalable and maintainable, and to do so, one must not only select the appropriate pattern but also follow good architectural principles. All the integration patterns have their own advantages, constraints, and factors that affect performance, reliability, and security.

The best practices below describe how every pattern is to be constructed and executed to be as effective as possible.

Request and Reply Pattern

The Request and Reply pattern is used when Salesforce must make a call to an external system and wait for an immediate response before continuing the process. This is a synchronous, real-time interaction where the external system must respond within a defined timeframe. Because it directly affects UI performance and user workflows, the reliability and responsiveness of the external system are critical.

Important Clarification
- Salesforce initiates the call in this pattern.
- The process is synchronous—Salesforce waits for the external system’s response.
- It is typically used for real-time decisioning, validation, or data retrieval, not large-scale data movement.
- This pattern falls under process integration because it drives immediate business logic execution.
When to Use
- Real-time price, credit, or inventory checks
- Instant validations during quoting or order processing
- Decision-making workflows that require accurate external data
- Situations where partial or stale data cannot be tolerated
Fire and Forget Pattern

The Fire and Forget pattern is used when Salesforce needs to send data or trigger a process in another system without waiting for a response. This is an asynchronous, one-way interaction that improves system performance, reduces UI latency, and decouples Salesforce from downstream applications. Because Salesforce does not wait for acknowledgment, reliability must be ensured through middleware or message queues.

Important Clarification
- Salesforce sends a message once and continues processing immediately.
- The receiving system is responsible for handling, processing, and acknowledging the request.
- This pattern is event-driven, used when the response is not needed in real time.
- It is part of process integration, not data synchronization.
When to Use
- Triggering billing, invoicing, or fulfillment workflows
- Sending notifications or events to downstream systems
- Kicking off background processes or asynchronous automations
- Low-latency user experiences where waiting for a response is unnecessary
Batch Data Synchronization Pattern

The Batch Data Synchronization pattern is used when large volumes of data must be exchanged between Salesforce and external systems at scheduled intervals instead of in real time. This is ideal for nightly jobs, data warehousing, large-scale transformations, and environments where performance must be preserved during business hours.

Important Clarification
- This pattern is not intended for real-time use cases.
- It supports bulk data movement, typically involving thousands or millions of records.
- It relies on ETL tools, Bulk APIs, or integration platforms to ensure transformation and load efficiency.
- This pattern belongs to data integration, not process integration.
When to Use
- Nightly syncs between Salesforce and ERP/financial systems
- Migrating or consolidating large datasets
- Periodic reconciliation of customer, order, or transaction data
- Environments with strict API limits or heavy daytime system usage
Remote Call-In Pattern (Inbound to Salesforce)

The Remote Call-In pattern is used when external systems need to call Salesforce to create, update, or retrieve data or to trigger Salesforce business logic. In this pattern, Salesforce exposes REST, SOAP, or custom Apex APIs, and the external application becomes the caller. This enables real-time inbound data processing and cross-system orchestration.

Important Clarification
- Salesforce does not initiate the call.
- External systems call Salesforce’s exposed APIs.
- This pattern is a process integration pattern, not a data movement pattern.
- API security, throttling, and validation rules are crucial to ensure safe and controlled data ingestion.
When to Use
- Mobile apps updating Salesforce records
- E-commerce platforms pushing orders into Salesforce
- External systems triggering Salesforce flows or Apex logic
- Real-time customer registration or service request intake
UI Update Based on Data Changes (Publish/Subscribe Pattern)

The UI Update Based on Data Changes pattern is used when Salesforce must automatically refresh UI components in response to data updates occurring either inside Salesforce or in external systems. This pattern leverages event-driven mechanisms like Platform Events, Change Data Capture (CDC), and the Streaming API so that Lightning components receive updates the moment data changes, without the user needing to refresh the page.

Important Clarification
- This is a publish/subscribe (pub/sub) pattern, not a polling pattern.
- Salesforce components subscribe to data change events.
- External or internal systems publish events that trigger UI refreshes.
- This is a virtual/process integration pattern, depending on whether Salesforce stores the updated data.
When to Use
- Real-time dashboards and operational control centers
- Live tracking (orders, shipments, service requests)
- Agent consoles requiring second-by-second updates
- Customer portals displaying live system or transaction status

5. How to Choose the Right Salesforce Integration Pattern

Choosing the right integration pattern depends on the level of interaction you need between Salesforce and external systems. Architects typically evaluate three core needs: data, process, and virtual access. Once those needs are clear, it becomes easier to map the requirement to the correct integration pattern.

Data Integration – When you need to move or sync data

Use this when your goal is to replicate, migrate, or synchronize data between Salesforce and other systems.

Best For:
- High-volume data transfers
- Nightly or scheduled sync
- ETL or MDM workflows
Common Examples:
- ETL jobs
- Master data sync
- Scheduled batch updates
Recommended Salesforce Patterns:
- Batch Data Synchronization
- Remote Call-In (if external systems push data into Salesforce)
Process Integration – When actions must happen in real time

Choose this when events in one system must immediately trigger workflows in another.

Best For:
- Real-time API interactions
- Validations before completing a transaction
- Updating Salesforce instantly from an external app
Common Examples:
- External apps triggering Salesforce flows
- Real-time purchase/transaction validation
- Real-time API request–response scenarios
Recommended Salesforce Patterns:
- Remote Process Invocation – Request & Reply
- Remote Process Invocation – Fire & Forget
- Platform Events / Event-Driven Integration
Virtual Integration – When you need to view external data without storing it

Use this when Salesforce should read and display data from external systems while keeping storage usage low.

Best For:
- Avoiding data duplication
- External databases or ERP systems that hold source-of-truth data
- Use cases where the data changes frequently
Common Examples:
- Salesforce Connect
- OData connections
- External Objects
Recommended Salesforce Patterns:
- Data Virtualization
- UI/Composite Integration

Why It Matters:

Virtual integration reduces storage costs, avoids redundancy, and keeps your Salesforce org clean while still giving users seamless access to essential data.

If Your Need Is	Choose	Appropriate Patterns
Synchronizing or Moving Data	Data Integration	Batch Data Sync, Remote Call-In
Triggering Actions Across Systems	Process Integration	Request & Reply, Fire & Forget, Platform Events
Viewing Data Stored Elsewhere	Virtual Integration	Data Virtualization, External Objects

6. Key Factors to Consider When Selecting a Pattern

Real-time vs. Deferred: Determine whether users expect instant feedback through synchronous integrations like Request and Reply, or if operations can be decoupled using asynchronous methods like Fire and Forget or Batch Synchronization.
One-way vs. Two-way: Assess whether data flows in one direction or needs bi-directional synchronization. For example, a two-way sync might combine Batch for bulk updates with Remote Call-In for inbound real-time updates.
Volume and Limits: Evaluate the size and frequency of data transfers. Large datasets typically demand batch-oriented solutions, whereas high-frequency small transactions benefit from real-time APIs or event-driven architectures.
System Capabilities: Understand the technical landscape of connected systems. Identify whether they support REST APIs, message queues, or change data events, as this impacts the integration method you can deploy.
Failure Handling: Consider how your integration handles errors. Certain patterns simplify retries, for instance, Batch Synchronization allows reprocessing of failed records, while event-driven designs queue and replay messages for resilience.

7. Conclusion: A Pattern-First Approach to Success

A pattern-first approach is important in a complex IT environment. The correct integration pattern is the place to begin with your architecture to make sure it has a solid foundation built on scalability, consistency, and long-term reliability. By matching your business scenario to one of the classic patterns (and following the best practices above), you minimize guesswork, reduce integration risks, and build a more robust, future-ready solution.

Whether integrating ERP data, linking a web store, or providing real-time dashboards, keep in mind: select the pattern that is appropriate to the problem, and then apply it wisely to ensure that performance is seamless and growth is sustainable.

At Congruent Software, we have experienced first-hand how a pattern-first approach can create solid, future-proof Salesforce integrations. Through making decisions on architecture in line with these proven design principles, we create integrations that are technically sound and also strategically aligned with the growth and performance objectives of our clients. Get in touch with us to learn how our Salesforce consulting team can help you build scalable integrations that fit your business requirement.

8. Frequently Asked Questions

What are the core Salesforce Integration Patterns?

The core patterns include Request & Reply, Fire & Forget, Batch Data Sync, UI Update Based on Data Changes, Remote Call-In, and Virtual Integration patterns like Salesforce Connect and External Objects.
How do I choose the right integration pattern for Salesforce?

Choose based on your need: data movement, real-time process execution, or virtual access to external data.
What is the difference between Data Integration and Process Integration?

Data Integration focuses on syncing records, whereas Process Integration focuses on triggering actions across systems in real time.
When should I use Virtual Integration?

Use Virtual Integration when you want real-time access to external data without importing or storing it in Salesforce.

The Definitive Guide to Salesforce Integration Patterns and Best Practices for Architects