Which data moves in which direction, where the conflicts are, and what has to happen when the connection drops.
A Shopify integration connects the storefront to the ERP so orders flow in and stock, pricing and fulfilment status flow out. The ERP remains the system of record for inventory and finance; Shopify is the sales channel. The hard parts are not the API calls — they are deciding which system owns each field, and what happens when one of them is unavailable.
Most integrations are specified as a list of things to sync and discover the real questions later. Who owns the price when it differs? What happens to an order received while the ERP is down? If stock sells out between sync cycles, who absorbs the oversell? Answering these before building is the difference between an integration that runs quietly and one that needs daily attention.
New orders create sales orders, with customer matching or creation, tax treatment and payment status mapped correctly.
Available-to-promise pushed on a schedule or on change. The interval is a commercial decision about oversell risk.
Usually ERP-owned, pushed outward. Deciding this clearly prevents the two systems disagreeing about price.
Despatch in the ERP writes fulfilment and tracking back, which triggers Shopify's customer notification.
Often the least-specified flow and the one that causes the most reconciliation work later.
An integration imports orders by webhook. It works for weeks, then a network blip causes Shopify to retry a delivery it believes failed. The ERP receives the same order twice and creates two sales orders. Both get picked. The customer receives two parcels.
This is not an edge case — webhook delivery guarantees are at-least-once by design, so retries are normal operation rather than a fault. Any integration that assumes each message arrives exactly once will eventually duplicate. The fix is idempotency: store the Shopify order identifier against the ERP sales order and check for it before creating anything, so a repeat delivery is recognised and acknowledged rather than processed.
Two related habits belong in the same design. Acknowledge the webhook quickly and process asynchronously, because slow responses cause the retries in the first place. And reconcile daily by polling for orders in a window and comparing against what the ERP holds, so a genuinely missed webhook is caught the next morning rather than at month-end.
| Term | What it means |
|---|---|
| Webhook | A callback Shopify sends when an event occurs, so the ERP learns about an order immediately. |
| Variant | A specific purchasable version of a product — size, colour — and the level that maps to an ERP item. |
| Fulfilment | The Shopify record of goods shipped, usually written back from the ERP with tracking. |
| Idempotency | Handling a repeated message without creating a duplicate. Essential, because webhooks retry. |
| Rate limit | The cap on API calls per interval. Integrations that ignore it fail under load, not in testing. |
If both systems can change price or stock, they will, and the last write wins silently.
A long interval means overselling. Shorten it on fast-moving lines or push on change.
APIs fail. Without a retry mechanism and a visible error queue, failures are discovered by customers.
Tax treatment by destination and customer type is where order mapping most often goes wrong.
| Metric | What it tells you | What distorts it |
|---|---|---|
| Orders in Shopify vs ERP | The daily reconciliation. Any gap is a missed or failed message. | |
| Duplicate orders created | Idempotency failures. Should be zero; anything above it is a design fault. | |
| Stock sync lag | Minutes between an ERP stock change and the storefront reflecting it. Drives oversell risk. | |
| API error rate by type | Rate limiting, authentication and validation errors each mean something different. |
We build and support the systems this page describes. Start with a free working proof of concept — no cost, no commitment.