Why ERP integration is the hard part of running a serious store
For a small store, the ERP is a spreadsheet and a person. For a growing Swiss merchant, the ERP — Abacus, Bexio, Microsoft Dynamics — is the financial and operational truth of the business. The moment Shopify and the ERP both believe they own customers, products, prices, stock and orders, you have two systems disagreeing about reality, and every disagreement eventually shows up as a wrong invoice, an oversold product or an order that never reaches the warehouse.
A Shopify ERP integration is not a connector you switch on. It is a contract between two systems about who decides what, what happens when one of them is unavailable, and how disagreements get reconciled. This article covers what each integration actually involves, the question that decides the whole architecture, what breaks in production, and how to scope the work honestly.
The system-of-record question decides everything
Before any code, answer one question for each kind of data: which system is the source of truth? This is the single decision that determines whether your integration is calm or chaotic.
- Products and prices — usually mastered in the ERP or a PIM, pushed to Shopify. The storefront should rarely be allowed to overwrite a price the ERP owns.
- Stock levels — almost always mastered in the ERP or WMS, with Shopify as a downstream mirror. Letting Shopify and the ERP both adjust stock independently is the fastest route to overselling.
- Orders — created in Shopify, pushed to the ERP for fulfilment and invoicing. The ERP becomes the source of truth for the order's financial state after that hand-off.
- Customers — this is where it gets genuinely hard, because both systems want to own the customer record. Decide deliberately, and accept that one side becomes a mirror.
Write this down as a table before scoping anything. We cover why this matters in painful detail in what breaks in a Shopify ERP integration.
What each integration actually involves
Abacus
Abacus is the Swiss ERP backbone for many established merchants — strong in accounting, payroll and Swiss compliance. Integration usually runs through Abacus' API layer or a middleware export/import, and the realistic challenges are mapping Shopify's order and tax model onto Abacus' accounting structures (cost centres, VAT codes, debtor records) and dealing with batch-oriented processes that don't fire instantly. Abacus tends to think in scheduled runs, Shopify thinks in real-time webhooks — bridging those two rhythms is most of the work.
Bexio
Bexio is the lighter, SaaS-native Swiss choice, popular with SMEs. It has a clean REST API, which makes the happy path pleasant: push an order, create a contact, generate an invoice. The honest caveats are rate limits, a simpler data model than a full ERP (so complex B2B pricing or multi-warehouse logic may not map cleanly), and the fact that "simple API" still means you own retries, idempotency and reconciliation. Bexio integrations look cheap until you handle the failure cases properly.
Microsoft Dynamics
Dynamics (365 Business Central or Finance & Operations) is the enterprise option, often already embedded in larger organisations. The API surface (OData, the Business Central API) is capable but the complexity is organisational as much as technical: entity mappings are deep, environments are gated, and you are usually integrating into a system that other departments depend on. Dynamics integrations are rarely "just" a Shopify project — they touch finance, IT and operations governance.
| System | Typical fit | API style | Where it gets hard |
|---|---|---|---|
| Abacus | Established Swiss merchants | API layer / middleware | Accounting model mapping, batch vs real-time |
| Bexio | Swiss SMEs | Clean REST | Rate limits, simpler data model, failure handling |
| Dynamics | Enterprise / larger orgs | OData / BC API | Deep entity mappings, governance, environments |
What breaks in production
Every ERP integration works in the demo. The cost lives in the failures, and they are predictable:
- Stock sync drift. Shopify and the ERP slowly disagree about quantities because an update was dropped, retried twice, or applied out of order. The symptom is overselling or phantom out-of-stocks.
- Duplicate orders or invoices. A webhook is delivered more than once (Shopify guarantees at-least-once, not exactly-once), and without idempotency you create the same invoice twice.
- Price desync. A price changes in the ERP but the push fails silently, so the storefront sells at the old price — or worse, a storefront edit overwrites the ERP's price.
- Lost orders. The ERP is down for maintenance, the webhook fires, nothing catches the failure, and the order is simply gone from the ERP's view until a customer complains.
- Out-of-order events. An "order updated" arrives before "order created" because they took different network paths. Naive handlers crash or corrupt state.
None of these are exotic. They are the normal weather of distributed systems, and an integration that doesn't plan for them is not finished — it is just untested.
The patterns that make it reliable
The reliable shape is the same regardless of which ERP you connect, and it is worth insisting on:
- Webhooks + a queue. Don't process Shopify webhooks synchronously against the ERP. Verify the HMAC, accept the webhook fast, drop it on a queue, and process asynchronously. This decouples Shopify's timing from the ERP's availability. The mechanics are explained in Shopify GraphQL, webhooks and dashboards explained.
- Idempotency everywhere. Every operation that writes to the ERP must be safe to run twice. Use the Shopify order ID or a derived idempotency key so a re-delivered webhook updates rather than duplicates.
- Retries with backoff. Transient failures — the ERP is busy, a rate limit hit — should retry automatically with exponential backoff and a dead-letter queue for the ones that keep failing.
- Reconciliation. Even with all of the above, drift happens. A scheduled reconciliation job that compares Shopify and the ERP and flags or fixes mismatches is the difference between catching a problem in hours versus discovering it at month-end close.
- Observability. If a sync fails, someone gets paged. Silent failure is the worst failure, because it compounds.
Building this well is closer to a custom Shopify app than to flipping on a connector, which is why honest scoping matters more here than almost anywhere else.
How to scope it honestly
Most ERP integration overruns come from scoping the happy path and discovering the failure handling later. Scope it the other way around:
- Map the system of record for every data type, in writing.
- List the events that must flow each way (order created, order cancelled, refund, stock change, price change, product created) and the direction of each.
- Define the failure behaviour for each: retry, alert, reconcile, ignore.
- Agree the reconciliation cadence and who owns the mismatches it surfaces.
- Decide what's explicitly out of scope — because "while we're at it" is how integrations double in cost.
If the integration's main job is moving work off people's plates rather than financial accuracy, you may find that lighter Shopify automation covers most of the value at a fraction of the cost — see what to automate in a growing store before committing to a full ERP build.
FAQ
Which is easier to integrate — Abacus, Bexio or Dynamics?
Bexio is usually the smoothest happy path because of its clean REST API, but "easy API" still requires retries, idempotency and reconciliation. Abacus and Dynamics are more capable and more involved — Abacus because of batch-oriented accounting processes, Dynamics because of deep entity mappings and organisational governance.
Can't I just use an off-the-shelf connector?
Sometimes, for simple cases. Connectors handle the happy path well, but they often hide the failure handling, give you little control over the system-of-record decisions, and become a black box when something drifts. For anything financially material or operationally complex, a controlled integration you own is usually the safer choice.
What's the biggest risk in an ERP integration?
An unclear system-of-record decision. If two systems both believe they own stock or prices, no amount of clever code prevents the disagreements from becoming wrong invoices and oversells. Decide ownership first; build second.
How do you prevent overselling?
Treat one system (usually the ERP or WMS) as the source of truth for stock, sync changes through a queue with idempotency, and run a reconciliation job that catches drift before it reaches a customer. Real-time perfection isn't realistic; fast detection and correction is.
How long does a Shopify ERP integration take?
It depends entirely on the number of event flows and the failure handling required, not on the connection itself. A narrow one-directional sync can be weeks; a bidirectional integration with reconciliation and monitoring across orders, stock and pricing is a substantial project. Scope decides the timeline.
Do you handle Swiss VAT and accounting specifics?
Yes — mapping Shopify's tax and order model onto Swiss accounting structures (VAT codes, debtor records, cost centres) is a core part of the work, especially with Abacus. This mapping is one of the most underestimated parts of any Swiss ERP integration.
If you're weighing an ERP integration, start with a diagnosis rather than a proposal. Book a paid Shopify audit and we'll map the system-of-record decisions, the event flows and the real failure modes before anyone writes code — or start lighter with a free Shopify audit to see where the risk actually sits.