---
# === IDENTITY ===
id: business/retail-transformation/retail-erp-to-commerce-integration/2026
canonical_question: "How do I actually integrate a retail ERP (Oracle Retail, SAP S/4HANA, NetSuite, Dynamics 365) with a commerce platform (Shopify, Adobe Commerce, BigCommerce, commercetools)?"
aliases:
  - "retail ERP ecommerce integration step by step"
  - "NetSuite Shopify integration implementation guide"
  - "SAP Retail Adobe Commerce integration recipe"
  - "Oracle Retail ecommerce middleware setup"
  - "ERP to commerce platform data sync execution"
  - "retail backend commerce connection implementation"
entity_type: execution_recipe
domain: business > retail-transformation > Retail ERP-to-Commerce Integration
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === VERIFICATION ===
last_verified: 2026-03-11
confidence: 0.88
version: 2.0
first_published: 2026-03-09

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: evolving
  last_breaking_change: "Shopify API version 2025-07 changed GraphQL fulfillment endpoints; Celigo released NetSuite-Shopify B2B template requiring updated bundle; SAP S/4HANA connector for Adobe Commerce added BTP-based data flows"
  next_review: 2026-09-07
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "System of record must be defined per data entity BEFORE integration design — ambiguity causes circular overwrite loops that corrupt data silently"
  - "Data mapping is the most underestimated task — retailers discover 30-50% more field mapping requirements during implementation than anticipated"
  - "Pre-built connectors handle 60-80% of use cases but require customization for retail-specific workflows (complex promotions, multi-location returns, consignment)"
  - "Test with production-volume data, not samples — integration working at 100 orders/day often breaks at 10,000 orders/day due to rate limits and queue saturation"
  - "Budget 15-20% of initial implementation cost annually for ongoing integration maintenance — APIs change, schemas update, business requirements evolve"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs a unified commerce strategy, not technical integration execution"
    use_instead: "business/retail-transformation/unified-commerce-roadmap/2026"
  - condition: "User needs POS technology selection before integration"
    use_instead: "business/retail-transformation/pos-modernization-decision-framework/2026"
  - condition: "User needs CX maturity assessment before planning integration"
    use_instead: "business/retail-transformation/customer-experience-maturity-assessment/2026"
  - condition: "User needs ERP selection guidance, not integration of an existing ERP"
    use_instead: "business/erp-selection/erp-selection-master-decision-tree/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: erp_system
    question: "Which retail ERP system is in use?"
    type: choice
    options:
      - "Oracle NetSuite"
      - "SAP S/4HANA Retail"
      - "Oracle Retail (Merchandising, Xstore)"
      - "Microsoft Dynamics 365 Commerce"
      - "Infor CloudSuite Retail"
      - "Other / custom ERP"
  - key: commerce_platform
    question: "Which commerce platform needs to be integrated?"
    type: choice
    options:
      - "Shopify / Shopify Plus"
      - "Adobe Commerce (Magento)"
      - "BigCommerce"
      - "commercetools (headless)"
      - "Salesforce Commerce Cloud"
      - "Custom / headless commerce"
  - key: integration_approach
    question: "What is the preferred integration approach?"
    type: choice
    options:
      - "iPaaS middleware (Celigo, Workato, Boomi)"
      - "Native connectors / pre-built integrations"
      - "Custom API integration"
      - "Unsure — need guidance"
  - key: technical_skill
    question: "What is the team's technical capability?"
    type: choice
    options: ["non-technical (need turnkey)", "semi-technical (can configure iPaaS)", "developer team (can build custom)"]
  - key: budget_for_tools
    question: "What's the integration budget?"
    type: choice
    options: ["$10K-$50K (pre-built connector)", "$50K-$200K (iPaaS with customization)", "$200K+ (custom API development)"]

# === EXECUTION METADATA ===
execution:
  required_inputs:
    - name: "Current systems inventory"
      source: "IT team / existing documentation"
      format: "document"
    - name: "ERP schema documentation"
      source: "ERP vendor or internal admin"
      format: "structured data"
    - name: "Commerce platform schema"
      source: "Commerce platform documentation"
      format: "structured data"
    - name: "Business requirements document"
      source: "Business stakeholders"
      format: "document"
  outputs:
    - name: "System of record matrix"
      format: "spreadsheet"
      description: "Data ownership assignments per entity (product, inventory, order, customer, pricing, fulfillment) with directional flow rules"
    - name: "Field mapping document"
      format: "spreadsheet"
      description: "Complete field-by-field mapping between ERP and commerce with transformation rules, data types, and validation constraints"
    - name: "Integration architecture decision"
      format: "document"
      description: "Selected approach (native connector, iPaaS, custom API) with vendor, cost projection, and timeline"
    - name: "Working integration with monitoring"
      format: "configured platform"
      description: "Deployed integration syncing inventory, orders, products, customers, and fulfillment with error handling, alerting, and dashboards"
  tools_required:
    - name: "Celigo"
      purpose: "iPaaS for NetSuite-Shopify/BigCommerce integration"
      tier: "paid"
      cost: "$16,500-$19,600/year"
      alternatives: ["Workato", "Boomi", "Jitterbit"]
    - name: "SAP Integration Suite / BTP"
      purpose: "iPaaS for SAP S/4HANA integrations"
      tier: "enterprise"
      cost: "$50,000-$150,000/year"
      alternatives: ["MuleSoft", "APPSeCONNECT", "Alumio"]
    - name: "Shopify Admin API"
      purpose: "Commerce platform API for product, order, inventory operations"
      tier: "paid"
      cost: "Included with Shopify Plus ($2,300+/mo)"
      alternatives: ["Adobe Commerce API", "BigCommerce API", "commercetools API"]
    - name: "PostHog / Datadog"
      purpose: "Integration monitoring and error tracking"
      tier: "free"
      cost: "$0 (free tier) to $200+/mo"
      alternatives: ["Grafana", "New Relic"]
  credentials_needed:
    - service: "ERP system"
      type: "API key or OAuth token"
      where_to_get: "ERP admin console (NetSuite: Setup > Integration > Token-Based Auth)"
      free_tier_limits: "N/A — requires active ERP license"
    - service: "Commerce platform"
      type: "API key"
      where_to_get: "Commerce admin (Shopify: Settings > Apps > Develop Apps)"
      free_tier_limits: "N/A — requires active commerce subscription"
    - service: "iPaaS platform"
      type: "OAuth or API key"
      where_to_get: "iPaaS vendor signup (e.g., celigo.com)"
      free_tier_limits: "Most iPaaS platforms do not offer free tiers for production use"
  estimated_duration: "4-24 weeks depending on approach (pre-built: 4-8 weeks, iPaaS: 8-16 weeks, custom: 12-24 weeks)"
  estimated_cost: "$10,000 (basic connector) to $500,000+ (custom enterprise API development)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/retail-transformation/retail-erp-to-commerce-integration/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-11)"

# === RELATED UNITS ===
related_kos:
  depends_on: []
  feeds_into:
    - id: "business/retail-transformation/unified-commerce-roadmap/2026"
      label: "Unified commerce strategy that relies on working ERP-commerce integration"
  related_to:
    - id: "business/retail-transformation/pos-modernization-decision-framework/2026"
      label: "POS modernization often requires parallel ERP-commerce integration"
    - id: "business/retail-transformation/retail-omnichannel-implementation/2026"
      label: "Omnichannel implementation depends on accurate cross-system data sync"
  alternative_to: []

# === SOURCES ===
sources:
  - id: src1
    title: "ERP Integration Tools in 2025: iPaaS, APIs & Real Use Cases Explained"
    author: Code Rapper
    url: https://coderapper.com/article/erp%E2%80%91supply%E2%80%91chain/erp-integration-tools-for-ecommerce/
    type: technical_blog
    published: 2025-04-15
    reliability: high
  - id: src2
    title: "Top 9 eCommerce Integration Solutions 2026"
    author: DCKAP
    url: https://www.dckap.com/blog/ecommerce-integration-solutions/
    type: technical_blog
    published: 2026-01-10
    reliability: high
  - id: src3
    title: "Retail ERP: Key Features, Benefits, Challenges & Platforms"
    author: iTransition
    url: https://www.itransition.com/erp/retail
    type: technical_blog
    published: 2025-06-01
    reliability: high
  - id: src4
    title: "NetSuite Shopify Integration: Complete Technical Guide"
    author: Houseblend
    url: https://www.houseblend.io/articles/netsuite-shopify-integration-technical-guide
    type: technical_blog
    published: 2025-10-01
    reliability: high
  - id: src5
    title: "Magento ERP Integration: Data mapping, Sync cadence, and Failure handling"
    author: Eduonix
    url: https://blog.eduonix.com/2026/03/magento-erp-integration-guide/
    type: technical_blog
    published: 2026-03-01
    reliability: high
  - id: src6
    title: "ERP Integration: What It Is and How It Works (2025)"
    author: Shopify
    url: https://www.shopify.com/enterprise/blog/erp-integration
    type: official_docs
    published: 2025-08-01
    reliability: authoritative
  - id: src7
    title: "ERP Integration with eCommerce: 2026 Guide"
    author: Centium
    url: https://centium.net/blog/erp-integration-with-ecommerce-2026-guide
    type: technical_blog
    published: 2026-01-15
    reliability: high
  - id: src8
    title: "SAP S/4HANA meets Adobe Commerce — Connector"
    author: TechDivision
    url: https://www.techdivision.com/en/newsroom/sap-s-4hana-connector
    type: official_docs
    published: 2025-06-01
    reliability: high
---

# Retail ERP-to-Commerce Integration Recipe

## Purpose

This recipe produces a working, monitored integration between a retail ERP system (Oracle NetSuite, SAP S/4HANA, Oracle Retail, Dynamics 365) and a commerce platform (Shopify, Adobe Commerce, BigCommerce, commercetools) — synchronizing product data, inventory levels, pricing, orders, customer records, and fulfillment status. It outputs a system of record matrix, complete field mapping document, deployed integration with error handling, and monitoring dashboards — within 4-24 weeks at $10K-$500K depending on complexity. Retailers that complete this integration report 25-40% reduction in stockouts, 80-95% elimination of manual data entry errors, and 70% faster order processing. [src7]

## Prerequisites
<!-- Agents: verify ALL prerequisites before executing. Missing prerequisites = failed execution. -->

- [ ] **Current systems inventory** — document listing all systems (ERP, commerce, WMS, POS, CRM) with versions, API capabilities, and current data flows
- [ ] **ERP schema documentation** — field-level documentation from ERP vendor or admin (NetSuite: Records Catalog; SAP: data dictionary; Dynamics: entity reference)
- [ ] **Commerce platform schema** — API documentation (Shopify: Admin API reference; Adobe Commerce: REST/GraphQL docs; BigCommerce: API v3 docs)
- [ ] **Business requirements document** — data flows needed (which entities, which direction, what frequency), edge cases (multi-warehouse, returns, promotions), and volume projections
- [ ] **ERP API credentials** — Token-Based Authentication in NetSuite, OAuth in SAP BTP, Azure AD in Dynamics 365
- [ ] **Commerce API credentials** — Custom app in Shopify (Settings > Apps > Develop Apps), Integration tokens in Adobe Commerce
- [ ] **Sandbox environments** — both ERP and commerce must have sandbox/staging environments available for testing

## Constraints
<!-- Hard rules. Agents: enforce throughout execution. Violating these = broken output or legal risk. -->

- Every data entity must have exactly one system of record — bidirectional sync without clear ownership creates circular overwrite loops that corrupt data silently. A retailer syncing customer data between NetSuite and Shopify without ownership lost 40% of customer addresses to overwrites. [src3]
- Data mapping phase must be completed before any development begins — retailers discover 30-50% more field mapping requirements during implementation than anticipated. Budget 2-4 weeks minimum. [src1]
- Shopify enforces strict API rate limiting (roughly 2-4 calls/second REST, 50 points/second GraphQL). NetSuite uses governance units. Both require queuing and retry logic for high-volume syncs. [src4]
- Test with production-volume data before go-live. Integration working at 100 orders/day often breaks at 10,000 orders/day due to rate limits, timeout issues, and queue saturation. [src3]
- Payment data must be tokenized for PCI compliance. Customer PII requires encryption in transit. Leaked API keys expose sensitive financial records. [src4]
- During peak promotional periods, batch-based sync delays can result in 5-8% oversold orders — plan sync frequency for peak, not average load. [src7]

## Tool Selection Decision

<!-- Agent selects the right tool path based on user inputs.
     Each path leads to a different execution flow below. -->

```
Which path?
├── NetSuite + Shopify/BigCommerce AND budget $10K-$50K
│   └── PATH A: iPaaS Pre-Built — Celigo NetSuite-Shopify connector
├── SAP S/4HANA + Adobe Commerce AND budget $50K-$200K
│   └── PATH B: SAP BTP + Connector — TechDivision SAP S/4HANA connector or APPSeCONNECT
├── Any ERP + Any Commerce AND budget $50K-$200K
│   └── PATH C: General iPaaS — Workato, Boomi, or MuleSoft with custom flows
└── Complex multi-system / headless / high-volume AND budget $200K+
    └── PATH D: Custom API — dedicated development team with event-driven architecture
```

| Path | Tools | Cost | Speed | Output Quality |
|------|-------|------|-------|---------------|
| A: iPaaS Pre-Built | Celigo + NetSuite + Shopify | $16.5K-$20K/yr + $5K-$15K implementation | 4-8 weeks | High — covers standard product, order, inventory, customer flows |
| B: SAP BTP + Connector | SAP Integration Suite + Adobe Commerce connector | $50K-$150K/yr + $30K-$80K implementation | 8-16 weeks | High — enterprise-grade with SAP ecosystem alignment |
| C: General iPaaS | Workato/Boomi/MuleSoft + custom flows | $20K-$100K/yr + $30K-$100K implementation | 8-16 weeks | High — flexible across any ERP-commerce combination |
| D: Custom API | Custom development + event bus (Kafka/RabbitMQ) | $200K-$500K+ build + $40K-$100K/yr maintenance | 12-24 weeks | Excellent — handles any complexity, scales to millions of transactions |

## Execution Flow

### Step 1: Build System of Record Matrix

**Duration**: 3-5 days
**Tool**: Spreadsheet (Google Sheets / Excel)

Interview business stakeholders and IT to assign ownership for every data entity. For each entity, determine: which system creates it, which system is the master, and which direction data flows. [src3]

```
System of Record Matrix Template:

| Data Entity          | System of Record | Direction           | Sync Frequency  | Conflict Rule              |
|----------------------|------------------|---------------------|-----------------|----------------------------|
| Product catalog      | ERP              | ERP → Commerce      | Batch (30 min)  | ERP always wins            |
| Product images       | Commerce         | Commerce → ERP      | Batch (daily)   | Commerce always wins       |
| Inventory levels     | ERP/WMS          | ERP → Commerce      | Near-RT (5 min) | ERP always wins            |
| Base pricing         | ERP              | ERP → Commerce      | Batch (30 min)  | ERP always wins            |
| Promotional pricing  | Commerce         | Commerce → ERP      | Event-driven    | Commerce owns promotions   |
| Orders               | Commerce         | Commerce → ERP      | Real-time       | Commerce creates, ERP fulfills |
| Customer records     | Commerce         | Commerce → ERP      | Real-time       | Commerce owns acquisition  |
| Fulfillment status   | ERP/WMS          | ERP → Commerce      | Real-time       | ERP owns warehouse ops     |
| Returns/refunds      | Commerce         | Bidirectional       | Real-time       | Initiating system wins     |
| Loyalty points       | ERP/CRM          | ERP → Commerce      | Near-RT (5 min) | ERP/CRM is master          |
```

**Verify**: Every data entity has exactly one system of record assigned. No "TBD" or "both" entries remain. Stakeholders have signed off.
**If failed**: If stakeholders disagree on ownership, escalate to executive sponsor. Do not proceed to Step 2 with ambiguous ownership — it will cause overwrite loops in production.

### Step 2: Complete Field-Level Data Mapping

**Duration**: 2-4 weeks
**Tool**: Spreadsheet + ERP/Commerce API documentation

Map every field that flows between systems. Include data type, transformation rules, validation constraints, and handling for null/missing values. Pay special attention to structural mismatches — Shopify product variants do not directly map to NetSuite Matrix Items. [src4]

```
Field Mapping Document Template:

| Source System | Source Field          | Target System | Target Field        | Transform Rule                           | Required | Notes                              |
|---------------|-----------------------|---------------|---------------------|------------------------------------------|----------|-------------------------------------|
| NetSuite      | item.internalId       | Shopify       | product.id          | Map via SKU lookup table                 | Yes      | NetSuite IDs ≠ Shopify IDs         |
| NetSuite      | item.displayName      | Shopify       | product.title       | Direct map, truncate to 255 chars        | Yes      |                                     |
| NetSuite      | item.basePrice        | Shopify       | variant.price       | Convert currency if multi-currency       | Yes      | Ensure 2 decimal places             |
| NetSuite      | quantityAvailable     | Shopify       | inventory_level.available | Subtract safety stock buffer (10%)  | Yes      | Buffer prevents overselling         |
| Shopify       | order.id              | NetSuite      | salesOrder.otherRefNum | Prefix with "SHOP-"                  | Yes      | Prevents ID collision               |
| Shopify       | order.line_items[]    | NetSuite      | salesOrder.item[]   | Map variant SKU → NetSuite item          | Yes      | Handle bundles separately           |
| Shopify       | order.shipping_lines  | NetSuite      | salesOrder.shipMethod | Lookup table: Shopify method → NS method | Yes     | Default to "Standard" if no match   |
| Shopify       | order.tax_lines       | NetSuite      | salesOrder.taxTotal | Overwrite NS tax with Shopify tax        | Yes      | Shopify is tax system of record     |
```

Test each mapping with real data from both systems. Flag any fields where formats differ (dates, currency, enum values, multi-select).

**Verify**: Mapping document covers all entities from Step 1 matrix. Every field has a transformation rule. No "TBD" entries remain. Sample data from both systems validates each mapping.
**If failed**: If more than 20% of fields lack clear mapping rules, extend the mapping phase by 1-2 weeks. Do not start development with incomplete mappings — it is the #1 cause of integration failure. [src1]

### Step 3: Select and Configure Integration Platform

**Duration**: 1-2 weeks
**Tool**: Selected iPaaS or development environment

Based on the Tool Selection Decision above, set up the integration platform. Create dedicated integration user accounts with minimal required permissions — never use personal admin credentials in production. [src4]

**Path A (Celigo + NetSuite + Shopify):**
```
1. Install Celigo integrator.io bundle in NetSuite
   - Setup > Company > Enable Features > SuiteCloud > SuiteBundler
   - Install Celigo bundle (search for "integrator.io" in Bundle Repository)

2. Install Celigo Shopify-NetSuite integration app
   - In Celigo: Marketplace > Search "Shopify-NetSuite"
   - Connect Shopify store (Admin API key from Settings > Apps > Develop Apps)
   - Connect NetSuite (Token-Based Auth: create integration record + token)

3. Configure data flows:
   - Products: NetSuite → Shopify (batch, every 30 min)
   - Inventory: NetSuite → Shopify (scheduled, every 5-15 min)
   - Orders: Shopify → NetSuite (real-time via webhooks)
   - Customers: Shopify → NetSuite (real-time with order)
   - Fulfillment: NetSuite → Shopify (scheduled, every 15 min)

4. Map locations: NetSuite locations → Shopify locations (1:1 or many:1)
5. Map shipping methods: Shopify methods → NetSuite ship methods
6. Map payment methods: Shopify payments → NetSuite payment methods
```

**Path B (SAP BTP + Adobe Commerce):**
```
1. Provision SAP Integration Suite on SAP BTP
2. Install SAP S/4HANA connector for Adobe Commerce (TechDivision or APPSeCONNECT)
3. Configure OData/BAPI connections to SAP S/4HANA
4. Set up Adobe Commerce REST/GraphQL integration tokens
5. Map data flows via SAP BTP Integration Designer
```

**Verify**: Integration platform connected to both systems. Test connection returns successful authentication. Sample API calls to both ERP and commerce return expected data.
**If failed**: If authentication fails, verify API credentials and user permissions. For NetSuite, ensure Token-Based Authentication is enabled (Setup > Company > Enable Features > SuiteCloud). For Shopify, verify API scopes include read/write for products, orders, inventory, customers.

### Step 4: Implement Data Flows with Sync Frequency Rules

**Duration**: 2-6 weeks
**Tool**: iPaaS platform or custom development environment
**Rate limit**: Shopify REST: ~2 calls/sec. Shopify GraphQL: 50 points/sec. NetSuite: governance units per script. Pace requests accordingly.

Build each data flow according to the mapping document and sync frequency from Step 1. Implement in this order — each flow builds on the previous: [src5]

```
Implementation order (dependencies matter):
1. Products       (ERP → Commerce) — foundation for all other flows
2. Inventory      (ERP → Commerce) — depends on product mapping
3. Pricing        (ERP → Commerce) — depends on product mapping
4. Customers      (Commerce → ERP) — independent
5. Orders         (Commerce → ERP) — depends on product + customer mapping
6. Fulfillment    (ERP → Commerce) — depends on order mapping
7. Returns/Refunds (Bidirectional) — depends on order + fulfillment mapping

Sync frequency rules:
- Real-time (webhooks/events): Orders, payment status, inventory critical alerts
- Near-real-time (every 5-15 min): Inventory levels, fulfillment updates
- Batch (every 30-60 min): Product catalog, base pricing, customer data
- Daily batch: Product images, category hierarchies, loyalty balances
```

For each flow, implement:
- **Queue/buffer**: Hold incoming events when target system is temporarily unavailable
- **Retry logic**: Auto-retry failed syncs 3x with exponential backoff (30s, 2min, 10min)
- **Idempotency**: Prevent duplicate orders/invoices from retry storms [src5]
- **Error logging**: Detailed, machine-readable logs for every failed record

**Verify**: Each data flow completes a full round-trip test: create record in source → verify it appears correctly in target → modify in source → verify update propagates.
**If failed**: If a specific flow fails, check field mapping for that entity first. Most failures trace to data type mismatches (date formats, currency precision, null handling) or API rate limits.

### Step 5: Load Test with Production-Volume Data

**Duration**: 1-2 weeks
**Tool**: Load testing framework + monitoring

Simulate peak sales events to validate throughput and identify bottlenecks before go-live. Use real production data (anonymized if needed for PII compliance). [src4]

```
Load test scenarios:
1. Normal day: 500-1,000 orders over 8 hours
   - Expected: All orders sync within 5 minutes
   - Watch for: Queue depth, API error rate, sync lag

2. Flash sale peak: 5,000 orders in 1 hour
   - Expected: Orders queue and process within 30 minutes
   - Watch for: Rate limit errors (429), timeout errors, memory usage

3. Inventory storm: 10,000 SKU updates in 30 minutes
   - Expected: All inventory updates reflected in commerce within 15 minutes
   - Watch for: Stale inventory on storefront (oversell risk)

4. Recovery test: Kill integration mid-sync, restart
   - Expected: No duplicate orders, no lost records, queue resumes
   - Watch for: Idempotency failures, orphaned records

Acceptance criteria:
- Order sync latency: < 5 min (normal), < 30 min (peak)
- Inventory accuracy: > 99% match between ERP and commerce
- Error rate: < 0.5% of transactions
- Zero duplicate orders after recovery
```

**Verify**: All four scenarios pass acceptance criteria. Monitoring dashboard shows real-time sync status, error rates, and queue depth.
**If failed**: If peak scenarios fail, increase queue depth, reduce batch sizes, or add parallel processing workers. If error rate exceeds 1%, review field mappings for the failing entity type.

### Step 6: Deploy to Production with Staged Cutover

**Duration**: 3-7 days
**Tool**: Integration platform + monitoring

Do not switch to live mode all at once. Use a staged cutover to minimize risk. [src4]

```
Staged cutover plan:

Day 1: Historical data sync
- Sync product catalog (full) from ERP → commerce
- Sync customer records (full) from commerce → ERP
- Verify counts match: ERP product count = commerce product count ±1%

Day 2: Inventory alignment
- Freeze inventory updates in one system (brief maintenance window)
- Run full inventory sync from ERP → commerce
- Verify: spot-check 50 SKUs across both systems

Day 3: Enable order flow (shadow mode)
- Orders flow to ERP but are NOT auto-processed
- Operations team manually verifies 20-50 orders match
- If >95% match: proceed. If <95%: pause and fix mappings.

Day 4: Enable order flow (live mode)
- Orders auto-process in ERP
- Enable fulfillment sync (ERP → commerce)
- Monitor: first 100 orders closely, then spot-check

Day 5-7: Enable remaining flows
- Returns/refunds flow
- Promotional pricing sync
- Full monitoring active with alerting
```

**Verify**: All data flows running in production. Error rate < 0.5%. No manual intervention required for standard transactions. Monitoring alerts are firing correctly on test errors.
**If failed**: If error rate exceeds 1% in first 24 hours, pause the failing flow (not all flows) and revert to manual processing for that entity while debugging. Do not roll back the entire integration — isolate the failing component.

### Step 7: Configure Monitoring and Alerting

**Duration**: 2-3 days
**Tool**: iPaaS dashboard + PostHog/Datadog/Grafana

Set up ongoing monitoring to catch issues before they affect customers. Integration is not a one-time project — it requires continuous monitoring. [src2]

```
Monitoring dashboard requirements:
- Sync status per flow (healthy/degraded/down)
- Records processed per hour (with trend)
- Error rate per flow (with threshold alerts)
- Queue depth (with backlog alerts)
- API rate limit utilization (% of limit consumed)
- Last successful sync timestamp per flow

Alert thresholds:
- Error rate > 1% for 15 minutes → Page on-call
- Queue depth > 1,000 records → Warning to Slack
- Any flow not synced in 30+ minutes → Page on-call
- Inventory mismatch > 2% → Warning to operations
- API rate limit > 80% utilization → Warning to engineering
```

**Verify**: Dashboard shows real-time data for all flows. Test alerts fire correctly when thresholds are breached.
**If failed**: If monitoring platform has issues, fall back to iPaaS native monitoring (Celigo has built-in error dashboards) and schedule manual spot-checks twice daily until monitoring is stable.

## Output Schema

<!-- Exact format of the deliverable. Downstream agents and dashboard cards
     reference this schema to consume the output. -->

```json
{
  "output_type": "erp_commerce_integration",
  "format": "configured platform + documents",
  "columns": [
    {"name": "system_of_record_matrix", "type": "spreadsheet", "description": "Data ownership per entity with sync direction and frequency", "required": true},
    {"name": "field_mapping_document", "type": "spreadsheet", "description": "Complete field-level mapping with transformation rules", "required": true},
    {"name": "architecture_decision", "type": "document", "description": "Selected approach, vendor, cost projection, timeline", "required": true},
    {"name": "integration_status", "type": "string", "description": "deployed | testing | failed — current state of the integration", "required": true},
    {"name": "data_flows_active", "type": "number", "description": "Count of data flows running in production (target: 7)", "required": true},
    {"name": "error_rate", "type": "number", "description": "Current error rate as percentage of total transactions", "required": true},
    {"name": "avg_sync_latency_seconds", "type": "number", "description": "Average time from source event to target update", "required": true},
    {"name": "inventory_accuracy_pct", "type": "number", "description": "Percentage match between ERP and commerce inventory", "required": true},
    {"name": "monitoring_url", "type": "string", "description": "URL to integration monitoring dashboard", "required": true}
  ],
  "expected_row_count": "1 (single integration deployment)",
  "sort_order": "N/A",
  "deduplication_key": "erp_system + commerce_platform + environment"
}
```

## Quality Benchmarks

<!-- How to evaluate if the output is good enough.
     Links to benchmark cards where applicable. -->

| Quality Metric | Minimum Acceptable | Good | Excellent |
|---------------|-------------------|------|-----------|
| Order sync latency | < 15 min | < 5 min | < 1 min |
| Inventory accuracy (ERP vs commerce) | > 95% | > 99% | > 99.5% |
| Integration error rate | < 2% | < 0.5% | < 0.1% |
| Data mapping completeness | > 80% fields mapped | > 95% fields mapped | 100% fields mapped |
| Oversell rate during peak | < 5% | < 1% | < 0.1% |
| Manual intervention required | < 5 orders/day | < 1 order/day | 0 orders/day |
| Recovery time from sync failure | < 4 hours | < 1 hour | < 15 min (auto-recovery) |

**If below minimum**: Re-run Step 2 (field mapping) for the failing entity. If error rate is above 2%, the most likely cause is incomplete field mapping or data type mismatches — not infrastructure issues. [src5]

## Error Handling

<!-- Common failures and recovery actions. Agents need this to handle
     execution errors without human intervention. -->

| Error | Likely Cause | Recovery Action |
|-------|-------------|----------------|
| API rate limit exceeded (429) | Too many requests in time window | Reduce batch size; implement exponential backoff (30s, 2min, 10min); for Shopify GraphQL, reduce query complexity below 50 points/sec [src4] |
| Authentication failed (401) | API key expired, token revoked, or permissions changed | Regenerate API credentials; verify integration user account is active; check token-based auth is enabled in ERP |
| Duplicate orders in ERP | Retry logic without idempotency protection | Implement idempotency keys using commerce order ID as dedup key; add check-before-create logic in ERP flow [src5] |
| Inventory mismatch > 5% | Sync lag during peak volume or missed webhook events | Run full inventory reconciliation (batch sync); review webhook delivery logs; increase sync frequency during peak periods |
| Field mapping error (400) | Data type mismatch or missing required field | Check specific field in error response; update transformation rule in mapping document; re-test with sample data |
| Order sync timeout | ERP processing too slow for real-time volume | Switch to async queue-based processing; increase ERP worker threads; batch orders in groups of 10-50 |
| Fulfillment not updating in commerce | Webhook misconfiguration or fulfillment status mapping mismatch | Verify fulfillment webhook URL is correct; check fulfillment status enum mapping (ERP statuses → commerce statuses) |
| Integration platform outage | iPaaS service disruption | Fall back to manual order processing; queue events for replay when service recovers; verify SLA with iPaaS vendor |

## Cost Breakdown

<!-- Real cost analysis so agents can warn users before execution. -->

| Component | Pre-Built ($10K-$50K) | iPaaS ($50K-$200K) | Custom API ($200K-$500K+) |
|-----------|----------------------|---------------------|---------------------------|
| iPaaS/platform license | $16.5K-$20K/yr (Celigo) | $20K-$100K/yr (Workato/Boomi) | N/A (own infrastructure) |
| Implementation labor | $5K-$15K (configuration) | $30K-$100K (custom flows) | $150K-$400K (development) |
| Data mapping phase | $5K-$10K (2-3 weeks) | $10K-$20K (3-4 weeks) | $15K-$30K (4-6 weeks) |
| Load testing | $2K-$5K | $5K-$10K | $10K-$20K |
| Monitoring setup | $0-$2K (built-in) | $2K-$5K | $5K-$15K |
| Annual maintenance | $3K-$5K/yr (15-20% of license) | $10K-$30K/yr | $40K-$100K/yr |
| **Year 1 Total** | **$32K-$57K** | **$77K-$265K** | **$220K-$565K+** |

## Anti-Patterns

### Wrong: Starting development before defining system of record
A retailer begins syncing customer data between NetSuite and Shopify without deciding which system owns the customer record. Both systems update customer addresses, creating circular overwrites. Six months later, 40% of customer records have incorrect addresses — and the root cause is invisible because both systems appear to be "working." [src3]

### Correct: Build the system of record matrix first
Create the matrix in Step 1. Every entity gets exactly one owner. The integration always flows FROM master TO subscriber. If returns need bidirectional flow, define explicit conflict resolution rules (e.g., initiating system wins, most-recent-timestamp wins).

### Wrong: Syncing all data in real-time regardless of business need
A retailer configures real-time sync for product catalog, pricing, inventory, orders, customer data, and fulfillment. The integration costs 3x more than necessary, API rate limits cause throttling during holiday peaks, and the engineering team spends 40% of their time managing rate limit exceptions. [src5]

### Correct: Match sync frequency to business requirement
Real-time: orders, payment status, critical inventory alerts. Near-real-time (5-15 min): inventory levels, fulfillment updates. Batch (30-60 min): product catalog, base pricing, customer data. This reduces API costs by 60-70% with zero customer-facing impact. [src1]

### Wrong: Testing with sample data and declaring ready for production
A retailer tests integration with 50 orders and 100 products. Production launches during a flash sale with 8,000 orders in 2 hours. The integration collapses — API rate limits hit, orders queue for hours, customers receive "in stock" for items that sold out 90 minutes ago. [src4]

### Correct: Load test with production-volume data before go-live
Simulate peak scenarios (Step 5). If the integration cannot handle 5x normal volume, it will fail during the next promotion. Fix throughput issues before they affect customers.

## When This Matters

Use when a retailer needs to actually build and deploy the integration between their ERP and commerce platform — not a strategic document about integration approaches, but the execution steps with specific tools, field mappings, sync patterns, and monitoring. Requires existing ERP and commerce platform as inputs; produces a working, monitored integration as output.

## Related Units

- [Unified Commerce Roadmap](/business/retail-transformation/unified-commerce-roadmap/2026) — broader transformation strategy that depends on working ERP-commerce integration
- [POS Modernization Decision Framework](/business/retail-transformation/pos-modernization-decision-framework/2026) — POS changes often require parallel ERP-commerce integration updates
- [Retail Omnichannel Implementation](/business/retail-transformation/retail-omnichannel-implementation/2026) — omnichannel capabilities depend on accurate cross-system data sync