A customer calls sales and asks about their order. The sales rep opens the CRM and sees: order entered, status open. In reality, the warehouse shipped the goods in the morning, the delivery note is posted in the ERP, the tracking number is available. The CRM knows nothing of this, because synchronisation runs once a night. The rep says they will have to check, and calls the warehouse.
This scene plays out daily in many companies, and it is not a sign of poor integration. The nightly synchronisation was introduced at a time when processes were slower and a day's delay bothered nobody. It is robust, understandable, and has been running for years. But expectations have changed. Customers follow up today, sales and service work with the same customers on the same day, and a status from yesterday is simply wrong in many cases.
Event-driven integration is the answer. Instead of reconciling data at fixed intervals, a system reports as soon as something happens: order created, delivery posted, invoice issued, payment received. The other systems react to it, within seconds rather than hours. This article describes what that means, which patterns exist, and what to watch out for in the transition.
What Batch Synchronisation Does, and Where It Hits Its Limits
A batch job reads, at regular intervals, all records that have changed since the last run and transfers them to the target system. The pattern has real advantages. It is easy to understand, easy to monitor, and tolerant of failures: if one run fails, the next catches up on everything. For master data that rarely changes, and for reconciliations where completeness matters more than speed, batch remains the right tool.
The limits show in everything that concerns the working day.
| Aspect | Batch synchronisation | Event-driven integration |
|---|---|---|
| Timeliness | Hours to a day | Seconds |
| Load | Peaks at the time of the run, nothing in between | Evenly spread, follows the actual business |
| Error handling | One failed run affects all records | One failed event affects one record |
| Traceability | Which run transferred which record is often hard to reconstruct | Every event carries timestamp, source and content |
| Complexity | Low, as long as data volumes stay small | Higher, because ordering, duplicates and losses have to be handled |
| Business context | Rows that have changed | Events that mean something: "delivery posted" rather than "field updated" |
The last point is often underestimated. A batch job transfers records. It does not know why a field changed. An event, on the other hand, says what happened. The target system can react to it in business terms, for instance by creating a task for sales when a delivery is delayed, instead of merely overwriting a date.
Three Patterns Between Batch and Real Time
Between the nightly run and a fully event-driven architecture lie gradations. Which one fits depends on what the systems involved can do and how quickly the information is needed.
| Pattern | How it works | Suited for | Limits |
|---|---|---|---|
| Frequent polling | The batch job runs every five minutes instead of once a night | Systems that cannot send events, transition phases | Generates load even without changes, timeliness stays at minutes |
| Webhooks and platform events | The source system sends a message to a defined receiver on change | Individual, clearly defined events between two systems | If the receiver is unreachable, the event is lost without a buffer |
| Event streaming via a messaging platform | Events are written to a stream, several receivers read independently | Many systems, high volumes, replayability, traceability | Its own infrastructure that has to be operated and monitored |
For most mid-sized companies, the journey starts with the second pattern. Salesforce offers Platform Events and Change Data Capture as mechanisms to report changes outward immediately. Many ERP systems can emit messages on document changes. An integration platform such as MuleSoft receives these events, buffers them, transforms them and distributes them. The third pattern becomes relevant when more than a handful of systems are involved, or when events also have to be reprocessed after the fact.
What Makes a Good Event
The most common mistake in the transition is treating technical changes as events. "Field delivery date in table order changed" is a database event. "Delivery for order 4711 posted on 3 December" is a business event. Only the second can be processed by a target system in business terms, without knowing the internal logic of the source system.
A usable event contains at least:
- A unique identifier of the event itself, so that receivers can tell whether they have already processed it.
- The type in business language: order created, delivery posted, invoice issued.
- The timestamp of the business transaction, not of the technical transfer.
- The reference to the affected business object, with the identifiers all systems know.
- The payload or a pointer to it: either the event carries the relevant data, or it says where to fetch it.
- A version number of the event format, so that format changes do not break all receivers at once.
An event describes what happened in the business, not what happened in the database. This distinction decides whether the integration lasts five years or breaks at the next system change.
Whether an event carries the data or only points to it is a trade-off. Events with a full payload make receivers independent of the source system, but they grow large and can transport outdated data if they arrive late. Events with a pointer stay small and deliver the current state on retrieval, but they generate additional calls. In practice, a mix has proven itself: the identifiers and the few fields needed for the reaction in the event, everything else via retrieval.
The Pitfalls Nobody Mentions in the Workshop
Event-driven integration is not harder than batch, but it is hard in different ways. Four problems show up in almost every project.
| Pitfall | What happens | Countermeasure |
|---|---|---|
| Ordering | "Order cancelled" arrives before "order created" because two events took different routes | Process events per business object in order, check version number or timestamp on the object, detect late events |
| Duplicates | The same event is delivered twice because the first acknowledgement was lost | Every receiver remembers processed event identifiers and ignores repeats |
| Lost events | The receiver was unreachable, the event was never delivered | Buffer with retry, queue for undeliverable messages, regular reconciliation as a safety net |
| Schema changes | The source system adds a field or renames one, receivers process the event incorrectly | Versioned event formats, new fields optional, old fields never silently removed |
The safety net in the third point deserves attention. Even in an event-driven landscape, a nightly reconciliation keeps running, but with a different job. It no longer transfers the data. It checks whether the systems agree and reports deviations. The batch job turns into a control mechanism. Anyone who switches it off notices lost events only when a customer calls.
Salesforce and MuleSoft as an Example
What this looks like concretely can be shown with a typical landscape of Salesforce as CRM, an ERP, and MuleSoft as integration platform.
From Salesforce, Platform Events and Change Data Capture deliver changes in real time. When an opportunity is won, an event is created that MuleSoft receives and passes on to the ERP as an order request. The ERP creates the order and in turn reports an event with the order number. MuleSoft writes the number into the opportunity, and within seconds sales sees that the order exists in the ERP.
In the other direction, the ERP reports deliveries, invoices and incoming payments. MuleSoft converts these messages into business events, decouples them from the ERP-internal format and distributes them: to Salesforce for the customer status, to the service system for open cases, to reporting. Every receiver gets the same event but processes it by its own rules.
The role of the integration platform is decisive here. It buffers events when a target system is unreachable. It detects duplicates. It translates between formats, so that Salesforce does not need to know how the ERP represents a delivery note internally. And it logs every event, so that it can be traced afterwards what went where and when. Anyone already running an API-led architecture according to the best practices for MuleSoft and Salesforce can introduce events as an additional layer on top without replacing the existing APIs.
A note for companies with older connections: anyone who still connects Salesforce via SOAP login integrations should use the migration that is due anyway to switch to event-based patterns at the same time, rather than merely modernising the old batch approach technically.
Not Everything Has to Be Real Time
The transition does not mean converting every data flow to events. The question has to be answered per data type: how quickly does the information have to reach the receiver, and what does a delay cost?
| Data type | Recommended pattern | Reason |
|---|---|---|
| Order, delivery and invoice status | Event | Customers and sales follow up during the day, a day's delay is a wrong status |
| Customer master data, addresses, contacts | Event for changes, batch for reconciliation | Changes are rare, but when they happen they should apply everywhere immediately |
| Price lists and terms | Batch at defined times | Changes apply from a cut-off date, not from the moment of entry |
| Product catalogue | Batch, event for availability | The catalogue changes predictably, stock levels do not |
| Historical data for reporting | Batch | Completeness matters more than timeliness |
| Reconciliation and control | Batch | Checks whether the event-driven flows arrived completely |
The result is a hybrid landscape in which both patterns coexist and each does what it does best. The trends shaping enterprise integration in the DACH region show that this pragmatic middle path is the norm, not the exception.
A Step-by-Step Transition
Nobody has to switch off the nightly synchronisation over a weekend. The transition can be shaped in four steps, each of which delivers value on its own.
| Step | Content | Result |
|---|---|---|
| 1. Select one data flow | The flow where the delay hurts most, usually order or delivery status | Clear scope, measurable benefit |
| 2. Define the events | Business events with identifier, type, timestamp, reference, payload and version | A format both systems understand |
| 3. Run in parallel | Events flow, the batch job keeps running, deviations are compared | Confidence that the events arrive completely |
| 4. Turn batch into a control mechanism | The batch job no longer transfers, it checks and reports | Events carry operations, reconciliation secures them |
The third step is the most important and the most frequently skipped. Parallel operation over a few weeks shows which events are missing, which arrive twice, and where the order is wrong. These findings feed into the rules before the batch job changes its role. Anyone who skips this step discovers the same problems in production.
What Should Be Settled Before Starting
| Area | Guiding question |
|---|---|
| Pain point | For which data flow does the delay cost time, customers or money today? |
| Source systems | Can the systems involved send events, or is polling needed as a transition? |
| Event definition | Are the events phrased in business terms, or do they merely mirror database changes? |
| Platform | Is there an integration platform that buffers, detects duplicates and logs? |
| Ordering and duplicates | How is it ensured that late and duplicate events do no harm? |
| Safety net | Does a reconciliation remain in place that detects lost events? |
| Versioning | How are changes to the event format introduced without breaking receivers? |
| Operations | Who sees when events get stuck, and who steps in? |
Conclusion
The nightly synchronisation has worked reliably for years, and for master data, price lists and reconciliations it continues to do so. For everything concerning the working day, it has become too slow. A sales rep who has to call the warehouse to learn a delivery status is working with a CRM that does not serve its purpose.
Event-driven integration solves this problem when it is set up properly: with events phrased in business terms, a platform that buffers and logs, rules for ordering and duplicates, and a reconciliation that remains as a safety net. The transition is not a major project but a sequence of steps that begins with the data flow where the delay hurts most.
For companies developing their system integration and their Salesforce platform, this is the obvious next step. Not because real time is fashionable, but because a status from yesterday is simply wrong today in many cases.