Your Shopify Store Works Fine. Your Back Office Is the Problem.

Here's a phrase we hear again and again from Shopify + NetSuite businesses: "I just don't completely trust the data."

The front end isn't the issue. Shopify handles orders. NetSuite handles the books. The problem is what happens in between. The sync that runs a few minutes late. The refund that posts to the wrong account. The inventory number that Shopify says is 50 but NetSuite says is 34, and nobody can agree which is right. For a growing business, that gap is a bit more than a minor inconvenience.

This is what a Shopify x NetSuite integration is really about. Not a technical puzzle. A trust problem. And one we've spent a decade helping businesses solve.

Where integrations go wrong

After many go-lives across HK and APAC, we have a clear picture of where these projects come apart. The failure modes are consistent. And they're rarely "technical." They come from scope that didn't match reality, and connectors being pushed past what they were set up to handle.

The problems we tend to see most often:

• Returns and refunds are the one we hear about most. Pre-fulfillment cancellations, partial refunds with discount codes, gift card refunds issued by customer service - all of these require manual intervention in most out-of-the-box connector setups. The first time it shows up is usually a partial refund on an order with stacked discounts. Higher tiers often gate better support for refunds, exchanges, and edge cases, which means businesses discover the gap only after go-live.
• Inventory sync errors are the ones that cost real revenue. The failure mode isn't dramatic. It's a connector quietly posting incorrect inventory counts to Shopify with no corresponding change in NetSuite, creating a mismatch that the business doesn't catch until orders are already placed. The mismatch is usually blamed on warehouse ops, until you check the sync logs. If you sell anything that can stock out, even small sync issues turn into cancelled orders and awkward customer emails.
• Payment reconciliation is where finance teams lose weeks. We've worked with businesses running what they'd describe as a standard Shopify setup (nothing exotic) where 90% of deposits through the connector had discrepancies against the bank account. The connector worked, technically. The reconciliation didn't. You'll see it as a deposit that's off by a small, repeatable amount - fees, rounding, or a mapping issue.
• B2B order flows carry their own risks. We've seen multiple cases where B2B imports stopped behaving as expected after a connector change, and the business only discovered it once orders failed to arrive in NetSuite. That pattern is exactly why we treat B2B as its own scope line, not a checkbox upgrade. Pricing reflects that complexity. The native connector is about $2,400 to $2,500 per year for a standard B2C setup, while the B2B tier is often reported closer to $12,000 per year. Most stakeholders have the same reaction to that jump, especially before they've felt the operational impact of B2B edge cases.
• Adding channels breaks things. An integration that runs cleanly for a single Shopify storefront often falls over when you add Amazon, a B2B portal, or a second regional store. What was a clean, contained data flow becomes an orchestration problem, and most point connectors weren't designed for it. We've rebuilt several integrations for clients who came to us after hitting this wall. In most cases, the original scope never accounted for growth.

None of this is inevitable. The businesses that avoid these failures aren't using fundamentally different technology. They're just starting with a more honest picture of what they're actually building.

What you're really spending

Connector pricing is usually where businesses start their evaluation... it's rarely where the cost ends.

The native NetSuite Connector runs around $2,500/year for a standard B2C setup. Celigo sits significantly higher and doesn't publish pricing publicly. Custom SuiteScript development typically runs $5,000–$25,000 per integration depending on complexity. Workato and Boomi sit above that for full multi-system orchestration.

What those numbers don't include is the labour cost of managing an integration that isn't quite right. Every reconciliation failure, every manual inventory correction, every payment discrepancy that needs investigating. That's time your operations and finance team is spending instead of something more useful. When you factor in labour, the 24-month total cost of ownership often stops looking like "connector fee plus setup." For many businesses, the dominant cost becomes exception handling: reconciliation, inventory corrections, refunds, and investigating mismatches. The spread is wide because volume and complexity drive it, but the pattern is consistent: the cheapest connector can become the most expensive integration if it creates weekly manual cleanup.

In practice, the cheapest connector isn't necessarily the cheapest integration. If it generates three hours of manual cleanup per week, it's more expensive than the platform that costs twice as much but runs without intervention.

The options — and when each one makes sense

Part of what we do is help clients pick the right tool for their actual situation, not the most popular one or the one their NetSuite rep recommended last. None of these tools are "set and forget." You're choosing what kind of complexity you want to manage.

NetSuite Connector (formerly FarApp) is the entry point. At around $2,500/year for B2C, it's the lowest-friction starting point for a simple, single-channel store with standard Shopify payment methods and straightforward fulfillment. Some businesses run it for years without serious problems. Others come to us frustrated by data they can't fully rely on, field mappings they can't change, and returns handling that requires workarounds. Knowing in advance which scenario you're likely to be in is most of what the scoping conversation is for.

Celigo is the premium iPaaS option most businesses eventually consider. More capable on complex flows: split shipments, multiple warehouses, harder edge cases. We've configured Celigo for clients where the investment was clearly justified. We've also seen clients over-invest in it for setups that didn't need it. Lately, pricing has become part of the Celigo conversation more often, especially for teams that started on it years ago and scaled up.

Workato and Boomi are what you reach for when the integration needs to connect multiple systems at once — Shopify, NetSuite, a 3PL, and a banking API in a single coordinated flow. This is the right layer for genuinely complex, multi-entity operations. It's also where two of our longer-standing client relationships sit: D1 Milano (NetSuite + Shopify + Workato, multi-currency watch retail) and WobbleWorks/3Doodler (NetSuite + Workato, global eCommerce that came to us running out of Google Sheets). Both required getting the architecture right upfront. Both have been running cleanly since.

Custom SuiteScript is worth serious consideration when the use case genuinely doesn't fit commercial connectors — and that happens more often than the tool vendors would like to admit. We build and maintain custom integrations for clients where the edge cases are real and deep, with the architecture explicitly designed to survive NetSuite's biannual updates. The risk with custom is what happens when the original developer isn't around. That's why we build everything with documentation and handover in mind from the start.

Why HK and APAC require a different conversation

The standard integration guides — and most connector documentation — are written for US businesses. Several things that matter in Hong Kong and across APAC simply don't appear in generic advice.

Multi-currency is the most immediate one. Whether you're using Shopify Markets to sell in multiple currencies or running multiple storefronts by region, the integration needs to carry currency detail cleanly into NetSuite. If everything gets flattened into a base currency too early, your books may still balance, but the underlying story becomes harder to read by currency and market. NetSuite OneWorld handles multi-currency well at the ERP level. The connector is where it frequently breaks down. We've seen clients arrive mid-year with books that technically balance but can't be read clearly by currency because the connector was never configured for it.

Local and regional payment methods are a consistent gap. AlipayHK and FPS in Hong Kong, plus methods you may add for expansion markets like PayNow in Singapore, usually need deliberate mapping into NetSuite. Octopus can also be part of the mix depending on how you implement it. Each method has its own settlement batches, fee logic, and transaction mapping that should be defined against your chart of accounts — otherwise reconciliation turns into a monthly investigation. We build this configuration as standard for HK clients because it's the difference between a clean close and a messy one.

Cross-border fulfillment adds complexity for businesses shipping into Mainland China. If NetSuite is your system of record for landed cost or customs documentation, the integration needs to accommodate CBEC requirements for the relevant product lines. This isn't universal — it depends on your logistics setup — but it's a question we scope explicitly rather than leave for after go-live.

Multi-location retail is a failure we've seen play out at more than one HK business. A Shopify POS creates a cash sale, the connector checks NetSuite inventory, finds zero (because stock has arrived physically but hasn't been receipted yet), and blocks the transaction. The retail team can't fix it. They don't have NetSuite access. Someone at head office has to intervene before the sale can go through. We've seen this show up a lot in businesses where receiving and POS operate on different schedules. The fix isn't complicated, but it requires knowing the failure mode exists before you build.

What a well-built integration actually looks like

WobbleWorks came to us running global eCommerce out of Google Sheets. Multiple sales channels, inventory split across regions, fulfilment through third parties. The integration we built with Workato connects NetSuite and their eCommerce stack in a way that the finance team can trust — not because it's technically elegant, but because it was scoped against their actual operations, including the edge cases, before a line of configuration was written.

D1 Milano (Italian watches, meaningful HK and international retail presence) runs NetSuite with Shopify and Workato. Multi-currency, multi-channel, hundreds of SKUs. When a model sells out, NetSuite and Shopify are telling the same story. Month-end close doesn't require anyone to manually reconcile the two systems. That sounds modest, but it represents a meaningful shift in how the operations team spends its time.

Neither of these is our most complex integration. Both are examples of what happens when the scope is honest, the APAC specifics are built in from the start, and someone with NetSuite depth is accountable for the outcome — not just the initial deployment.

How we approach a new integration

Most integration problems are visible before the first line of configuration is written. A structured pre-implementation phase is where we catch them.

Data quality first. We audit your SKUs, customer records, and item data across both systems before mapping anything. Syncing bad data produces bad synced data, and inconsistencies that look minor in isolation compound quickly once data starts flowing.

Workflow mapping before tooling. We document the actual order-to-fulfillment flow — every exception type, every edge case, before recommending a connector. Partial fulfillments, backorders, B2B credit terms, returns with and without restocking: if the flow isn't clearly modelled, the integration can't reflect it accurately.

Staging before production. We build and test in a sandbox environment, not against your live data. This is where the edge cases surface: split payment scenarios, discount stacking, custom fields, multi-storefront currency flows. Better to find these in staging than at month-end.

Parallel validation at go-live. We run both systems simultaneously for a defined period and reconcile daily before switching over. The discrepancies that surface here are the ones you'd otherwise find under pressure.

The questions we'd ask ourselves on your behalf are also the ones you should ask any integration partner: Have they done this for an HK-registered entity with local payment gateways and potentially cross-border logistics? What does their support process look like when something breaks? Who maintains the integration after go-live? How have they handled a NetSuite update cycle that affected one of their live clients?

If you can get clear answers to those, you have a reasonable basis for evaluating a partner. If you can't, that's worth knowing too.

The point

The businesses that end up with integrations they trust aren't doing anything exotic. They're working with someone who's built enough of these — across enough APAC-specific scenarios — to know where the problems live before they appear.