Guides → Migrate from Shopify to SGEN

Migrate from Shopify to SGEN

Plan the move, run the import, verify the result — without losing an order during the commerce cutover.

Shopify to SGEN migration is the path for moving an existing Shopify store into the SGEN platform. The work spans three phases: a pre-migration inventory on the Shopify side, the import event itself, and a validation cycle inside SGEN before the storefront is treated as production-ready.

This guide walks the full arc — what to export from Shopify, what to expect when the commerce data lands in SGEN, where the platform model differs, the eight-step sequence to run, the pitfalls to plan for, and the post-migration verification that earns the storefront a production-ready stamp.

What is this for?

Read this guide when you are planning a Shopify to SGEN migration and want the structural picture before you commit to a date. The guide pairs the pre-migration inventory with the import procedure and the post-migration validation cycle, so the team knows what to gather, what to expect, and what to verify before live order acceptance moves across.

The guide is written for the operator running the migration. The audience is the agency principal, the in-house ecommerce manager, the developer scoping the move, or the founder who runs the Shopify store and is moving it to SGEN. It assumes basic Shopify administrator access on the source side and a working SGEN site with the ecommerce module enabled to import into.

Good use cases

You are an agency migrating one or more client storefronts from Shopify to SGEN and need the platform-level map.
You are an in-house team scoping the move and want the import shape laid out before signoff.
You are a developer running the migration and need the sequence, the gotchas, and the verification checklist.
You are a founder evaluating the move and want the realistic timeline by catalogue size.
You are returning to a paused migration and need the next-step anchor.

What NOT to use this for

Per-Liquid-template translation internals — Shopify theme code does not transfer; the SG-Builder rebuild composes the storefront from SGEN sections rather than reusing the source theme.
Shopify administration help — this guide assumes the Shopify side is operable. Shopify-side recovery is outside the SGEN documentation surface.
Pixel-perfect theme replication — Shopify's theme system and SGEN's SG-Builder use different layout models. The Gotchas section below frames the expectation; this guide does not document theme-by-theme visual translation.

How this connects to other features

Migration and Import Overview — the parent Reference area for migration discipline in SGEN, including the risk-aware framing this guide leans on.
Import — the structural model for how data lands inside SGEN after the import event.
Backups — the foundational safeguard, captured before any high-stakes operation.
Post Migration — the validation discipline that earns the migrated storefront its production-ready stamp.
Search and Replace — the bulk-content cleanup pass that usually follows a Shopify import (asset CDN URLs, embed paths).
Recovery Considerations — the rollback framing if the import behaves in a way the validation cycle cannot accept.
Migrate from WordPress — sibling migration guide; the inventory-export-import-validate-promote shape is the same across sources.
Migrate from Webflow — sibling migration guide; the rebuild-in-SG-Builder discipline shares ground with the Shopify path.
Migrate from Squarespace — sibling migration guide; the commerce cutover discipline is shared across commerce-driven migrations.

Before you start

A clean migration depends on the Shopify side being inventoried and exportable before the import event runs. Gather the following before opening SGEN:

From the Shopify store

Administrator access to the source Shopify admin, with permission to use the export tools across products, customers, orders, discounts, gift cards, and store settings.
Products CSV generated from Products → All products → Export → All products → CSV for Excel, Numbers, and other spreadsheet programs. The CSV carries the product titles, descriptions, vendor, type, tags, variants, prices, inventory, SKUs, barcodes, and image URLs.
Customers CSV generated from Customers → Export → All customers. The CSV carries the customer records — name, email, phone, tags, addresses, accepted-marketing flag, total spent, and order count.
Orders CSV generated from Orders → Export → All orders. The CSV carries the order history — order number, status, customer, line items, shipping, taxes, discounts, financial status, and fulfilment status. Plan whether historical orders move across or stay archived on Shopify; the export covers both options.
Collections export for each manual collection (the smart-collection rules are not exported as data — recreate the rule definitions inside the SGEN store collection surface during the rebuild).
Discounts and gift cards — export discount codes and gift-card balances separately. Note that the Shopify export covers the codes and balances; the discount rule logic needs to be recreated inside the SGEN promotions surface.
Blog posts CSV if the source store runs the Shopify blog feature — export through Online Store → Blog posts → Export.
Pages list — every non-product page (About, FAQ, shipping policy, return policy, contact, etc.). Pages export through the bulk export or through the Shopify admin API. Capture the slug, the content, and any page-level metafields.
Asset catalogue — a list of every image, video, and downloadable file referenced on the source store, including the original filenames and the Shopify CDN URLs. The product CSV references images by URL; the binaries must move alongside.
Theme detail — active theme name, any per-section settings, any custom Liquid templates, and any theme-level custom code. Note that Liquid does not transfer to SGEN; the inventory captures the visual intent that the SG-Builder rebuild will recreate.
Apps inventory — every Shopify app installed on the source store, with a note on what each app does. The apps do not transfer; the inventory drives the module-mapping conversation later in this guide.
Custom code surfaces — anything in the Online Store → Themes → Edit code surface (theme JavaScript, custom Liquid snippets) and any per-page custom code.
Payment gateway detail — the active payment gateway (Shopify Payments, third-party processor, manual methods), the merchant account credentials, and any tax-calculation configuration.
Shipping configuration — the shipping zones, rates, carrier-calculated settings, and any third-party shipping app rules.
Tax configuration — the tax regions, tax overrides, registered tax numbers, and any third-party tax app rules.
URL redirects — export the URL redirect set from Online Store → Navigation → URL Redirects.
DNS posture — the current Shopify plan, the connected custom domain, and any Shopify-hosted email forwarding.

From the SGEN side

A live SGEN site to import into, with the ecommerce module enabled. The platform supports importing into staging first, then promoting staging to live — this is the recommended posture for any non-trivial migration.
An on-demand backup captured immediately before the import event. The backup is the rollback target if validation does not accept the imported state. See Backups for the safeguard discipline.
Module activation review — confirm the SGEN modules that match the Shopify feature inventory are enabled on the target site. The ecommerce module is the headline activation; forms, custom objects, blog, and SEO surfaces also need to be enabled before the import so the imported records have a home to land in.

Where to find it

The Import tool lives at the admin → Settings → Import. Select the Shopify format, upload the product and blog exports, and activate the ecommerce module on the SGEN site before you run the import so product records have a destination to land in.

Steps

The full sequence is eight steps. Each is explicit about what to do, what changes, and what to verify before moving on.

1. Inventory the Shopify side

Walk the source store once with the inventory checklist above. Note every product variant, every collection, every discount, every shipping zone, every payment gateway connection, every app, every theme customisation, every URL redirect. The inventory is the artefact the rest of the migration leans on — skipping it is the single largest cause of post-import surprise.

Save the inventory as a working document. Mark each item as "covered by SGEN module," "needs rebuild in SG-Builder," or "needs a follow-up decision after import." The three-column shape carries through the rest of the migration.

Pay close attention to four areas Shopify operators often underestimate. First, the variant matrix — a single product can carry dozens of variants (size, colour, material) and the CSV export shape needs careful inspection to make sure every variant lands. Second, the order-history decision — moving three years of historical orders is heavier than moving the catalogue alone and influences the import timeline. Third, the app dependencies — the SGEN ecommerce module replaces many app responsibilities natively, and the mapping is module-by-module rather than app-by-app. Fourth, the payment gateway re-configuration — the gateway connection is store-specific and needs a deliberate handoff.

2. Clean the Shopify source before export

Run a cleanup pass on the source store before exporting. The pass removes content that should not arrive in SGEN — products marked as archived that should not move, draft products that were never finished, discontinued variants still listed, customer records with no orders that were imported from a previous source.

Inside the source admin, archive products that should not transfer, audit the customer list for test records, confirm the product catalogue reflects current inventory, and decide which historical orders move across (full history, last twelve months, or catalogue-only with order history archived on Shopify). Run a final pass on the theme code panel and the app list to confirm any third-party integrations (reviews, loyalty, subscriptions, analytics) are accounted for in the inventory and have a destination on the SGEN side.

3. Export from Shopify

Export the Shopify side in four passes — each pass covers a different data layer, and each lands a different file shape.

First, open Products → All products → Export. Select All products and CSV for Excel. Download the CSV. Save the resulting file to a known location. Repeat the export from the Collections surface if any manual collections need to move.

Second, open Customers → Export. Select All customers. Download the CSV. Save the resulting file to the same known location.

Third, open Orders → Export. Decide on the order-history scope (all orders, a date range, or open orders only). Download the CSV. Save the resulting file alongside the others.

Fourth, capture the asset library. Use the asset URLs noted in the inventory to retrieve each image, video, and downloadable file from the Shopify CDN, either by downloading them individually, by using a Shopify admin app to bulk-download, or by capturing the URLs for the SGEN import wizard's direct-fetch option once the import event begins.

The Shopify export files do not include the theme code, the app data, the payment gateway configuration, or the shipping rate tables. Those layers are recreated on the SGEN side rather than imported.

4. Capture a backup of the SGEN target

In SGEN, open SG-Dashboard → Sites, select the target site, then trigger an on-demand backup before the import event. The backup captures the target site's current state — the rollback point if the validation cycle finds the imported state unacceptable.

Backups run as background jobs. The notification arrives when the backup file is ready. Do not start the import until the backup completes. See Backups for the per-operation Reference.

5. Run the import to a staging context

Open the admin → Migration on the target site. Select Shopify as the source. Upload the products CSV, the customers CSV, the orders CSV, the collections export, the blog and pages export, and the asset archive (or point the wizard at the source asset CDN if direct fetch is available). Confirm the destination scope and start the import.

Run the import on staging first. The platform's recommended posture is import-to-staging, validate, promote-to-live. Importing directly to live is supported for low-risk cases where the validation window can be compressed — but a staging-first run pays back the time on every migration above the smallest size. For commerce-driven migrations, staging-first is the default rather than the option.

The import lands records inside the corresponding SG-Admin modules. Products land in the admin → STORE MANAGEMENT → Products, with variants attached. Collections land in the admin → STORE MANAGEMENT → Collections. Customers land in the admin → Customers. Orders land in the admin → STORE MANAGEMENT → Orders. Blog posts land in the admin → Posts. Pages land in the admin → Pages. Imported records carry identification metadata that distinguishes them from records created directly on the SGEN side. See Import for the structural model.

6. Rebuild the storefront in SG-Builder, configure commerce surfaces

This is the step Shopify migrations spend the most time on. The CSV exports carry the catalogue and the customer records; the theme that rendered the storefront does not translate into the SG-Builder component tree. The storefront needs to be rebuilt in SG-Builder, using the imported catalogue as the source of record for product data and assets.

The work is template-driven. Build the page template once for each archetype the storefront uses — a product detail template, a collection list template, a cart template, a checkout template, a marketing page template, an account template — and apply the template across the imported records. For most Shopify storefronts, four to six SG-Builder templates cover the entire shopping surface.

Configure the SGEN ecommerce module's settings to match the source store. The configuration includes:

Payment gateway — set up the SGEN payment gateway connection (the gateway choice is store-specific; the SGEN ecommerce module supports the common gateways through dedicated configuration screens).
Shipping zones and rates — recreate the shipping configuration from the inventory.
Tax regions and overrides — recreate the tax configuration from the inventory, and re-register tax numbers if the SGEN side requires per-region configuration.
Discount codes and promotions — recreate the discount rule logic inside the SGEN promotions surface; the imported discount codes carry the codes themselves, not the rule definitions.
Currency and pricing — confirm the storefront currency, the rounding rules, and any multi-currency configuration.
Inventory tracking — confirm the inventory rules (track inventory, allow oversell, low-stock notifications) match the source posture.

The Shopify app inventory drives the module-mapping conversation here. Many Shopify apps replace native ecommerce capability that the source store opted out of using directly; the SGEN ecommerce module covers most of that capability natively. The remaining cases are handled by Custom Objects (for bespoke data the source app stored) or by Custom Codes (for behavioural snippets the source app injected).

7. Walk the post-migration validation cycle, then run search-and-replace

Once the import lands and the SG-Builder rebuild is complete on staging, walk the Post Migration validation cycle before treating the staging storefront as ready to promote. The cycle confirms imported records render as expected, internal links resolve, media displays, custom fields landed correctly, and store-wide settings carry the intended values.

A Shopify export carries the source store's asset CDN URLs verbatim. After the import lands on SGEN staging, run a Search and Replace pass to rewrite the Shopify CDN URLs to the SGEN equivalents, fix any embedded references, and clean residue that the import preserved verbatim.

Typical replacements include:

Shopify asset CDN host → SGEN media host (https://cdn.shopify.com/... → the SGEN media equivalent)
Old custom domain → new domain (https://oldstore.com → https://newstore.com)
Shopify form action paths → SGEN form submission paths (handled inside the form module when the forms are rebuilt, not by string replacement)
Inline analytics, reviews, or loyalty-widget snippets that have a first-party SGEN module equivalent — the snippets can be replaced with the module's embed pattern, or stripped if the module renders the same behaviour natively.

Run the search-and-replace pass on staging first. Spot-check the affected product pages, collection pages, and the checkout surface before confirming the pass landed cleanly.

8. Plan the commerce cutover, build the redirect map, promote staging to live

Commerce migrations carry a constraint that content-only migrations do not — live order acceptance has to hand off from one platform to the other without dropping an order. The commerce cutover is the discrete event that closes the source storefront to new orders, runs the final order export, and opens the SGEN storefront for live order acceptance.

The cutover sequence:

Communicate the cutover window to customers and to the team handling fulfilment (a notice on the source storefront, an email to the customer base, a brief on the fulfilment team's working channel).
Pause new-order acceptance on the source storefront at the start of the window (Shopify supports this through the storefront password or through a storefront-level notification banner).
Run a final orders export from the source storefront to capture any orders placed between the main migration import and the cutover window.
Import the final orders CSV into SGEN through the ecommerce module's orders importer.
Configure the SGEN payment gateway as live (the gateway was set up earlier; switching it to live is the cutover-time step).
Update DNS to point the storefront domain at the SGEN side.
Open the SGEN storefront for live order acceptance.
Monitor the first hour of live traffic to confirm orders are landing in the admin → STORE MANAGEMENT → Orders and the payment gateway is processing transactions cleanly.

Build the redirect map alongside the cutover sequence. The Shopify URL structure (especially /products/, /collections/, and /pages/) and the SGEN URL structure may not match exactly. Capture every source URL the redirect map needs to cover (use the URL redirects export from step one, plus any inventory of external incoming links — paid ads, affiliate links, search-engine indexed URLs), and configure the redirects through the SGEN redirect surface.

Once validation passes, the search-and-replace pass is clean, the ecommerce surfaces are configured, the redirect map is in place, and the cutover sequence is rehearsed, promote the staging storefront to live through the standard staging-to-live promotion path. Capture a fresh backup of the live target before promotion, so the rollback point survives the promotion event.

After promotion, run a final post-promotion validation pass — the live storefront sometimes behaves differently from staging because of DNS, caching, payment-gateway live mode, or per-environment configuration. The final pass closes the migration.

What success looks like

A successful Shopify to SGEN migration ends in a verifiable state on the live storefront. The following observable outcomes anchor the success criteria:

Every product that existed on the Shopify source resolves on the SGEN storefront, with every variant, price, inventory count, and image carried across.
Every collection (manual and smart) is recreated on the SGEN side, with the same product membership or the recreated rule logic.
Every customer record landed on the SGEN side, with addresses, tags, and order-count metadata intact.
The decided-on order history landed on the SGEN side, with each order's line items, financial status, and fulfilment status intact.
Discount codes are active on the SGEN side, with the rule logic recreated and the codes themselves carrying across.
The payment gateway is configured, in live mode, and processing test transactions cleanly.
Shipping zones, tax regions, and inventory rules match the source posture.
The storefront URL structure either matches the source or is covered by the redirect map.
Every image referenced in content renders from the SGEN media surface, not from the Shopify CDN.
Internal links resolve to the new storefront, not to the old one.
Storefront-wide settings (logo, favicon, contact information, footer text, policies) carry the intended values.
The site's structured data (product schema, collection schema, OpenGraph) matches the planned values.
The cutover window completed cleanly, with no orphan orders on either platform.

When all of the above hold, the migration is production-ready.

What to do if it does not work

Migration sometimes lands in a state the validation cycle cannot accept. The following five failure modes cover the majority of cases:

Import event fails mid-run

Open the admin → Migration event log. The platform records per-batch progress, so the failure point is identifiable. Common causes: a CSV column header was renamed during a previous export and the wizard cannot map it (re-export from Shopify with the default column set), the asset archive is incomplete (re-package the asset directory), or a variant row references a missing image (confirm the image carried across). Reopen the import wizard and resume from the failure point.

Imported product pages render with content but no visual structure

The Shopify theme drove layout through Liquid templates; SGEN drives layout through the SG-Builder. After import, product pages will often carry the product data without the surrounding visual structure the theme provided. The fix is the template-driven rebuild described in step six. For storefronts with consistent product archetypes, building the product detail template once is the efficient path.

Discount codes carry across but the discount logic does not apply

The Shopify export carries the discount codes and the redemption history; the discount rule logic (e.g. "10% off when cart contains two products from collection X") needs to be recreated inside the SGEN promotions surface. Walk the discount inventory from step one and recreate each rule. Test each discount with a sample cart before treating the migration as complete.

Orders carry across but fulfilment status is missing or wrong

The Shopify orders export carries the order header and the line items. Per-line fulfilment status sometimes lands in a default state rather than the source state. Walk a sample of orders and confirm the financial status (paid, partially refunded, refunded) and the fulfilment status (fulfilled, partially fulfilled, unfulfilled) match the source. If a column did not map, contact support to re-run the order import with the correct mapping.

Payment gateway test transactions fail

The SGEN ecommerce module supports the common payment gateways; the configuration is per-gateway. Common causes of test-transaction failure: the gateway is in test mode rather than live mode (or vice versa), the merchant account credentials are entered for a different store, or the currency configuration does not match the gateway's account currency. Walk the gateway configuration screen and confirm each field against the gateway provider's reference.

If none of the above match the failure mode, capture the validation evidence (which orders, which products, which behaviour, what the admin event log shows), then open the Recovery Considerations Reference to plan a rollback to the backup captured in step four.

Pitfalls

Six pitfalls catch most teams running a Shopify to SGEN migration for the first time. Plan for them before the import event runs.

Pitfall 1 — Treating the CSV exports as the whole store

Shopify's CSV exports carry the catalogue, the customers, and the orders. They do not carry the theme, the apps, the payment gateway configuration, the shipping rate tables, the tax overrides, the discount rule logic, or the metafield definitions. Operators who upload only the CSVs end up with a catalogue surrounded by missing infrastructure. Plan all the layers alongside each other — CSVs for data, manual recreation for configuration, SG-Builder rebuild for the storefront — and confirm each layer has a destination on the SGEN side.

Pitfall 2 — Underestimating the variant matrix

A single Shopify product can carry dozens of variants across multiple option dimensions (size, colour, material). The CSV exports a row per variant, and the wizard needs to land each variant against the parent product. Variants that fail to map create incomplete product records on the SGEN side. Walk a high-variant product after import to confirm every variant landed, and address mapping gaps before the rest of the validation cycle.

Pitfall 3 — Skipping the app-to-module mapping decision

Shopify apps are the source store's extension layer. Most of what apps do — reviews, loyalty programmes, subscriptions, advanced shipping, multi-currency, abandoned-cart recovery, product recommendations — is covered natively by the SGEN ecommerce module or by the surrounding SGEN modules. The mapping is module-by-module rather than app-by-app, and skipping the decision lands a SGEN storefront with the catalogue but without the surrounding capability. Plan the app-to-module mapping during the inventory and confirm each app has either a SGEN module covering its behaviour or a deliberate decision to ship without it.

Pitfall 4 — Skipping the commerce cutover window

Running both Shopify and SGEN accepting orders simultaneously creates reconciliation work — orders on Shopify need to be manually re-entered on SGEN, customers may receive duplicate order confirmations, and the source-of-truth for "what is the current order state" becomes ambiguous. Plan a cutover window, communicate it to customers and to fulfilment, and treat it as a discrete event. The window is usually one to four hours; longer windows are sometimes appropriate for catalogues with high order volume.

Pitfall 5 — Forgetting the redirect map (especially for product and collection URLs)

Shopify generates product URLs as /products/ and collection URLs as /collections/. The SGEN equivalent module may generate URLs with a different template. Product pages that lived at one URL on Shopify may live at a slightly different URL on SGEN. Paid ads, affiliate links, search-engine indexed URLs, and email marketing URLs all reference the source URLs. Plan a redirect map before the cutover, with special attention to the product and collection URLs, so external links and search-engine indexes are not orphaned at promotion.

Pitfall 6 — Not capturing the pre-import backup

The backup in step four is the rollback target. Operators who skip it because the import "should work" lose the rollback option when the validation cycle finds something unacceptable. For commerce-driven migrations, the rollback option is especially valuable — the cost of an unrecoverable failed import on a live storefront is measured in lost orders and customer trust. Capture the backup every time — it costs minutes and saves the migration.

Gotchas — behaviour differences Shopify users plan for

SGEN's architectural model differs from Shopify's in ways that are not bug-shaped — the platform behaves a particular way by design. Plan for the following so the differences arrive as expected outcomes rather than surprises.

Themes (Liquid) vs SG-Builder

Shopify drives storefront layout through themes written in the Liquid template language, with sections, blocks, and theme settings layered on top. SGEN drives storefront layout through the SG-Builder, a scoped component system administered through the SGEN admin surface. The shift is from "edit theme files in Liquid" to "compose with components in SG-Builder."

Imported product, collection, and content records arrive without Shopify theme structure. Operators rebuild the storefront in SG-Builder, usually by building one template per page archetype (a product detail template, a collection list template, a cart template, a checkout template, an account template) and applying it across the imported records. The work is one-time per archetype rather than per page.

Apps vs first-party SGEN modules

Shopify organises extended capability through apps from the Shopify App Store. SGEN organises the equivalent capability through first-party modules — the ecommerce module covers what many commerce apps deliver, the forms module covers what many lead-capture apps deliver, the custom objects module covers what many bespoke-data apps deliver. The first-party model removes the app-conflict failure mode that drives some of the Shopify maintenance burden, and it changes the mental model: instead of installing an app to add a feature, the operator activates the module that already exists.

For most Shopify storefronts, the module mapping covers the feature set with fewer moving pieces. The remaining cases are handled by Custom Codes (for site-wide custom CSS or scripts) or by Custom Objects (for bespoke data shapes the source apps stored).

Payment gateway re-configuration is unavoidable

Shopify Payments is tied to the Shopify platform — the merchant account, the payout schedule, the chargeback handling all live inside Shopify's payment pipeline. Moving to SGEN means setting up a payment gateway through the SGEN ecommerce module, with the merchant account configured on the gateway provider's side. The shift is from "platform-bundled payments" to "gateway-of-choice payments." The capability is comparable; the configuration is a deliberate setup step.

If the source store used a third-party gateway through Shopify (Stripe, PayPal, Authorize.net, others), the gateway account can usually be reconfigured on the SGEN side without changing the merchant account — only the connection point moves.

Shipping zones, rates, and carrier-calculated rules

Shopify ships shipping configuration as part of the platform — shipping zones, flat rates, carrier-calculated rates, and shipping-app rules all live inside Shopify's shipping settings. SGEN's ecommerce module covers the equivalent ground through dedicated configuration screens. The capability shape is comparable; the configuration is recreated rather than imported.

If the source store ran a third-party shipping app for advanced rules (rate tables by weight, by zone, by product type, by customer segment), confirm the SGEN ecommerce module covers the rule set natively. The configuration is rebuilt during step six.

Tax regions, overrides, and tax-app rules

Shopify ships tax configuration through Shopify Tax (the platform's built-in tax engine) or through third-party tax apps. SGEN's ecommerce module covers the equivalent ground through tax-region configuration. The configuration is recreated rather than imported. If the source store registered tax numbers in specific regions, the registration carries across as a paperwork step; the SGEN side needs the numbers entered against the matching regions.

Custom fields and metafields

Shopify metafields store bespoke data against products, collections, customers, orders, and pages. SGEN's equivalent is custom fields against the matching SGEN records. Metafield definitions are recreated on the SGEN side; metafield values transfer through the CSV export when the column is present.

Backups and recovery are platform-managed

Shopify ships limited backup capability through the export tools and through third-party backup apps. SGEN ships backup and restore as platform capabilities, scheduled through SG-Dashboard and stored alongside the site, with on-demand backup available at any time. The behavioural shape is comparable; the surface and the scope differ. For a live commerce platform, the platform-managed backup is the safeguard that makes risky operations (theme rebuilds, configuration changes, app removals) recoverable.

Verification — five post-migration checks

Walk these five checks after the import lands on staging and the SG-Builder rebuild is complete, before promoting staging to live. Each is a concrete observation, not a self-report.

Check 1 — Product, customer, and order counts match the inventory

Compare the count of imported products (and variants), customers, and orders inside the admin against the count from the Shopify inventory. The numbers should match. A mismatch usually points at a CSV column that did not map, a high-variant product where some variants failed to land, or draft content that the cleanup pass removed intentionally.

Check 2 — Spot-check storefront rendering across page archetypes

Open one product detail page (high-variant), one product detail page (single-variant), one collection list page, one cart, one checkout (in test mode), and one account page. Each should render without console errors, with media in place, with prices and variants displaying correctly, with the cart and checkout flowing end-to-end. The spot-check covers the major archetypes; it is not a per-page review.

Check 3 — Commerce surfaces behave end-to-end

Walk one round-trip through the storefront — add a product (with variant selection) to the cart, apply a discount code, proceed to checkout, select shipping, calculate tax, and confirm payment in test mode. The round-trip confirms the catalogue, the discount logic, the shipping configuration, the tax configuration, and the payment gateway are wired through to the imported records. Walk a customer-account round-trip — log in as an imported customer, view order history, confirm the past orders display correctly.

Check 4 — Search-engine artefacts survived

Page titles, meta descriptions, OpenGraph tags, and structured data should carry the values planned in the inventory. Spot-check via the page source or a structured-data testing tool. Product schema is particularly important for storefront search-engine performance — verify the product schema renders with the correct price, availability, and review-aggregate data (if applicable) before promotion.

Check 5 — Redirect map covers the product and collection URLs

Walk a sample of the old Shopify URLs and confirm each either resolves directly or redirects to the new equivalent. Pay special attention to product URLs (/products/) and collection URLs (/collections/), since search-engine indexes and external links reference them heavily. URLs that resolve to a missing-page state should be added to the redirect map before the cutover, not after.

When all five checks pass, the migration is verified. Run the cutover sequence (see step eight), promote staging to live, capture a fresh post-promotion backup, and run the validation cycle a final time on the live storefront to close the migration.

Examples

Example 1 — Small boutique store (under 50 products, no apps, one payment gateway)

A founder is moving a small boutique store from Shopify to SGEN. The store has 40 products with light variant counts (size, colour), 200 customers, 18 months of order history (about 500 orders), three forms, no installed apps beyond the defaults, and a Shopify Payments connection. The migration runs end-to-end in roughly two working days. Day one is the pre-migration inventory, the source cleanup, the CSV exports, and the import to staging. The SG-Builder rebuild of the product detail and collection templates takes the afternoon. Day two is the form rebuilds, the payment gateway configuration, the search-and-replace pass for CDN URLs, the validation cycle, the redirect map, the rehearsed cutover, and the staging-to-live promotion with the cutover window timed for early morning when order volume is lowest.

Example 2 — Medium specialty store (200-800 products, several apps, advanced shipping)

An agency is moving a client specialty store from Shopify to SGEN. The store has 500 products with heavy variant counts (size, colour, material, customisation), 4,000 customers, three years of order history (about 18,000 orders), eight forms, six installed apps (reviews, loyalty, subscriptions, advanced shipping, abandoned-cart recovery, multi-currency), a Stripe payment gateway, and four shipping zones with carrier-calculated rates. The migration runs across five to seven working days. Day one is the pre-migration inventory and the source cleanup. Day two is the CSV exports and the import to staging. Days three and four are the SG-Builder rebuild, the app-to-module mapping (reviews and loyalty become SGEN modules, subscriptions become custom-object configuration), the payment gateway re-setup, and the shipping configuration recreation. Day five is the discount logic recreation, the search-and-replace pass, the validation cycle, the redirect map, and a dry-run cutover on staging. Day six is the live cutover window, the production validation pass, and the post-cutover monitoring. Day seven is the buffer for any cleanup the production validation surfaces.

Example 3 — Large multi-region store (5,000+ products, many apps, multi-currency, complex tax)

A publisher is moving a multi-region commerce site from Shopify to SGEN. The store has 6,000 products with deep variant matrices, 50,000 customers, five years of order history (about 150,000 orders), twenty installed apps covering reviews, loyalty, subscriptions, advanced shipping, advanced tax, B2B pricing, wholesale, multi-currency, abandoned-cart recovery, product recommendations, post-purchase upsells, and several others, a payment gateway per region (four gateways across four regions), and complex tax registrations across multiple countries. The migration runs across a full working three weeks. Phase one (one week) is the pre-migration inventory, the app-to-module mapping in detail, the tax-registration paperwork plan, the catalogue cleanup, and the CSV exports. Phase two (one week) is the import to staging in batches, the SG-Builder rebuild across the page archetypes, the payment gateway setup per region, the shipping and tax configuration recreation, the discount logic recreation, the form rebuilds, the multi-currency configuration, and the loyalty / subscription / wholesale module setup. Phase three (one week) is the validation cycle on staging, the redirect map across product and collection URLs (with per-region URL planning), the search-and-replace pass, the cutover rehearsal, the live cutover window, the production validation pass, and the post-cutover monitoring. The publisher schedules the cutover for a low-traffic window per region and runs the validation cycle a final time after promotion per region.

Recommended timeline

The timeline below covers the work end-to-end. The variability inside each bracket is real — a small catalogue with one payment gateway and no apps lands at the lower end; a multi-region catalogue with twenty apps, several gateways, and complex tax lands at the upper end.

Store size	Products + orders	Apps + gateways + tax regions	End-to-end timeline
Small	Up to ~50 products / ~1,000 orders	0-2 apps, 1 gateway, 1 tax region	One to two working days
Medium	50-1,000 products / 1,000-30,000 orders	3-8 apps, 1-2 gateways, 1-3 tax regions	Five to seven working days
Large	1,000-10,000 products / 30,000-300,000 orders	8-20 apps, 2-4 gateways, multiple tax regions	Two to three working weeks
Enterprise	10,000+ products or multi-region or multi-currency	Variable	Three-plus working weeks with a planned commerce cutover window

The timeline is wall-clock time including the validation cycle, the SG-Builder rebuild, the commerce configuration, and the planned cutover window — not only the import event. The CSV import is usually a single afternoon at any size; the SG-Builder rebuild, the app-to-module mapping, the payment gateway setup, the shipping and tax configuration, the cutover rehearsal, and the live cutover window account for most of the remaining hours.

Examples in context — how a Shopify migration earns its production stamp

Migration is the entry path; validation is what closes it. The most common cause of "migration regret" on a Shopify source is treating the CSV import as the finish line, then discovering during the cutover that the discount logic did not transfer, the shipping rates need rebuilding, and the payment gateway test transactions are failing.

The discipline this guide leans on — inventory before exporting, map the apps to modules during the inventory rather than during the rebuild, capture the backup before importing, run on staging before live, rebuild the storefront in SG-Builder, recreate the commerce configuration deliberately, rehearse the cutover before the live event, validate before promoting — is the same discipline the Migration and Import Overview lays out at the structural level. Following it on a Shopify migration is the difference between a migration that produces a working storefront on day three and a migration that produces a working storefront on day twenty-one after three round-trips of cutover cleanup.

The sibling guides Migrate from WordPress, Migrate from Webflow, and Migrate from Squarespace cover other source paths. The shape is the same; the source-side specifics differ. All four guides lean on the same inventory-export-import-validate-promote discipline.

Vocabulary cross-reference

Products CSV — the catalogue artefact produced by Shopify Products → Export. Carries titles, variants, prices, inventory, SKUs, and image URLs.
Customers CSV — the customer artefact produced by Customers → Export. Carries name, email, tags, addresses, and order-count metadata.
Orders CSV — the order-history artefact produced by Orders → Export. Carries order header, line items, financial status, and fulfilment status.
Variant matrix — the set of variants under a single product (size × colour × material). The CSV exports a row per variant; the wizard lands each variant against the parent product.
App-to-module mapping — the inventory exercise of matching each Shopify app to the SGEN module that covers its behaviour (or to a deliberate decision to ship without it). Done once per migration.
Payment gateway re-configuration — the discrete setup step where the SGEN ecommerce module's payment gateway is connected to the merchant account, configured for the storefront currency, and tested in live mode.
Shipping configuration — the zones, rates, and carrier-calculated rules. Recreated on the SGEN side rather than imported.
Commerce cutover — the discrete event that hands live order acceptance from the source storefront to SGEN. Usually a one-to-four-hour window; longer for high-volume catalogues.
Identification metadata — the trace data SGEN attaches to imported records so they are distinguishable from records created directly on the SGEN side.
Staging-first posture — the recommended discipline of importing to staging, validating, then promoting to live. Default for commerce migrations.
Redirect map — the table of old Shopify URLs and their SGEN equivalents, applied at promotion time. Pays particular attention to product and collection URLs.
Promotion — the operation that moves a validated staging state into live production. Distinct from the import event itself and from the commerce cutover.
DNS hand-off — the discrete event of changing the host record from the Shopify nameservers (or A records) to the SGEN equivalents. Usually timed with the commerce cutover.

Maintenance discipline

When SGEN's migration tooling adds support for new Shopify import shapes (automated app-to-module mapping, direct-fetch from the Shopify Admin API, advanced shipping translation, multi-currency automation), update this guide and log the change in Changelog. The guide stays valuable because the structural shape — inventory, export, import, rebuild, configure, validate, cutover, promote — stays small. New capability lands inside that shape rather than expanding it.

When the Shopify side changes (new CSV columns, new admin export format, new platform capability), revise the prerequisites and the export step rather than spawning a new guide. The single-guide discipline keeps the migration path findable for the operator running it.

On this page