Skip to content

/ Journal — Migration

Migrating ERP, 3PL and Ecommerce Integrations to Shopify

— title: “” seo_title: “” keyword: “” slug: “” meta_description: “Plan Shopify migration integrations for ERP, 3PL, WMS and ecommerce systems, covering data ownership, APIs, testing, cutover and monitoring.” excerpt: “” —

/ Services — Shopify migration integrations

Migrating ERP, 3PL and ecommerce integrations to Shopify.

Shopify migration integrations are often the part of a replatforming that carries the greatest operational risk. A storefront can look finished while orders are being duplicated, inventory is drifting, cancellations never reach the warehouse, or finance is reconciling against the wrong identifiers.

Connecting:  [ ERP ]  [ PIM ]  [ OMS ]  [ WMS ]  [ 3PL ]  →  [ Shopify ]  [ Shopify Plus ]

( Short answer )

Treat integration migration as a controlled redesign of the commerce operating model.

Migrating ERP, 3PL, warehouse and ecommerce connections is not a matter of pointing an old connector at a new endpoint. Shopify introduces a different data model, API behavior, event model and operating rhythm. The migration has to define which system owns each decision, how records are matched, what happens when messages arrive late or twice, and how the business will trade while the old and new stacks overlap.

OwnEstablish systems of record and immutable identifiers first.

MapMap events and fields; choose app, iPaaS or custom API patterns deliberately.

BuildBuild idempotent queues, retries and reconciliation.

TestTest full business journeys.

Cut overCut over with explicit order and inventory boundaries, dual-running rules, monitoring and named owners.

/ In plain terms

Why Shopify integration migration is different from data migration.

A data migration moves a defined set of records from one shape to another. An integration continuously makes decisions while the business changes around it. Products are updated, stock moves, customers edit orders, warehouses split fulfillments, refunds occur, and carriers produce tracking events. Every one of those changes can race with another system.

That distinction changes the project plan. Importing a catalogue successfully proves that one batch worked. It does not prove that the ERP can publish a price change safely during a promotion, that a 3PL can accept a replacement order after cancellation, or that a failed inventory update will recover without overselling.

The live search landscape for Shopify migration is dominated by general checklists, migration apps and store-transfer services. ERP and 3PL results tend to focus on connector selection or broad benefits. The practical gap is the transition itself: ownership, identifiers, event behavior, reconciliation and safe cutover. Those are the controls this guide emphasizes.

/ Operating model

Start with the operating model, not the connector.

Before selecting middleware or writing an API call, document how the business is supposed to work after launch. Follow one order from product setup through purchase, allocation, fulfillment, return and financial posting. Then follow inventory from receipt through availability, reservation, pick, cancellation and adjustment.

For each step, record the system that creates the fact, the system allowed to change it, every system that consumes it, the expected latency and the response when it fails. This produces a useful architecture instead of a list of logos.

Define a system of record for every business object. “The ERP is the source of truth” is too broad to implement. A product record contains different kinds of truth. The ERP may own cost and tax classification, a PIM may own descriptions and media, Shopify may own online merchandising, and the 3PL may own physically available stock. Ownership must be set at field or event level where responsibilities differ.

( Domain — typical system of record — questions to settle )

+Product identity — ERP or PIM. Who creates SKUs? Can a SKU ever change? Who owns variant structure?

+Online content — PIM or Shopify. Where are titles, media, SEO fields, metafields and collection rules edited?

+Price — ERP, pricing engine or Shopify. Which markets and customer groups are covered? Are promotional prices time-bound?

+Inventory — WMS/3PL, ERP or an allocation service. Is the feed on-hand, available-to-sell or allocated? Which location owns each quantity?

+Order capture — Shopify. When is an order exportable: created, paid, risk-cleared or manually approved?

+Fulfillment — 3PL/WMS. Who creates fulfillments, tracking, partial shipments and exceptions?

+Returns and refunds — OMS, returns platform, ERP or Shopify. Who authorizes the return, receives stock, calculates refund and posts finance?

+Customer and consent — Shopify, CRM or CDP. Which attributes can flow back? How are consent and deletion requests governed?

Once ownership is explicit, enforce it. A two-way sync in which both systems can overwrite price or inventory is not flexibility; it is an unresolved conflict. Prefer one authoritative direction for each field and define narrow exceptions with timestamps, priority rules and audit logs.

/ Identifiers ( 05 )

Design identifiers before mapping fields.

Integration failures often begin with matching logic. Names, email addresses and product titles are mutable. They are poor keys. A durable model keeps a cross-reference between each platform’s internal ID and a stable business identifier.

01 · Products

Products and variants

Use a governed SKU or another immutable external key. Keep separate mappings for Shopify product and variant IDs.

02 · Orders

Orders

Store Shopify’s stable API identifier as well as the merchant-facing order name or number. Display numbers are useful to people but should not be the only integration key.

03 · Locations

Locations

Map every Shopify location to the corresponding warehouse, store or virtual pool code. Do not assume labels match.

04 · Customers

Customers

Use platform IDs and a controlled external customer ID. Email can change and may not be unique across every business model.

05 · Post-order

Fulfillments, returns and refunds

Retain both source and destination IDs so an update can be applied idempotently.

Never rely on IDs from a sandbox surviving into production. Create mappings as records are created in the production store, or generate business-owned external keys before migration. Store the mapping table somewhere queryable and backed up; it becomes essential during reconciliation and support.

/ Data model

Map the Shopify data model, not just the old payload.

A safe migration translates business meaning, not only fields. Review products and variants, inventory items and inventory levels, locations, orders, transactions, fulfillments, returns, refunds, discounts, duties, taxes, company records, metafields and metaobjects. Confirm which objects the chosen Shopify plan and APIs make available for the required workflow. Pay particular attention to assumptions embedded in the legacy integration.

Build a canonical mapping document with the source field, business definition, transformation, Shopify destination, owner, nullable behavior, validation rule and example. Include rejected values and defaults. If a field has no destination, decide whether to place it in a metafield, keep it in the integration layer, archive it, or retire it deliberately.

01One warehouse represented as one inventory number

02One order always producing one shipment

03One currency per store

04Order edits represented as delete-and-recreate

05Bundles represented as a single ERP line but multiple fulfillment components

06Gift cards, discounts, duties, tips or tax rounding omitted from finance exports

07Returns assumed to equal refunds

08Customer records merged solely by email

/ Architecture

Choose the right API and connector architecture.

The main options are a native connector or Shopify app, an integration platform as a service (iPaaS), or a custom integration using Shopify APIs. Mature stacks often combine them: a proven 3PL connector for standard fulfillment, middleware for orchestration, and custom services for differentiating rules.

For new API work, use Shopify’s current GraphQL Admin API and supported API versions rather than carrying forward assumptions from a legacy REST integration. Model query cost, permissions and version upgrades as operational requirements. Shopify documents calculated query-cost limits for GraphQL, while limits differ across APIs and plans. The integration should inspect the rate-limit metadata returned by Shopify, pace work through queues, and back off on throttle or transient errors.

Shopify also limits input arrays to 250 items and caps standard pagination at 25,000 objects. Large migrations and reconciliation jobs should therefore be partitioned and, where suitable, use GraphQL bulk operations rather than pretending a single interactive process can read the entire estate safely.

Pattern Best fit and main tradeoff

Native app or vendor connectorBest fit: standard processes supported by both vendors.
Tradeoff: fastest route, but edge cases, visibility and control can be limited.

iPaaS or middlewareBest fit: several systems, transformations and operational monitoring.
Tradeoff: reusable orchestration, but licensing and specialist ownership remain.

Custom Shopify integrationBest fit: distinct workflows, volume profile or business logic.
Tradeoff: maximum control, with full responsibility for security, versions and operations.

Batch file exchangeBest fit: low-frequency legacy processes or controlled transition.
Tradeoff: simple and auditable, but higher latency and weaker real-time behavior.

( Connector evaluation )

Evaluate a connector with operational questions.

+Does it support every required Shopify object and event, not only order creation?

+Can it represent multiple locations, partial fulfillments, cancellations, edits, refunds and returns?

+Where are transformations configured and versioned?

+Can operators replay one failed record without replaying an entire batch?

+Does it expose payloads, correlation IDs, attempts and error reasons?

+How does it handle duplicates, out-of-order events and downtime?

+Who supports it during launch, weekends and peak periods?

+What happens to queued data if the contract ends or the connector is replaced?

/ Webhooks

Use webhooks as signals, not as the ledger.

Shopify webhooks provide near-real-time notifications and are more efficient than constant polling. They are ideal for triggering work such as exporting an order or reacting to an update. They are not a complete event ledger.

Shopify’s official webhook guidance states that ordering is not guaranteed within a topic or across topics, and recommends using event or resource timestamps to organize updates. It also recommends reconciliation jobs because delivery can be missed or mishandled. That has direct architectural consequences.

A webhook should usually create a durable unit of work. The worker then validates, transforms and writes the update. This separates Shopify’s delivery window from ERP or 3PL availability and gives the team a safe replay mechanism.

01Verify the HMAC signature before accepting a delivery.

02Persist the webhook ID and ignore duplicate deliveries.

03Acknowledge quickly, then process asynchronously through a queue.

04Fetch the current resource state when the payload is insufficient or freshness matters.

05Compare timestamps or versions before applying an older update over a newer one.

06Run scheduled reconciliation using updated timestamps and saved checkpoints.

07Monitor subscription health and confirm required topics after deployment or app changes.

/ Sync rules

Make sync direction and conflict rules explicit.

For each flow, document direction, trigger, frequency, target latency, transformation and conflict behavior. “Real time” is not a specification. An inventory flow may need a 60-second objective during normal trading and a tighter control around launches, while product enrichment can run in scheduled batches.

Flow Direction and control

Products and variantsERP/PIM → Shopify. Stable external keys and validation before publish.

Content and merchandisingPIM/Shopify depending on ownership. Prevent automated feeds from erasing merchant edits.

PricesERP/pricing engine → Shopify. Market, currency, customer and effective-date context.

InventoryWMS/3PL/ERP → Shopify. Available-to-sell definition, location mapping and stale-update protection.

OrdersShopify → ERP/OMS/3PL. Release gate, idempotency and duplicate prevention.

Fulfillment and tracking3PL/WMS → Shopify. Line-level quantity, partial shipment and carrier mapping.

Cancellations and returnsOften bidirectional orchestration. State machine, authority boundary and compensation steps.

When a flow must be bidirectional, use a state machine rather than two generic update jobs. Define valid transitions, which actor can initiate each one, what constitutes completion and which compensating action follows a partial failure.

/ Retries ( 04 )

Build retries that do not create duplicates.

Retries are necessary because networks, APIs and downstream systems fail. Blind retries are dangerous because the first request may have succeeded even if the response was lost. Every write operation needs an idempotency strategy.

Create an idempotency key from a stable event or business operation, persist the outcome, and check it before repeating work. A Shopify order export might use the Shopify order ID plus an operation type and version. A fulfillment update might use the warehouse shipment ID. The exact key matters less than the guarantee that the same business action cannot be applied twice.

Classify errors before retrying:

01 · Transient

Transient

Timeout, rate limit or temporary service error. Retry with bounded exponential backoff and jitter.

02 · Data

Data

Unknown SKU, invalid address or missing location mapping. Quarantine for correction; repeated retries will not help.

03 · Access

Authorization or configuration

Expired credential, removed scope or wrong endpoint. Alert an owner immediately.

04 · Conflict

Conflict

A newer state already exists. Re-read the current record and apply the documented precedence rule.

Use a dead-letter queue or equivalent exception store, but do not let it become a graveyard. Every failed record should show business impact, age, attempts, payload references, owner and next action. Provide controlled replay after the cause is fixed.

/ Cutover runbook ( 10 )

Plan the cutover as a sequence of business boundaries.

The central cutover question is not “When does Shopify go live?” It is “At what exact point does each type of work stop entering the old pipeline and start entering the new one?” Orders, inventory, products, customer changes, fulfillments and returns may need different boundaries.

Create a migration and cutover runbook.

( Runbook )

01Freeze integration design. Lock mappings, credentials, endpoints, schedules and production configuration.

02Take initial snapshots. Record counts and balances for products, variants, locations, inventory, open orders, fulfillments, returns and queued messages.

03Load base data and mappings. Create production records and persist cross-system IDs.

04Reconcile before traffic. Compare totals and field-level samples, including difficult exceptions.

05Pause old outbound flows. Stop only the writers covered by the runbook; keep required read access and logs.

06Capture the final delta. Move changes made since the base load and record the cutoff timestamps.

07Activate new subscriptions and workers. Verify production webhook topics, queues, credentials and downstream connectivity.

08Open Shopify order flow. Use an unambiguous order boundary and verify the first real records end to end.

09Reconcile at short intervals. Compare Shopify orders, ERP postings, 3PL receipts, fulfillments and inventory movements.

10Retire old writers gradually. Keep the legacy stack available read-only until finance, operations and technology sign off.

Define rollback before launch. Rolling back the storefront does not automatically reverse orders already sent to an ERP or 3PL. The plan must say what happens to new Shopify orders, inventory decrements and fulfillment events if traffic is returned to the old site. After a point of no return, forward-fixing may be safer than rollback.

( Dual-running )

Dual-running without creating two sources of truth.

Dual-running can reduce risk, but only when it means “compare outputs” rather than “let both stacks control production.” Two active order exporters or two inventory writers can create the failure the overlap was meant to prevent.

Use one of three controlled patterns:

Shadow modeThe new integration consumes real events and produces expected outputs without writing to downstream production. Compare results with the legacy path.

Partitioned productionRoute a clearly defined subset, such as one store, market or warehouse, through the new path. Ensure records cannot cross partitions accidentally.

Time-bounded switchoverOld pipeline owns records before a timestamp or sequence boundary; new pipeline owns records after it.

/ Testing ( 15 )

Test business journeys, failure modes and recovery.

Unit tests for field mappings are necessary but insufficient. Integration acceptance testing should follow representative business journeys through all connected systems, including the return path to Shopify.

+Simple and multi-line orders, with and without discounts

+Domestic, international, tax-exempt and multi-currency orders

+Guest, returning customer and B2B scenarios where relevant

+Split allocation across locations and partial fulfillment

+Backorder, preorder, bundle and subscription behavior

+Payment authorization, capture, failure, cancellation and refund

+Order edit before and after release to fulfillment

+Full and partial cancellation, return and exchange

+Unknown SKU, missing mapping and invalid address

+Duplicate webhook and duplicate file delivery

+Out-of-order events and stale inventory update

+Shopify throttle, ERP outage and 3PL timeout

+Worker restart with in-flight messages

+Dead-letter correction and replay

+Reconciliation after an intentionally missed event

Use production-like volumes, not only five clean orders. Measure peak queue depth, processing latency, API cost, downstream throughput and recovery time. If a batch fails halfway through, prove that the rerun neither skips nor duplicates successful records.

Use evidence-based launch gates. A launch gate should state the threshold and the evidence. Examples include zero duplicate orders during the rehearsal, 100% mapping coverage for sellable SKUs, inventory variance below an agreed tolerance, all launch-critical journeys passed, no unresolved severity-one defects, and recovery from a forced outage within the agreed objective.

/ Monitoring ( 04 )

Monitor business outcomes, not just HTTP status.

An integration can return successful API responses while producing the wrong operational result. Monitoring should cover four layers.

01 · Transport

Transport

Webhook receipt, API error rate, throttle rate, endpoint availability.

02 · Processing

Processing

Queue depth, oldest message age, throughput, retries, dead letters.

03 · Data

Data

Unmapped SKU, missing location, stale update, reconciliation variance.

04 · Business

Business

Orders not acknowledged, fulfillment delay, inventory drift, posting imbalance.

Every log line should carry correlation identifiers across Shopify, middleware, ERP and 3PL. Dashboards should separate normal retry noise from customer-impacting failure. Alerts need a threshold, route and playbook; otherwise they become background email.

Run reconciliation continuously after launch. Compare all Shopify orders with ERP/OMS acknowledgements, all released orders with 3PL receipts, fulfillments with Shopify updates, and inventory by SKU and location. Reconciliation is not an admission that webhooks failed. It is the control that proves the distributed system remains correct.

/ Ownership

Assign ownership before incidents happen.

“The integration team owns it” is not enough when an order is stuck between companies. Assign technical and business ownership for each flow.

Document support hours, severity definitions, escalation contacts, access procedures and vendor response expectations. Rotate credentials safely, use least-privilege scopes, and keep secrets out of mapping files and logs. Schedule API-version and connector reviews rather than waiting for deprecation to become a launch-sized project.

01Business owner: defines the desired outcome and accepts operational tradeoffs.

02Data owner: governs definitions, identifiers and quality.

03Technical owner: maintains code, connector configuration, credentials and API upgrades.

04Operations owner: monitors queues, resolves exceptions and communicates customer impact.

05Vendor owner: manages ERP, iPaaS or 3PL escalation and service obligations.

06Incident commander: coordinates high-impact failures and chooses rollback or forward-fix.

/ Checklist ( 16 )

A practical Shopify integration migration checklist.

+Every integration, scheduled job, file transfer, webhook and manual workaround is inventoried.

+System-of-record ownership is defined at object and critical-field level.

+Stable identifiers and production cross-reference tables are designed.

+Shopify data-model differences and unsupported legacy assumptions are resolved.

+Connector, middleware and custom-code choices have explicit rationale and owners.

+Sync direction, trigger, latency, conflict behavior and replay behavior are documented.

+Webhooks are authenticated, deduplicated, queued and backed by reconciliation.

+Rate limits, API versions, bulk processing and access scopes are covered.

+Retries are bounded and idempotent; data failures are quarantined.

+End-to-end journeys include partial, failed and out-of-order scenarios.

+Production-volume rehearsal and recovery tests meet agreed gates.

+Order, inventory and fulfillment cutover boundaries are unambiguous.

+Dual-running cannot create two production writers for the same fact.

+Dashboards and alerts cover transport, processing, data and business outcomes.

+Named owners can diagnose, replay, reconcile and escalate after launch.

+Legacy writers remain disabled while read access and evidence are retained through sign-off.

/ FAQ ( 08 )

Shopify migration integrations, answered.

What integrations should be reviewed during a Shopify migration?

Review every system that reads or writes commerce data: ERP, PIM, OMS, WMS, 3PL, POS, CRM, CDP, tax, accounting, returns, subscriptions, loyalty, marketplaces, product feeds, support, analytics and data warehouse tools. Include scheduled files, webhooks, scripts and manual workarounds, not only named apps.

Should the ERP or Shopify be the system of record?

It depends on the data. Shopify commonly owns online order capture and merchandising, while an ERP may own cost, accounting or core product identity. A PIM may own content and a 3PL may own warehouse stock. Define ownership per object and critical field rather than declaring one system authoritative for everything.

How should inventory sync between a 3PL and Shopify?

Agree whether the feed represents on-hand or available-to-sell inventory, map each warehouse to the correct Shopify location, protect against stale updates, and define latency and oversell rules. Queue updates, reconcile quantities by SKU and location, and make one system authoritative for each inventory pool.

Are Shopify webhooks guaranteed and delivered in order?

No. Shopify states that webhook ordering is not guaranteed, and recommends reconciliation because deliveries can be missed or mishandled. Verify signatures, deduplicate with the webhook ID, process asynchronously, compare timestamps and periodically query Shopify for records updated since the last checkpoint.

Can old ERP or 3PL connectors be reused with Shopify?

Sometimes, but only after validating Shopify’s data model, API versions, supported objects, locations, partial fulfillment, order edits, returns, rate limits and monitoring. Reusing the vendor relationship may be sensible; reusing undocumented legacy assumptions is risky.

How long should ERP and 3PL integration testing take?

The answer depends on flow count, data quality, order complexity, vendors and peak volumes. Plan enough time for multiple end-to-end cycles, operational user acceptance, production-volume rehearsal, defect correction and a full cutover rehearsal. Complex integrations usually need sustained testing, not a final-week smoke test.

Should old and new ecommerce integrations run at the same time?

Use controlled overlap only. Shadow mode can compare outputs without writing production data; partitioning can move a clearly isolated subset; a time boundary can assign records to old or new paths. Do not allow both stacks to create the same order or overwrite the same inventory pool.

How do you know a Shopify integration migration is successful?

Orders reach the right downstream systems once, inventory and financial records reconcile, fulfillments and returns update correctly, queues stay within latency targets, exceptions have owners, and recovery procedures work. Success is proven by business-level reconciliation and stable operations, not only successful API responses.

/ Next

Plan the integration migration before it becomes the critical path.

Signature Works designs and delivers Shopify and Shopify Plus migrations where the storefront must connect cleanly to ERP, PIM, OMS, WMS, 3PL, finance and customer systems. We turn undocumented legacy behavior into a clear target architecture, testable flows, a controlled cutover and an operating model your team can support.

If your migration cannot afford missing orders, duplicated fulfillment or unexplained stock, bring integration discovery forward. It is much cheaper to resolve ownership and identifiers in architecture than during launch weekend.

Discuss your Shopify migration ↗

Also worth a look:  Migrations and rescues  ·  Custom apps and features  ·  Shopify technical ownership

Written by the founder

Every Journal post comes from work on a real store, with the numbers to back it.

/ Next

Want this done on your store?

Tell us what’s going on. A first look costs nothing.

Start a project ↗