Ankita

salesforce integration Pattern

Salesforce provides 6 core integration patterns that can be used for various integration scenarios
with external systems. These patterns help define how systems should communicate and exchange
data with Salesforce. The integration patterns are designed to address different business
requirements, such as real-time, batch, and event-driven integrations.

Here are the 6 key integration patterns in Salesforce:

1. Request and Reply

• Description: In this pattern, Salesforce makes a request to an external system and waits for
an immediate response.
• Use Case: Typically used in real-time integration where Salesforce needs an immediate
response from an external system to proceed with the next action.
• Example: A user clicks a "Check Availability" button in Salesforce, which sends a request to
an external inventory system to check the stock level. The response is then used to show the
result to the user.
• Implementation: This can be achieved via Apex (SOAP/REST APIs) or using Outbound
Messages.

2. Fire and Forget

• Description: Salesforce sends a request to an external system but does not wait for any
response. It simply "fires" the request and continues with its operations.
• Use Case: Useful when you don't need an immediate response and can handle delays or
failures later.
• Example: Salesforce sends a data update to an external CRM system, but doesn't need to
wait for confirmation before continuing its process.
• Implementation: Can be implemented with Apex Callouts, Outbound Messages, or
Platform Events.

3. Batch Data Synchronization

• Description: This pattern is used for synchronizing large volumes of data between Salesforce
and external systems on a scheduled or periodic basis.
• Use Case: When large amounts of data need to be integrated, such as nightly data imports
or exports.
• Example: Syncing customer data from an external ERP system to Salesforce every night.
• Implementation: Typically implemented via Batch Apex, Data Loader, or third-party
integration tools like MuleSoft, Jitterbit, and Dell Boomi.

4. Publish-Subscribe

Joyful Learning
 Ankita

• Description: Salesforce publishes events or messages that external systems subscribe to.
This decouples the sender and receiver, allowing systems to act upon the event without
directly communicating with each other.
• Use Case: Suitable for event-driven architectures where external systems need to be
notified of changes in Salesforce or vice versa.
• Example: A new order is created in Salesforce, and an external system listens for this event
to trigger shipment processing.
• Implementation: Implemented using Platform Events or Change Data Capture (CDC) in
Salesforce. External systems can subscribe to these events via webhooks or APIs.

5. Data Virtualization

• Description: This pattern allows Salesforce to access external data without actually storing it
inside Salesforce. The external data is viewed as if it is part of the Salesforce environment
but resides in an external database or system.
• Use Case: Useful when you need to access real-time data from external systems without
duplicating or storing it in Salesforce.
• Example: Displaying customer order details from an external system within Salesforce
without importing the data into Salesforce.
• Implementation: This can be achieved using Salesforce Connect, which uses OData (Open
Data Protocol) or custom adapters to connect to external systems like SAP, SQL databases,
or custom RESTful services.

6. Smart Data Replication

• Description: In this pattern, Salesforce periodically replicates data from external systems,
but with logic to ensure that only the relevant and updated data is transferred.
• Use Case: Typically used when data needs to be replicated but only changes need to be
transferred to minimize data overhead and optimize synchronization.
• Example: Periodically syncing customer or product data from an external system but only
transferring records that have been updated or modified.
• Implementation: This can be done with Apex Scheduled Jobs, Data Sync Tools (such as
Informatica, MuleSoft), or Incremental Batch Jobs.

Summary of Integration Patterns:

Joyful Learning
 Ankita

Pattern Description Use Case

Synchronous, Salesforce sends request Real-time data exchange requiring
Request and Reply
and waits for a response. immediate responses.
Asynchronous, Salesforce sends request Non-blocking actions that don't
Fire and Forget
but doesn't wait for response. require immediate responses.
Batch Data Periodic synchronization of large data Scheduled data imports/exports,
Synchronization volumes. batch data processing.
Event-driven integration where systems Event-driven architectures with
Publish-Subscribe
publish/subscribe to events. decoupled systems.
Accessing external data without storing Real-time data access without
Data Virtualization
it in Salesforce. duplication.
Smart Data Selective, periodic replication of data Incremental updates to reduce data
Replication from external systems. transfer overhead.

These patterns can be used alone or in combination, depending on the integration scenario and
requirements. Salesforce provides a variety of tools and features like Apex, Platform Events,
Salesforce Connect, and External Services to help implement these patterns efficiently.

Integration Direction
In Salesforce integration, the integration direction refers to the flow of data between Salesforce and
external systems or applications. Understanding the direction of integration is crucial to determining
the architecture, tools, and technologies to use. The common integration directions in Salesforce
are:

1. Salesforce to External System (Outbound Integration)

• Description: This integration direction involves sending data from Salesforce to an

external system.
• Use Case: Common when you need to update or share data stored in Salesforce with
other systems, such as updating a third-party system or sending notifications.
• Examples:
o Outbound messages: Salesforce sends data to an external system via SOAP
messages.
o API Calls: Salesforce makes REST or SOAP API calls to external systems
(e.g., sending lead data to a marketing automation tool).
o Platform Events: Salesforce publishes events, and external systems can
subscribe to those events.
o Apex Callouts: Custom Apex code can be used to make API calls to external
systems to send data.
• Tools Used:
o Apex (REST/SOAP Callouts)
o Outbound Messages
o Platform Events
o Salesforce Connect (for accessing external data in real time)
o External Services (to connect to external APIs)

Joyful Learning
 Ankita

2. External System to Salesforce (Inbound Integration)

• Description: This direction involves bringing data into Salesforce from an external
system.
• Use Case: Common when you need to import data into Salesforce or receive updates
from other systems.
• Examples:
o Data Import: Importing customer data, leads, or products into Salesforce
from an external database or system (via Data Loader, for example).
o API Integration: External systems making REST or SOAP API calls to
Salesforce to insert or update data.
o External Services: External applications can call Salesforce APIs to add or
modify data (e.g., creating an opportunity in Salesforce based on data from an
ERP system).
• Tools Used:
o REST/SOAP APIs
o Apex Web Services (to expose Salesforce data to external systems)
o Salesforce Connect (for accessing external data in real-time)
o External Data Sources (such as OData or custom connectors)
o Bulk API (for large data imports)
o Change Data Capture (CDC) (to track changes in Salesforce and push to
external systems)

3. Bidirectional Integration

• Description: In this scenario, data flows both ways between Salesforce and an
external system. This is typically used when Salesforce needs to sync data with
external systems in real-time or periodically.
• Use Case: Common in scenarios where Salesforce needs to maintain up-to-date
records with an external system (like a CRM system or ERP) and vice versa.
• Examples:
o Two-way sync: Salesforce updates an external ERP system with customer
data, and in turn, the ERP system updates Salesforce with order status or
inventory changes.
o Marketing Automation: Leads and campaigns in Salesforce are synchronized
with an external marketing automation platform, and responses (like email
opens or clicks) are sent back into Salesforce.
• Tools Used:
o Apex (for custom integration logic)

Joyful Learning
 Ankita

o MuleSoft Anypoint Platform (to integrate and sync data between Salesforce
and external systems in both directions)
o Informatica Cloud Data Integration
o Jitterbit and Dell Boomi (for cloud-based integration platforms)
o Salesforce Connect (for integrating with external data in real-time)

4. Middleware and Integration Tools

• Description: Middleware tools are often used to facilitate bidirectional integrations

by handling data transformations, routing, and orchestration between Salesforce and
external systems. These tools can integrate multiple systems at once.
• Examples:
o MuleSoft: Integrates Salesforce with various systems using APIs and
connectors.
o Jitterbit and Dell Boomi: Middleware tools that support bi-directional
integrations with Salesforce and external systems.
• Tools Used:
o MuleSoft Anypoint Platform
o Informatica Cloud Integration
o Jitterbit and Dell Boomi

Summary of Salesforce Integration Directions

Integration
Description Use Case Example Tools Used
Direction
Salesforce to Data flows from Sending order data to Apex Callouts,
External System Salesforce to an an external ERP Outbound Messages,
(Outbound) external system. system. Platform Events
External System Data flows from an Importing leads from a REST/SOAP APIs,
to Salesforce external system into marketing automation Apex Web Services,
(Inbound) Salesforce. tool. Salesforce Connect
Data flows in both Syncing customer data
MuleSoft,
Bidirectional directions between between Salesforce
Informatica, Apex,
Integration Salesforce and external and an external ERP
Salesforce Connect
systems. system.

Key Takeaways:

• Outbound integrations move data from Salesforce to external systems.

• Inbound integrations bring data from external systems into Salesforce.
• Bidirectional integrations synchronize data in both directions, ensuring both systems
are always up to date.
• Middleware tools like MuleSoft, Jitterbit, and Boomi are often used for complex or
large-scale bidirectional integrations, especially when involving multiple systems.

Joyful Learning