Customer Master Data Cross-System Sync in Practice: Implementing a Create Strategy from CRM to Kingdee
What this strategy solves
In supply chain integration for a retail enterprise, customer master data is unavoidable. When a store or sales team creates a new customer in CRM, that record must reach the ERP — otherwise subsequent orders, receivables, and reconciliation will all be misaligned.
This guide focuses on one specific scenario: create. A new customer is created in CRM and automatically pushed to the ERP's customer file. It looks simple, but if the code mapping is poorly designed, three months later the two sides will not match, and the business team will open tickets.
Data flow and field mapping
The source is the CRM side, the target is the ERP side, with Qeasy data integration platform handling protocol adaptation and field transformation in the middle.
| Business meaning | Source (CRM) | Middle layer | Target (ERP) |
|---|---|---|---|
| Customer code | Customer number (auto-generated) | Pass through, no rewriting | Customer code (required, primary key) |
| Customer name | Customer name | Pass through | Customer name |
| Customer category | Customer type enum | Centrally managed code mapping | Customer group code |
| Credit limit | Credit limit (numeric) | Pass through, unified unit | Credit limit |
| Default currency | Currency code (CNY) | Standardized to ISO 4217 | Currency code |
| Created at | System timestamp | Convert to ERP timezone | Created date |
Core idea: customer codes pass through from source unchanged; Qeasy does not rewrite them, both sides share one primary key. Enum fields (customer category) are maintained through a centralized mapping table, not hard-coded in scripts.
How to configure on Qeasy
The whole strategy is configured on the Qeasy data integration platform, with three core parts.
1. Source adapter
The source is the CRM's customer object. Set page size to around 200 — pulling too many at once will trigger rate limits. Use the source's created_at field for the incremental start point; set the initial value to a date slightly earlier than the current business date and run a full backfill once.
2. Target adapter
The target is the ERP's customer file create interface. Key configuration:
- Use single-record create mode (do not enable batch), because the ERP side is sensitive to concurrent creates; safer to go one record at a time.
- Failure retry: 3 times, interval 30 seconds, enough to cover typical network jitter.
3. Field mapping and transformation
This is where most pitfalls happen. We recommend splitting mapping into three layers:
- Pass-through layer: name, code, phone, etc., map directly.
- Code mapping layer: enum values such as customer category, currency, industry code — maintain them centrally in Qeasy's "Code Mapping" module, not hard-coded in scripts.
- Derived layer: convert
created_atto ERP timezone, auto-fill organization based on the operator's affiliation.
Implementation steps
We usually go live in three phases to avoid pulling full volume on day one and overwhelming both systems.
Phase 1: Full backfill (before go-live) A one-shot script pushes all historical CRM customers to ERP. After it finishes, manually sample 20 records to verify. Run this as a temporary task in Qeasy, then stop it.
Phase 2: Switch incremental start point (go-live day) Once the full backfill is verified, switch the incremental start point to the go-live timestamp. From that moment, only newly created customers in CRM enter the queue. This strategy's crontab polls every 5 minutes — close to real-time without pressuring the source.
Phase 3: Exception monitoring (first week after go-live) Check the failure queue daily for the first week. Qeasy parks records that cannot be written to ERP into an exception table. The three common causes are: required field empty, duplicate code, organization not authorized. Each needs a fallback handling logic rather than a simple rerun.
Pitfalls we hit in real projects
A few real failures from actual projects, all later written into the customer's runbook.
Pitfall 1: Customer codes generated independently on both sides. The most common mistake. Two sides run two code rules, and three months later they will not match. The safe approach: pass through from CRM unchanged, Qeasy does not rewrite, both sides share one primary key.
Pitfall 2: Enum values hard-coded in scripts. CRM has 8 customer categories, ERP has 12, and the business team may add more at any time. Hard-coded means a script change requires a release. The safe approach: use Qeasy's "Code Mapping" module for centralized management; adding a new value is a click in the UI.
Pitfall 3: Timezones not unified.
CRM is on a public cloud, ERP is in a different timezone. Passing created_at through directly results in a future timestamp. The safe approach: convert once in Qeasy's derived field to ERP timezone.
Pitfall 4: Create and update not separated.
This guide covers create only, but note: if create and update are configured in the same strategy, the update path can easily overwrite dirty data from the create path. The safe approach: split create and update into two independent strategies, with the sequence field clearly marking the order.
Pitfall 5: No checkpoint for the first full backfill. Tens of thousands of customers pulled at once, a network hiccup means starting over. The safe approach: Qeasy's full-volume task natively supports checkpoint resume, but you must ensure the source interface supports segmenting pulls by primary key.
Applicable and not applicable scenarios
Applicable: CRM is the customer master data entry point, ERP is the downstream business system; customer volume within hundreds of thousands; minute-level latency is acceptable.
Not applicable: Customer master data is owned by ERP, CRM only references it; bidirectional sync where both sides modify the same field; customer volume in millions requiring a dedicated intermediate database.