Once a Shopify store hits a certain size, order volume, or complexity, “we’ll just export a CSV and update the ERP manually” stops being viable, and the real question becomes how to connect Shopify to your ERP properly. At that point, most merchants land on one of two paths: an off-the-shelf ERP integration app from the Shopify App Store, or a custom-built connector using Shopify’s API directly. Both are legitimate. Which one is right depends on specifics most generic advice glosses over.
This isn’t a checklist of what to look for in an ERP integration, that’s a separate, more foundational question. This is specifically the build-vs-buy decision once you already know roughly what you need the integration to do.
What an Off-the-Shelf Integration App Actually Gives You
Pre-built ERP integration apps (connecting Shopify to systems like NetSuite, SAP, Microsoft Dynamics, or Cin7, among others) generally offer:
- Pre-mapped standard data flows, orders, inventory, customers, sometimes pricing, configured through an admin interface rather than code
- Faster initial setup, often weeks rather than months
- Ongoing maintenance handled by the app vendor, including keeping pace with Shopify API version updates
- Lower upfront cost, usually a subscription fee rather than a development project
- A support channel that exists independent of any one developer or agency
The trade-off is that you’re working within the app’s data model and supported field mappings. If your ERP setup is fairly standard, common order statuses, standard inventory sync, no unusual custom fields, this is very often the right call, and building custom for a standard need is usually wasted spend.
What a Custom-Built Connector Gives You
A custom connector, built directly against Shopify’s Admin API (REST or GraphQL) and your ERP’s API, gives you:
- Full control over exactly what data syncs, how often, and how conflicts are resolved
- The ability to map non-standard fields, custom order statuses, or business logic that doesn’t fit a generic app’s model
- No dependency on a third-party app vendor’s roadmap, pricing changes, or potential discontinuation
- Direct handling of edge cases specific to your business (multi-warehouse allocation logic, custom pricing tiers, non-standard tax handling)
The trade-off is real: higher upfront development cost, a longer initial build timeline, and ongoing responsibility for maintaining the integration as both Shopify’s API and your ERP evolve over time, unless that maintenance is contracted out explicitly.
The Decision Framework
Rather than a generic “it depends,” here’s what actually drives the decision in practice:
How standard is your data model? If your order, inventory and customer data fits reasonably within common patterns, an app is very likely sufficient and meaningfully cheaper. If you have genuinely custom fields, non-standard fulfilment logic, or unusual multi-entity structures (multiple warehouses, multiple selling entities, complex bundling), that’s a strong signal toward custom.
What’s your order volume and sync frequency requirement? High-volume stores needing near-real-time sync sometimes hit rate limits or latency issues with certain apps’ architecture. This is worth testing directly against a specific app’s documented limits before committing, not assuming either way.
How specific is your ERP? Well-known, widely-integrated ERPs (NetSuite, Xero, MYOB, Cin7) tend to have more mature, better-maintained app options. Less common or heavily customised ERP instances are more likely to need a custom build simply because no app vendor has built for that exact configuration.
What’s your tolerance for ongoing dependency? An app means depending on a vendor’s continued support and roadmap. A custom build means depending on either in-house technical capacity or a contracted developer relationship for maintenance. Neither eliminates dependency, they just shift where it sits.
What does the total cost of ownership actually look like over 2-3 years, not just year one? Apps often look cheaper up front and custom builds catch up in year one, but this reverses over a longer horizon if your app subscription cost scales with volume or if you’re paying for multiple apps to cover gaps a single custom connector would handle natively.
A Middle Path: Customising an App-Based Foundation
It’s worth noting there’s often a middle ground, using an app for the core, well-supported sync (orders, basic inventory) while building a smaller custom piece for the specific non-standard requirement (a particular pricing rule, a specific warehouse allocation logic), rather than treating it as a binary all-app or all-custom decision. This is frequently the most cost-effective route for merchants with mostly-standard needs and one or two genuinely unusual requirements.
An Illustrative Scenario: Where the Line Actually Falls
Imagine a mid-sized homewares wholesaler running Cin7 as their ERP, selling both direct-to-consumer and B2B through Shopify. Their core requirement, syncing orders, inventory levels and customer records, is a well-supported, common pattern that a mature ERP integration app handles comfortably.
Where it gets more interesting is their B2B pricing structure: different wholesale customers negotiate individual pricing tiers that don’t map cleanly to Shopify’s standard B2B catalogue and price list functionality, and their warehouse allocation logic prioritises certain regional customers during stock shortages in a way no off-the-shelf app is likely to support natively.
In a case like this, the sensible approach usually isn’t “custom build everything” or “force it all into the app.” It’s using the app for the well-supported core sync, and building a smaller, targeted custom piece, perhaps a middleware layer or a Shopify Function, specifically for the pricing and allocation logic that genuinely diverges from standard patterns. This keeps cost proportional to actual complexity, rather than either overpaying for a fully custom build or accepting a poor-fit app that can’t handle the business’s real requirements.
Warning Signs You’ve Chosen Wrong
Signs an app isn’t enough: you’re building workarounds outside the app to handle data it can’t map, you’re maintaining a manual reconciliation process alongside the “automated” sync, or you’re hitting the app’s field or volume limits regularly.
Signs custom was overkill: your business logic hasn’t actually diverged from what standard apps support, but you’re paying ongoing developer costs to maintain functionality an app would have handled for a subscription fee, or the custom connector has become a single point of failure with no documented handover if the original developer moves on.
Questions to Ask Before Signing Off Either Path
Regardless of which direction you’re leaning, these questions tend to surface the real answer faster than a generic comparison can:
- “What happens to our data flow if this app or connector goes down for a day?” Both paths need a documented failure mode, does inventory go stale silently, or is there an alert and a manual fallback process?
- “Who actually owns troubleshooting when something breaks?” For an app, is it the app vendor’s support team, your internal team, or your agency? For a custom build, is there a maintenance agreement in place, or does it depend on one developer’s availability?
- “How does this handle a Shopify API version deprecation?” Shopify periodically deprecates older API versions. A maintained app vendor handles this as part of their product; a custom connector needs someone actively responsible for keeping pace, or it risks breaking silently when an old API version is retired.
- “What’s our realistic exit plan if we need to switch approaches later?” Neither path should be treated as permanent, knowing roughly what it would take to migrate from an app to custom, or vice versa, is worth understanding upfront rather than discovering under pressure later.
A Practical Evaluation Checklist
- [ ] Document your actual required data flows (orders, inventory, customers, pricing) and how standard vs custom each one is
- [ ] Check whether a mature, well-reviewed app exists for your specific ERP
- [ ] Test sync volume/frequency requirements against a candidate app’s documented limits
- [ ] Model total cost of ownership for both paths over a 2-3 year horizon, not just initial setup
- [ ] Assess your realistic in-house capacity to maintain a custom connector, or budget for contracted maintenance
- [ ] Consider a hybrid approach if only one or two requirements are genuinely non-standard
When to Bring in a Specialist
This decision is much easier to get right with someone who’s actually built both paths and seen where each breaks down at scale. If you’re weighing this up for your store, Nexly’s Shopify ERP integration work covers both off-the-shelf app configuration and custom connector builds, and we’ll tell you honestly which one your specific requirements actually justify.
FAQ
Is a custom ERP connector always better than an app?
No. For standard data flows and well-supported ERPs, an app is usually faster, cheaper and lower-risk. Custom builds earn their cost when your requirements genuinely diverge from what apps support, not by default.
How much more expensive is a custom ERP connector than an app?
It varies enormously based on scope and ERP complexity, so avoid trusting any generic number, the more useful exercise is comparing total cost of ownership for your specific requirements over a multi-year horizon, not just comparing an app’s subscription fee to a headline development quote.
What happens if the ERP app I’m using gets discontinued?
This is a genuine risk with any third-party app dependency. It’s worth checking an app’s update history and vendor stability before committing, and having a contingency plan (migration path to another app, or a custom build) rather than assuming indefinite support.
Can I switch from an app-based integration to a custom connector later?
Yes, and it’s a reasonably common path, many merchants start with an app while validating their process, then move to custom once volume or complexity justifies the investment. Plan for this as a possible future step rather than a one-time irreversible decision.
Do custom ERP connectors need ongoing maintenance?
Yes. Both Shopify’s API and most ERPs evolve over time, and a custom connector needs someone responsible for keeping it working through those changes, either in-house or via a contracted support arrangement.
Not sure which path fits your ERP setup?
If you want a straight answer on whether an app or a custom connector makes sense for your specific ERP and data model, book a call with Nexly and we’ll walk through your requirements before recommending either path.
