iPaaS, Middleware or Custom Code: How Should Your Apps Connect?

iPaaS (integration platform as a service) is a subscription tool, such as Zapier, Make or n8n Cloud, that connects your apps without code: when something happens in one app, it acts in another. You need it only when your apps' built-in integrations don't cover a job, and for a few hundred runs a month it's usually far cheaper than custom code.

The three options in the title differ mostly in who looks after the connection. With iPaaS the vendor runs the platform and you maintain the workflows. With middleware, either a single-purpose sync app or an integration engine you host yourself, you take on more of the running. With custom code, a developer writes the connection and someone has to maintain it for as long as you use it. The subscription is rarely the biggest cost; the upkeep is, and that decides the answer for most small firms.

Follow me on Instagram@sagnikteaches

Four ways two apps can talk to each other

Always check the first row before the others. A native integration between your quoting tool and your accounting app, if one exists and does the job, beats anything you'd build; native integrations versus Zapier covers how to judge whether a built-in one is good enough.

Connect on LinkedInSagnik Bhattacharya

How an iPaaS runs a workflow, and what it bills you for

Every iPaaS workflow has the same bones: a trigger (a new form submission, a new invoice, an email with a certain subject), then one or more actions (create a record, send a message, add a row). There are two ways a trigger notices something happened:

Subscribe on YouTube@codingliquids

• Polling: the platform checks the app on a timer. Zapier checks every 15 minutes on its Free plan, every 2 minutes on Professional and every minute on Team.
• Webhooks: the app sends a message the moment something happens, so the workflow runs instantly. What a webhook is explains why some automations are instant and others lag.

The billing unit is where the platforms really differ, and it changes which one is cheapest for a given workflow:

So a ten-step workflow run 500 times a month is 5,000 Zapier tasks but only 500 n8n executions, while a two-step workflow is cheap everywhere. Count steps and runs before comparing list prices.

What "middleware" means at small-business scale

In large companies, middleware means heavyweight integration software run by an IT team. In a small business it usually means one of two things.

Single-purpose sync apps. Many app marketplaces list connectors that do one job well, such as syncing an online shop's orders into an accounting app with the right tax treatment. They're middleware sold as a finished product: less flexible than iPaaS, but someone else has already solved the awkward details of that one pairing. If one exists for your exact pair of apps, compare it with building the same thing in an iPaaS.

Integration engines you host. The n8n community edition is free to self-host with almost the full feature set, and runs on a small cloud server. The trade is spelled out in n8n's own documentation: self-hosting needs technical knowledge for installation and configuration, and you must provide and manage the infrastructure, whereas n8n Cloud needs none. n8n self-hosted versus cloud costs goes into that choice in depth; the short version is that self-hosting pays off when many busy workflows share one server and someone technical already looks after it.

When custom code is the right answer

Custom code earns its cost in a narrower set of cases than developers sometimes suggest:

• Very high volume. Thousands of runs a day, where per-task pricing adds up and a small hosted script costs almost nothing to run.
• Logic an iPaaS handles badly. Complex matching, lots of branching, or calculations that become a tangle of steps in a visual builder.
• An app with an API but no iPaaS connector. Common with niche industry software.
• A product you sell. If the integration is part of what customers pay for, you want it in your own code base.

Hosting is rarely the obstacle. Cloudflare's Workers, one serverless option, lists a free plan of 100,000 requests a day, with the paid plan starting at $5 a month. The real costs are the build and, above all, the maintenance: apps change their APIs, credentials expire, and the developer who wrote it moves on.

One integration, costed three ways over three years

Here's the worked comparison. A six-person surveying firm wants every new instruction from its website form to set off the same chain:

1. Create the client in the accounting app.
2. Create the job in the job-management app.
3. Create a project folder in shared storage.
4. Use an AI step to turn the enquiry into a short job brief.
5. Email the client an acknowledgement.
6. Post a note to the team channel.

It gets about 60 instructions a month. The website form can send a webhook, so the trigger is instant. The AI step uses OpenAI's gpt-5-nano with the firm's own API key: at $0.05 per million input tokens and $0.40 per million output, 60 briefs of roughly 1,500 tokens in and 300 out cost about one cent a month, so it's left out of the totals below.

The assumptions, which you'd replace with your own: internal technical time at $50 an hour, a freelance developer at $600 a day.

For one integration at this volume, iPaaS wins by a wide margin, and Make could be cheaper still: with the instant webhook trigger, 60 runs of about seven modules is roughly 420 credits a month, inside Make's free 1,000. Two things would change the picture. Upkeep dominates options B and C, so a firm that already pays someone technical and runs a dozen workflows on the same server spreads that cost thinly. And volume changes option A's line, as the next section shows. For how these costs compare with a developer building directly into your apps, what connecting two business apps really costs lays out the wider set of options.

What changes at twenty times the volume

Suppose the surveying firm merges with two others and handles 1,200 instructions a month through the same chain. The same arithmetic now gives:

• Zapier: 1,200 runs × 6 tasks = 7,200 tasks a month, far beyond Professional's 750. The next tiers cost considerably more; check Zapier's pricing page for the tier that covers your volume, and when Zapier gets too expensive for how to find your tipping point.
• n8n Cloud: 1,200 executions, still inside the Starter plan's 2,500, because a six-step run counts once.
• Self-hosted n8n or custom code: almost no change in running cost, since a small server or the serverless free plan handles 1,200 runs easily.

That's the general shape: iPaaS priced per step is cheapest at low volume and climbs steeply; execution-priced and self-run options stay flat. The right answer at 60 runs a month can be the wrong one at 1,200, so recheck the sums whenever volume grows.

The AI step inside an integration needs its own checks

AI steps are what most small firms add to integrations now, and they fail differently from normal steps: they don't error, they produce a plausible wrong answer. Here's the brief-writing step from the worked example:

From the enquiry below, produce a job brief as JSON with exactly
these fields: property_type, address, survey_type, access_notes,
client_deadline. If the enquiry doesn't state a field, use null.
Don't guess or infer missing details.

ENQUIRY:
[form text inserted by the workflow]

An illustrative output for an enquiry that said "three-bed semi, need a full building survey, keys with the estate agent, we exchange end of next month":

{"property_type": "three-bedroom semi-detached house",
 "address": null,
 "survey_type": "full building survey",
 "access_notes": "keys with the estate agent; call 24 hours ahead",
 "client_deadline": "before exchange, end of next month"}

The problem is "call 24 hours ahead": the enquiry never said it. The model filled a gap with a common instruction despite the prompt. Two fixes work at any platform. Add a check step that compares each field against the source text, or route briefs with notes the enquiry doesn't support to a person. And keep "null" rather than guesses, so a missing address stops the job being created at all instead of producing a folder named after nothing.

What each option holds: logins, tokens and your data

Every connection needs permission to act in your apps, usually a token granted when someone clicks "connect" and signs in, or an API key pasted into a settings box. Whoever holds those can read and change data in the connected apps, so the security question is where the keys live and whose data passes through.

Two practical points catch small firms. First, grant the narrowest permission each workflow needs: a workflow that only creates folders doesn't need access to delete them, and many apps let you choose the scope when you connect. Second, watch for connections tied to people. If the workflow's Gmail connection belongs to an employee who leaves, it breaks the day their account is closed. On Make, there's an extra wrinkle: people connecting ordinary @gmail.com accounts to Gmail, Drive or Sheets need their own Google Cloud OAuth client, which is one more reason to run business workflows from business accounts. When you review workflows each quarter, list every connection, who owns it, and what it can touch.

How each option breaks, and how you'd notice

• iPaaS workflows stop quietly. Zapier auto-pauses a Zap when 95% of its runs error over seven days. Make's scheduled triggers keep using credits while nothing arrives. In Power Automate, a flow that keeps failing for 14 days is switched off. The fix is an owner and an alert for every workflow; how to stop automations breaking silently sets that up.
• Self-hosted middleware ages. Missed updates, a full disk, backups nobody tested. It works for months and fails on the day the only person who understands it is on holiday.
• Custom code outlives its author. An app changes its API, the script fails, and the developer has moved on. Insist on documentation, code in your own account, and credentials you control.

A realistic example of the first kind: a painter and decorator's workflow turned accepted quotes into deposit invoices. The quoting app renamed a field in an update, every run errored, and the Zap paused itself a week later. Nobody noticed for three weeks, until a customer asked why no invoice had arrived; four deposits hadn't been requested. An error alert to the owner's phone would have caught it on day one.

An integration brief to fill in before choosing

Whichever option you lean towards, write the brief first. It turns a vague "can we connect these?" into something you can price. A filled-in version for an architect practice:

INTEGRATION BRIEF                               Date: [month, year]
Job:         when a fee proposal is accepted in [proposal app],
             create the project in [project app], a folder in
             shared storage, and a deposit invoice in [accounts app]
Volume:      8-12 accepted proposals a month
Native option?  [proposal app] has a built-in link to [accounts app]
             for invoices only; covers step 3, not steps 1-2
Trigger:     proposal status changes to "Accepted" (webhook available)
Steps:       3 actions + 1 check (fee matches the signed proposal)
Must never:  send an invoice without the check passing
Owner:       [first name]; error alerts to their phone
Option chosen: native link for invoices + iPaaS for steps 1-2
Review:      after 3 months, or if volume passes 100 a month

The brief usually settles the question on its own. Most small-business integrations turn out to be low-volume, few-step jobs where a native link plus a simple iPaaS workflow is cheapest to build and easiest to keep alive, with custom code reserved for the rare case the brief shows it's needed.

Connecting apps: questions owners ask

Is Zapier an iPaaS?

Yes. Zapier, Make, n8n Cloud and Microsoft Power Automate are all integration platforms delivered as a subscription service, which is what iPaaS means. They differ mainly in how they bill: Zapier counts each successful action step, Make counts credits per module, and n8n counts whole workflow runs. That billing unit matters more to your costs than the list price.

Do I need a developer to use iPaaS?

Not for straightforward workflows. Zapier and Make are built for non-developers, and n8n Cloud needs no technical setup. You'll want technical help when a workflow needs custom API calls, complex data mapping or careful error handling, or if you choose to self-host n8n, which its own documentation says needs technical knowledge for installation, configuration and running the server.

What happens to my automations if the iPaaS vendor changes its prices?

You pay the new price or move, and moving means rebuilding each workflow on another platform, since workflows don't export between vendors in a usable form. Keep a written description of every workflow, its trigger, steps and owner, so a rebuild takes hours rather than days, and review costs at each renewal rather than when the invoice surprises you.

Further reads

• Zapier vs Make vs n8n for AI Automation: Which Fits Your Business? — The three main iPaaS options compared for AI automation.
• What Is an API? Why It Matters When You Buy Software — The plain-English background every option here depends on.
• What Is n8n, and Should a Small Business Use It? — What n8n is, before you decide to host it yourself.
• How to Add AI Steps to Zapier: Classify, Summarise, and Draft — How to add the AI step used in the worked example.
• Automation Audit: Find the Zaps and Scenarios Nobody Owns — Find the workflows nobody owns before adding more.
• No-Code AI Tools vs a Custom Build: When Templates Stop Working — When templates stop working and a custom build makes sense.
• AI Tools and AI Development: The Complete 2026 Guide — the AI hub, including every tutorial in the AI-for-business series.

Sources: Zapier, Make and n8n pricing and billing rules as of September 2026; n8n documentation on choosing between Cloud and self-hosting; DigitalOcean Droplet pricing; Cloudflare Workers pricing; OpenAI API pricing (gpt-5-nano).