3 Key Integration Patterns for Boomi and Salesforce
Your organization has grown to rely on Salesforce as an essential part of the business. It’s widely used, is the center of multiple business processes, and houses invaluable data. You might have a simple spreadsheet-style integration that is working but see even greater uses and are ready to evolve your solution to do more. You envision automating Salesforce data integration, using the CRM to kick-off order fulfillment, interfacing with manufacturing for on-demand orders, streamlining marketing messaging and responses, and growing your business based on world-class customer engagement.
You’ve got big Salesforce plans but aren’t sure how you might achieve your goals. It’s time to find an iPaaS solution to help you do all of that.
Given that Salesforce is a cloud platform, a cloud-based solution makes the most sense. Dell Boomi is an ideal fit for this use case. Boomi supports integrations between cloud services (cloud to cloud) and cloud to on-prem (cloud to ground) out of the box. A product suite with multiple toolsets, including an MDM, API management, and application integration, Boomi is easy-to-use, flexible, and empowers citizen developers with the tools to build and manage their own integrations. Not every integration problem can be accomplished without IT involvement, but Boomi takes most of the heavy burden.
The question is, how do you get these two powerful tools to work together for your specific use cases? If you have experience with Salesforce, you know that adding functionality can range from simple click-to-add features to implementations that require custom coding or Apex knowledge. If, on the other hand, you’re a seasoned Boomi user, you understand that the existing connectors and the agility of the solution means you have a wealth of choices to connect your systems.
The key is to marry the right integration pattern to the use case. Here are some of the most common Salesforce and Boomi Integration patterns.
Pattern 1: Batch Using the Salesforce Connector
Probably the most common integration pattern is batch, invoked on a recurring schedule. This pattern is ideally suited for data integration that lends itself to incremental processing without a need for immediate updates. The batch pattern is an appropriate option for a process that does data extraction and transformation for bi-weekly billing or synchronizing Salesforce objects to a data warehouse on a somewhat large scale (thousands, tens, or hundreds of thousands of records).
Boomi offers a connector for Salesforce that easily connects into any native Salesforce application, like Sales Cloud and Service Cloud. It’s a simple solution to set up and allows for low code and no code integrations. One of the best features of this connector is how easily you can integrate with multi-tiered data structures (1-7 layers deep).
A batch integration pattern using this connector is the right choice for use cases that:
- The emphasis is on quickly delivering the integration
- The use case doesn’t require near-real-time synchronization
Some things to keep in mind with this pattern:
- Need to be mindful of cloud usage fees - for instance, using a cloud atom in Boomi and synchronizing large data volumes regularly
- You should use the bulk API for large batches of data, e.g., more than 1,000 upserts at a time
Pattern 2: Event-Driven with the Platform Events Connector
The second pattern is for more urgent data integration needs. The event-driven behavior is called for when the data in or out of Salesforce must be kept synchronized in near real-time. Some common use cases: urgent terminations; customer order fulfillment; warehouse stock updates, meeting shipping SLAs, etc.
Whatever the case, this integration is ideal for integrations where “minutes matter.” The Boomi Platform Events connector passively listens for events from the Salesforces’ Platform. These events are configured within the Salesforce platform and fire when appropriate, given the use case (e.g., when a new order is submitted). It’s handy for syncing adds, moves, and changes to a record as opposed to a full data set.
Using the Platform Events Connector is ideal in cases where:
- Minutes (or seconds) matter in terms of the data synchronization
- There is sufficient time to allow for a more sophisticated setup with some light Salesforce coding and configuration
- Only single Boomi atoms are being used
For instance, this project leveraged event-driven integrations with Boomi as part of an integration platform re-implementation that resulted in a platform that was able to deliver grant funds to community organizations in need quickly and more efficiently than the previous .NET and MS Dynamics solution allowed.
Note: This pattern won’t currently work for cases where an atom cloud is being used. It is possible to create custom Apex callouts through Outbound Messaging instead, but that requires a REST endpoint for the integration to call.
Alternate Approach: You can also approximate this pattern by building a polling process within Boomi that uses the Salesforce Connector. The poller can execute on a given frequency and request changes from Salesforce based on Last Modified Date. Be careful with over-using this approach; it is less efficient and may result in more load on the system.
Pattern 3: On-Demand using Boomi’s Atmosphere API
One of the most overlooked features of Dell Boomi is the Atmosphere API, which can be invoked from any REST or SOAP client with appropriate credentials. Our third pattern will use this facility to trigger an event-driven batch. This technique can be a useful compromise between batch processing and the need to fire an event as soon as possible after an update takes place, without the stress of a high-frequency polling pattern.
An on-demand integration with the Atmosphere API is a useful tradeoff between the near real-time responsiveness of event fired updates and the need to synch a number of objects or data elements at once. This event-driven batch pattern is relatively simple to implement and has the added advantage of not consuming a licensed connection.
Considerations for this pattern:
- Does not consume a Boomi connection license
- Exceptions must be handled indirectly, as results cannot be returned directly to the caller
- You cannot pass a complex data type to the API. You’re limited to process properties.
If your caller requires a direct response or the update involves complex data types, like objects or arrays, building your own API is a better bet than trying to use the Atmosphere API. It will take more work and knowledge of the endpoints, but in the end, it will be a cleaner implementation and easier to maintain and re-use.
While these three integration patterns may cover the most common integration needs, we know your business may have unique situations that go beyond the ordinary. Big Compass can help you determine the right Salesforce integration approach using our Assessment and Design services. Let’s connect and discover what’s right for you.
ADOPTION & EXPANSION
+ Number of APIs
+ Business coverage
+ Number of contracted apps
+ API usage
+ API reuse
EFFICIENCY & COST SAVINGS
+ Number of APIs in each SDLC stage
+ Time spent in each SDLC stage
+ Cost and time to build an API
+ App development velocity
+ Number of launches per year
+ Number of defects
SECURITY & VULNERABILITIES
+ Security violation
+ Policy enforcement
+ Time since the last version was published
+ Number of throttling issues
+ Time to onboard
+ Number of deployments
+ Number of incidents
+ Percentage of customers impacted. per incident
+ Time to resolve incidents