Master Data Management Across ERPs: Golden Record, Survivorship Rules & Sync Patterns

TL;DR

• Bottom line: Cross-ERP MDM requires a dedicated MDM hub (Informatica, Reltio, Profisee, or SAP MDG) that creates golden records via match/merge, enforces attribute-level survivorship rules, and synchronizes changes back to source ERPs through event-driven or batch integration. No ERP can serve as the MDM hub for another ERP's master data.
• Key limit: Survivorship must be configured per attribute, not per record — record-level survivorship discards valuable data from non-winning sources and is the #1 implementation mistake. [src2]
• Watch out for: Bidirectional sync without conflict resolution. If two ERPs update the same customer address simultaneously, the last-write-wins race condition corrupts the golden record. [src1]
• Best for: Organizations running 2+ ERP systems (SAP + Salesforce, Oracle + NetSuite, D365 + legacy) that need consistent customer, vendor, or product master data across all systems.
• Implementation timeline: Single-domain consolidation: 3-6 months. Multi-domain coexistence: 12-18 months. Enterprise-wide centralized: 18-24+ months. [src6]

System Profile

This card covers cross-ERP Master Data Management — the architecture, survivorship logic, and synchronization patterns needed to maintain a single golden record across multiple ERP and CRM systems. It is platform-agnostic but references the four dominant MDM platforms for concrete implementation details. This card does NOT cover single-system data governance, product information management (PIM), or one-time data migration.

API Surfaces & Capabilities

MDM platforms expose APIs for match, merge, golden record CRUD, survivorship configuration, and event subscription.

ERP-Side API Surfaces for Master Data Sync

Rate Limits & Quotas

MDM Hub Limits

Per-Request Limits

Authentication

Authentication Gotchas

• SAP MDG authentication differs between on-premise (X.509/basic) and cloud (OAuth 2.0) — migration requires credential rearchitecture. [src1]
• Reltio API keys grant full tenant access — use OAuth 2.0 with scoped permissions in production. [src4]
• Informatica IDMC tokens issued per pod — multi-pod deployments need separate auth per region. [src1]

Constraints

• Attribute-level survivorship is mandatory: Record-level survivorship ("trust CRM for everything") loses valuable data. Each attribute must have independent survivorship rules. [src2]
• Match key design determines quality: Poor match keys cause over-merging (false positives) or under-merging (missed duplicates). Requires iterative tuning with sample data. [src3]
• Bidirectional sync requires ownership rules: Without per-attribute data ownership, simultaneous updates create race conditions. [src1]
• Timezone mismatch corrupts temporal data: SAP stores in user timezone, Salesforce in UTC, NetSuite in company timezone. Normalize to UTC at the MDM hub.
• SAP MDG staging workflow adds latency: MDG uses a change request + approval workflow — not suitable for <1s real-time sync without bypassing governance. [src5]
• MDM hub is not an ESB: The hub manages master data (customer, vendor, product). Transaction data should flow through iPaaS/ESB, not the MDM hub.
• Poor source data quality propagates: MDM is not a substitute for source-system data quality — clean data before loading into the hub.

Integration Pattern Decision Tree

START — User needs cross-ERP Master Data Management
├── What's the primary use case?
│   ├── Analytics / reporting only (no writeback needed)
│   │   └── CONSOLIDATION style
│   │       ├── Batch ETL from all ERPs nightly
│   │       ├── Match/merge → golden records
│   │       └── Feed BI/analytics; source ERPs unchanged
│   ├── Cross-reference lookup (which records match across systems?)
│   │   └── REGISTRY style
│   │       ├── MDM hub as index/cross-reference only
│   │       ├── Minimal disruption, fast deployment
│   │       └── WARNING: Rarely viable in production — data quality stays poor
│   ├── Operational sync (golden records used in real-time operations)
│   │   ├── Can you designate one hub as sole master data author?
│   │   │   ├── YES → CENTRALIZED style (18-24+ months, most disruptive)
│   │   │   └── NO → COEXISTENCE style (most common enterprise pattern)
│   │   │       ├── MUST define per-attribute ownership rules
│   │   │       └── MUST implement conflict resolution before go-live
│   │   └── How many data domains?
│   │       ├── Single domain → 3-6 months
│   │       ├── 2-3 domains → 9-12 months
│   │       └── Enterprise-wide → 12-18+ months
│   └── Hybrid (different styles per domain)
│       ├── Customer data → coexistence (operational)
│       ├── Product data → consolidation (analytics)
│       └── Vendor data → centralized (procurement-owned)
├── Which MDM platform?
│   ├── SAP-heavy landscape → SAP MDG (native integration)
│   ├── Multi-vendor, cloud-first → Reltio (<300ms, LLM matching)
│   ├── Enterprise, 100+ sources → Informatica IDMC (300+ connectors)
│   └── Microsoft/Azure stack → Profisee (Azure-native)
└── What middleware for ERP sync?
    ├── SAP CPI → SAP-to-SAP + SAP-to-cloud
    ├── MuleSoft → Multi-vendor, API-led connectivity
    ├── Boomi → Cloud-to-cloud, rapid deployment
    └── Azure Integration Services → Microsoft ecosystem

Quick Reference

Survivorship Rule Types

MDM Architecture Style Comparison

Step-by-Step Integration Guide

1. Assess master data landscape and select MDM style

Map all systems that create or consume master data. For each data domain, identify the current system of record and data quality issues. [src6]

# Inventory: list all systems with master data
# system,domain,records,dup_rate,completeness,api,update_freq,sor
# SAP S/4HANA,vendor,150000,8%,92%,"OData v4, BAPI",real-time,yes
# Salesforce,customer,500000,15%,78%,"REST v62.0, Bulk API",real-time,yes
# NetSuite,customer,200000,12%,85%,"SuiteTalk REST",hourly,no

Verify: Complete system inventory with duplicate rates and data quality scores for each domain.

2. Design match keys and survivorship rules

Define matching criteria (deterministic + probabilistic) and attribute-level survivorship rules before touching any technology. [src2, src3]

# Match key design for Customer domain
match_rules:
  - name: "exact_match"
    type: deterministic
    keys: ["tax_id"]
    action: auto_merge
  - name: "fuzzy_match"
    type: probabilistic
    keys:
      - field: "company_name"
        algorithm: "jaro_winkler"
        threshold: 0.85
    min_score: 0.90
    action: auto_merge

# Survivorship rules
survivorship:
  customer_name:
    rule: source_priority
    priority: [CRM, ERP]
    fallback: most_recent
  billing_address:
    rule: source_priority
    priority: [ERP, CRM]
  email:
    rule: most_recent
    require_valid_format: true
  tax_id:
    rule: source_priority
    priority: [ERP]

Verify: Every attribute in your golden record has an explicit survivorship rule with fallback.

3. Configure MDM hub and initial data load

Deploy the MDM platform, configure match/merge rules, and perform initial bulk load from all source systems. [src1]

# Reltio initial data load via REST API
import requests
RELTIO_BASE = "https://{tenant}.reltio.com/reltio/api/{tenant_id}"
HEADERS = {"Authorization": "Bearer {token}", "Content-Type": "application/json"}

def load_entities_bulk(entities, entity_type="configuration/entityTypes/Customer"):
    BATCH_SIZE = 1000
    for i in range(0, len(entities), BATCH_SIZE):
        batch = entities[i:i + BATCH_SIZE]
        payload = [{"type": entity_type, "attributes": {...}, "crosswalks": [...]} for e in batch]
        resp = requests.post(f"{RELTIO_BASE}/entities", headers=HEADERS, json=payload)
        if resp.status_code == 429:
            sleep(2)  # Rate limit backoff

Verify: GET /entities?filter=crosswalks.type==*&max=1 returns entities with cross-references.

4. Implement ongoing synchronization

Set up event-driven sync between ERP systems and the MDM hub using CDC or Platform Events. [src1, src4]

# Salesforce CDC -> MDM Hub sync
def process_cdc_event(event):
    changed_fields = event["payload"]["ChangeEventHeader"]["changedFields"]
    delta_payload = {field: event["payload"][field] for field in changed_fields if field in FIELD_MAP}
    mdm_client.update_entity(crosswalk=("Salesforce", event["recordId"]), attributes=delta_payload)

Verify: Update a record in Salesforce, wait <5s, verify golden record in MDM hub reflects the change.

5. Implement conflict resolution and data stewardship

Configure automated and manual conflict resolution for bidirectional sync scenarios. [src1, src2]

# Conflict detection: competing updates within 60s window
def resolve_conflict(golden_record, update_a, update_b, survivorship_rules):
    for attr in conflicting_attrs:
        rule = survivorship_rules.get(attr)
        if rule["rule"] == "source_priority":
            # Higher-priority source wins
        elif rule["rule"] == "most_recent":
            # Newer timestamp wins
        else:
            create_stewardship_task(golden_record["id"], attr)  # Manual review

Verify: Simulate a conflict — update same customer in two ERPs within 60s. Confirm survivorship resolves or creates stewardship task.

Code Examples

Python: Bulk entity load with cross-references

# Input:  Source system extracts (JSON) from SAP, Salesforce, NetSuite
# Output: Golden records created in MDM hub with cross-references
import requests
from time import sleep

def load_entities_bulk(entities, base_url, headers, batch_size=1000):
    results = {"created": 0, "matched": 0, "errors": 0}
    for i in range(0, len(entities), batch_size):
        batch = entities[i:i + batch_size]
        resp = requests.post(f"{base_url}/entities", headers=headers, json=batch)
        if resp.status_code == 200:
            r = resp.json()
            results["created"] += r.get("created", 0)
            results["matched"] += r.get("matched", 0)
        elif resp.status_code == 429:
            sleep(2)
            continue
        else:
            results["errors"] += len(batch)
    return results

cURL: Test match API

# Input:  OAuth token, entity attributes to match
# Output: List of potential duplicate entities with match scores

curl -X POST "$RELTIO_BASE/entities/match" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "configuration/entityTypes/Customer",
    "attributes": {
      "Name": [{"value": "Acme Corporation"}],
      "PostalCode": [{"value": "10001"}]
    }
  }' | jq '.potentialMatches[] | {uri, score, attributes.Name}'
# Expected: Array of match candidates with scores 0.0-1.0

Data Mapping

Cross-ERP Field Mapping Reference (Customer Domain)

Data Type Gotchas

• Datetime timezone mismatch: SAP stores in user timezone; Salesforce always UTC; NetSuite in company timezone. Normalize all to UTC at the MDM hub. [src1]
• Currency storage: SAP stores in smallest currency unit (cents); Salesforce and NetSuite store as decimal. Convert at sync time.
• Address structure: SAP uses structured addresses (separate street, house number). Salesforce uses freeform. Use address standardization service at the hub.
• Null vs. empty string: SAP returns initial values ("00000000" for empty dates); Salesforce returns null. Treat as equivalent "no data" in survivorship. [src2]

Error Handling & Failure Points

Common Error Patterns

Failure Points in Production

• Match key drift: Keys degrade as data patterns change. Fix: Quarterly match key effectiveness reviews; monitor false positive/negative rates. [src3]
• Survivorship rule gaps: New attributes added without survivorship config — defaults to last-writer-wins. Fix: Alert on attributes without explicit rules; block new field sync until rules defined. [src2]
• Connector version mismatch: MDM connector expects API v61 but ERP upgraded to v62. Fix: Pin connector versions; test in sandbox after every ERP upgrade. [src1]
• Bulk load timeout: Initial load of 5M+ records times out. Fix: Load in 100K batches; disable real-time matching during load; batch match/merge after. [src1]
• Data steward bottleneck: >5% records routed to manual review. Fix: Auto-merge above 0.95, auto-reject below 0.60; manual review only 0.60-0.95. [src2]

Anti-Patterns

Wrong: Record-level survivorship

# BAD — record-level survivorship discards valuable data
survivorship:
  customer_record:
    rule: source_priority
    winner: CRM  # CRM record wins entirely
    # Result: ERP billing address, credit limit, payment terms all lost

Correct: Attribute-level survivorship with fallbacks

# GOOD — each attribute has its own survivorship rule
survivorship:
  customer_name:
    rule: source_priority
    priority: [CRM, ERP]
    fallback: completeness
  billing_address:
    rule: source_priority
    priority: [ERP, CRM]  # ERP owns financial data
  credit_limit:
    rule: source_priority
    priority: [ERP]  # ONLY finance system sets this

Wrong: Point-to-point sync between ERPs

# BAD — N ERPs = N*(N-1)/2 integrations; no golden record
SAP <---> Salesforce (custom sync)
SAP <---> NetSuite (custom sync)
Salesforce <---> NetSuite (custom sync)
# 3 ERPs = 3 integrations; 5 ERPs = 10 integrations

Correct: Hub-and-spoke via MDM platform

# GOOD — N ERPs = N integrations; MDM hub is golden record authority
SAP <-> MDM Hub <-> Salesforce
              |
           NetSuite
# 3 ERPs = 3 integrations; 5 ERPs = 5 integrations

Wrong: Sync full records on every change

# BAD — sends ALL 150+ fields even if only email changed
def sync_to_mdm(salesforce_account):
    mdm_client.upsert_entity(salesforce_account.to_dict())

Correct: Delta sync — only changed fields

# GOOD — only sync changed attributes
def sync_to_mdm(cdc_event):
    changed_fields = cdc_event["changedFields"]
    delta = {f: cdc_event["payload"][f] for f in changed_fields if f in FIELD_MAP}
    mdm_client.update_entity(crosswalk=("Salesforce", cdc_event["recordId"]), attributes=delta)

Common Pitfalls

• Starting with coexistence when consolidation suffices: Many orgs jump to bidirectional sync when they only need analytics-grade golden records. Start consolidation, prove value in 3-6 months, then graduate. [src5]
• Ignoring data quality before MDM: Loading dirty data produces "golden garbage." Invest in source-system cleansing before initial load. [src6]
• Underestimating data steward workload: Plan for 2-5% of records requiring manual review during initial load. Staff stewards before go-live. [src6]
• Single match key strategy: Using only deterministic or only fuzzy matching creates problems. Combine both: deterministic for auto-merge, probabilistic for candidates. [src3]
• Not tracking change origin: Without source-system tagging, bidirectional sync creates infinite loops. Every change event must carry a source_system tag. [src1]
• Treating MDM as a one-time project: MDM is ongoing. Match keys degrade, new systems join, survivorship rules need tuning. Budget for continuous operations. [src6]

Diagnostic Commands

# Check golden record cross-references (Reltio example)
curl -H "Authorization: Bearer $TOKEN" \
  "$RELTIO_BASE/entities/{entity_uri}?options=crosswalks" | jq '.crosswalks'

# Verify survivorship — which source won for each attribute
curl -H "Authorization: Bearer $TOKEN" \
  "$RELTIO_BASE/entities/{entity_uri}?options=sourceValues" | jq '.attributes'

# Check match candidates
curl -X POST "$RELTIO_BASE/entities/match" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type":"configuration/entityTypes/Customer","attributes":{"Name":[{"value":"Acme Corp"}]}}' \
  | jq '.potentialMatches'

# Monitor stewardship queue
curl -H "Authorization: Bearer $TOKEN" \
  "$RELTIO_BASE/tasks?status=OPEN&type=POTENTIAL_MATCH&max=10" | jq '.total'

# Verify sync status — last sync per source
curl -H "Authorization: Bearer $TOKEN" \
  "$RELTIO_BASE/entities?filter=crosswalks.type==configuration/sources/Salesforce&max=1&orderBy=-updatedTime" \
  | jq '.[0].updatedTime'

Version History & Compatibility

When to Use / When Not to Use

Cross-System Comparison

Important Caveats

• MDM platform pricing varies dramatically — Reltio and Informatica typically $200K-$1M+/year for enterprise; Profisee generally lower; SAP MDG included in S/4HANA license but requires implementation services.
• Implementation costs typically exceed software licensing by 2-4x — budget $500K-$2M for multi-domain enterprise MDM including consulting and change management. [src6]
• "92% of businesses admit they have duplicate records" — the problem is universal, but solution complexity varies by organizational maturity. [src6]
• Cloud-native MDM platforms (Reltio, Informatica IDMC) auto-upgrade — survivorship rules and match keys must be regression-tested after each platform update.
• SAP MDG is strongest in SAP-heavy landscapes. For multi-vendor ERP, platform-agnostic MDM (Informatica, Reltio) provides better coverage. [src5]
• Match key effectiveness degrades over time — plan for quarterly reviews and ongoing tuning, not set-and-forget configuration.