What is iPaaS? Integration Platform as a Service Explained

iPaaS in plain English

iPaaS stands for Integration Platform as a Service. Strip away the acronym and you have: cloud-hosted middleware that connects your business applications without requiring custom code for every integration.

Think of it as a universal translator sitting between your systems. Shopify speaks its own language. NetSuite speaks another. Salesforce has its own dialect entirely. An iPaaS platform understands all of them and handles the translation, so data moves between systems automatically and accurately.

The reason iPaaS exists is straightforward. Ten years ago, a typical mid-market company ran maybe five or six software applications. Today that number is closer to 40-80, depending on who's counting (Productiv's 2024 SaaS report pegged the average at 56 apps per company). Every one of those applications generates data that someone, somewhere in the organization, needs to reconcile with data from another system. Finance needs Shopify revenue to match NetSuite GL entries. Operations needs warehouse updates to reflect in order management. Marketing needs CRM data to flow into campaign tools.

For a while, companies solved this with CSV exports, manual data entry, and a lot of spreadsheets. Then they tried point-to-point API integrations built by developers. Both approaches work until they don't. The spreadsheet method breaks down around 50 orders per day. The custom API approach breaks down when the developer who built it leaves, or when one vendor changes their API, or when you need to add a sixth integration and realize you're now running a software shop inside your accounting department.

iPaaS platforms emerged to fill that gap. They provide pre-built connectors to popular applications, visual tools for mapping data between systems, automated error handling, and a management layer so your operations team can monitor everything without calling a developer every time something fails.

How iPaaS actually works

Every iPaaS platform — Celigo, Boomi, Workato, all of them — operates on roughly the same architecture. Four layers.

Connectors are pre-built adapters for specific applications. A Shopify connector knows how to authenticate with Shopify's API, read order data, create products, update inventory. A NetSuite connector understands SuiteScript, saved searches, record types, and all the idiosyncrasies of Oracle's ERP. Good connectors abstract away the API complexity so you're working with business objects (orders, customers, invoices) instead of raw JSON payloads.

Flows (sometimes called integrations, recipes, or processes depending on the vendor) define the actual business logic. A flow says: when event X happens in System A, do actions Y and Z in System B. Flows can be triggered by schedules (run every 15 minutes), events (new order created), or webhooks (real-time push notifications).

Data mapping and transformation sit between the source and destination. Shopify stores a customer's full name as a single field. NetSuite expects first name and last name as separate fields. The iPaaS handles that split. It also handles type conversions, default values, conditional logic, and lookups — like finding the correct NetSuite subsidiary based on the Shopify store that the order came from.

Error handling and monitoring are what separate iPaaS from a script that someone wrote and forgot about. When a record fails to sync — and records will fail to sync — the platform catches the error, logs it, retries if appropriate, and alerts someone. Celigo, for example, gives you a dashboard showing every failed record with the specific error message and the ability to fix and retry without re-running the entire batch.

A concrete example makes this tangible. A customer places an order on Shopify at 2:47 PM. Within minutes, Celigo's Shopify connector picks up the new order. The flow checks whether the customer already exists in NetSuite (lookup by email). If yes, it maps the order to that customer record. If not, it creates a new customer first. Then it creates a sales order in NetSuite with the correct items, prices, tax, and shipping. NetSuite's inventory commits against the order. When the warehouse ships it, the fulfillment record in NetSuite triggers a reverse flow that pushes tracking information back to Shopify, which emails the customer automatically.

That entire chain runs without a human touching it. When it breaks — say, an item SKU doesn't match — the error gets caught, queued, and flagged for someone to resolve.

iPaaS vs the alternatives

iPaaS is not the only way to connect applications. It occupies a specific position in the market, and it's worth understanding where it fits relative to other approaches.

Custom code (API integrations)

You hire developers. They read the API documentation for both systems. They write code that calls one API, transforms the data, and pushes it to the other. This is the most flexible approach — you can build literally anything. It is also the most expensive to maintain. Every API version change requires developer time. Every new edge case requires code changes. Every new integration starts from scratch. We've seen companies spend $150K-$300K building custom integrations that an iPaaS platform handles out of the box.

Custom code makes sense when you need something highly specialized that no iPaaS platform supports, or when you're a software company and integration development is a core competency.

Native connectors

Many SaaS vendors offer built-in integrations. Shopify has a NetSuite connector. Salesforce has connectors for dozens of applications. These are typically free or low-cost and easy to enable.

The problem is scope. Native connectors usually handle the most basic sync scenarios. Shopify's native NetSuite connector, for instance, doesn't handle multi-subsidiary NetSuite environments, complex pricing rules, or custom fields without significant additional work. You also end up managing each connector independently, with no unified error handling or monitoring across integrations.

Native connectors work for simple, single-direction data syncs. They fall apart when business logic gets involved.

ESB / traditional middleware

Enterprise Service Bus platforms — MuleSoft, TIBCO, IBM Integration Bus — predate iPaaS. They're on-premise or hybrid, designed for massive enterprises with dedicated integration teams. A MuleSoft deployment can handle virtually any integration scenario, including legacy systems, on-premise databases, and custom protocols.

The cost and complexity are proportional. MuleSoft implementations start around $50K/year in licensing alone and require developers who know the DataWeave transformation language and the Anypoint platform. For a company running $20M-$200M in revenue with a five-person IT team, this is a serious mismatch. ESBs make sense at the Fortune 500 level. Below that, iPaaS covers the same ground at a fraction of the cost.

Zapier / Make

Zapier and Make (formerly Integromat) popularized no-code automation. They're excellent for connecting SaaS apps in simple workflows — when a form is submitted, create a row in a spreadsheet and send a Slack notification.

They break down for ERP-level integrations. Zapier's NetSuite support is limited. Neither platform handles the transactional complexity of order-to-cash flows, multi-record dependencies, or the error volumes that come with syncing thousands of records daily. If you're integrating a CRM with your email tool, Zapier is perfect. If you're integrating Shopify with NetSuite at 500+ orders per day, you need a platform built for that complexity.

The iPaaS landscape: who's who

The iPaaS market has consolidated around a handful of major players. Each has a distinct positioning.

Celigo dominates the NetSuite mid-market. Founded by former NetSuite employees, the platform was built specifically around NetSuite's data model and business processes. Their pre-built Integration Apps for Shopify, Amazon, Salesforce, and 3PLs come with mapped fields, pre-configured business logic, and documented setup playbooks. For NetSuite-centric companies, Celigo offers the fastest path from zero to production. BrokenRubik is an authorized Celigo partner — we implement, customize, and support Celigo integrations as part of our NetSuite practice.

Boomi (formerly Dell Boomi, now independent after a private equity buyout) is the enterprise generalist. Strong connector library covering hundreds of applications, solid data governance features, and reliable high-volume processing. If your integration architecture spans many systems beyond NetSuite — Workday, ServiceNow, custom databases — Boomi handles that breadth. The tradeoff is that Boomi's NetSuite-specific knowledge is shallow compared to Celigo's.

Workato has carved out a niche with IT teams that want to build. The platform combines iPaaS with workflow automation (similar to Zapier but enterprise-grade). Recipe-based pricing can be attractive at first, but costs escalate when you realize a single "integration" might require 15 recipes to handle all the edge cases. Strong community and marketplace of shared recipes.

MuleSoft is Salesforce-owned and priced accordingly. Best-in-class if you need API lifecycle management and deep Salesforce integration. For pure ERP integration, it's overkill and overpriced for most mid-market companies. Requires Java developers, not business analysts.

Zapier and Make are consumer-grade. They handle simple app-to-app workflows. They don't belong in the same conversation as ERP integrations, but they're fine for lightweight automations running alongside your core iPaaS platform.

What iPaaS costs

Nobody in this market publishes transparent pricing, so here's what we see across client engagements.

Celigo: $20K-$60K/year. The base platform runs $600-$1,200/month. Each pre-built Integration App (Shopify-NetSuite, Salesforce-NetSuite, etc.) adds $300-$1,000/month. A typical mid-market deployment with three to four integrations lands in the $3,000-$5,000/month range. Volume-based tiers apply for high-transaction environments.

Boomi: Similar range to Celigo. $18K-$60K/year for mid-market. Pricing is based on connections and data volume. Enterprise licenses push past $100K/year easily.

Workato: Recipe-based pricing starts looking affordable at $15K-$20K/year but can reach $50K+ once you account for the number of recipes needed for complex integrations. Their pricing model incentivizes simple integrations; complex NetSuite flows require many recipes.

MuleSoft: $50K/year minimum. Realistically, $100K-$250K/year for a meaningful deployment. Plus developer salaries for the team that builds and maintains it.

Implementation costs sit on top of licensing. A Celigo integration for Shopify-to-NetSuite typically costs $8K-$25K to implement properly, depending on customization requirements. Complex multi-system deployments can reach $50K-$100K in implementation fees. This is where working with a partner like BrokenRubik matters — we've done enough of these that we know the shortcuts that won't bite you later and the "shortcuts" that absolutely will.

When iPaaS makes sense (and when it doesn't)

Good fit

You're running three or more cloud applications that need to exchange data regularly. You have recurring sync requirements — orders, inventory, customers, financial data — not just a one-time migration. Your team managing the integrations is primarily operations or finance staff, not developers. NetSuite is your system of record and you need other applications to stay in sync with it.

A quick gut check: if someone on your team is exporting CSVs from one system and importing them into another on a regular schedule, that's an iPaaS candidate.

Bad fit

You only need a single integration between two systems. Building a direct API connection (or using a native connector) may be simpler and cheaper than bringing in a full iPaaS platform. The overhead of managing a platform doesn't justify itself for one data flow.

You're a large enterprise with a dedicated 20-person integration team and complex on-premise systems. You probably need MuleSoft or TIBCO, not a mid-market iPaaS.

Your total integration budget is under $15K/year. At that level, a Celigo or Boomi license eats your entire budget before implementation. Consider native connectors or a targeted custom build instead.

Common iPaaS use cases for NetSuite companies

Most of our Celigo implementations fall into a few well-worn patterns.

Ecommerce to ERP is the most common. Shopify or BigCommerce orders flow into NetSuite as sales orders. Customer records sync bidirectionally. Inventory levels push from NetSuite back to the storefront. Product catalogs — including pricing, images, and descriptions — publish from NetSuite to the web store. This single integration pattern accounts for probably 40% of the Celigo deployments we've done.

CRM to ERP connects front-office and back-office. Salesforce opportunities convert into NetSuite estimates or sales orders. Customer data stays synchronized so sales reps see accurate billing history and support teams see accurate purchase history. Some companies also flow NetSuite invoice data back into Salesforce so account managers have full financial visibility.

HR to ERP automates payroll posting. Platforms like ADP, Gusto, or Paylocity push payroll journal entries directly into NetSuite's general ledger. Employee records sync between HR and ERP to keep vendor records, approval hierarchies, and cost center assignments current. This one saves finance teams hours of manual journal entry work every pay period.

3PL to ERP keeps warehouse operations in sync. When a third-party logistics provider receives inventory, confirms a shipment, or adjusts stock levels, those updates flow into NetSuite's fulfillment and inventory records automatically. Companies using ShipBob, Fulfillment by Amazon, or enterprise WMS platforms like Manhattan Associates use this pattern heavily.

Data warehouse feeds push NetSuite data into analytics platforms. NetSuite to Snowflake (or BigQuery, or Redshift) gives your BI team access to ERP data without running saved searches that slow down your production NetSuite instance. This is increasingly common as companies build centralized analytics on top of multiple data sources.

---

Here's what an iPaaS-powered integration looks like in practice.

Frequently Asked Questions

Frequently Asked Questions

What does iPaaS stand for?expand_more

How is Celigo different from other iPaaS platforms?expand_more

How much should I budget for an iPaaS implementation?expand_more

Should I build custom integrations or use an iPaaS platform?expand_more

Can I migrate from one iPaaS platform to another?expand_more