The hub went live with a clean golden record for every customer. One of its rules standardized the country field to the three-letter ISO code, which was the right call for every modern system downstream. Two weeks later, finance noticed that tax amounts were wrong for 31,000 customers. The legacy billing programs compared the country field against two-letter codes. Every standardized value fell through to the WHEN OTHER branch of an EVALUATE statement, and the default tax rate applied. Nothing had failed. The integration had worked exactly as designed, and the design had never looked at the programs that read the data.
Master data management promises one trusted record per business entity. Integration with legacy systems is where that promise meets constraints that modern systems do not impose. Legacy sources often expose no API. Their keys differ from one system to the next. The rules that define what a valid customer is live in program logic rather than in a schema. And they keep writing: batch loaders, online maintenance screens, and interface jobs continue to change the same records the hub is supposed to own.
The integration path below has seven steps, and each one produces an artifact that the next one needs. The legacy-specific work sits in steps two, three, and four, and in the write-back half of step six. Those are the parts that generic MDM roadmaps compress into a line item labeled “connect source systems,” and they are where integrations succeed or fail.
Impact Checks Inside the CAB Meeting
SMART TS XL gives configuration, risk, and architecture teams one code-derived inventory, so the numbers finally agree.
FIND OUT MORE…Why Legacy Integration Is the Hard Part of MDM
Published MDM guidance describes the integration work in similar terms: inventory the source systems, profile them, design the golden record, define matching and survivorship, load the initial data, and synchronize changes. The sequence is sound, and it quietly assumes that the sources can be described and connected with standard tools. Modern sources can. A SaaS CRM publishes its schema, its change events, and its write API. A legacy core publishes none of these. What it offers instead is source code, copybooks, job schedules, and datasets in formats such as VSAM and IMS that standard integration tools handle poorly. Every assumption in the standard roadmap needs a legacy translation. The table pairs each assumption with what the legacy estate actually looks like.
| MDM roadmap assumption | Legacy reality |
|---|---|
| The source publishes its schema | The schema is a copybook, with REDEFINES variants selected by a code in the record |
| Attributes are typed and nullable | Packed decimals, fixed-length padded text, and spaces or zeros standing in for null |
| Each source has one write path | Online screens, nightly loaders, and interface jobs all update the same record |
| Validation can be read from constraints | Validation lives in IF and EVALUATE logic across many programs |
| The source can accept write-back through an API | Updates must go through programs that apply the rules, not around them |
| Change events are available | Changes can only be inferred from logs or batch extracts |
The Seven Steps at a Glance
Each step below produces something the next step cannot proceed without. The table shows the artifact and the legacy-specific work that makes it different from the standard version. The order matters. Choosing a style before locating the data keeps the project honest about what the sources can support. Finding every writer before designing synchronization prevents the loops and overwrites that undermine most coexistence designs. Converting data before matching it prevents the false mismatches that padded text and sentinel values produce. Proving and governing last closes the loop, because a hub that nobody measures decays into one more copy of the data.
| Step | Artifact | Legacy-specific work |
|---|---|---|
| 1. Choose the style | Style decision per domain and source | Match style to what each legacy source can accept |
| 2. Locate master data in code | Master attribute map | Read copybooks, REDEFINES, key structures, and code sets |
| 3. Find every writer and reader | Authority map | Inventory batch loaders and branches that depend on code values |
| 4. Extract and convert safely | Conversion rules and reject counts | Handle EBCDIC, COMP-3, sentinel nulls, and layout variants |
| 5. Match and survive | Match rules and survivorship policy | Resolve identity across files with different keys |
| 6. Synchronize both ways | Sync design with loop prevention | Write back through sanctioned programs, not around them |
| 7. Prove and govern | KPIs and change control | Re-validate mappings when master copybooks change |
The Seven Steps in Detail
The steps are described in order, with a consistent shape for each: the goal, the work, the artifact it produces, and the check that shows it is done. The detail on steps two through four is deliberately heavier than a typical MDM guide, because those steps decide whether the hub can be trusted. Each step also lists the failure it prevents, since the reasons for the order are clearer when the failures are named. Where the legacy work is code analysis, the step says so, because those are the places where a tool that reads source changes how long the step takes. The samples are illustrative, but the patterns are the ones that recur across legacy estates.
Step 1: Choose the Style for Each Domain and Source
Goal. Match the MDM implementation style to what each legacy source can actually support. Four styles are in common use: registry, consolidation, coexistence, and centralized.
Work. Decide the style per domain, and per source when sources differ. The right style is the lowest one that meets the business need, because each step up demands more of the legacy system.
| Style | What the hub does | What the legacy source must support | Risk |
|---|---|---|---|
| Registry | Links records across sources; data stays put | Read access only | Low |
| Consolidation | Copies, matches, and merges into a hub; sources are not updated | Extracts or change capture | Medium |
| Coexistence | Syncs golden records back while sources keep authoring | A safe write path and change-origin tracking | High |
| Centralized | Records are created and edited only in the hub | Retirement or rewiring of legacy create and edit paths | Highest |
Artifact. A style decision per domain and source with the reason recorded.
Check. Every source marked for coexistence or centralized has a confirmed write path, which step three establishes.
Step 2: Locate Master Data in Code
Goal. Find every place the master entity is defined and every attribute it carries, including the variants and code sets that standard profiling cannot see.
Work. For each master entity, such as customer, product, account, or vendor, locate its record layouts in file definitions, copybooks, and database definitions. List attributes with types, valid values, and keys. Capture the REDEFINES variants and the discriminator that selects them.
cobol
01 CUSTOMER-RECORD.
05 CUST-ID PIC 9(10).
05 CUST-TYPE PIC X(1).
88 CUST-PERSON VALUE 'P'.
88 CUST-ORG VALUE 'O'.
05 CUST-STATUS PIC X(2).
88 CUST-ACTIVE VALUE 'AC'.
88 CUST-INACTIVE VALUE 'IN'.
88 CUST-SUSPENDED VALUE 'SU'.
05 CUST-COUNTRY PIC X(2).
05 CUST-OPEN-DATE PIC 9(8).
05 CUST-BODY PIC X(120).
05 CUST-PERSON-DATA REDEFINES CUST-BODY.
10 PERS-LAST-NM PIC X(30).
10 PERS-FIRST-NM PIC X(20).
10 PERS-BIRTH-DT PIC 9(8).
10 FILLER PIC X(62).
05 CUST-ORG-DATA REDEFINES CUST-BODY.
10 ORG-LEGAL-NM PIC X(60).
10 ORG-REG-NO PIC X(20).
10 FILLER PIC X(40).
Three things in this record matter for mastering. CUST-TYPE is the discriminator, and it decides whether the record becomes a person or an organization in the golden record. The 88-level names are the legacy vocabulary for status, and the two-letter country field is a legacy convention that other programs depend on. The same 120 bytes mean different things depending on one character, so any mapping built without the discriminator will load the wrong fields.
Artifact. A master attribute map: attribute, location, type, valid values, and the writers that change it.
Check. Every attribute in the golden record schema traces to at least one source location, and every discriminator value found in real data has a documented layout.
Step 3: Find Every Writer and Every Reader
Goal. Know which programs change each master attribute and which programs depend on its values, before a single sync is designed.
Work. Run where-used analysis on every attribute in the map. Classify each program: online maintenance that applies validation, batch loaders, interface feeds, utilities, and read-only consumers. Mark the sanctioned entry points, meaning the programs that enforce the rules, and any program that writes the field directly. Then examine the readers for branches that depend on specific values.
| Attribute | Writers | Readers | What the readers do with it |
|---|---|---|---|
| CUST-STATUS | 4: online maintenance, dormancy batch, fraud hold, migration loader | 38 | 11 branch on the code values with EVALUATE |
| CUST-COUNTRY | 2: online maintenance, address feed | 26 | Compare against two-letter codes to select tax and regulatory rules |
| PERS-LAST-NM | 3: online maintenance, KYC import, name-change batch | 41 | Display, matching, statement printing |
| ORG-REG-NO | 1: online maintenance | 9 | Regulatory reporting |
The CUST-COUNTRY row is the opening story in one line. A hub that standardizes values without knowing that 26 programs compare against two-letter codes will break all 26. The fix is a choice to be made deliberately: keep the legacy vocabulary at the integration boundary, or change the readers, which is a larger project.
Artifact. An authority map: for each attribute, its writers, its sanctioned entry point, and its readers with their value dependencies.
Check. Unknown writers equal zero before any write-back is enabled. A writer discovered after go-live will overwrite golden values without anyone noticing.
Step 4: Extract and Convert Safely
Goal. Move legacy values into the hub without changing their meaning.
Work. Define a conversion rule for each legacy construct and measure rejects instead of silently correcting them. The table lists the constructs that cause most conversion defects.
| Legacy construct | Hub representation | Trap |
|---|---|---|
| PIC 9(8) date, YYYYMMDD | ISO date | Zeros or 99999999 used as a sentinel for unknown |
| COMP-3 packed decimal | Decimal with the declared scale | Mapped to floating point, losing exactness |
| EBCDIC text | UTF-8 | Code page errors on national characters |
| Spaces or zeros as null | Explicit null | Blank values counted as populated |
| 88-level code sets | Reference data with a mapping table | Values with no mapping silently dropped |
| REDEFINES variants | Subtype entities | Layout applied without checking the discriminator |
| Fixed-length padded names | Trimmed strings | Padding breaks equality comparisons |
Artifact. Conversion rules with reject counts by rule.
Check. A round trip on a sample reproduces the legacy value for every attribute, and every reject has a cause recorded.
Step 5: Match and Survive
Goal. Decide which records represent the same real-world entity and which attribute value wins when they disagree.
Work. Legacy sources identify the same customer with different keys, so identity has to be resolved on attributes. Standardize first, then generate candidates with deterministic rules, then apply probabilistic matching to near misses, and route the uncertain band to a steward.
sql
-- Deterministic candidates across two staged legacy customer tables
SELECT a.cust_id AS key_in_custmstr,
b.holder_id AS key_in_acthld,
a.birth_dt,
a.postal_norm
FROM stg_custmstr a
JOIN stg_acthld b
ON UPPER(TRIM(a.last_nm)) = UPPER(TRIM(b.last_nm))
AND a.birth_dt = b.birth_dt
AND a.postal_norm = b.postal_norm
WHERE a.cust_type = 'P';
Survivorship decides each attribute individually. A policy written down as configuration is reviewable, and it makes the vocabulary decision from step three explicit.
yaml
survivorship:
status:
rule: most_authoritative_source
order: [online_maintenance, dormancy_batch, migration_loader]
fallback: most_recent_update
legal_name:
rule: most_authoritative_source
order: [kyc_system, custmstr, acthld]
country:
rule: standardize_then_most_recent
vocabulary: iso_3166_alpha2 # legacy programs compare two-letter codes
birth_date:
rule: majority_vote
conflict_action: send_to_steward
Artifact. Match rules, thresholds, and a survivorship policy with a fallback for every attribute.
Check. The steward queue is staffed, and a sample of auto-merged pairs has been reviewed for false merges.
Step 6: Synchronize in Both Directions
Goal. Keep the hub and the legacy sources consistent without loops and without bypassing legacy rules.
Work. Pick the transport for each direction. Hub-bound changes come from batch extracts or from log-based change capture. Source-bound changes are the hard half, and they follow one principle: write through the sanctioned program, never around it. The table summarizes the common patterns.
| Pattern | Direction | Latency | Legacy impact | Caution |
|---|---|---|---|---|
| Batch extract and load | Source to hub | Hours to a day | Low | Misses intraday changes |
| Log-based change capture | Source to hub | Seconds to minutes | Low to medium | Captures the hub’s own write-back unless tagged |
| Queue or API front door | Hub to source | Seconds | Medium | Requires a wrapper around the sanctioned program |
| Event mirror | Source to hub and consumers | Seconds | Medium | Needs every writer feeding the stream |
Writing directly to a VSAM file or a DB2 table bypasses the validation, auditing, and downstream triggers that the sanctioned program applies. Writing through it keeps the legacy rules in force and keeps responsibility where it already lies. A change-origin tag stops loops: when the hub writes to a source, the change capture that follows is marked as hub-originated and the hub ignores it.
Hub golden record update
|
v
Integration layer: maps hub vocabulary to legacy vocabulary, tags change origin as HUB
|
v
Sanctioned entry point: online maintenance program (applies validation and audit)
|
v
VSAM or DB2 master record
|
v
Change capture: hub ignores any change tagged origin = HUB, so no ping-pong loop
Each attribute needs one owner at a time, recorded in the authority map from step three. Two systems that both author an attribute with no declared owner will overwrite each other, and the hub will have made the problem faster, not smaller.
Artifact. A synchronization design with transport, ownership, conflict rule, and loop prevention for every attribute.
Check. A test update from each side propagates once, in the right direction, with the right vocabulary, and does not echo.
Step 7: Prove It and Keep It True
Goal. Show that the integration works and keep it working as the legacy estate changes.
Work. Track measures that expose decay, and attach change control to the artifacts that the integration depends on.
| Measure | What it shows |
|---|---|
| Golden record coverage | Share of source records linked to a golden record; published guidance suggests targets in the high nineties |
| Duplicate rate before and after | Whether matching is doing its job |
| Unmapped code values | Legacy values with no hub mapping |
| Steward queue age | Whether uncertain matches are being resolved |
| Sync lag | Time between a change and its arrival |
| Write-back reject rate | Share of hub updates the sanctioned program refuses |
| Reconciliation breaks | Differences between hub and source with no cause |
Change control matters as much as measurement. A change to a master copybook changes the layout the mapping was built against, and a new writer changes the authority map. Both should trigger revalidation of the mappings, using the same where-used and impact queries that built them. Moving a domain from coexistence toward a centralized style should follow evidence that its legacy writers have been retired, not a calendar.
Common Failure Modes
Most integration failures repeat. The table lists the recurring ones with their causes and the step that prevents each.
| Failure | Cause | Prevented by |
|---|---|---|
| Hub values break legacy branches | Standardized values that readers do not recognize | Step 3 reader analysis; map vocabulary at the front door |
| Sync loops | No change-origin tagging | Step 6 origin tags |
| Direct writes bypass validation | Hub writes to files or tables directly | Step 6 sanctioned entry points |
| Wrong layout loaded | REDEFINES discriminator never profiled | Step 2 discriminator coverage |
| Golden values overwritten overnight | Unlisted batch loaders | Step 3 writer inventory |
| Precision loss | COMP-3 mapped to floating point | Step 4 conversion rules |
| Orphan master records | Dead programs and files counted as live sources | Dead code identification in step 2 |
Frequently Asked Questions
Which MDM style should we use with legacy systems? The lowest style that meets the business need. Registry or consolidation suits sources that cannot safely accept updates. Coexistence needs a safe write path and loop prevention, and centralized needs the legacy create and edit paths to be retired.
Do we need change data capture? For near-real-time consolidation, usually yes. Batch extracts suit daily or slower needs. Whichever you choose, tag hub-originated changes so write-back does not echo.
Can the hub write directly to a VSAM file or DB2 table? It can, but it should not. Direct writes bypass the validation and auditing the legacy programs apply. Write through the program that already enforces the rules.
Why match after conversion instead of before? Padding, sentinel values, and code page differences produce false mismatches. Converting and standardizing first gives the matcher clean inputs.
How does MDM relate to a data catalog? The catalog documents what data exists and how it flows. The hub resolves and maintains the trusted record. For legacy sources, the catalog and the hub both depend on the same code-derived attribute and lineage facts.
How SMART TS XL, ASK AI, and the MCP Connector Support Legacy MDM Integration
SMART TS XL supplies the structural evidence behind steps two through four and the legacy half of step six, and its ASK AI and MCP Connector capabilities decide how many people on the integration team can use that evidence.
Enterprise search across languages locates master attributes across source libraries, copybooks, and database definitions, which builds the master attribute map. Application dependency mapping returns the writers, readers, and programs sharing each copybook, which is the authority map. JCL expansion and job mapping resolves the batch loaders and interface jobs that update master records and the order in which they run, which is how unlisted writers are found. Static code analysis surfaces the validation and derivation logic in the programs, which is the real mastering logic the hub has to respect or replace. Legacy modernization analysis identifies dead code and unreferenced files so they are not treated as live sources. Structural impact analysis shows what a change to the hub vocabulary or to a master copybook will reach.
ASK AI over verified context lets integration engineers and data stewards ask these questions in plain language against a scoped result set of the actual programs, copybooks, tables, and jobs. A request such as which programs update the customer status and which branch on its values, which jobs and programs touch the customer file, or every validation rule that applies to the country field becomes an input to the authority map or the survivorship policy. Findings stay linked to source lines, so a steward who disputes a rule can open the code behind it, and saved prompts let the same questions be rerun whenever a master copybook changes. The SMART TS XL MCP Connector makes the same answers available inside approved assistants such as ChatGPT, Claude, Copilot, Gemini, and Grok, so an integration engineer can ask which programs compare the country field to a two-letter code without leaving the tool they already use. Access is read-only, authenticated, and role-based.
| Integration need | Evidence | Capability |
|---|---|---|
| Master attribute map | Layouts, REDEFINES variants, code sets, keys | Enterprise search |
| Authority map | Writers, readers, copybook sharers | Application dependency mapping |
| Unlisted batch writers | Jobs and programs that update master records | JCL expansion and job mapping |
| Validation and derivation rules | Rule logic in programs | Static code analysis and ASK AI |
| Live-source scope | Dead and unreferenced code | Legacy modernization analysis |
| Vocabulary and copybook change effects | Programs and feeds affected | Structural impact analysis |
| Steward and engineer questions | Source-linked answers in plain language | ASK AI and the MCP Connector |
Three boundaries keep expectations accurate. SMART TS XL is not an MDM hub. It does not match, merge, or store golden records, run change capture, or perform the synchronization. It supplies the structural evidence the integration design depends on. Its analysis is structural, so dynamic calls and runtime configuration are flagged for review, and profiling of actual data values is done with data profiling tools. And decisions about style, vocabulary, and survivorship remain with the data owners, who now have a verified account of what the legacy side does.
The Hub Is the Easy Part. The Legacy Writers Are the Project.
The hub in the opening story was built correctly. Its matching was sound, its survivorship rules were reasoned, and its standardized values were the right values by any modern standard. What it lacked was a list of the programs that read the data, and that list was in the code the whole time.
Integrating legacy systems with master data management is mostly the work of finding out what those systems do: where the master data lives, who changes it, who depends on its values, and what rules guard it. Do that first, and the rest of the project is ordinary MDM engineering. Skip it, and the hub becomes one more writer in an estate that already has too many, with the added distinction of being the one nobody told the legacy programs about.


