How to Connect E-Commerce, ERP, and CRM Systems: A Practical Guide
How to integrate your online store, ERP, and CRM: data ownership, sync patterns, APIs and webhooks, error handling, Canadian tax and currency, and rollout.
The short answer
To connect an e-commerce platform, an ERP, and a CRM, first decide which system owns each type of data — usually the ERP for products, pricing, and inventory; the store for capturing orders; and the CRM for relationships. Then choose an integration pattern, map every field explicitly (including identifiers, units, tax codes, and currencies), set sync timing per data flow, and build for failure with idempotent processing, retries, and reconciliation. Roll out in phases, starting with inventory and orders.
Key takeaways
- Most integration problems are ownership problems. Assign one system of record to each data domain before building anything.
- An integration platform or a small event-driven hub usually beats a web of point-to-point scripts.
- Map identifiers, variants, units of measure, tax codes, and currencies explicitly — this is where integrations break.
- Webhooks can arrive twice, late, or not at all. Design for idempotency and run reconciliation jobs.
- Roll out in phases: products and stock first, then orders, fulfillment, and finally CRM enrichment.
Most growing businesses end up with three core systems: an e-commerce platform such as Magento 2, Shopify, or WooCommerce; an ERP that runs inventory, purchasing, and finance; and a CRM that tracks customers and sales. Each works well on its own. The trouble starts in the gaps between them, where people re-type orders, export stock levels, and reconcile customer records by hand.
This guide explains how to connect them in a way that is reliable, maintainable, and doesn’t create new problems.
Why disconnected systems cost more than they seem
The visible cost is time spent re-keying data. The hidden costs are usually bigger:
- Overselling because stock in the store lags behind the warehouse.
- Pricing errors when B2B contract prices differ between the ERP and the store.
- Slow fulfillment because orders wait for someone to enter them.
- Poor customer conversations because sales reps can’t see orders or invoices.
- Unreliable reporting because every system tells a slightly different story.
Step 1: Decide which system owns each piece of data
Before choosing tools or writing code, agree on the system of record for each type of data. If two systems can both edit the same field, they will eventually disagree, and no sync logic can fix that.
A typical ownership map for a business selling online and wholesale:
| Data | System of record | Flows to | Typical timing |
|---|---|---|---|
| Products and attributes | ERP or PIM | Store, marketplaces | Scheduled or on change |
| Prices and price lists | ERP | Store, CRM | On change |
| Inventory | ERP or WMS | Store, marketplaces | Near real time |
| Orders | Store (capture) → ERP (fulfill) | ERP, CRM | Near real time |
| Fulfillment and tracking | ERP or WMS | Store, customer | Near real time |
| Customers and contacts | CRM, with billing fields in ERP | Both ways, by field | On change |
| Invoices and payments | ERP or accounting | CRM | Daily or on change |
Write this down, share it with every team that edits data, and treat it as part of the integration design.
Step 2: Choose an integration pattern
There are three common patterns.
| Pattern | How it works | Good for | Watch out for |
|---|---|---|---|
| Point-to-point | Each system calls the others directly | Two systems, one simple flow | Becomes a fragile web as systems are added |
| Integration platform (iPaaS) | A platform sits between systems with prebuilt connectors | Common systems, moderate volume, teams that want visual tools | Per-task pricing at high volume; complex logic can get awkward |
| Event-driven hub | Systems publish changes to a queue; small services consume them | Higher volume, custom logic, many systems | Requires development and operational ownership |
For most small and medium-sized businesses, an integration platform or a small custom hub with a queue is the right choice. Avoid point-to-point scripts beyond the simplest cases: they are cheap to build and expensive to own.
Step 3: Map the data field by field
This is where integrations succeed or fail. Map every field explicitly and document the edge cases.
Identifiers
- Use one stable product identifier, usually the SKU, shared across the store and the ERP.
- Keep a cross-reference table for customer part numbers, supplier SKUs, and marketplace listing IDs.
- Store the external IDs of each record, such as the ERP customer number in the CRM and the store order ID in the ERP, so records can always be matched.
Variants and bundles
Stores model variants differently from ERPs. Magento uses configurable products with simple children, Shopify uses products with variants, and many ERPs treat each variant as a separate item. Decide how parents, children, kits, and bundles map, and how stock for a bundle is calculated.
Units of measure
The ERP may stock by the case of 12 while the store sells individual units. Conversions must be explicit, and the store must never sell more units than the cases on hand allow.
Taxes
In Canada, orders can carry GST, HST, PST, or QST depending on the destination province, and B2B customers may be tax-exempt with a valid exemption on file. US orders bring state and local sales tax rules. Keep tax calculation in one place — your tax engine, store, or ERP — and make sure the integration carries the right tax codes and amounts with every order, rather than recalculating them differently in each system.
Currencies
If you sell in CAD and USD, decide whether each currency has its own price list or prices are converted, and which system performs the conversion. Orders should carry their original currency and amounts into the ERP.
Statuses
Order statuses rarely match one to one. Create an explicit mapping:
| Store status | ERP status | Notes |
|---|---|---|
| Paid / processing | Sales order released | Created by the integration |
| Partially shipped | Partially fulfilled | Tracking pushed for each shipment |
| Shipped / complete | Fulfilled / invoiced | Final tracking pushed to the store |
| Cancelled | Cancelled | Only if not yet picked |
| Refunded | Credit memo | Created in ERP or accounting |
Step 4: Set timing for each data flow
Not everything needs to be real time. Choose timing per flow:
- Near real time for inventory, orders, and fulfillment, where delays cause oversells and customer complaints.
- On change for prices, customers, and product updates.
- Scheduled for reporting data, catalog enrichment, and reconciliation.
How you get notified of changes depends on the platform:
- Shopify sends webhooks for events such as order creation and inventory changes, and its GraphQL Admin API is the current API for integrations. Shopify treats its REST Admin API as legacy. Webhook delivery isn’t guaranteed, so Shopify recommends running reconciliation jobs alongside webhooks.
- WooCommerce supports webhooks for orders, products, and customers, and has a REST API under
/wp-json/wc/v3/. - Magento Open Source doesn’t send webhooks out of the box. Integrations typically poll the REST API with an
updated_atfilter or use a small custom module that publishes events to a queue. Adobe Commerce offers event and webhook capabilities through Adobe’s developer ecosystem. - ERPs and CRMs vary widely. Modern cloud systems usually offer APIs and webhooks; older ones may require scheduled exports.
Step 5: Build for failure
Every integration will eventually receive duplicate events, hit rate limits, or meet a record it can’t process. Design for that from the start:
- Idempotency. Processing the same event twice must not create two orders. Use the source system’s ID as an idempotency key.
- Retries with backoff. Temporary failures such as timeouts and rate limits are retried automatically, with increasing delays.
- Dead-letter queue. Records that keep failing are set aside with the error reason, so one bad record doesn’t block everything else.
- Reconciliation. A scheduled job compares the systems — open orders, stock levels, customer counts — and reports differences. This catches anything missed by webhooks.
- Alerting. The right person hears about failures within minutes, not when a customer complains.
- Logging with correlation IDs. Every record can be traced from the store through the integration to the ERP.
Step 6: Test with real data and real edge cases
Happy-path testing isn’t enough. Before going live, test against copies of real data and deliberately include:
- Partial shipments and backorders
- Cancellations before and after picking
- Full and partial refunds
- Discounts, gift cards, and split payments
- Tax-exempt B2B customers and cross-border orders
- Products with variants, bundles, and unit conversions
- Orders containing a SKU that doesn’t exist in the ERP
Step 7: Roll out in phases
Connecting everything at once makes problems hard to isolate. A sequence that works well:
- Products and inventory from the ERP to the store, which reduces oversells immediately.
- Orders from the store into the ERP, run in parallel with manual entry for a short period to compare.
- Fulfillment and tracking from the ERP back to the store and customer.
- Customers and accounts between the ERP and the CRM.
- CRM enrichment — orders, invoices, and support history visible to sales.
Measure each phase against a baseline before moving to the next.
Where AI fits
AI is most useful after your systems are connected, not instead of connecting them. Once data flows reliably, you can add:
- Agents that answer questions across systems: “Why is this order late?” or “What has this customer ordered this year?”
- Exception triage that classifies failed records and suggests fixes.
- Document intake that turns emailed purchase orders into draft orders in the ERP.
- Reporting summaries that explain what changed and why.
An AI agent working on disconnected, inconsistent data will give confident but unreliable answers. Integration comes first.
Integration checklist
- System of record agreed and documented for every data domain
- Integration pattern chosen with a clear owner for operating it
- Identifier strategy and cross-reference tables defined
- Variants, bundles, and units of measure mapped
- Tax codes and currencies mapped and tested
- Order status mapping documented
- Timing defined per data flow
- Idempotency, retries, dead-letter handling, and reconciliation in place
- Alerts routed to named people
- Edge cases tested with real data
- Phased rollout plan with a baseline for each phase
If you are planning an integration between your store, ERP, and CRM, our ERP & CRM integration service explains how we approach it, or you can get in touch to talk through your systems.
Frequently asked questions
How long does an e-commerce to ERP integration take?
It depends on the systems, the quality of their APIs, and how much data needs to flow. A focused integration covering inventory and orders between a modern store and an ERP with a good API is often a matter of weeks. Heavily customized or legacy ERPs, many sales channels, and complex B2B pricing take longer. A short assessment of both systems gives a reliable estimate.
Should we use a pre-built connector?
Pre-built connectors are worth evaluating first, especially for common pairings. They work well when your processes match the connector’s assumptions. When you have custom fields, B2B pricing rules, multiple warehouses, or unusual order flows, a configurable integration platform or a custom integration is usually more reliable than bending your processes to fit a connector.
What if our ERP doesn’t have an API?
Many older ERPs can still be integrated through scheduled file exchanges (CSV or XML over SFTP), a vendor-supplied integration module, or carefully controlled database access through an intermediate layer. These approaches need the same validation, logging, and reconciliation as API integrations.
Should customer data live in the CRM or the ERP?
Usually both, with clear ownership per field. The CRM typically owns contacts, relationship history, and pipeline; the ERP owns billing accounts, payment terms, credit limits, and tax status. The integration keeps a shared customer ID and syncs each field from its owner.