How ERPNext and Shopify integration works
A merchant selling on Shopify needs orders, customers, items and stock levels reflected in ERPNext so that accounting, invoicing and warehouse records stay current without re-keying data. The supported route is the ecommerce_integrations app, which is installed into ERPNext and configured with a Shopify connection. It creates Sales Orders from Shopify orders, creates customers and items when they are missing, maps taxes and shipping charges to accounts you define, pushes inventory from ERPNext warehouses to Shopify locations on an hourly schedule, and can import historical orders for a date range. Before you start, confirm the exact setting names, the Shopify API scopes the app requests and the menu paths in the app documentation for your ERPNext version, since none of these are fixed in this overview.
The decisions that shape the build happen before any sync is switched on. You need to decide which Shopify locations map to which ERPNext warehouses, which default customer, item group, price list and company the app uses, and which tax and shipping accounts receive each amount. Check how the app handles discounts, gift cards, refunds, partial fulfilments and multiple currencies in your store, because these cases often produce Sales Orders or invoices that need manual correction. Confirm with the app documentation whether returns and cancellations flow back to ERPNext automatically. Test the mapping on a Shopify development store or a copy of your ERPNext site first, and keep the historical import window small until the first results match your expectations.
Several things stay manual or need a separate process, and the reader should plan for them explicitly. Payment capture, settlement reconciliation and fee accounting are usually handled through a payment gateway setup rather than the order sync itself. Product content, images, variants and pricing changes in Shopify need a clear owner, because the item mapping only covers what the app is configured to read. Stock counts taken on the warehouse floor still happen in ERPNext, and the hourly inventory push is only as accurate as those counts. Ask the app maintainers or a partner to confirm what each sync direction covers in your version, and write down the reconciliation check your finance team will run each month.
What you need before connecting ERPNext to Shopify
Most Shopify connections stall on prerequisites rather than on the connector itself. The cards below cover the ERPNext version, the hosting path, the Shopify access, the master data and the people who will own exceptions, in the order they usually block a build.
A supported ERPNext version
Confirm the site runs a version still under Frappe support before you build on it. Version 15 is supported until the end of 2027 and version 16 until the end of 2029, while version 14 reached end of life on January 31, 2026. Check the ecommerce_integrations app is available for your chosen version and install it on the site. Plan the upgrade path now if you are on an unsupported line, since the connector mapping will be rebuilt on top of it.
A reachable public URL with TLS
Shopify must reach your ERPNext site over HTTPS to deliver webhooks and receive callbacks, so the site needs a public hostname and a valid certificate. Choose between Frappe Cloud, Docker Compose or a bench install based on who will patch and back up the server. Confirm the firewall allows inbound traffic on the path the webhooks use, and test it from outside your network before you configure the app.
Shopify access to create a custom app
Someone with the store owner or staff permission to develop custom apps must create the app in Shopify and grant only the scopes the sync needs, such as orders, products, customers, inventory and locations. Record who holds that access and who approves changes to scopes later. Without this, no credentials can be generated and the connection cannot be tested against live data.
Clean ERPNext master data
Before the first order arrives, the site needs a company, a chart of accounts, warehouses that match Shopify locations, tax templates for each rate you charge and shipping accounts for freight income. Orders that reference missing accounts or warehouses fail or post to the wrong place. Review these records with your accountant, because mapping errors here become posted Sales Orders and invoices.
Server Scripts if your mapping needs them
If your tax, shipping or item rules depend on Server Scripts, check the version rules first. From version 15, Server Scripts are disabled by default and must be enabled with the server_script_enabled setting. Frappe Cloud public shared benches do not allow them, so a mapping built on Server Scripts needs a dedicated bench or self-hosted site. Decide this before design, because moving later changes the deployment.
A named owner for exceptions
Name one person who reviews failed order syncs, unmatched SKUs, rejected tax lines and inventory differences each day. Name a second person for escalation to Shopify or your hosting provider. Without a named owner, failed orders sit in error logs while customers wait and stock counts drift. Agree on the response expectations in writing before go-live, since no connector sends these records to your team automatically.
Connecting a Shopify store to ERPNext step by step
This sequence takes a Shopify store from a bare ERPNext site to a verified order flow, with each step closed by a check that proves it worked before the next one starts. The ordering matters: the ecommerce_integrations app and credentials come first, mappings come before any test order, and scheduled inventory sync and historical import are switched on only after the test order has produced correct records.
Install the ecommerce_integrations app on the site
Install the ecommerce_integrations app on the ERPNext site that will receive Shopify orders, using the same Frappe version as the rest of the site. Your ERPNext administrator or implementation partner runs the install from the bench command line on your infrastructure, then confirms the app's Shopify settings page appears in the desk. Confirm the install by checking that the app is listed among the site's installed apps and that the Shopify Settings page opens without errors. Keep this on a staging site first if you have one, because later steps create master data that is harder to clean up in production.
Create the custom Shopify app with limited permissions
In your Shopify admin, create a custom app for this integration and grant only the access scopes the ecommerce_integrations documentation lists for orders, customers, products and inventory. Do not grant broader store permissions because they are not needed for the sync and widen the impact of a leaked credential. Your Shopify store owner or staff account with app-development rights does this step, and should record which scopes were granted and why. The check is that the app's granted scopes match the documented list exactly, with nothing extra, and that the app is installed on the target store.
Enter app credentials and store domain in ERPNext
Copy the API credentials generated for the custom Shopify app and enter them, together with the store's myshopify domain, in the Shopify Settings page in ERPNext. Store the secrets only in the ERPNext settings record and restrict who can open that record through roles. Save the configuration and use the connection test or the first sync trigger provided in the settings to confirm ERPNext can reach the store. The check is a successful connection status on the settings page and no authentication errors in the error log after the test.
Map Shopify locations to ERPNext warehouses
Map each Shopify location that holds stock to a specific ERPNext warehouse, so that inventory levels pushed by the hourly sync land in the correct stock ledger. Your inventory lead decides the mapping, and a finance or operations reviewer confirms that each warehouse belongs to the right company and cost center. Map every location you intend to sync, and leave out locations that should not affect ERPNext stock. The check is that each mapped location shows its warehouse in the settings table and that a manual stock comparison for one item matches between Shopify and ERPNext.
Map tax and shipping to accounts and templates
Map the tax rates and shipping charges that Shopify applies to the ERPNext accounts and tax templates used for sales invoices. Your accountant defines which income, tax liability and shipping income accounts receive each amount, and confirms how tax-inclusive or tax-exclusive pricing is treated for each market. Mismatched mappings produce invoices that look correct in Shopify but fail reconciliation in the ledger. The check is that the mapping table covers every tax rate and shipping method active on the store, with no unmapped entries flagged by the settings page.
Run a test order and confirm the records
Place a test order in Shopify using a test customer and a product that exists on both sides, then wait for the sync to create the records. Your implementation team or accountant checks that a Sales Order appears with the correct customer, items, quantities, prices, tax lines and shipping charge, and that a Customer and Item were created or matched as the settings intend. Compare totals line by line against the Shopify order. The check is that every field on the Sales Order matches the Shopify order, with no duplicate customers or items, and that the error log shows no failed records for this order.
Enable hourly inventory sync and historical import
Only after the test order passes, enable the scheduled hourly inventory sync for the mapped locations and run the historical order import for the date range your finance team has agreed. Run the historical import in batches and watch the error log and the record counts as it runs, since large volumes can slow the site and create duplicates if the import is repeated. Confirm the scheduler is running on the site before relying on the hourly job. The check is that the next scheduled inventory run updates stock in the mapped warehouses, and that imported historical orders match the Shopify order count for the period without duplicates.
How Shopify orders, customers, items and taxes map to ERPNext
This table compares each Shopify object with the ERPNext document it creates or updates, and what the mapping decides for your books and stock. Read it before the build starts, because several defaults change accounting, stock and customer records once historical orders are imported. Confirm every default in the connector's mapping settings with your own store configuration.
| Shopify object | ERPNext object | What the mapping decides | What to confirm |
|---|---|---|---|
| Order | Sales Order | Which order events create a Sales Order, and how line items, totals and order status are carried into ERPNext. | Whether tax-inclusive pricing is enabled in Shopify and how the price list in ERPNext treats tax, since this changes item rates and totals. |
| Customer | Customer | Whether a Shopify customer is matched to an existing ERPNext Customer by email or ID, or a new one is created, and which Customer Group and territory apply. | Duplicate handling for guest checkouts and existing B2B accounts, and whether historical customers are created during the initial import. |
| Product variant | Item | How each variant maps to an ERPNext Item, including the item code, item group and whether variants are stored as templates with attributes. | Item code format, handling of SKUs that change, and whether deleted or archived variants should stay active in ERPNext. |
| Location | Warehouse | Which Shopify locations sync stock into which ERPNext warehouses, and therefore which stock balance each inventory update changes. | Location to warehouse pairs, the company that owns each warehouse, and the hourly inventory sync direction for each location. |
| Shipping line | Account or shipping charge | Whether shipping is booked as a separate charge line on the Sales Order and Sales Invoice, and which income account receives it. | The income account for shipping, whether shipping is taxed separately, and how free shipping or carrier-specific rates appear on invoices. |
| Tax line | Sales Taxes and Charges template | Which tax template applies to each order, and whether tax is calculated by ERPNext or taken as reported by Shopify. | Tax rates per jurisdiction, tax-inclusive versus tax-exclusive settings, and whether multiple currencies need separate tax accounts. |
| Discount or price rule | Pricing Rule or line discount | Whether Shopify discounts are carried as line-level price reductions, as separate discount lines, or not carried at all. | Which discount types are supported by the app, how order-level discounts are split across items, and effect on revenue reporting. |
| Fulfillment | Delivery Note | Whether a Shopify fulfillment creates a Delivery Note that reduces stock and links back to the Sales Order. | Whether stock is reduced at order or at fulfillment, and how partial fulfillments and returns are recorded. |
| Currency | Customer and Sales Order currency | Whether orders in other currencies keep their presentment currency or convert to the company currency at the order date rate. | Shopify presentment and settlement currencies, exchange rate source in ERPNext, and which currency each price list uses. |
Choosing what to sync live and what to import once
New Shopify orders flow into ERPNext as Sales Orders as they are placed, so sales, fulfillment and accounting work from the same record. This is the path most teams want running from day one, because every later step (stock reservation, invoicing, tax reporting) depends on orders arriving reliably. The trade-off is that live sync is only as good as its mapping. Customer, item, tax and shipping rules must already exist, or orders will fail or land in an error log.
- Timeliness: confirm how often the app polls or receives orders in the version you install, since the delay between a Shopify order and its ERPNext record depends on that setting.
- API load: each order pulls related customer and product data, so high order volume during sales events increases calls against the Shopify API rate limits.
- Duplicate risk: an order that is retried after a timeout can create a second Sales Order unless the app stores the Shopify order ID and checks it before creating records.
- Ownership afterward: your team owns failed order queues, mapping changes when products or tax settings change, and reconciliation against Shopify payouts.
- Edge cases: test cancellations, partial refunds and orders edited after placement, since these need their own handling rules.
Before go-live, place test orders in a development store and confirm each one appears once, with the right tax, shipping and customer records.
Inventory sync pushes stock levels by Shopify location into ERPNext warehouses or from ERPNext warehouses back to Shopify, depending on which system is the stock source. It is usually scheduled rather than live, which keeps Shopify API calls predictable across a large catalogue. The main decision is which system is authoritative for each location, because two systems updating the same stock figure will drift apart.
- Timeliness: an hourly schedule means stock on the storefront can lag actual stock by up to an hour, which matters for low-stock or high-demand items.
- API load: inventory updates touch every mapped variant at each run, so catalogue size and the number of locations drive the work per run.
- Location mapping: each Shopify location must map to exactly one ERPNext warehouse, or stock is counted twice or assigned to the wrong site.
- Ownership afterward: your team owns the location-to-warehouse map, stock adjustments made in ERPNext, and checks after stock counts.
- Verification: confirm the sync frequency options and the direction of each sync in the app version you install, then compare a sample of variants in both systems after one full cycle.
Keep an eye on negative stock and items with no mapping, since these often cause the most support tickets.
A historical import loads past Shopify orders into ERPNext so that customer history, revenue reporting and tax records cover the period before go-live. It runs once or in batches over a chosen date range, and it is separate from the live flow. Because it reads old orders that the live sync may also see, overlap between the two is the main risk.
- Date range: confirm the import date-range controls in the app version you install, and choose a cut-off date that the live sync does not reach back into.
- Duplicate risk: an order placed near the cut-off can be imported historically and again by live sync, so the cut-off must be set carefully and duplicate checks tested first.
- API load: large historical pulls consume rate limit budget, so run them outside peak trading hours and in batches.
- Ownership afterward: your team owns the historical Sales Orders, their invoices and tax entries, and any corrections needed for orders that changed status after import.
- Accounting impact: decide with your accountant whether historical orders create invoices and ledger entries or stay as reference records, since this changes period-end reports.
Run the import against a copy of the site first and compare order counts and totals per month with Shopify reports.
Some data sits outside what the connector maps automatically. Examples include custom checkout fees, gift card liabilities, bundles that do not match ERPNext item structures, and returns that need physical handling. Teams either build custom work for these or handle them by hand. The choice depends on volume and on how often the same case recurs.
- Volume: rare cases can be handled by a documented manual step, while frequent cases justify custom mapping or a scripted process.
- Accounting gaps: items such as gift cards or store credit may need their own accounts and journal patterns, which the default mapping may not create.
- Custom work cost: custom mapping adds build and maintenance effort, and upgrades of the connector can affect it, so ask for the scope in writing.
- Ownership afterward: your team owns the manual procedure, its checklist and the person responsible for each exception type.
- Verification: list every Shopify order type you sell, mark which ones the app maps without changes, and test the rest with real examples before launch.
Ask the implementation partner to confirm each gap in the app version you plan to run, instead of assuming the default behavior covers it.
How to test the Shopify connection before go-live
Run the test plan on a staging ERPNext site connected to a Shopify development store, and do not point a production store at the connector until every case below has matched its expected result. Create one paid order, one refunded order, one partially fulfilled order, one order with a percentage or fixed discount plus shipping, one order from a new customer, and one variant stocked at two Shopify locations. Each case should map to a known Sales Order state in ERPNext. Confirm with the ecommerce_integrations app documentation and your own build notes which document each Shopify event creates (Sales Order, Sales Invoice, Delivery Note or none), because the expected ERPNext result depends on that mapping, not on what Shopify shows.
For each test order, compare the ERPNext Sales Order grand total, each tax line and each shipping line against the Shopify order, line by line. Mismatches usually come from tax-inclusive versus tax-exclusive pricing, rounding on discounts, or a shipping fee mapped to the wrong account. Record the Shopify order name, the ERPNext document name and the difference for every field, then fix the mapping and rerun the same order rather than editing the ERPNext document by hand. For inventory, make a stock adjustment in Shopify at each location, wait for one full sync cycle, and confirm the Bin quantities by warehouse in ERPNext match the Shopify location counts. Confirm the sync interval with your build team, because the scheduled job timing determines how long you wait before checking.
Test the historical order import on a narrow date range first, such as a few days that include a refund and a partial fulfillment, and check that duplicates are not created on a second run. Only then expand to the full range. Ask the implementer whether the import processes orders in batches and how it handles failures partway through. The ERPNext Data Import documentation advises importing only a few thousand records at a time, but that guidance applies to the Data Import tool, not necessarily to this connector, so confirm its batch behavior in writing before you plan the full import window.
Securing the Shopify app credentials and the ERPNext endpoint
The Shopify connector links two systems that hold customer and payment-adjacent data, so the weakest point is usually a broad app token, a loosely permissioned settings record or an unauthenticated inbound endpoint. The cards below cover the controls that connect the Shopify app, the ERPNext records it writes and the public address Shopify calls, and what to verify before go-live.
Scope the Shopify app to minimum permissions
Create the custom Shopify app with only the read and write scopes the sync needs, such as orders, customers, products and inventory locations. Each extra scope widens what a leaked token can change in the store. Review the granted scopes after installation and compare them with the mapping you agreed. Ask the implementation partner to document each scope against the sync direction that requires it, so a later reviewer can remove what is no longer used.
Store API credentials with restricted access
Keep the Shopify access token and API secret in the integration settings record, not in custom scripts, exported fixtures or version control. Limit who can read that record, and confirm that backups and logs do not expose it. Rotate the credentials when someone with access leaves the project or changes role, and record the rotation date. The connector can only be as secure as the least-trusted person who can open that settings record.
Restrict who edits integration mappings
Mapping records decide which tax account, shipping item, warehouse and customer group each order uses, so a wrong edit posts incorrect books. Create a dedicated role for integration administrators and grant it access to the settings and mapping doctypes only. Use ERPNext role and user permissions to keep sales staff from changing mappings, and confirm that role changes take effect in a test before production use.
Verify webhook authenticity and HTTPS
Shopify sends webhooks to a public address on your ERPNext site, so that endpoint must terminate HTTPS at a proxy you control and reject requests that fail signature verification. Confirm the signature check uses the shared secret for your app and fails closed. Test with a deliberately altered payload and a request with a missing signature. Limit the public path to the webhook routes rather than exposing the whole site.
Keep Server Scripts disabled unless needed
Server Scripts run Python on document events or as API endpoints, which makes them a powerful place for custom sync logic and also a path for code execution by anyone who can create them. From version 15 they are disabled by default and need the server_script_enabled setting to run. Keep that setting off unless a documented requirement needs it, and review any enabled script as code. Frappe Cloud public shared benches do not allow them at all, which matters if you plan to host there.
Audit records the integration creates
Review Sales Order and Customer records the connector creates, including who or what created them, the source Shopify order number and the tax and shipping lines. Use ERPNext version tracking on these doctypes and set up a periodic report of integration-created customers without contact details or with unexpected tax templates. Agree who reviews the exceptions and how often, so a faulty mapping is caught before it reaches month-end close.
Why Shopify orders fail to appear as Sales Orders in ERPNext
This table maps common Shopify to ERPNext sync failures to their likely cause, the check that confirms it and the fix to apply. Start with the ERPNext error log and background job status, since most missing or duplicated records leave a trace there. Work through the rows in order, because a failed order sync often blocks the item, customer and tax records that later rows depend on.
| Symptom | Likely cause | Check | Fix |
|---|---|---|---|
| Orders missing entirely | Webhook not reaching the ERPNext site, or the site URL changed after the webhooks were registered | Review webhook delivery status in the Shopify admin and confirm the site is reachable over HTTPS from outside your network | Correct the endpoint URL, re-register the webhooks and replay recent orders from the Shopify admin |
| Orders missing entirely | Shopify app credentials expired, were revoked or were reinstalled with fewer permissions | Open the Shopify Settings document in ERPNext and check the connection status and the scopes granted to the custom app | Reauthorize the custom app with the required read and write scopes, then rerun the order sync |
| Orders missing entirely | Background jobs or the scheduler are not running, so queued sync tasks never execute | Check Background Jobs in ERPNext for queued or failed jobs and confirm the scheduler is enabled on the site | Restart the workers and scheduler, clear the stuck queue and rerun the failed sync jobs |
| Duplicate Sales Orders after a historical import | The historical order import overlaps the window already covered by live webhook sync | Compare the Shopify order number on each duplicate pair and identify the date range of the import | Cancel and delete the duplicates that came from the import, then set the import start date after the first live order |
| Customers created twice | Customer matching uses email, and the same buyer appears with different email casing or a second address | Search Customer records by email and by Shopify customer ID to find the pair | Merge the records, then confirm the matching rule and store the Shopify customer ID on the ERPNext customer |
| Items skipped during order sync | Shopify SKUs do not match ERPNext item codes, often due to trailing spaces, case or variant formatting | Review the sync log for the skipped SKU and compare it to the Item code in ERPNext | Align the SKU or item code mapping, create the missing item and rerun the affected orders |
| Tax totals differ from Shopify | The tax template does not match the Shopify rate, or prices are tax-inclusive in Shopify but treated as exclusive in ERPNext | Compare one order line by line: unit price, tax amount and the tax account used on the Sales Order | Set the price list to match Shopify's tax setting, correct the tax template rate and amend affected orders before invoicing |
| Shipping lines fail | No account is mapped for shipping charges in the integration settings | Look for a shipping-related error in the sync log and check the shipping account field in the connector settings | Map a shipping income account and an item for shipping charges, then rerun the failed orders |
| Inventory counts drift after a location remap | Shopify location IDs were changed to new warehouses, but the old mappings still push stock to the previous warehouse | Compare Bin quantities in ERPNext with the inventory levels shown for each Shopify location | Update the location-to-warehouse mapping, then reconcile stock with a stock reconciliation entry for affected items |
What a Shopify to ERPNext integration costs and takes
What drives the cost of a Shopify to ERPNext integration?
The cost follows the written scope, and the main drivers are the depth of item and order mapping, the number of Shopify locations that feed inventory, the complexity of tax and shipping rules, the volume of historical orders to import, the number of custom fields to carry across, and the testing effort needed to prove each path. A store with one location, standard tax settings and a short order history sits at the simple end. Multiple markets, custom accounting treatment for discounts or fees, and many custom fields push effort up. Ask any provider to itemize these drivers in the quote so you can see which ones you can reduce.
Does ERPNext itself cost money to run for Shopify sales?
ERPNext is free and open source, and the ERPNext pricing page states that self-hosting it is free. If you choose Frappe Cloud instead, shared site hosting starts at 5 US dollars per month, and Frappe Cloud servers start at 20 US dollars per month for shared instances and 125 US dollars per month for dedicated servers. Your Shopify plan, your hosting for the ERPNext server if you self-host, backups, and the time of your staff or a partner are separate costs. Confirm current figures on the pricing page before budgeting, because hosting prices can change.
How long does a Shopify to ERPNext integration take?
The duration depends on the scope, and it should be agreed in writing before work starts rather than estimated from a generic plan. Timing is driven by the same factors as cost, plus the time your team needs to make master data decisions and approve test orders. Ask the provider to list the phases, such as access setup, mapping design, build, historical import, test cycles and go-live, with the client input each phase needs. Delays most often come from unresolved tax and location decisions, not from the connector itself.
What must our team provide before the integration starts?
Plan to provide four things. First, administrative access to the Shopify store so the custom app permissions can be created and reviewed. Second, decisions on master data, including how Shopify products map to ERPNext items, which customer records to create, default tax templates, shipping accounts and the warehouse for each Shopify location. Third, test orders covering normal sales, refunds, discounts, taxes and shipping. Fourth, a named approver who can sign off mappings and go-live. Without these, the build waits on answers that only your business can give.
Can an internal team build the Shopify to ERPNext integration alone?
A team with ERPNext administration skills, Shopify app experience and clear accounting rules can often build a simple setup in house, using the ecommerce_integrations app and its documentation. The work becomes harder when you need custom mapping, several locations, historical import, or a tested path for refunds and tax. Assess the skills you have in ERPNext accounting, stock, Shopify administration and Python, and check who will own the integration after go-live. A partner can fill specific gaps with a fixed scope instead of taking over the whole project.
What happens after go-live, and who maintains the integration?
After go-live the integration needs routine care: applying ERPNext and app updates, checking that scheduled inventory syncs run, reviewing failed order imports, and confirming that Shopify permissions still match what the app needs. Plan who receives failure notifications and who fixes them. Ongoing support, upgrades and monitoring can be contracted as a retainer, and that work should be written into the scope so it is not treated as an afterthought. Confirm with the provider how updates are tested before they reach your live store.
How do we ask for a quote based on a written scope?
Start with a written scope that names the Shopify store and locations, the ERPNext version and hosting model, the mapping rules for items, customers, taxes and shipping, the inventory sync design, the historical order range to import, the custom fields involved, and the test plan with its acceptance criteria. Ask the provider to state deliverables, client responsibilities, assumptions and exclusions for each item. DeployOpen does not publish a price list, and a quote follows from that written scope, so the more precise the scope, the more comparable the quotes will be.
How DeployOpen scopes, delivers and supports this integration
DeployOpen plans, implements, customizes, integrates, hardens, documents and supports self-hosted open-source platforms inside your own infrastructure. For ERPNext and Shopify integration, we start from a written scope that names the Shopify store, the ERPNext site and the sync rules before any build begins.
How we scope
- Confirm the Shopify store, locations, currencies and tax setup that the ERPNext site must match.
- Agree in writing which order statuses, customer fields, item attributes and inventory locations sync.
- Record the custom Shopify app permissions needed, and who in your team approves them.
- Define the historical order import window and the reconciliation checks that sign it off.
- Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts.
How we build
- Install and configure the ecommerce_integrations app on your ERPNext environment, in your own cloud or data center.
- Map Shopify taxes, shipping charges and discounts to ERPNext accounts and tax templates.
- Build the order to Sales Order flow, with customer and item creation rules agreed during scoping.
- Configure hourly inventory sync by location and test stock movements against a staging store.
- Run test orders, refunds and historical imports against sample data before any production cutover.
How we hand over
- Document each mapping table, sync rule, scheduled job and exception path in a handover pack.
- Walk your finance, stock and integration staff through daily reconciliation and failed sync handling.
- Record the Shopify app permissions, credential locations and rotation steps for your team to own.
- Provide a go-live checklist covering cutover order, rollback steps and the first-week monitoring plan.
- Transfer administration access so your team runs the integration without depending on us.
How we support
- Offer ongoing support, upgrades and testing for the integration as a retainer after go-live.
- Track ERPNext and ecommerce_integrations version changes and plan upgrades in a test environment first.
- Review failed order syncs, inventory drift and tax mapping changes when Shopify or your rules change.
- Confirm with your team which support scope, response expectations and change process fit your operations.
- Keep the integration documentation current as the Shopify configuration and ERPNext setup evolve.
