Short answer: System integration is the practice of making two or more subsystems act like one — exchanging data and triggering each other's behaviour. The four common patterns are point-to-point (fast to ship, impossible to maintain past three systems), hub-and-spoke (one broker in the middle, usually a queue), ESB (hub-and-spoke with transformation and routing baked in), and API-led (every system exposes a stable contract that others consume). Pick the pattern that matches how many systems you have and how often the contracts change. The reason most integrations fail is not the pattern — it is that nobody owns the integration after it ships. Decide who owns it before you draw the first arrow.
Combining two or more sub-systems into a functioning whole is called System Integration. Data passes the limits. Events set off reactions on the opposite end. When a customer submits a form on your site, they ideally end up in the CRM, in the warehouse, in the billing table, and on the welcome-email queue – in this order, without a human helping that happen row on by row on a spreadsheet.
The most popular integration design pattern in the world, by headcount, continues to be spreadsheet copy. Don’t let anyone tell you otherwise.
This guide is for engineers, platform anchors, and the PMs who need to justify the four iterations taken by the “simple integration.” We will walk through the definition, the four patterns that cover roughly ninety percent of real integrations, how modern PM tools (including LiteTracker) integrate without turning into yet another system to integrate, and the honest truth on why almost all integrations fail it’s almost never the pattern.
The references I make here come from sixteen years of connecting systems that were never meant to meet. This was also sourced from Tanzu Labs’ practice around platform engineering, which LiteTracker is built on.
System integration, plainly defined
Choose two systems. As they say, the CRM and the billing platform. Every department has a model of a customer. The models have conflicting views on several topics. These include the name field’s shape, whether the ID is a UUID or an integer, and if a deleted customer is really deleted or archived. System Integration refers to the practice of linking together different computing systems and software applications physically or functionally, to act as a coordinated whole.
That's the complete content. The various tools, patterns and vendor categories (iPaaS, ESB, integration platform) exist to answer this question: how do we get data and events to move between systems that were not designed to know about each other, in a way that we can maintain for longer than 6 months?
The book (ENGAGEDCOST0END) brings a few flavours. The connection created between systems on a similar software layer is known as horizontal integration. For instance, connecting the CRM to the email tool is horizontal integration. Both, the email tool and the CRM live on the customer-facing layer. Vertical integration connects systems across layers: from warehouse-floor scanners to ledgers. Enterprise application integration is the catchall term when the systems are internal, and heterogeneous enough that someone has written a cheque for it. These terms assist discourse with suppliers; they seldom aid engineers.
Engineers typically find a useful categorization of integration architectures by pattern. These shapes are used to illustrate the look of your platform while discussing how the new changes are spaced out over the next three years We will address each one in turn.
Why integration is the quiet reason your project is late
In almost every enterprise codebase, you will find that over half of the engineering time on a mature product is used for integration, not for features. Extracting data from the warehouse to the dashboard. Sending events from the API to the queue. Maintain a rough alignment among the three user models. Sync job was rebuilt since the vendor deprecated the webhook format.
If you are managing a software project where the team is constantly missing the forecast, the first place to look is not the velocity. It serves as the interface. The structural reason teams become quick with features but slow with integrations is that features only ship once, while integrations ship once only to have to continuously ship forever. Every integration in your possession is a minor yet constant burden on the roadmap. This is mostly neglected in project management stages. Integration is treated as a ‘just do it’ sub-task. In practice, it is a stage of its own and never ends.
The roadmap committee is unsure whether “the integration team” should even exist because nobody wrote down the stage. Integration is not a project stage; it is a weather system.
If you are the product owner, select a person as integration owner from day one. We shall return to this topic.
The four patterns, from fast-and-fragile to slow-and-durable
Most integrations you will encounter in a production grade codebase fall into one of the four categories. We are going to walk them in order of complexity, because that is also, roughly, the order teams reach for them as the system grows.
1. Point-to-point
One system talks directly to another. No broker, no middle layer, no central contract.
Most teams will start with this integration. Your billing software has an invoice, your email tool has a template, and when an invoice gets paid, your billing software calls the email tool’s API. The code can be found on your billing service. The URL is fixed. You ship a change to the billing service if the email tool alters its API.
When there are two or three systems and integration is just a line item on someone’s roadmap, point-to-point integration is the right default. The code is uncomplicated. The owner of the caller is the owner of the integration. The caller immediately recognizes the failings when the callee is down. It’s obvious.
The arrangement shatters by the fifth system. Often teams discover this, usually in month fourteen: n systems with point-to-point integrations have n² possible connections, and in practice the real codebase gets to about n(n-1)/2 of them. In total, there are six systems, fifteen integrations, and about a hundred and twenty behaviour edges to maintain. At this point, the team cannot predict the outcome if they change any one of these things. A service billing deploy breaks a sync of which no one remembered to notify.
Whether your business has two systems, three systems, and under, point-to-point is the honest default. The following patterns are added to your toolbox when the math stops working.
2. Hub-and-spoke
One central broker in the middle. Every system talks to the broker, not to each other.
Usually, the broker is a queue (Kafka, RabbitMQ, SQS, Pub/Sub) or an orchestration tool (Zapier, make.com, Workato the iPaaS category Wikipedia calls out). When something occurs, each system publishes to it; each system subscribes to the topics that interest it.
The nearly universal reason for adopting hub-and-spoke is the n² problem above. If we have six systems that use hub-and-spoke, we only have six integrations (each to the broker), not fifteen. The broker serves as the single point of reference for investigating movement.
That authentic cost implies, the broker is now a system you can control. The collapse of one entity leads to the collapse of all integrated entities. When misconfigured, the device has a failure mode of silent data loss, which is the worst failure mode an integration can have. The recently adopted hub-and-spoke by the team has resulted in three types of system in practice rather than two as the business systems, the broker and the connectors. This is underestimated by many teams, who then spend two quarters firefighting the broker.
A specific type of post-mortem reads that “the queue was fine, the consumer was fine, nobody noticed the DLQ had been full since Tuesday”. If you adopt a broker, write the DLQ-monitoring runbook before you ship the first integration. We have seen several teams skip this. It never ends well.
3. ESB — Enterprise Service Bus
Hub-and-spoke, plus a layer that does transformation, routing, and sometimes orchestration.
Hub and spoke evolved to ESB, when the organization got large enough that they need to modify the application data flowing through (perhaps currency conversion, format mapping, enriching that data from a third system, routing based on content).
For most product teams reading this, an ESB is likely not the suitable answer. Since the 2000s and 2010s, the ESB category had peaked within large enterprises. As such, the majority of greenfield work since has reached for lighter patterns (API-led, event-driven architectures with queues) as the ESB tends to concentrate too much business logic in one tool nobody wants to own. Your organisation likely has an ESB team if it has an ESB. An ESB is likely unnecessary at this time if it is not being utilized.
The enterprise integration patterns library the canonical Hohpe/Woolf catalogue that names the recurring shapes (message filter, content-based router, aggregator, dead letter channel) is the useful idea from the ESB era that lives on in today’s integration work. Regardless of which tool is being used today, those names still describe what the integration code is doing, which makes them worth knowing.
4. API-led integration
Every system exposes a stable, documented API. Other systems consume it. The integration is the contract.
通常情况下,现代平台团队都在这里。 The event flow is no longer centered towards a broker where everything is being routed through a single class in a single service, but a single API for each service. Integrations are created as consumers of these APIs, typically through a thin service dedicated to each one.
Contract durability is the main reason for most product companies to go for API-led. The owning team signs a contract with a well-designed API. The consumers can be constructed, sustained, or even changed without impacting the producer. Martin Fowler’s piece on enterprise REST is still the most honest write-up of the trade-offs and worth reading before any argument about REST vs GraphQL vs the thing your senior dev read a blog post about last Thursday.
The production team must consider their API as a product. That’s the honest cost. If the API is updated without package versioning or deprecation discipline, every consumer breaks. When there is no sufficient documentation for APIs, each consumer re-implements the same mistakes. API-led integration changes the task from “build the integration” to “build the API that integrations can live on”. Many organisations don’t realise how disciplined engineering must be.
Your seasoned engineers will devote much of their time here in year three as well. If you’re designing a platform, ensure API ownership is a job not a side effect.
How to pick between them
| Pattern | Right when | Breaks when | What it costs |
|---|---|---|---|
| Point-to-point | 2–3 systems, few integrations | 5+ systems, every change ships to every edge | Simple to build, expensive to maintain |
| Hub-and-spoke | 4+ systems, event-driven work | Nobody owns the broker | New system to run (the broker) |
| ESB | Large enterprise, complex transformations | Teams reach for it before they need it | A dedicated ESB team |
| API-led | Durable platforms, long-lived services | APIs evolve without versioning discipline | API ownership as a real job |
Select the pattern that corresponds to the number of systems you have and the frequency of contract changes. Not the trend that is popular. That is not what your vendor offers. This pattern didn’t get your CTO through a bad quarter at their last job.
How PM tools integrate — and why that pattern repeats
LiteTracker and most project management tools support four integrations types. Different vendors use different terms but all refer to the same shapes.
- REST API. The tool exposes a REST API. You can create stories, add comments, move them through states, pull velocity data, do anything the UI does. This is the API-led pattern at the application layer. Most PM tools follow the same shape — a REST endpoint, OAuth or token auth, pagination that mostly works, and a webhook companion for the push side.
- Webhooks. The tool fires an HTTP POST to a URL you configure when something happens — a story moves to accepted, a comment lands, an iteration closes. This is the hub-and-spoke pattern with your webhook endpoint as the broker consumer.
- CSV import/export. The oldest integration pattern. Dump the data as CSV, move it, re-import it. Point-to-point via human. Underrated for one-time migrations.
- Native integrations. Vendor-provided connectors to specific other tools (Slack, GitHub, email) that live inside the tool and are maintained by the vendor. Convenient when they exist; a lock-in risk when they are the only option.
It doesn’t matter in which mechanism you are using. The action you take with the data on the other side. One of the most common mistakes we observe in teams is that the integration process concludes with a Slack message, which subsequently leads to the demise of data itself. Once the story transitions to accepted, it triggers a message in the #engineering channel. This is a notification, not an integration. If the objective was to refresh the roadmap tool, then the roadmap tool will remain incorrect at the week’s end.
This pattern is precisely what LiteTracker adheres to. The webhook triggers, the data is made queryable via the API, and your team possesses the integration, which is housed in a slim service, not a vendor’s black box. The reason we have been able to offer unlimited users on the free tier is that we have kept the surface area deliberately small, so the maintenance cost is small and so the whole thing costs us very little to maintain forever. LiteTracker’s features are the 20% of PM-tool features that drive 80% of results and we keep the integration surface in that 20% on purpose.
Integration as a project, versus integration as a feature
The final division that counts. Migrating only once is a project. Ongoing capabilities are features. They should be run differently.
A migration has limits. Data is being migrated from old system to new system, one time. The criteria for success are made clear by the fact that the rows’ counts must match, foreign key constraints are resolved and the business can carry on. You manage it as a traditional project, utilizing the five stages outlined in the project management stages guide. This includes initiating (justification), planning (requiring tables and order), executing (migration), monitoring (checks), and closing (obsolete system read-only, then remove). The migration cannot be treated as if you will keep migrating; you will not, and the team is wasting energy building infrastructure for something that is not an ongoing need.
A feature of ongoing integration. The CRM will be synced the the warehouse every ten minutes, forever. You operate it as a functional product, fully featured with backlog, estimated in story points, owned by a team, and instrumented like everything else. The ongoing integration should not be treated as a one-off project, shipped and forgotten about; it will rot as no one owns it after the project team… Three weeks of uncoupled silence, and nobody’s responsible for noticing. Six months later, this repeats.
The agile delivery and agile implementation articles explain how to manage the feature side as a stream of work, shaped like an iteration rather than a project. The project side is what systems development life cycle covers when the integration is truly bounded.
If you’re not sure whether your integration is a project or a feature, it is a feature. If it has a clear end date, it is a project. If there’s not a date you plan to turn the thing off, it is a feature, and it needs an owner.
Why most integrations fail (hint: not the pattern)
This is the take the SERP won't tell you. Integrations fail for reasons that are almost never the pattern. An integration pattern creates ownership where none exists. You can run a shoddy point-to-point integration with a clear owner forever; it will be ugly, but it will work, and when it breaks the right person will notice. An API-led integration might be created which is beautiful and has no owner. It will run for six months and will be quietly broken. The best part is that no one will notice.
Failure modes involving ownership have three common forms.
- The integration shipped as part of a project, then the project team dissolved. Nobody is paged when it breaks. The dashboard that measures it is in a Grafana folder nobody opens.
- The integration is "shared ownership" between two teams. Which is to say: nobody owns it. Both teams think the other one is handling the alert. Neither of them is.
- The integration is owned by the team that produces the data, but the one that consumes it is the only one who notices when the data is wrong. The producer sees green metrics; the consumer sees stale data; the escalation path has three handoffs. By the time anyone fixes it, the business has already made a decision on the stale data.
The solution is uninteresting and precise. Designate only one team as the owner. Not “shared”. One. Make that integration a line item in the team's backlog. Allocate a dedicated budget for maintenance, whether in the form of points per iteration or a percentage of capacity. The owning team is paged when alerts from this instrument are triggered. Make sure to go through it with the owning team at least once a quarter during a retro event.
The article provides a detailed explanation of ownership mechanics. The essential point is, “the platform team” is not an owner. Instead, an owner is “the platform team’s integration pod of three engineers, with Ada as the on-call anchor.”
Refrain from shipping the integration if the owner is unknown.
A short list of things that are not system integration
Three non-system integrations being passed off as system integrations. It saves lots of time in meetings if these…
- Opening a tool in an iframe inside another tool. This is embedding, not integration. The data does not cross the boundary; the user experiences a smaller window. The two systems still do not know anything about each other.
- Writing a report that pulls from two databases. This is reporting, not integration. The data crosses a boundary once, into the report. Nothing changes in either source system.
- A Slack notification about a thing that happened in another tool. This is a notification, not an integration. If the only effect of the "integration" is a message in a channel, you have built a wire-tap, not a pipe.
All of these things are good. They aren’t integrations in any meaningful sense, and calling them integrations will get you an architecture diagram that lies by week four.
Frequently asked
What is system integration in plain English?
System integration is the process whereby two or more systems are made to behave like one; this includes making the systems transfer data to and from one another, trigger behaviour in one another, and keeping their models within the same rough bounds about things like customer, order, user, invoice, etc. A system integration error occurs when systems do not know about each other.
What are the main types of system integration?
About 90% of real work falls under four patterns. A system directly calls another system. Brokered (or broker-based) system design. ESB with hub-and-spoke along with transform and route capabilities A steady Application Programming of Interfacing allows any programming interface to consume a system. Choose the one that corresponds to the number of systems in the contracts and their frequency of change
What is the difference between vertical and horizontal system integration?
Horizontal integration links together components that exists on the same tier of a stack like CRMs with email tools both in customer facing stack. Connecting systems across businesses layers is known as vertical integration. this includes scanner on the warehouse floor to the general ledger. The help of the labels facilitate conversation with vendors but real work remains the same.
What is enterprise system integration?
Enterprise system integration refers to the integration work that is done internally, within a single organisation having heterogeneous systems. As the name suggests, this is a service that will usually get mentioned in the procurement section of an RFP. It is the environment within which patterns like ESB, iPaaS, and API-led integration were defined. In the case of most product teams, “enterprise integration” is a vendor-category label; the engineering work still comes down to the four patterns above.
What is API-led integration and when should I use it?
The term "API-led integration" refers to a pattern wherein each system exposes a documented, stable API, and integrations are executed as consumers of these APIs. This is the apt choice for durable platforms with long-lasting services. The expense is that the manufacturing team should consider the API as a product – version, depreciation discipline, documentation. If your organization cannot provide the required staff, being in hub and spoke with broker is often more honest.
What is the most common cause of integration failure?
Ownership, by far the most important. Usually, the pattern is not the root cause. Integrations go wrong when no one is accountable for them after they have shipped. This happens when there is “shared ownership” between teams, project teams are dissolved, and the teams that consume the integration are the only ones aware of problems. When there is one team that owns it, with the integration on their backlog and maintenance budget allocated, most integration failures cease happening.
Do I need an ESB?
Most likely no. The pattern that dominated the integration space of large enterprises in the 2000s and 2010s was ESB. Nowadays, most of the work has moved to API-led integration or event-driven architectures with queues. Your organisation probably has an ESB team only if it has an ESB, and it probably does not need one yet if it does not have an ESB. The enterprise integration patterns catalogue continues to correctly name recurring shapes, remaining an invaluable artefact from the ESB era.
Still stuck
Most mature products have a systematic integration, costing them silently. The four design patterns outlined by the book will cover almost everything you will need to build. Pick by the number of systems and the volatility of the contracts, not by what is fashionable. Make the integration functional on shipping day. Identify the owner before shipping out. An ongoing integration is a feature; a one-off migration is a project. Don’t get these two mixed up. These four moves carry more weight than any pattern argument.
Try LiteTracker on the free tier (unlimited users, no credit card, no time limit) if you run a software team and your integration surface is silently eating your roadmap. The key signals you can track for determining your integration tax are velocity on accepted stories, the cycle time, and mid-iteration adds. The agile delivery article is a good follow-up read.
In any event: designate the owner prior to shipping.