Comparisons
Connector, iPaaS or custom build: the technical differences
A connector, an iPaaS flow and a custom integration call the same APIs and meet the same rate limits. They differ in four places: who decides the call pattern, where your pricing rules can live, what happens to a record that fails, and who changes the mapping when an API version is retired.
Updated
The short answer
Three ways to connect a store to an ERP, in the terms used on this page:
- Connector: a finished product for one pair of systems, such as Oracle's NetSuite Connector or one of Celigo's managed Integration Apps. The vendor chose the flows and fields. You set options.
- iPaaS: a hosted platform on which flows are assembled from prebuilt connections and templates, such as Celigo's integrator.io or Zapier. You or a partner configure and maintain the flows.
- Custom build: an integration written for your systems and your rules, then hosted and run by the party that built it. That is what we do.
| Connector | iPaaS | Custom build | |
|---|---|---|---|
| Throughput | Same API limits. Call pattern fixed by the product | Same API limits. You tune page size and schedule | Same API limits. Call pattern designed per flow: bulk reads, 250 records per write |
| Sync pattern | The schedule the product offers | Scheduled runs with a change filter and a lag | Webhooks and a queue for orders, scheduled runs for bulk, a nightly comparison |
| Pricing and customer logic | The fields the product maps | What the template maps, extended in the flow builder | Any rule you can state: price levels, tiers, per-customer catalogs |
| Failure behavior | The error list of the product | Error dashboard and retry. Some skips raise no error | Queue, backoff, dead-letter queue, replay, daily comparison |
| Who changes the mapping | The vendor, on its release schedule | You or your partner. Managed apps are updated by the vendor | The party that runs it |
Statements about Celigo and Zapier on this page come from their own documentation and pricing pages, read on October 3, 2026.
Throughput and sync pattern
No option gets a higher limit from the API. Shopify gives every app 100 cost points per second on a standard plan and 1,000 on Plus. NetSuite accepts 5 concurrent requests on its Standard tier, 15 on Premium and 20 above that. Oracle documents one exception: requests from its own NetSuite Connector are excluded from concurrency governance and do not count toward the account limit.
Celigo's implementation guide for Shopify and NetSuite describes flows that run on a schedule and ask what changed since the last run. It recommends a lag of 10 to 15 minutes on the order flow, so that an order has reached its final payment status before it is picked up. With a lag of 15 minutes, the guide says, an order placed 5 minutes ago is not picked up on the current run. For inventory it recommends a run every 15 to 30 minutes for active stores, and for catalog data every hour or every few hours.
Take an order placed at 10:02 and a flow that runs every 15 minutes with a 15-minute lag. The run of 10:15 skips it. The run of 10:30 picks it up: 28 minutes.
At 50 orders a day those 28 minutes go unnoticed. At 500 orders an hour, 8.3 a minute, every order waits 15 to 30 minutes: between 125 and 250 orders are in the store and not yet in the ERP at any moment.
For throttling the same guide gives two instructions. When Shopify returns THROTTLED: reduce the page size and set a longer schedule interval. For inventory at scale: send 100 to 250 items per inventorySetQuantities call, because one SKU per call throttles on a large catalog. The second one changes the sum. 50,000 variants at one per call are 500,000 cost points, 83 minutes on a standard plan. At 250 per call they are 200 calls and 20 seconds, as worked out in Shopify API rate limits.
Capacity is counted in different units per platform:
| Platform | Unit | What it means at volume |
|---|---|---|
| Celigo | Endpoints and active flows per edition. No charge per transaction | A new system or a new flow counts, a busier day does not |
| Zapier | Tasks. Each successful action in a workflow is one task | 6,000 orders a month at 4 actions each: 24,000 tasks. 15,000 stock updates a day: 450,000 tasks a month |
| Custom build | None | Volume is limited by the API limits of the two systems |
In a custom build the pattern is chosen per flow. Orders arrive by webhook, go into a queue and are written to the ERP within the limit of that ERP. Full reads use bulk operations. Writes go in batches of 250. A nightly comparison of both systems finds what a webhook missed. The sums are in working out integration throughput and, for the ERP side, in NetSuite concurrency and governance limits.
Pricing and customer logic
A B2B price structure has more layers than a product with a fixed field mapping carries. A wholesale customer rarely pays the base price. Take item KB-2210:
| Price layer | Value |
|---|---|
| Base price | 12.50 |
| Price level Wholesale | 10.00 |
| Agreement with Bakker Installatie B.V. | 9.60 |
| Tier from 50 pieces | 8.90 |
Bakker Installatie orders 60 pieces. The right line total is 60 x 8.90 = 534.00. An integration that carries only the base price puts 60 x 12.50 = 750.00 in the store, a difference of 216.00 on one order line.
What Celigo documents on this point:
- A help article on the NetSuite to Shopify item export states that Celigo can only pass one price level at a time and that the saved search supports a single price level. The documented workaround is a set of custom fields in NetSuite, filled by a script, that hold the other price levels. The article was last updated in April 2021.
- Per-customer catalogs are covered in a separate product, the Shopify B2B and NetSuite integration template. It syncs NetSuite price levels to Shopify catalogs and models each Shopify company location as a NetSuite sub-customer. The company flow needs a Shopify Plus account, as specified by Shopify.
- For the sub-customer model Celigo points to a NetSuite limit: a customer hierarchy holds at most 10,000 customers and sub-customers. Once that is reached NetSuite refuses a new sub-customer and the order import flow fails.
- The B2B product is published as a template. Celigo's own comparison of Integration Apps and templates says that an Integration App receives bug fixes, new functionality and support, and that a template receives none of those and is fully editable after installation.
In a custom build the price logic is written as rules and tested against your own customers before go-live: which layer wins, how tiers stack, which customers see which items. The store receives the price the ERP would invoice. How that works per layer is on prices and customer-specific pricing.
Failure behavior
An API is down, a record is refused, a limit is hit. What matters is what happens to the record. Celigo's guide makes three statements about its own behavior:
| Situation | What the Celigo guide states |
|---|---|
| A NetSuite item has no record in the item ID map | The inventory sync cannot resolve it to a Shopify product and skips it silently |
| A flow is paused for maintenance and enabled again | The delta timestamp has to be checked. A stuck delta is named as the most common cause of missing records after a maintenance window |
| Failed records are retried before the cause is fixed | Retrying in bulk creates noise in the error log and can create partial records |
The same guide describes what the platform does provide: a flow dashboard in which a failing record can be opened with its source payload and the error response, and a retry once the cause is fixed. That is a working error process for records that fail with an error. The first row is the one to plan around, because a skip without an error does not appear in a dashboard.
A custom build handles failure in code that is written for it:
- Each message is stored in a queue before it is sent and removed after the receiving system confirms it.
- A
429or503is retried with growing pauses, for example after 1, 5, 15, 60 and 120 minutes. - The store order number goes along as an external ID, so a retry after a timeout finds the first order and does not create a second.
- After the last attempt the message goes to a dead-letter queue with its original payload and can be replayed.
- An item without a mapping goes on a review list with the reason. It is not skipped.
The full sequence, with a three-hour outage as the example, is in what happens when an integration fails.
Who changes the mapping when the API changes
APIs change on a schedule. Shopify releases a new API version every three months and supports each stable version for at least 12 months. The REST Admin API has been legacy since October 1, 2024. From version 2026-04 the inventorySetQuantities mutation requires an idempotency key. An integration that keeps calling it the old way works on 2026-01 and returns an error after the version upgrade. Somebody has to make that change, at least once a year.
| Who makes the change | What you depend on | |
|---|---|---|
| Connector | The vendor | The vendor's release date |
| iPaaS, managed app | The vendor, for the managed parts. Celigo locks those parts so it can upgrade them | The vendor's release date, plus your own changes around it |
| iPaaS, template or own flow | You or your partner. Celigo states that templates receive no bug fixes, new functionality or support | The person or partner who maintains the flow |
| Custom build, hosted and run by the builder | The builder | The agreement with the builder |
Upkeep also covers your own changes: a supplier renames a column, the ERP gets a new required field, a second warehouse opens. In a connector that is a feature request. On an iPaaS it is a change in the flow builder. In a custom build it is a change in code by the party that runs it.
What a custom build from us includes
We build the integration to your systems and your rules, for a fixed build price, and then host and run it for a monthly fee. Running it means monitoring every run, keeping up with the API versions of both systems, and fixing the integration when a source changes. You get a dashboard with logs and a login, a dry run before go-live, approval of changes, exclusions and overrides, and a diff per run that shows which records changed and to which value.
The store to ERP setup as a whole is described on ecommerce ERP integration, and all flows on integrations. The comparison with one platform in detail is on Celigo alternative. Tell us which systems you run and where the current setup stops.
Frequently asked questions
What is the difference between a connector and an iPaaS?
A connector is a finished product for one pair of systems: the vendor has chosen the flows, the fields and the schedule, and you fill in settings. An iPaaS is a platform on which flows are assembled from prebuilt connections and templates, on a subscription. On an iPaaS you can change the mapping yourself; in a connector you can change what the settings expose.
Is a custom integration faster than an iPaaS?
All three are bound by the same API limits, for example 100 cost points per second on a standard Shopify plan. Speed comes from the call pattern. A flow that polls on a schedule with a 15-minute lag delivers an order up to 30 minutes after it was placed. A webhook with a queue delivers it in seconds, and 250 stock figures per call move 50,000 variants in 200 calls.
Can a connector handle customer-specific prices?
That depends on what the product maps. Celigo documents for its NetSuite to Shopify item export that it passes one price level at a time, and it covers per-customer catalogs in a separate Shopify B2B template that needs Shopify Plus. A custom integration maps every price level, tier and customer agreement you can describe as a rule.
Who maintains an integration when Shopify or NetSuite changes its API?
With a connector, the vendor. With an iPaaS it depends on the product: Celigo states that its managed Integration Apps receive bug fixes and new functionality, and that templates do not. With a custom build it is whoever runs it. We host and run what we build and change it when a source changes. Shopify retires each API version at least 12 months after release.
What does an iPaaS charge for?
The unit differs per platform. Celigo measures an edition in endpoints and active flows and states that it does not charge per transaction. Zapier counts tasks: every successful action in a workflow is one task. An order flow with 4 actions at 6,000 orders a month is 24,000 tasks. A custom build has a fixed build price and a monthly fee for hosting and running it.
Tell us what you need
Tell us which systems you use and what needs to work better. We reply personally within one working day. We help you define the work, then agree the price and timing before you commit.
- You know the price and the timeline before you commit to anything
- We work out the connection that takes the work off your hands
- We handle the build, hosting, monitoring and maintenance
- Your team has less information to retype and fewer discrepancies to chase