A mid-sized European distributor, fifteen years after it rolled out an integration bus. Orders flow through the bus from the B2B portal into the ERP, stock levels into the web shop, invoices into finance and customer records into the CRM. It works. Nobody remembers its last serious outage. But the team that understands it is three people, and the backlog of changes waiting for them is past forty items. A newly hired CIO finds three proposals on her desk: move everything to an iPaaS, build an event platform on Kafka, or “just expose APIs” and unplug systems from the bus one by one.
That is not a description of one specific company. It is a shape that repeats wherever integration was built between roughly 2005 and 2015. Each of the three proposals has its champions, and each is sold as the modern answer to an old problem. The question that actually needs settling, though, is not a technology question.
This article is for architects and CTOs who have inherited a bus and must decide what to do with it. We do not repeat the general tour of integration patterns, which we covered in software integration: patterns and approaches. We defend one position that many vendors will dispute: the problem is almost never the bus itself; it is the business logic that has been piled into it. A “replace the ESB with something modern” project done one-to-one rebuilds the same central dependency in a more expensive form. You retire a bus flow by flow, moving the logic into the systems that own it, and you introduce an event broker only where one fact has more than one consumer.
Is an enterprise service bus technical debt, or still sensible infrastructure?
An enterprise service bus is an intermediary layer through which systems exchange messages instead of calling each other directly. In its classic form it does several jobs at once: it transports messages, translates protocols (SOAP to flat files, HTTP to a queue), transforms data formats, routes messages based on their content and orchestrates multi-step processes. These jobs are catalogued in Gregor Hohpe and Bobby Woolf’s Enterprise Integration Patterns, which defines a language of 65 integration patterns and remains the shared vocabulary of integration architects two decades later.
The first three jobs are infrastructure. Somebody has to move messages, bridge protocols and map formats regardless of architectural style. The last two, content-based routing and orchestration, are business logic. A rule such as “send orders above EUR 10,000 from new accounts to credit review first” is a decision owned by finance, not a property of the network. When that rule lives in the bus, the integration team becomes the de facto owner of the process, not the team that is accountable for it in the business.
James Lewis and Martin Fowler named the problem in their March 2014 article “Microservices”. They criticized the tendency to hide complexity inside ESBs and set against it the principle of “smart endpoints and dumb pipes”: the messaging infrastructure should move messages, and the intelligence should live in the services. They also quoted Jim Webber’s less flattering expansion of the acronym: “Erroneous Spaghetti Box”.
Read that critique carefully, though. It is not aimed at the existence of an intermediary layer. It is aimed at what gets put into it. A bus that carries messages between a few stable systems and translates formats is not technical debt. It is infrastructure that works, has a known cost and blocks nobody. It turns into debt when every change in any system needs the bus team, because the bus holds rules that nobody else can change.
That distinction gives you the first practical task, before anyone compares products. Walk through the flows on the bus and, for each one, answer a single question: is this transport and mapping, or is it a business decision? The ratio between the two tells you more about the cost of future change than the age of the product does.
How do ESB, APIs and event-driven architecture actually differ?
The three terms often appear in one sentence as if they were competing products. They are not. They are three different answers to the questions “who knows about whom?” and “who waits for whom?”
An ESB is a topology. Systems talk to a central intermediary that knows every participant and decides where each message goes, synchronously or through queues. Its strength is a single point of control and monitoring. Its weakness is a single point through which every change has to pass.
An API is a contract. A system exposes operations that others call, usually synchronously, and get an answer immediately. The caller knows the provider and waits for it. That is the natural choice when you need an answer now: a price, a stock level, a payment authorization. You can expose APIs directly or through a gateway, which we described in API gateway: what it is and usage patterns. A gateway handles authentication, rate limits and routing, but it should not hold business logic, for the same reason a bus should not.
Event-driven architecture inverts the dependency. A system publishes a fact that happened (“order placed”, “customer address changed”) without knowing who will receive it. Consumers subscribe to what interests them and react at their own pace. The publisher waits for nobody. The best-known broker for this style is Apache Kafka, but the pattern also runs on RabbitMQ, on cloud services such as Azure Service Bus and Amazon EventBridge, or on the queues that ship with many buses.
The difference has consequences that are easy to miss. With an API, the caller owns the handling of a provider failure: if the warehouse does not answer, the web shop must decide what to show the customer. With events, that responsibility moves to the consumer, which must cope with duplicated, late or out-of-order events. With an ESB, responsibility often sits nowhere visible, because the bus “retries”, “buffers” and “handles exceptions”, and nobody outside the bus team knows exactly how.
| Criterion | ESB | Synchronous API | Events through a broker |
|---|---|---|---|
| Who knows whom | The bus knows everyone | Caller knows provider | Publisher does not know consumers |
| Who waits for whom | Depends on configuration | Caller waits for provider | Nobody waits |
| Where logic lives | Often in the bus | In the provider | In the consumers |
| Best use | Protocol bridging, systems without APIs | Queries that need an answer now | One fact, many consumers |
| Typical failure | Business rules buried in flows | Call chains, cascading outages | Events without an owner or schema |
| Contract described by | Flow configuration | OpenAPI | AsyncAPI, event schema |
Most organizations need all three mechanisms at once. The question is not “which style do we choose?” but “which style for which flow?”, and that cannot be settled once for the whole company.
Where does the cost of data integration come from, and why is the license the smallest part?
“Cost of data integration” sounds like something you can price like a license. In practice the license or platform fee is one of five cost lines, and rarely the largest.
Platform. The bus license, the iPaaS subscription, the broker cluster or the cloud service charges. This is the most visible line because it arrives as an invoice.
Building flows. The work behind each new connection: analysis, data mapping, error handling, testing. MuleSoft’s 2025 Connectivity Benchmark Report, based on responses from more than 1,050 IT leaders, found that IT teams spend an average of 39% of their time building custom integrations. That cost never appears under an “integration” heading in the budget, because it is spread across salaries.
Maintaining flows. Every upgrade of a source or target system can change a data format, a mandatory field or behavior on error. An integration that worked stops working not because anyone broke it but because the world around it moved. This cost grows with the number of flows and with the rate of change in the systems they connect.
Operations. Monitoring, handling messages that failed, retries, explaining to the business why an invoice never arrived. On a bus this work is centralized; in an event-driven architecture it is spread across consumer teams.
Cost of delay. The hardest line to quantify and often the biggest. If every change needs the bus team and the queue is forty items long, every business project waits. This cost never shows up in the IT budget. It shows up as late launches in other departments.
The same MuleSoft report illustrates the scale: the average organization runs 897 applications, and only 29% of them are integrated. Bear in mind that this is a report from an integration platform vendor, which has an interest in presenting the problem as large. The proportions are nonetheless consistent with what any mid-sized or large company sees: systems multiply faster than anyone connects them.
For the bus decision the conclusion is blunt. Comparing iPaaS quotes with the bus license compares only the first of five lines. A decision that does not change the cost of maintaining flows and the cost of delay changes nothing that matters, even if the platform invoice goes down.
When should you keep your existing ESB?
Retiring a bus is expensive and risky, so it needs a justification. There are situations in which the sensible decision is to leave it alone and stop investing in new flows.
The bus moves; it does not decide. If the flow inventory shows that the bus mostly transports messages, bridges protocols and maps formats while business logic sits in the systems, the bus is not your bottleneck. Replacing it with another technology costs a migration without changing the cost of maintenance.
The systems on both sides are stable. A bus connecting an ERP, a finance system and a data warehouse that change once every few years generates little maintenance. Rewriting those flows is work with zero business effect.
The product is supported over your planning horizon. If the vendor guarantees security fixes for the next five years, there is no time pressure. You can retire the bus gradually, at the pace at which the systems it connects are replaced anyway.
Some systems have no other interface. An old warehouse system that exchanges files over SFTP, or a mainframe that talks through MQ queues, will not grow a REST API because an architect wishes it would. A bus or some other adapter is needed whatever the target style.
In these cases the recommendation is to freeze the bus, not replace it. Freezing means two rules. First, no new business logic goes into the bus; new rules go into the systems that own them. Second, new integrations between systems that have modern interfaces are built outside the bus, through APIs or events. The bus keeps doing what it does well and shrinks naturally as the systems around it are replaced.
Freezing has another advantage: it reduces the risk of losing know-how. The small bus team stops being a bottleneck for new projects, because new projects no longer need it. It becomes a maintenance team for a shrinking number of flows.
When does retiring the bus make sense, and what forces the decision?
There are also situations in which keeping the bus is expensive or impossible. One of three signals usually forces the issue.
End of support. This is the hardest signal because it comes with a date. A current example: in December 2025 Microsoft announced that BizTalk Server 2020 will be the final version of the product. According to Microsoft Learn documentation as of September 2026, sales of BizTalk Server 2020 are expected to end on March 31, 2027, mainstream support runs until April 12, 2028, and Microsoft then plans optional, paid, temporary extended-mainstream support until April 10, 2030. The documentation notes that this paid coverage is expected to exclude some capabilities, including the ESB Toolkit and Business Activity Monitoring. A company whose flows depend on those components has a concrete deadline, not an abstract modernization wish. Similar lifecycle decisions apply to other platforms from the 2000s, and the first step is always to check your own product’s lifecycle with the vendor, not in articles.
The change queue. If the bus team is the bottleneck for most projects in the company, the cost of delay exceeds the cost of maintenance. Measure this signal instead of feeling it: the median time from an integration change request to production, the number of projects waiting, and the share of changes that touch business logic rather than transport.
Business logic in the bus. When pricing, credit or process rules live in bus flows, every department that wants to change them depends on the integration team. That is not only cost but risk: those rules usually have no tests that business people understand, and nobody outside the bus team knows how they behave.
One signal is not always enough. End of support on a bus that only moves messages means migrating to another transport, not re-architecting. A change queue without logic in the bus may simply mean the team is too small. It is the combination of signals, and above all the presence of business logic, that justifies retiring the bus as an architectural program.
It is worth naming what does not justify it. The age of the technology on its own, the fashion for microservices, a desire to “be event-driven” and a vendor’s slide deck about a modern platform are not reasons. They come up in every discussion, and you need to be able to tell them apart from the arguments that carry a date and a number.
Is iPaaS the successor to the ESB, or just a bus in the cloud?
iPaaS (integration platform as a service) is the most common proposal for replacing a bus. Microsoft’s documentation explicitly calls Azure Logic Apps the successor to BizTalk Server. Other vendors sell comparable platforms, typically headlined by hundreds of prebuilt connectors to SaaS applications.
Functionally an iPaaS does what a bus does: it connects systems, maps data and orchestrates flows. The difference is the delivery model. You do not run servers, you get ready-made connectors to popular applications, and you pay per flow, per call or for reserved capacity. For a company whose integrations are mostly with SaaS applications (CRM, marketing automation, HR), that is a real advantage: a connector to a popular application is cheaper than a home-grown adapter.
Here lies the trap, and Microsoft’s own BizTalk-to-Logic Apps migration guidance illustrates it well. It advises against reproducing the BizTalk MessageBox inside a workflow and recommends using a separate broker such as Azure Service Bus, RabbitMQ or Apache Kafka for publish-subscribe. It also recommends designing for at-least-once processing with idempotency and deduplication. In other words, even the platform vendor, which has every interest in moving as much as possible onto its platform, says that a one-to-one move of the bus is not a good idea.
Move all the logic of your old bus into an iPaaS and you get the same central dependency under a different cost model. The team that knows the platform is still the bottleneck. Business rules still live in flows. And a cost that used to be fixed (license and servers) becomes variable and grows with call volume. Microsoft’s guidance also lists, explicitly, the temporary cost of running both platforms in parallel during migration as something to include when you compare total cost of ownership.
So when does iPaaS make sense? When integrations are mainly with SaaS applications that have prebuilt connectors, when the company does not want to operate integration infrastructure, and when most flows are transport and mapping. An iPaaS is a good home for what was infrastructure on the bus. It is not a good home for what was business logic on the bus.
When are APIs enough, and when do you need an event broker?
The second popular proposal is “let’s go event-driven”. A broker solves a specific problem and brings specific costs, so it pays to know when you need one.
APIs are enough when the caller needs an answer now. The shop asks for a price, the mobile app for a balance, the order system for availability. Wrapping such a query in an event and waiting for a reply event adds complexity with no benefit. APIs are also enough when the relationship is one-to-one and there is no sign of more consumers.
A broker is needed when one fact has many consumers. An order being placed matters to the warehouse, invoicing, the CRM, the data warehouse and the loyalty system. If the order system calls each of them through an API, it has to know them all, and adding a sixth consumer means changing the order system. If it publishes an event, the sixth consumer simply subscribes. That is the genuine benefit of event-driven architecture: adding consumers without touching the publisher.
A broker also helps when a consumer cannot always be available. A system with maintenance windows, batch processing or lower throughput than the publisher can consume events at its own pace. The queue absorbs the difference.
The price is complexity on the consumer side and in operations. Events can arrive twice, out of order or late. You have to manage event schemas and their versions, because changing a field in an event that five systems subscribe to is as risky as changing a public API. The rules we laid out in semantic versioning for APIs and libraries apply to event schemas just as much. AsyncAPI exists to describe event-driven contracts, with version 3.0 released in December 2023, and the CloudEvents specification standardizes event metadata; it graduated within the Cloud Native Computing Foundation in January 2024.
The broker itself has a cost. A Kafka cluster is infrastructure that someone has to run, although since version 4.0 in March 2025 Kafka operates without ZooKeeper, which simplifies operations. Managed services move that cost onto the invoice: Amazon EventBridge’s price list charges USD 1.00 per million custom events, with every 64 KB chunk of payload billed as a separate event. At millions of events a day those are reasonable sums, but calculate them before the decision, not after.
A practical rule: start with APIs, and introduce a broker where the second and third consumer of the same fact appears. A company that “goes event-driven” everywhere at once usually ends up with a broker carrying queries disguised as events and an operations bill nobody planned for.
How do you avoid losing events: outbox, CDC and idempotent consumers?
There is one problem a bus often solved quietly and that you must solve deliberately when you move to events: consistency between the database write and the event publication.
It works like this. The order system saves an order and publishes “order placed”. If it publishes first and the write then fails, consumers have heard about an order that does not exist. If it writes first and the process crashes before publishing, the order exists but the warehouse never hears about it. This is the dual-write problem, and more careful coding does not make it go away.
The transactional outbox is the standard answer. Chris Richardson describes it on microservices.io: the application writes the event to an outbox table in the same database transaction as the business change, and a separate relay forwards events from that table to the broker. The event is sent if and only if the transaction commits, and in the order the application produced it. Richardson lists two drawbacks plainly: a developer can forget to write the event, and the relay can publish the same event more than once, for instance if it crashes after publishing but before recording that it did.
Change data capture (CDC) is the second technique, especially useful for systems whose code you cannot or do not want to change. Instead of modifying the application, you read the database’s transaction log. Debezium, the most widely used open-source tool of this kind, relies on PostgreSQL’s logical decoding to extract committed changes from the write-ahead log, turns every row-level change into an event and records its log position so that it resumes where it left off after a restart. CDC is excellent for getting data out of a legacy system without touching it, which we covered in the context of the strangler fig pattern. It has a limit, though: it publishes changes to tables, not business facts. “A row changed in ORDERS” is not the same as “the order was approved”, and somebody has to translate the one into the other.
The two are often combined. The application writes business events to an outbox table, and CDC reads that table and forwards its contents to the broker. Richardson calls this way of relaying transaction log tailing, as opposed to periodically polling the table (polling publisher).
Idempotent consumers are a precondition for both techniques. Because an event can arrive more than once, the consumer must recognize a duplicate, for example by recording the IDs of events it has already processed. Microsoft’s BizTalk migration guidance recommends exactly the same thing: design for at-least-once processing, with idempotency and deduplication. This is not an implementation detail; it is a requirement that belongs in every consumer’s contract.
The practical consequence for the bus decision: if your bus guaranteed delivery through distributed transactions or its own message store, moving to events shifts that responsibility into the applications. That is work you have to estimate for each flow, not once for the platform.
How do you retire a bus flow by flow?
If the signals justify retirement, the worst plan is a “platform migration” project with a cutover date. The best is retiring flow by flow, moving logic to its owners as you go. The mechanics resemble the strangler fig pattern, except that you are replacing an integration layer rather than a legacy application.
Step 1: inventory and classify. For every flow on the bus record which systems it connects, how often it changes, how many business rules it contains, who owns the business process and whether the systems on both ends have modern interfaces. This list underpins every later decision, and it usually uncovers flows that nobody uses.
Step 2: choose a target style per flow. A query that needs an answer goes to an API. A fact with many consumers goes to a broker. Transport to a system without a modern interface stays in an adapter, which can be the bus, an iPaaS or a lightweight service. Bulk data movement to a warehouse stays with ETL or CDC tooling.
Step 3: move the logic out. Business rules leave the flow and go to the system that owns them. The credit check rule goes to the finance system or a dedicated service owned by the finance team. This is the hardest and most important step, because it requires understanding what each rule does, and it often reveals that some rules are dead.
Step 4: run in parallel and compare. The new flow runs alongside the old one and results are compared before the old one is switched off. Contract tests help confirm that the new path behaves as consumers expect; see our piece on contract testing and API compatibility.
Step 5: switch off and delete. The flow on the bus is disabled and its configuration removed. Measure progress by the number of flows switched off and the fall in bus cost, not by the number of new services.
Order matters. Start with flows that change most often and carry the most business logic, because that is where maintenance cost is highest and the gain from moving logic out is largest. Leave stable flows between systems that will themselves be replaced until last, or let them disappear along with those systems.
There is also one decision you cannot postpone: the date after which the bus accepts no new flows. Without it, retirement never ends, because every new project finds a reason to add “just this one” to the bus.
What does each option cost to run?
The honest answer is that it depends on the number of flows, the rate of change in the connected systems and where the logic lives. You can still show what each option’s cost is made of and how to estimate it. The comparison below is a frame for your own calculation, not a price list.
| Option | Platform cost | People cost | Transition cost | Hidden risk |
|---|---|---|---|---|
| Frozen bus | License and infrastructure unchanged | Small maintenance team, shrinking with the number of flows | Low: only the “nothing new on the bus” rule | Loss of know-how, product end of support |
| One-to-one bus migration to iPaaS | Variable subscription growing with call volume | Unchanged; the bottleneck moves to the new platform | High: rewrite every flow, run both platforms in parallel | The same central dependency under a new cost model |
| Flow-by-flow retirement | Falls over time; broker and gateway costs rise | Shifts to domain teams | Spread over time, funded in stages | Retirement with no end date, two platforms forever |
| Events everywhere | Broker cluster or per-event charges | High: schemas, idempotency, operations in every team | High, often with no benefit for synchronous queries | Queries disguised as events, schema sprawl |
You can estimate people cost parametrically. An illustrative example: an integration maintenance team of two senior engineers. ARDURA’s published reference rates put senior developers at EUR 335–485 per day. Taking the midpoint and 20 working days a month, that is about EUR 16,400 a month, or roughly EUR 197,000 a year. That figure does not depend on whether the team works on a bus, an iPaaS or a broker. It depends on how many flows must be maintained and how often they change. That is why a decision that reduces the number of flows, or moves logic into domain teams, changes the cost more than a change of platform does.
Estimate transition cost flow by flow. For each flow: time to analyze, rewrite, move logic out, run in parallel and switch off. A pure transport flow may take days; a flow with a dozen business rules may take weeks. The sum across all flows, plus the cost of running platforms in parallel, plus a reserve for flows nobody understands, is the realistic migration budget. It is typically several times the license cost of the new platform, which is exactly why it should be calculated before the vendor conversation.
The final element is the cost of delay. If the bus change queue is blocking business projects, the value of those projects pushed back by a quarter is an argument a board understands better than any architecture comparison. Estimate it, even roughly, because it is usually what decides whether retirement pays off.
Who should own integration after the change?
Changing technology without changing responsibility gives you the same organization with new tools. The bus centralized not just messages but accountability: the integration team was responsible for everything that moved between systems. Once the bus is retired, that accountability has to land somewhere specific.
The team that exposes an API owns it. It is responsible for the contract, versioning, availability and documentation. Consumers raise requirements but do not change the API themselves.
The team that publishes an event owns it. It is responsible for the schema, the business meaning and backward compatibility. Consumer teams own their own processing: idempotency, error handling, latency.
The integration platform has a platform team, but no business logic. Somebody has to run the broker, the API gateway, the schema registry and the monitoring tools. That team supplies infrastructure, standards and support, but it does not write business rules. This is “dumb pipes” expressed as an organizational principle.
The split has a cost: every domain team now needs integration skills it previously did not, because someone else did integration for it. In a company whose domain teams are small, or are vendor teams, that is a real barrier. One way through is a transition period in which integration specialists join domain teams while logic is being moved out, transfer what they know and return to the platform team. Where the internal team lacks the capacity, this is also a natural place for temporarily augmenting the team with senior integration engineers rather than hiring permanently for a one-off migration.
Also make sure there is one place where all contracts are visible: a catalog of APIs and events with owners, versions and consumers. The bus gave you that visibility for free, because everything passed through it. In a distributed architecture you have to build it on purpose, or within two years nobody knows who subscribes to which event.
What are the most common mistakes when moving off a bus?
A handful of mistakes recur often enough to name them before the program starts.
Migrating the platform instead of the logic. Moving flows one-to-one onto a new platform, with the same rules in the same place. Result: a new invoice, the same problem.
Events without owners. A broker everyone publishes to however they like, without schemas, versions or documentation. A year later nobody knows what the “status” field in “order_updated” means or who relies on it.
API call chains instead of a bus. Replacing orchestration on the bus with a chain of synchronous calls between services. Each link adds latency and a point of failure, and one system’s outage cascades into the rest.
No end date. Retirement without a deadline after which the bus accepts no new flows and will be switched off. The company then runs two integration platforms indefinitely, which costs more than either on its own.
Ignoring reliability. Going event-driven without an outbox, without idempotency and without handling for messages that fail. The first broker or consumer outage ends in lost orders and manual reconciliation.
Replacing the team along with the technology. Sidelining the people who know the bus because “it’s old technology”. They know why each rule exists and what happens when it disappears. Without them, moving logic out turns into archaeology.
All of these share one root: treating integration as a technology problem that a new tool will solve. Integration is first of all a decision about who is accountable for what and where the rules live.
What are the key takeaways for architects and CTOs?
The ESB decision is not a choice between old and new. It is a decision about where business logic should live and who should own it. The technology follows from that decision, not the other way round.
Remember six things. First, inventory the flows on your bus and separate transport from business logic, because that ratio says more about the cost of change than the product’s age. Second, if the bus only moves messages between stable systems, freeze it instead of replacing it: nothing new on the bus, new integrations outside it. Third, retirement is justified by signals with a date and a number: end of support, a measurable change queue, business logic in the flows. Fourth, an iPaaS is a good home for integration infrastructure but not for logic, and a one-to-one migration moves the problem without solving it. Fifth, start with APIs and add an event broker where one fact has many consumers, from day one with an outbox, CDC where it fits, and idempotent consumers. Sixth, count maintenance cost and cost of delay, not just platform cost, and set the date after which the bus accepts no new flows.
If you are facing a decision about the future of your integration bus and need an independent flow inventory, or a team that can move logic into the right systems, see how we approach custom software development and systems integration, or get in touch. We start with a discovery phase of one to two weeks that ends with a defined scope and a target architecture.