Comparison guide

Acumatica native commerce, decoupled commerce, or middleware: when to choose each

If your business runs on Acumatica and you're adding a storefront, you have three ways to connect them. Use native connectors when you sell in standard ways through BigCommerce, Shopify, or Amazon. Use middleware when commerce is one of several systems that must stay in sync. Choose a decoupled build when the way you sell doesn't fit a packaged storefront. The right one depends on how much business logic the storefront has to carry.

The three ways to connect commerce to Acumatica

Start with what each one is, in plain terms, before weighing the trade-offs.

1. Native connectors: the commerce integrations Acumatica builds and ships. In the Retail Edition, the connectors for Amazon, BigCommerce, and Shopify are included, with no extra software to buy. The Adobe Commerce connector is built by Kensium and costs extra.
2. Middleware: an integration platform such as Celigo or Jitterbit that sits between your systems and keeps them in sync, with prebuilt Acumatica connectors and mapping you control.
3. Decoupled (headless) commerce: a storefront that runs as its own application (Shopware, Drupal Commerce, or a custom front end) and reads from Acumatica through its API, with Acumatica staying the system of record.

Native connectors: when the built-in integrations are enough

Acumatica's native connectors sync the things most online sellers need: catalogue and product data, inventory, orders from online and offline channels, customers, shipments, and refunds. Storefront discounts flow back to the Acumatica sales order. Because they're configured rather than coded, they're the fastest and cheapest path to a working integration when your storefront is one of the three Acumatica supports.

They also cover more B2B ground than they used to. Shopify B2B syncs customer-specific and tiered pricing from Acumatica, captures purchase orders and payment terms at checkout, and supports company accounts with multiple buyers. BigCommerce connects to its B2B Edition, and Acumatica Customer Price Classes map to BigCommerce Customer Groups. The 2025 releases modernized BigCommerce Payments and moved the Shopify connector to Shopify's GraphQL Admin API.

Where native connectors break is custom logic. Setup is field mapping, so anything past that, a configurator that has to validate build rules, pricing a connector can't represent, or a non-standard workflow, needs middleware or custom development. And native connectors don't do headless: if your storefront is Drupal Commerce, Shopware, or a custom build, there's no native connector to reach for. Choose native when you sell through BigCommerce, Shopify, or Amazon in standard ways and want the shortest path to live. It's the right default, and there's no reason to over-build past it.

Middleware: when you're wiring up more than one system

Middleware earns its place when commerce isn't the only integration. If Acumatica has to stay in sync with a storefront plus a third-party logistics provider, a marketplace, and a CRM, a platform like Celigo can orchestrate all of it with prebuilt connectors and mapping you control, instead of a tangle of point-to-point links. It also gives you a place to hold custom field mapping and business rules a native connector can't. The trade-off is another system to license, learn, and maintain, and it's overkill for a single storefront a native connector already handles.

Decoupled commerce: when the experience has to fit the business

A decoupled build separates the storefront from the commerce engine and connects it to Acumatica through the ERP's contract-based REST API, which binds to stable business objects rather than screen fields, so ERP upgrades and customizations don't break it. That's the foundation for reading live pricing, inventory, and customer data straight from Acumatica when a page renders or a quote is built. It's the path when a packaged storefront can't express how you sell.

Lustre Products makes custom elevator handrails and safety barricades, where about 85% of orders arrived as a 25-column paper worksheet that had been the industry standard for 35 years. Acumatica could store the order, but its configurator produced text, not a validated visual build, and moving to the ERP made order entry slower because specs were keyed twice. The fix is a visual configurator, a headless Shopware storefront, and an Acumatica connector that pushes clean, structured orders into the ERP with no re-keying. A native connector couldn't have carried the configuration rules.

Accurate Industries, the largest steam room and sauna equipment distributor in the US, runs Acumatica with a Drupal Commerce storefront across B2C and B2B, including specialized discount pricing. The two systems didn't talk out of the box, so Acro generated an API client from Acumatica's OpenAPI spec, found it wasn't sufficient on its own, and built a PHP library and a Drupal module to connect them bi-directionally. The trade-off with decoupled is ownership: you get the most control and the best fit, and in return you own the build and its upkeep. It's the wrong answer when a catalogue and a cart would have done.

How to choose

Work down these questions in order. The first one that lands tells you most of what you need to know.

1. Is your storefront BigCommerce, Shopify, or Amazon, and do you sell in standard ways? Start with the native connector and don't build past it without a reason.
2. Do several systems need to stay in sync, without a custom storefront? Use middleware.
3. Does the way you sell need a storefront a package can't express, a configurator, complex B2B logic, or an unsupported platform? Go decoupled.
4. Is it really a pricing or data problem wearing an integration costume? Fix the Acumatica side first. The right integration can't rescue pricing the ERP isn't modelling correctly.

Cost and time follow the same order. Native is cheapest and fastest. Middleware adds a subscription and setup but saves you from hand-wiring many systems. Decoupled costs the most up front and over time, and it's the only one that fits a business a package can't.

Where customer-specific pricing fits

Most Acumatica commerce projects live or die on pricing. Acumatica handles customer-specific and price-class pricing, volume breaks, promotional prices, and effective dates natively. What differs is how that reaches the storefront: Shopify B2B syncs per-customer and tier pricing so each buyer sees their own price, BigCommerce maps Price Classes to Customer Groups but doesn't export true per-customer prices without a workaround, and a headless storefront reads live prices from Acumatica through the API and honours every rule exactly.

Frequently Asked Questions

Next step

Get the foundation right before you build.

For readers scoping a platform decision or wanting a full architecture recommendation.