Salesforce integration means connecting Salesforce to another system so records move between them. Nearly every real integration is one of five patterns: request and reply, fire and forget, batch synchronization, event driven, and UI integration. The pattern you choose sets your API consumption, your latency, and how the integration behaves when the other side is down.
Salesforce integrations are the backbone of modern CRM ecosystems. Whether you are connecting Salesforce with marketing platforms, finance systems, data warehouses, or custom applications, choosing the right integration pattern and following proven best practices determines performance, security, and scalability.
This guide explains the core Salesforce integration patterns, when to use each one, and the best practices that experienced architects rely on.
What Are Salesforce Integration Patterns?
Salesforce integration patterns are standardized approaches used to connect Salesforce with external systems. Each pattern solves a specific type of business and technical requirement such as real time data sync, asynchronous processing, or high volume data transfer.
Choosing the wrong pattern often leads to API limits issues, data inconsistency, or security risks.
Core Salesforce Integration Patterns
| Pattern | Who calls whom | Timing | Use it when | What it costs you |
|---|---|---|---|---|
| Request and reply | Salesforce calls out | Synchronous | A user is waiting on screen for the answer | One API call per interaction, plus the user waits for the round trip |
| Fire and forget | Salesforce calls out | Asynchronous | The other system needs to know, but nobody is waiting | One call per event, and you own the retry logic |
| Batch synchronization | Either direction | Scheduled | Volume is high and data that is minutes or hours old is fine | One Bulk API call per batch instead of one per record |
| Event driven | Salesforce publishes | Near real time | More than one system cares about the same change | Platform Event delivery allocation, not your REST API limit |
| UI integration | Salesforce embeds | On page load | The other system already has a screen worth showing | Whatever the embedded app costs, plus a Canvas or iframe setup |
The five patterns at a glance, then each one in detail below.
| Pattern | Who calls whom | Timing | Use it when | What it costs you |
|---|---|---|---|---|
| Request and reply | Salesforce calls out | Synchronous | A user is waiting on screen for the answer | One API call per interaction, plus the user waits for the round trip |
| Fire and forget | Salesforce calls out | Asynchronous | The other system needs to know, but nobody is waiting | One call per event, and you own the retry logic |
| Batch synchronization | Either direction | Scheduled | Volume is high and data that is minutes or hours old is fine | One Bulk API call per batch instead of one per record |
| Event driven | Salesforce publishes | Near real time | More than one system cares about the same change | Platform Event delivery allocation, not your REST API limit |
| UI integration | Salesforce embeds | On page load | The other system already has a screen worth showing | Whatever the embedded app costs, plus a Canvas or iframe setup |
1. Remote Process Invocation Request and Response
This pattern is used when Salesforce calls an external system and waits for an immediate response.
Common use cases include:
- Real time validation
- Pricing or availability checks
- External calculations
Best suited APIs:
- REST API
- SOAP API
Use this pattern only when the response is required instantly and processing time is predictable.
2. Remote Process Invocation Fire and Forget
Salesforce sends data to an external system without waiting for a response.
Typical scenarios include:
- Sending notifications
- Logging activities
- Triggering downstream workflows
This approach improves performance and avoids UI delays.
3. Batch Data Synchronization
Batch integration handles large volumes of data at scheduled intervals.
Common examples:
- Nightly data sync
- Data warehouse updates
- Historical record imports
Tools and APIs often used:
- Bulk API
- ETL tools
- Middleware platforms
This pattern is ideal when real time data is not required.
4. Event Driven Integration
Event driven integration uses events to notify systems when something changes.
Salesforce technologies involved:
- Platform Events
- Change Data Capture
- Streaming API
This pattern is highly scalable and works well for modern microservices architectures.
5. UI Integration
UI integration embeds external applications directly inside Salesforce.
Examples include:
- Lightning Web Components
- iFrames
- Salesforce Canvas
This pattern focuses on user experience rather than data movement.
Salesforce Integration Best Practices
Use a Dedicated Integration User
Always use a Salesforce integration user instead of a human user. This improves security, auditability, and permission control.
Apply Least Privilege Access
Grant only the permissions required for the integration. Avoid system administrator access unless absolutely necessary.
Handle API Limits Proactively
Design integrations to:
- Use bulk APIs where possible
- Avoid unnecessary polling
- Cache responses when appropriate
Monitoring API usage prevents unexpected failures.
Build for Failure and Retries
Network issues and external system downtime are inevitable. Always implement:
- Retry mechanisms
- Error logging
- Dead letter handling for events
Secure Credentials Properly
Use Salesforce features like:
- Named Credentials
- Connected Apps
- OAuth authentication
Never hardcode secrets in Apex or external code.
Design for Scalability
Choose asynchronous and event driven patterns for high volume or unpredictable workloads. This ensures long term performance as data grows.
Monitor and Audit Integrations
Enable logging and track:
- API usage
- Failed requests
- Data inconsistencies
This makes troubleshooting faster and compliance easier.
Choosing the Right Salesforce Integration Pattern
Two questions settle it most of the time. Is somebody waiting for the answer right now, and does more than one system need to hear about the change? Yes to the first means request and reply. Yes to the second means event driven. No to both means batch.
If you need instant feedback, use real time request and response. If performance matters more than immediacy, use asynchronous or event driven patterns. If you are moving large datasets, batch integration is the safest choice.
There is no single best pattern. The right solution depends on business urgency, data volume, and system constraints.
Why Integration Strategy Matters
Poorly designed integrations increase maintenance cost, introduce security risks, and limit scalability. A well planned Salesforce integration strategy enables automation, real time insights, and seamless customer experiences.
The pattern is the decision that costs the most to reverse. On the integrations we build at Appnigma, moving a batch sync to event driven after launch almost always means rewriting the error handling, the retry logic, and the monitoring too, because none of those assumptions survive the change.
Frequently Asked Questions
What is the most common Salesforce integration pattern?
Real time API based integration using REST is the most common for transactional use cases.
Which Salesforce integration pattern is best for high volume data?
Batch data synchronization using Bulk API is best for large datasets.
Are event driven integrations better than APIs?
Event driven integrations are better for scalability and decoupled systems, while APIs are better for direct interactions.
Should I use middleware for Salesforce integrations?
Middleware is useful when managing multiple systems, transformations, and complex workflows.
