ERP Integration with Shopify B2B: NetSuite, SAP, and Beyond

Why ERPs Are Non-Negotiable for B2B at Scale

A Shopify B2B store without ERP integration is a data silo. You're managing inventory in NetSuite, fulfillment in your warehouse system, and customer pricing in Shopify—but none of them talk.

The result: oversold inventory, duplicate orders, manual reconciliation nightmares, and customer support nightmares. A enterprise brand selling $50M+ annually can't afford data inconsistency. One mispricied customer contract or oversold SKU can cost $100K in emergency fixes.

The winning architecture is simple: Shopify B2B as the storefront + ERP as the source of truth for inventory, orders, and financials. Real-time synchronization between them.

The Architecture Pattern That Works at Enterprise Scale

Most ERP-to-Shopify integrations fail because they don't model the data flow correctly. Here's the pattern that survives at scale:

Direction of flow:

System	Role	Direction	Why
ERP (NetSuite, SAP, Infor)	System of record	Source of truth	Single source of inventory, pricing, GL
Shopify B2B	Customer interface	Source of customer data	Best UX for wholesale, subscription, pricing tiers
Integration Layer (middleware)	Sync orchestrator	Bidirectional (with guards)	Prevents data corruption, enforces business rules

Data flow:

• Inventory: ERP → Shopify B2B (push every 15-30 min or webhook-driven)
• Pricing/Contracts: ERP → Shopify B2B (push on contract change)
• Orders: Shopify B2B → ERP (push in real-time, with validation)
• Fulfillment/Invoice: ERP → Shopify B2B (push on shipment/invoice)

Critical rule: Never let Shopify be the source of truth for inventory. If you oversell a SKU in Shopify, the ERP will correct it—and customers get angry. Instead, pull inventory from ERP every 15 minutes and update Shopify. If a customer orders when inventory is between syncs, your order validation catches the overage and rejects it.

Integration Pattern 1: Synchronous (REST API)

Best for: Mid-market B2B ($10M-$100M revenue), low-frequency updates (pricing, contracts)

Synchronous integration pulls data on demand. Example: You update a customer contract in NetSuite. The integration polls the ERP REST API, detects the change, and updates Shopify customer data and pricing tiers.

Implementation:

ERP API Polling (every 30 min)
  ↓
Middleware (Lambda, Node, Python)
  ↓
Shopify Admin GraphQL API
  ↓
Update customer metafields, pricing, tiers

Pros:

• Simple to implement
• Works with most ERPs (NetSuite, SAP, Infor have REST APIs)
• Easy to debug and monitor

Cons:

• Polling adds latency (30-60 min delay is common)
• Doesn't scale to high-frequency changes
• Inefficient for inventory (wastes API calls checking unchanged data)

Use case: NetSuite → Shopify customer pricing updates (happens once per quarter for most contracts).

Integration Pattern 2: Event-Driven (Webhooks + Message Queue)

Best for: Enterprise B2B ($100M+ revenue), real-time inventory, high order volume

Event-driven architecture uses webhooks and message queues to push changes immediately. When inventory changes in SAP, SAP pushes an event to your middleware. The middleware validates and updates Shopify in real-time.

Implementation:

ERP Webhook (on inventory change)
  ↓
Message Queue (RabbitMQ, AWS SQS)
  ↓
Middleware (with retry logic, DLQ for failures)
  ↓
Shopify Admin API
  ↓
Update inventory, product availability

Pros:

• Real-time (sub-second latency)
• Scales to millions of events/day
• Reduces API polling overhead
• Built-in retry logic prevents data loss

Cons:

• More complex to implement
• Requires webhook support in ERP (not all have it)
• Monitoring and debugging require better tooling

Use case: SAP → Shopify B2B inventory sync for high-turnover electronics retailer.

Integration Pattern 3: Batch ETL (For Historical Data & Reconciliation)

Best for: Legacy ERPs, large data migrations, daily reconciliation

Batch ETL runs nightly (or weekly) to reconcile Shopify against the ERP and fix inconsistencies. This is your safety net—even if real-time sync fails, daily batch catches errors.

Implementation:

Daily Batch Job (2 AM EST)
  ↓
Extract from ERP (inventory, orders from last 24h)
  ↓
Transform (validate, enrich with Shopify IDs)
  ↓
Load into Shopify (upsert inventory, create missing orders)
  ↓
Log discrepancies (oversells, mismatched orders) → alert ops team

Pros:

• Handles legacy ERPs with poor API support
• Catches sync failures automatically
• Generates reconciliation reports

Cons:

• Not real-time (24h lag)
• Expensive for large datasets (API rate limits)
• Requires careful upsert logic to avoid duplicates

Use case: Oracle ERP → Shopify daily reconciliation. Catches missed orders and inventory drift.

The Data Models You Need

1. Inventory Sync Model

SKU → Warehouse Location → Quantity on Hand
          ↓                      ↓
    Shopify Location      Shopify Inventory Level

Key fields:
- ERP SKU (source of truth)
- Shopify Product ID (lookup via metafield)
- Warehouse code (maps to Shopify location)
- Available qty
- Reserved qty (in-transit orders)
- Safety stock threshold
- Last sync timestamp

Always maintain a mapping table (ERP SKU ↔ Shopify Product ID). If this breaks, you'll have data orphans and manual reconciliation nightmares.

2. Customer & Pricing Model

ERP Customer ID → Customer Tier → Pricing Tier
       ↓                               ↓
Shopify Customer ID           Shopify Metafield (pricing rules)

Key fields:
- ERP customer ID
- Shopify customer ID
- Customer tier (Platinum, Gold, Standard)
- Contract start/end date
- Negotiated discounts
- Minimum order qty
- Payment terms (Net 30, Net 60)

Store pricing as Shopify metafields (not product prices). This lets you apply tier-based pricing at checkout without duplicating price data.

3. Order Mapping Model

Shopify Order ID → ERP Sales Order ID → Invoice ID
       ↓                ↓                    ↓
Shopify Order      SAP SO               NetSuite Invoice

Key fields:
- Shopify order number
- ERP sales order ID
- ERP invoice number
- Order date
- Fulfillment date
- Invoice date
- Sync status (pending, synced, failed)

Link orders bidirectionally so you can look up an ERP order from Shopify (for support) and vice versa (for reconciliation).

Common Integration Pitfalls (and How to Avoid Them)

Pitfall 1: Overselling Due to Sync Lag

Problem: Shopify shows 10 units. Customer orders 8. Meanwhile, ERP sync hasn't run yet. Inventory is actually 3 units. Customer gets angry when you can't ship.

Solution:

• Pull real-time inventory before accepting orders (synchronous check)
• Set safety stock thresholds in Shopify (if Shopify shows 10 but ERP says 3, pad the difference)
• Reject orders that violate real-time ERP inventory

Pitfall 2: Duplicate Order Sync

Problem: Network hiccup causes Shopify to send the same order twice to the ERP. Customer gets two shipments.

Solution:

• Use idempotent order IDs (Shopify order number + timestamp hash)
• Check for duplicates in middleware before pushing to ERP
• Implement deduplication logic: if order already exists in ERP, skip

Pitfall 3: Pricing Tier Conflicts

Problem: Customer has contract pricing in ERP (25% discount) but Shopify is showing list price. Customer checks out at wrong price.

Solution:

• Store all customer pricing in Shopify metafields (derived from ERP)
• Apply pricing overrides at checkout, not in product prices
• Sync contract changes within 5 minutes of ERP update
• Log all pricing mismatches to support team

Pitfall 4: Inventory Reconciliation Failures

Problem: Shopify says 100 units, ERP says 50. You don't know which is right. Manual audit takes 4 hours.

Solution:

• Run daily batch reconciliation (ERP is always source of truth)
• Generate exception reports (oversells, missing orders)
• Implement automated corrections (sync always wins)
• Audit logs for compliance

Integration Tools & Platforms

Tool	Best For	Pros	Cons
Tenten Custom Build	Enterprise ($250K+), complex logic	Built for your exact needs, ownership, scaling	High cost, long timeline, requires maintenance
Zapier / Make	Low-code, simple syncs	No-code, quick setup, affordable	Limited by platform features, slow, not real-time
Durable / Workato	Mid-market, complex workflows	More advanced than Zapier, good UI	Expensive per transaction, vendor lock-in
Built-in Shopify Flow	Basic automation	Native, no extra cost	Very limited for ERP sync
Custom Node/Lambda + REST APIs	Developers, custom requirements	Maximum flexibility, cost-effective at scale	Requires engineering resources

For most enterprise B2B, you'll end up with custom integration (option 5) because ERPs are too unique and business rules too specific for off-the-shelf tools.

Article FAQ

Q: How long does an ERP-Shopify integration take?

Depends on complexity. Simple inventory sync (NetSuite → Shopify) with 500 SKUs: 4-8 weeks. Full integration (inventory, orders, pricing, fulfillment) with custom business logic: 12-16 weeks. Always budget extra time for ERP API documentation (it's often incomplete) and data cleanup.

Q: What happens if the integration breaks?

You have a safety net: (1) Batch reconciliation catches orphaned data within 24 hours. (2) Monitoring alerts notify ops if sync fails. (3) Manual sync procedures (Shopify CLI, Zapier) can push/pull data while fixes are in progress. Design for failures upfront.

Q: Should I sync Shopify orders back to the ERP in real-time?

Yes. Within 5 minutes of order placement. This gives your fulfillment team immediate visibility. Delay causes out-of-stocks and customer support issues. The order sync is usually the highest-priority path in your integration.

Q: How do I handle returns and refunds?

ERP is source of truth. When a return is processed in your WMS/fulfillment system, it flows → ERP → Shopify. Don't process refunds in Shopify first (you lose the audit trail). Process in ERP, then sync to Shopify.

Q: What about customer pricing negotiations that happen outside the contract?

Store them in ERP as contract amendments, with effective dates. Sync to Shopify metafields. Never let sales or customer success people manually override prices in Shopify—it breaks reconciliation. All pricing changes must flow through ERP.

---

Key Takeaways

• ERP is your source of truth. Shopify is the customer interface. Middleware is the orchestrator. Never reverse this hierarchy.
• Real-time is better than batch, but batch is your safety net. Combine event-driven sync for live data with daily batch reconciliation for error detection.
• Inventory is the most critical path. Get this right first. Overselling kills customer relationships. Sync inventory every 15-30 minutes minimum.
• Data mapping tables prevent orphans. Maintain ERP SKU ↔ Shopify Product ID mapping, customer mapping, and order mapping. This is your recovery tool.
• Monitoring catches failures early. Alert on sync latency, failed orders, oversells, and pricing mismatches. Ops team needs visibility.

Call to Action

ERP integration is complex, but it's non-negotiable for B2B scale. Getting it wrong costs six figures in manual reconciliation, lost orders, and customer churn.

Contact Tenten to design and build your ERP-Shopify integration. We've architected integrations for Fortune 500 retailers, and we'll build yours for your exact tech stack and business model.

---

Author Perspective

We've debugged dozens of broken ERP integrations. The pattern is always the same: someone tried to take a shortcut, overlooked a data edge case, or didn't understand how their ERP API actually works. The ones that work at scale are built with discipline: clear data models, idempotent operations, and comprehensive monitoring.