- Middleware is the layer between your business systems. It moves data from one to another, translates it, applies your rules, and records what happened. It can be a platform you configure, like Zapier or Make, or software built for your workflow.
- APIs and middleware aren't alternatives. In our restaurant analogy, the API is the waiter. Middleware is the expediter at the pass, who uses those waiters to keep every order moving the right way.
- A native connector is enough when it handles your records, fields, sync direction, and timing, and you can see when it fails. Start there.
- Custom middleware earns its place when your business rules, record relationships, or recovery needs go beyond what a connector or automation platform can handle.
- Platforms stop retrying a failed delivery after anywhere from 4 hours to about 3 days. Whatever you choose, someone has to own what happens next. Run our Integration Fit Test on one real record before you decide.
Direct answer: Middleware is software that sits between business systems and helps them work together. It receives data from one system, translates and validates it, applies your business rules, passes it on, and records what happened. You need custom middleware only when a native connector or automation platform can't support the workflow, data rules, or failure handling your business requires. If a supported connector already does what you need, and you can tell when it fails, you may not need anything custom.
In the first post in our Software in Plain English series, I explained APIs with a restaurant. The waiter carries your order to the kitchen and brings back your meal. You never walk into the kitchen yourself. That analogy almost always gets a follow-up question: "Okay, so what's middleware?"
It's a fair question, and it comes with a catch. Most companies that build custom integrations have a reason to tell you that you need one. Sometimes you do. Often you don't. As a team that builds middleware for a living, I think the most useful thing we can do is explain both: what middleware is, when a simpler option is the right answer, and how to tell the difference before anyone writes code.
The question comes up a lot because most business software still isn't connected to the rest of the business. Each year, MuleSoft surveys IT leaders about how many applications their organizations run and how many are integrated. The number of apps keeps going up. The share that's connected is going down.
Your business probably doesn't run 957 applications. But if you run a billing system, a CRM, a store, and an email platform, you've already made this decision several times, whether or not anyone called it middleware.
01 — The short answer
What Is Middleware in Plain English?
IBM describes middleware as "software glue" that binds different systems together. That's a good start, but the term covers a lot of ground. Engineers also use it for message brokers, application servers, and other infrastructure most business owners never need to think about.
This guide is about integration middleware: the software that helps your business applications exchange data and coordinate work. Here's the version I use with clients:
Middleware is the layer between your systems that decides what should happen when something changes in one of them.
A customer cancels in your billing system. Middleware is what notices, checks the details, works out what that cancellation means for your CRM, your email list, and your support desk, makes those updates, and keeps a record. It might also translate a field ("plan_code: ANNUAL_PRO" becomes "Annual Pro"), match the customer to the right record, or hold the update and try again if the CRM is temporarily unavailable.
That layer can be something you configure on a hosted platform or something built specifically for your workflow. Both are middleware. The difference is how much of the behavior you control, and who's responsible for it.
02 — The analogy
The Restaurant Gets a Delivery App
Back to the restaurant. In the API post, there was one dining room, one kitchen, and a waiter in between. Now the restaurant is busier. Orders come in from the dining room, a delivery app, phone orders, and a catering inquiry form. The grill, the fryer, and the pastry station each need their own part of every order.
Somebody has to stand at the pass, the counter between the kitchen and everyone else, and make sense of all of it. In a professional kitchen, that's the expediter. The expediter doesn't cook and doesn't take orders. They read every ticket, send each item to the right station, catch the "no nuts" note, hold a ticket when the fryer goes down, and notice that table 12's order never came out. Then they tell the manager.
That's middleware. And the different ways a restaurant can handle the pass line up with the different ways a business can connect its systems:
| At the restaurant | In your software |
|---|---|
| The waiter who carries an order between two places | API: the defined way one system asks another for something |
| The delivery app's tablet that prints straight to the kitchen | Native connector: a prebuilt link between two specific products |
| A ticket printer you program with routing rules ("drinks to the bar") | Automation platform: configurable middleware such as Zapier or Make |
| An expediter trained on your kitchen's own rules | Custom middleware: coordination logic built for your workflow |
| The ticket rail, with every order clipped in sequence | Event log or queue: a record of every change and what happened to it |
| "Table 12's order never came out" | A failed sync: an update that didn't arrive or didn't apply |
| The manager the expediter tells | The named owner who gets the alert and decides what to do |
Two things this analogy gets right. First, the delivery tablet is often perfect. If the app's menu matches your menu and the orders print correctly, nobody needs to stand there translating them. Second, even the simplest setup needs someone who notices when an order goes missing. The tablet can't tell you about the ticket it never printed.
It also clears up the most common confusion: APIs and middleware aren't competing choices. An API is a door into one system. Middleware uses those doors, usually several of them, to coordinate what happens across systems. The waiter and the expediter work together. Our software terms glossary has short definitions of the other words you'll hear along the way.
03 — Start simple
When Is a Native Connector Enough?
Before talking about custom work, it's worth being clear about when you don't need it. A native or packaged connector is usually enough when all of these are true:
- It supports the records you care about. If you need subscriptions and invoices, a connector that only syncs contacts isn't the right one.
- It maps the fields you need, including the custom ones your team actually uses.
- It syncs in the direction you need, one way or both, with a clear rule for which system wins when they disagree.
- The timing works. A nightly sync is fine for reporting. It's not fine for granting access the moment someone pays.
- You can see when it fails, through a log, an alert, or an error report someone actually reads.
Here's a typical "this is fine" scenario. Your sales team wants each customer's plan name and renewal date visible on their CRM record. Your billing platform offers a supported connector that syncs those fields every few minutes, shows a sync log, and emails an admin when a record fails. Nobody is correcting the data by hand. That connector is doing its job. Building something custom here would add cost and maintenance without solving a problem.
When a connector does fall short, it's usually not because it's broken. It's because the business needs something it wasn't designed to do. Our posts on when HubSpot needs a custom integration and connecting Shopify to your CRM walk through what that looks like for those specific platforms.
04 — The comparison
Native Connector, Automation Platform, or Custom Middleware?
These are three practical ways to get the job done, not three rigid categories. Zapier and Make are middleware too: you configure them instead of building them. Here's how we compare the options with clients:
| Decision factor | Native connector | Automation platform | Custom middleware |
|---|---|---|---|
| Best fit | Standard workflows between two supported products | Configurable, multi-step workflows across many apps | Business-specific rules the other options can't express |
| Data rules | Supported objects and mappings, as the vendor defines them | The triggers, actions, and transformations the platform offers | Designed around the rules you agree on |
| Which system wins | Usually fixed by the connector | Possible to set up, but has to be built into every workflow | Defined field by field, in one place |
| Failure handling | Varies by connector; check the logs and alerts | Varies by platform and plan; check retries and replay | Has to be designed, built, and tested |
| Control | The vendor decides how it behaves and when it changes | Configurable, within what the platform supports | Full control, along with full responsibility |
| Ongoing ownership | The vendor, plus someone on your team who watches it | The platform, plus whoever owns each workflow | A named business owner plus an engineering team |
Choose based on what the workflow requires, not on which option sounds more advanced. Custom code isn't automatically more reliable. A well-configured connector with good error visibility can beat a custom build nobody maintains.
And these options mix well. One of the most common setups we recommend keeps the native connector for the routine sync and adds a small piece of custom middleware for the one rule the connector can't handle. You don't have to replace what's working to fix what isn't.
05 — The test
The Integration Fit Test: Run One Real Record Through It
Feature lists won't tell you whether your current connection fits. One real record will. Pick a record that matters to the business, like a cancelled subscription, a paid order, or a new lead from a specific campaign. Then answer six questions about that one record, with Yes, No, or Not sure:
The Integration Fit Test
Answer each question for one business-critical record, with your current connection.
- Workflow fit: Does the connection handle every action this record should trigger, in every system that needs it?
- Data integrity: Does it match and update the right record every time, without creating duplicates?
- Business logic: Can it apply your rules, including which system wins when two disagree?
- Visibility: If this record failed to sync today, would anyone know, and how?
- Recovery: Can a failure be fixed without creating inconsistent or duplicate data?
- Ownership: Is a named person responsible for watching this connection and acting when it breaks?
Your answers point to different next steps. "Not sure" is the most common answer we hear, and it's useful information on its own.
| If your answers look like this | It usually means |
|---|---|
| Yes to all six | Keep what you have. Revisit when the workflow changes. |
| "Not sure" on visibility or recovery | You have a monitoring gap, not necessarily a build. Turn on the logs and alerts your current tools already offer, and test a failure on purpose. |
| "No" on ownership | Name an owner first. No technology fixes an integration that nobody is watching. |
| "No" on workflow fit or data integrity | Check the connector's settings and the automation platforms before anything custom. A different configuration may solve it. |
| "No" on business logic and recovery, for a record the business depends on | This is where custom middleware usually earns its place, often alongside the connector you already have. |
This is a screening tool, not an architecture decision. But it turns "our integration feels unreliable" into specific gaps you can act on, and it's the same set of questions we work through on a Discovery Call.
06 — When something breaks
What Should Happen When a Sync Fails?
Most explanations of middleware stop at "it connects your systems." The more useful question is what happens when the connection doesn't work. Here's a situation we see a lot:
A customer cancels in your billing system on Friday evening. On Monday morning, your CRM still shows them as active, and a renewal reminder goes out automatically.
Usually nothing was broken in the usual sense. The webhook, the automatic notice one system sends another when something changes, failed to deliver. Maybe the receiving server was down for a few minutes, or a deploy went out at the wrong moment. Every major platform retries failed deliveries automatically. But each one stops eventually, and the windows are shorter than most people expect.
So what happens after the last retry? Each platform handles it differently, but the pattern is the same:
None of this means those platforms are unreliable. Retries handle the everyday blips well. The point is that failure handling is something you design and verify, not something you get just by using the word "middleware." Whatever sits between your systems, a connector, a Zap, or custom code, should do three things:
- Record. Keep a log of which change was received, when it was processed, and whether the destination accepted it. That's the ticket rail.
- Retry. Try temporary failures again on a sensible schedule, without repeating the action. A retry should never send a second welcome email or charge a card twice.
- Report. When retries don't work, alert a named person with enough detail to act: which record, what failed, and what's still waiting.
Two more details matter more than they sound. Updates can arrive more than once. Shopify's documentation says your app might receive the same webhook more than once. They can also arrive out of order, which Stripe calls out directly. Good middleware recognizes a duplicate, checks the current state with the source system before acting, and runs a regular reconciliation, a scheduled comparison that catches anything the notifications missed. Our Recurly integration guide shows what that looks like for subscription billing.
07 — An example
An Example: Recurly, HubSpot, and the Company With Three Subscriptions
Here's how this plays out in practice. This is an illustrative example, a composite of the kind of Recurly–HubSpot work we do as a Recurly integration partner, not a description of one client's system.
- What the operations team needed. When a customer cancels, the account manager gets a task. When a company has no active subscriptions left, its HubSpot record moves to "Former customer," and it comes off the renewal email list.
- What the existing connection did well. It synced each subscriber's plan, status, and renewal date onto their contact record. That part worked, and it stayed.
- What it couldn't represent. Many customers were companies with several subscriptions, one per location. When one location cancelled, the connection updated that contact, and a workflow marked the whole company as churned. The rule the business actually needed was "former customer only when the last subscription ends," and that requires looking across all of the company's subscriptions before deciding.
- What the middleware added. A small service receives Recurly's cancellation webhooks, confirms the details through Recurly's API, looks up every subscription for that account, applies the company-level rule, and updates HubSpot. Everything else stays with the existing connection.
- How failures are caught. Every event is logged with its Recurly notification ID, so a repeat delivery is recognized and skipped. If HubSpot is temporarily unavailable, the update waits and retries. A nightly reconciliation compares active subscriptions in Recurly with customer status in HubSpot and flags any mismatch.
- Who maintains it. The operations manager gets the alerts and decides on exceptions. The client owns the code. The engineering team updates it when Recurly or HubSpot change their APIs.
The achievement here isn't "we connected Recurly to HubSpot." They were already connected. It's that one business rule now works, and when it doesn't, someone finds out the same day instead of at renewal time. For the full CRM picture, see How CRM Integrations Work and our guide to integrating Recurly with HubSpot, Salesforce, or Zoho.
08 — After launch
Who Owns Middleware After It's Built?
"You own the code" is an important promise, and it's one we make on every project. But owning the code is only one part of owning an integration. Before any middleware goes live, get clear answers to these:
| Question | What a good answer looks like |
|---|---|
| Who owns the code? | Your business, written in common languages any trained engineer can maintain |
| Who controls hosting and platform accounts? | Accounts and credentials your business can access, not ones only a vendor can reach |
| Who gets the alerts? | A named person on your team, plus your engineering partner if you choose |
| Who updates mappings and API connections? | Agreed in advance, because the platforms on both ends will keep changing |
| Who decides how to recover a failure? | Your team decides; engineering carries it out and confirms the data is consistent |
| What documentation do you keep? | Data mappings, business rules, alert routing, and recovery steps, written for the next person |
Owning the code doesn't remove your dependence on the platforms it connects, or the need for occasional engineering time when they change. What it does give you is the freedom to choose who does that work. At Virgo Development, every integration ships with monitoring and documentation, and ongoing support is billed only when engineering time is actually used. No retainer is required unless you want proactive monitoring.
09 — A new question
Can AI Build the Integration for Me?
More and more often, people come to us after starting an integration with an AI tool. That's a reasonable place to start. AI can write the code that calls an API, and it can get a working prototype running quickly.
What it can't do is decide your business rules, like which system wins, what "former customer" means, or who gets the alert. It also won't monitor anything once it's running. Those are the parts of the Integration Fit Test that decide whether an integration holds up. If you've got a prototype that mostly works, our post on taking an AI prototype to production covers what usually comes next.
10 — Common questions
Quick Answers
What is middleware in simple terms?
Middleware is software that sits between business systems and helps them work together. It receives data from one system, translates and validates it, applies business rules, passes it to the next system, and records what happened. It can be a hosted platform you configure or software built for a specific workflow.
What is the difference between middleware and an API?
An API is a defined way for one system to request data or actions from another. Middleware uses APIs to coordinate work across systems: it decides what should happen when something changes, translates data between them, and handles failures. They work together rather than replacing each other.
Is Zapier middleware?
Yes. Zapier, like Make, is a hosted automation platform, which is a form of middleware you configure instead of build. It handles many workflows well, including multi-step ones. Custom middleware becomes the better fit when a workflow needs business rules, record matching, or failure recovery the platform can't support.
When is a native connector enough?
A native connector is usually enough when it supports the records and fields you need, syncs in the right direction at the right speed, and lets you see when a sync fails. If your team isn't correcting data by hand and nothing important is missing, the connector is doing its job.
Does a two-way sync always need custom middleware?
No. Many connectors and automation platforms support two-way sync. What matters is whether you can set clear rules for which system wins when the two disagree, avoid duplicates, and recover from failures. Custom middleware is worth considering when those rules can't be set up any other way.
Who maintains middleware after it is built?
That should be agreed before launch. A business owner should receive alerts and decide how to handle exceptions, and an engineering team should update the code when connected platforms change their APIs. With custom middleware, the business should own the code, the documentation, and access to the hosting and platform accounts.
11 — Let's talk
Not Sure Whether Your Business Needs Middleware?
If your team is moving information between systems by hand, correcting sync errors, or bending your process to fit your software, it's worth a closer look. Bring us a list of the systems you connect today and where your team still re-types or corrects data. We'll help you work out whether a native connector, an automation platform, or custom middleware is the right fit, and we'll tell you if what you have is already enough.
Schedule a free 30-minute Discovery Call with me and the team, or see how we approach system integration and middleware.
Jamie Lords ↗ LinkedIn is CEO of Virgo Development, a 100% U.S.-based software engineering team with headquarters in St. George, Utah. Virgo has built custom integrations and middleware for more than 21 years, connecting platforms including Recurly, HubSpot, Shopify, Salesforce, and Zoho. This is the third post in our Software in Plain English series, after What Is an API? and Software Development Terms Every Business Owner Should Know. Sources: Salesforce, 2026 Connectivity Benchmark Report and 2025 MuleSoft Connectivity Benchmark Report; IBM, What is middleware?; Shopify, Ignore duplicate webhooks and Troubleshoot webhooks; Zapier Help, What is replay?; HubSpot, Error handling; Stripe, Receive Stripe events in your webhook endpoint; Recurly, Automatic retries, Webhooks states and Manual retries. Platform behavior was checked against each vendor's documentation in November 2026 and can change. The Integration Fit Test is Virgo Development's working framework, not an industry standard. The Recurly–HubSpot example is an illustrative composite, not a description of any one client's system. Compiled November 2026.