Shopify to Legacy ERP: Integration Without the Nightmare

When Your Shopify Store Outgrows Spreadsheets (But Your ERP Is Ancient)

A retail operations manager rang me last month, slightly panicked. They'd moved their sales online to Shopify during lockdown—brilliant move, revenue up 180%. But now? Their team was manually copying orders into a 15-year-old ERP system. Every. Single. Day.

Three hours of copying and pasting. Every morning. And that's when things went well.

Stock levels were wrong. Orders got missed. The warehouse was furious. Finance couldn't reconcile anything. The MD was asking why they couldn't just "make the systems talk to each other."

Sound familiar?

Here's the thing: connecting Shopify to legacy ERP systems isn't rocket science. But the advice you'll get from most vendors? It's either "rip everything out and start fresh" (terrifying and expensive) or "just use our middleware platform" (which costs more per month than your hosting).

I've spent the last few years helping retailers like you bridge this exact gap. Not with million-pound projects. With practical integration that works.

The Real Problem Nobody Talks About

Your Shopify store is modern, cloud-based, with a lovely REST API. Your ERP? It's probably one of these:

• Sage 50 or Sage 200
• An old version of SAP Business One
• A custom Access database someone built in 2008
• Epicor, Syspro, or another mid-market system that predates smartphones
• Something even more obscure that "works perfectly fine, thank you very much"

These systems weren't designed for e-commerce. They were designed when "online ordering" meant sending a fax.

The conventional wisdom? You've got three options:

1. Replace the ERP entirely. Sure, let me just find 18 months and convince the finance director to sign off on a project that'll disrupt the entire business. Easy.

2. Buy expensive middleware. Platforms like Celigo or Jitterbit work brilliantly—if you've got the budget and technical team to support them. Most small retailers don't.

3. Keep doing it manually. Which is what you're doing now, and it's killing you.

Here's what I've learned: there's usually a fourth option. And it's cheaper, faster, and less risky than any of those.

What Actually Works for Real Businesses

I'm not going to pretend there's one magic solution. Every legacy system is its own special snowflake of pain. But I've found patterns that work across most Shopify ERP integration projects.

The Pragmatic Integration Ladder

Start simple. Add complexity only when you need it.

Level 1: Structured Export/Import

Before you write a single line of code, see if you can get 80% of the way there with better exports.

Shopify lets you export orders as CSV. Your ERP probably has some kind of import function (even if it's hidden in a menu nobody uses). Recently worked with a fashion retailer who went from 3 hours of manual entry to 20 minutes of import processing. That's an 85% time saving for basically zero cost.

Yes, it's still manual. But it's structured manual work. Less error-prone. Auditable. And it buys you time to build something better.

Level 2: Scheduled Automation

This is where most of my clients end up. A small application that runs every 15 minutes:

1. Pulls new orders from Shopify's API
2. Transforms the data into whatever format your ERP needs
3. Pushes it in via CSV import, ODBC connection, or direct database access
4. Updates Shopify with tracking numbers when orders ship

Not real-time. But for most retailers? You don't need real-time. You need reliable.

One of my clients processes about 200 orders a day through a system like this. It's been running for two years with minimal intervention. Saved them roughly 25 hours a week compared to manual entry. That's more than half a full-time employee.

Level 3: Real-Time Webhooks

When you actually need instant updates—maybe you're doing drop-shipping or you've got multiple sales channels fighting over the same inventory—webhooks are worth the added complexity.

Shopify fires a webhook the moment something happens. Your middleware catches it and processes immediately. I've built systems that update stock levels across Shopify, Amazon, and eBay within seconds of a sale. Works brilliantly when you've only got one of each item.

But here's the thing: webhooks fail. Networks drop. Your server goes down for maintenance. You need retry logic, queue management, error handling. It's more sophisticated, which means more things can break.

Only go here if you actually need it.

A Real Example (Without Breaking Confidentiality)

Last year I worked with a home goods retailer. They'd been on Shopify for three years but still running their warehouse and purchasing through Sage 200.

Their pain points:

• 15-20 hours per week manually entering orders
• Stock levels were "best guess" most of the time
• Returns were a complete nightmare—nothing matched up
• Finance spent two days at month-end reconciling everything

Their IT budget? Not huge. They'd got quotes from integration platforms that would've cost them more per year than their Shopify subscription. Didn't make sense.

Here's what we built:

A Python application (could've been Node.js or PHP—doesn't really matter) that runs on a small cloud server. Every 10 minutes it:

1. Checks for new Shopify orders
2. Validates them (catches missing postcodes, invalid phone numbers, etc.)
3. Writes them directly to Sage 200's SQL database using their documented schema
4. Pulls fulfilment updates from Sage
5. Updates Shopify with tracking information
6. Handles returns by creating credit notes

We also built a simple dashboard so their operations team could see what was syncing, catch any errors, and manually retry failed orders.

Results after six months:

• Order entry time reduced by 90%
• Stock accuracy went from "terrible" to 98%+
• Month-end reconciliation dropped from 2 days to 3 hours
• Paid for itself in about 4 months through time savings alone

Not perfect. There are edge cases they still handle manually—custom orders, B2B pricing, that sort of thing. But it eliminated the soul-crushing daily grind.

How to Actually Build This (Technical Bit)

Right, let's get practical. Here's what a basic Shopify to ERP integration looks like.

Step 1: Understand Both Systems

Shopify's API is well-documented and relatively pleasant to work with. Your ERP? That's the challenge.

Questions I always ask:

• Does it have an API? (Many older systems don't)
• Can you access the database directly? (SQL Server, Oracle, MySQL?)
• Does it have import/export functions?
• What's the data schema? (This is usually the hard part)

For Sage 200, I typically connect directly to the SQL database. For Sage 50, it's trickier—you might need to use their ODBC driver or work with CSV imports. For really old systems, sometimes you're writing directly to text files that get batch-imported.

Step 2: Map the Data

This is where most projects get stuck. Shopify calls it a "variant." Your ERP calls it a "SKU" or "stock code" or "item number." They need to match.

I usually create a mapping table:

# Simple example of data transformation
def transform_shopify_order_to_erp(shopify_order):
    erp_order = {
        'customer_code': get_or_create_customer(shopify_order['customer']),
        'order_ref': f"WEB-{shopify_order['order_number']}",
        'order_date': shopify_order['created_at'],
        'lines': []
    }
    
    for item in shopify_order['line_items']:
        erp_order['lines'].append({
            'sku': map_shopify_sku_to_erp(item['sku']),
            'quantity': item['quantity'],
            'price': item['price'],
            'vat_code': determine_vat_code(item)
        })
    
    return erp_order

Nothing fancy. Just boring, reliable transformation logic.

Step 3: Handle the Edge Cases

This is what separates integration that works from integration that breaks at 2am.

• What happens if the SKU doesn't exist in your ERP?
• What if the customer's address is invalid?
• What if Shopify is down when you try to update tracking?
• What if someone manually edits an order in both systems?

I always build in:

Error logging - Everything goes to a log file. When something breaks (and it will), you need to know what happened.

Retry logic - Network blip? Try again in 5 minutes. Don't just fail and forget about it.

Manual intervention queue - Some orders will need human review. That's fine. Make it easy for your team to see them and fix them.

Idempotency - If you process the same order twice, it shouldn't create duplicates. Check if it already exists before inserting.

Step 4: Test the Hell Out of It

Create test orders in Shopify. Lots of them:

• Normal orders
• Orders with multiple items
• Orders with discounts
• Orders with custom options
• Returns and exchanges
• Cancelled orders

Watch them flow through. Check they arrive correctly in your ERP. Verify the numbers match. Do this for weeks before you trust it with real orders.

The Gotchas I've Learned the Hard Way

VAT is a nightmare. Shopify and your ERP probably handle VAT differently. You might need to back-calculate VAT-exclusive prices from Shopify's VAT-inclusive totals. Fun times.

Shopify's inventory management is optional. Some stores track inventory in Shopify, some don't. If you're syncing stock levels both ways, you need to be really careful about race conditions.

Customer matching is harder than you think. Same person orders with slightly different email addresses. Or different billing addresses. Or they've got an account in your ERP but checked out as a guest in Shopify. You need logic to handle this.

Shipping costs. Does your ERP track shipping as a line item? A separate charge? Part of the order total? This causes more problems than it should.

Currency and rounding. If you're dealing with multiple currencies, or if Shopify and your ERP round differently, your totals might be off by a penny. Finance will notice.

Order amendments. Customer emails to change their order after it's placed. Now it's been modified in Shopify but already pushed to your ERP. How do you handle that?

None of these are insurmountable. But they're all things that'll bite you if you don't plan for them.

When This Approach Doesn't Work

Let's be honest about limitations.

Don't do this if:

• Your ERP is so locked down you literally can't access the data. Some cloud ERPs are like this. You're stuck with their integration options.

• You need sub-second inventory updates across dozens of channels. At that scale, you probably need proper middleware or a more sophisticated architecture.

• Your team has zero technical capability and no budget to hire anyone. You need someone who can troubleshoot when things break.

• You're planning to replace your ERP in the next 6 months anyway. Just limp along with manual processes until the new system is in.

Also consider alternatives if:

• Your ERP vendor offers integration that actually works and isn't extortionately priced. Sometimes the official option is fine.

• You're already using a platform like Zapier or Make (Integromat) for other automations and they support both your systems. Might be worth the subscription.

• You've got complex B2B requirements, multiple price lists, custom workflows. At some point the custom code becomes harder to maintain than a proper integration platform.

Quick FAQ From Real Conversations

Q: How long does this typically take to build?

For a basic order sync? 4-6 weeks from start to finish, including testing. More complex requirements—multiple warehouses, B2B pricing, custom workflows—might take 8-12 weeks.

Q: What if our ERP doesn't have an API?

Most don't. I usually work directly with the database (if it's SQL-based) or use ODBC connections. Worst case, we generate import files that your ERP can batch process.

Q: Can we do this in-house?

If you've got a developer who understands APIs and databases? Absolutely. The technical challenges aren't that complex. It's more about understanding both systems and handling all the edge cases.

Q: What about stock levels going back to Shopify?

Yep, that's usually part of it. The integration pulls current stock from your ERP and updates Shopify. How often depends on your needs—every 15 minutes is typical, but some clients do hourly.

Q: What happens when something breaks?

Good question. You need monitoring. I usually set up email alerts for errors and a simple dashboard showing sync status. Most issues are caught within an hour.

Q: Can we add more channels later?

That's the beauty of this approach. Once you've got the ERP integration working, adding Amazon or eBay is just another data source. The hard part—getting data into your ERP—is already solved.

This Isn't About Technology, Really

Here's what I've learned after years of doing this: the technology is rarely the hard part.

The hard part is understanding your business processes well enough to automate them. It's getting your product data clean. It's deciding what happens when something goes wrong.

I've seen companies spend a fortune on fancy integration platforms and still struggle because they never sorted out their basic data quality. I've seen others succeed with what's essentially a clever Python script because they took the time to understand what they actually needed.

Your Shopify store and your legacy ERP can absolutely work together. You don't need to replace everything. You don't need to spend a fortune on enterprise middleware.

You just need a pragmatic approach and someone who's willing to get their hands dirty with the details.

If you're wrestling with this right now—trying to figure out how to connect your e-commerce to systems that predate the iPhone—I'd be happy to chat. No sales pitch, just a conversation about what might actually work for your situation.

Because honestly? I'm tired of seeing retailers spend money on solutions they don't need when something simpler would work just fine.

Drop me a line: callum@stirlingjones.co.uk

Let's talk about what's actually possible for your business.