Legacy Systems Master Data Management

How to Integrate Legacy Systems With Master Data Management

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 assumptionLegacy reality
The source publishes its schemaThe schema is a copybook, with REDEFINES variants selected by a code in the record
Attributes are typed and nullablePacked decimals, fixed-length padded text, and spaces or zeros standing in for null
Each source has one write pathOnline screens, nightly loaders, and interface jobs all update the same record
Validation can be read from constraintsValidation lives in IF and EVALUATE logic across many programs
The source can accept write-back through an APIUpdates must go through programs that apply the rules, not around them
Change events are availableChanges 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.

StepArtifactLegacy-specific work
1. Choose the styleStyle decision per domain and sourceMatch style to what each legacy source can accept
2. Locate master data in codeMaster attribute mapRead copybooks, REDEFINES, key structures, and code sets
3. Find every writer and readerAuthority mapInventory batch loaders and branches that depend on code values
4. Extract and convert safelyConversion rules and reject countsHandle EBCDIC, COMP-3, sentinel nulls, and layout variants
5. Match and surviveMatch rules and survivorship policyResolve identity across files with different keys
6. Synchronize both waysSync design with loop preventionWrite back through sanctioned programs, not around them
7. Prove and governKPIs and change controlRe-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.

StyleWhat the hub doesWhat the legacy source must supportRisk
RegistryLinks records across sources; data stays putRead access onlyLow
ConsolidationCopies, matches, and merges into a hub; sources are not updatedExtracts or change captureMedium
CoexistenceSyncs golden records back while sources keep authoringA safe write path and change-origin trackingHigh
CentralizedRecords are created and edited only in the hubRetirement or rewiring of legacy create and edit pathsHighest

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.

AttributeWritersReadersWhat the readers do with it
CUST-STATUS4: online maintenance, dormancy batch, fraud hold, migration loader3811 branch on the code values with EVALUATE
CUST-COUNTRY2: online maintenance, address feed26Compare against two-letter codes to select tax and regulatory rules
PERS-LAST-NM3: online maintenance, KYC import, name-change batch41Display, matching, statement printing
ORG-REG-NO1: online maintenance9Regulatory 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 constructHub representationTrap
PIC 9(8) date, YYYYMMDDISO dateZeros or 99999999 used as a sentinel for unknown
COMP-3 packed decimalDecimal with the declared scaleMapped to floating point, losing exactness
EBCDIC textUTF-8Code page errors on national characters
Spaces or zeros as nullExplicit nullBlank values counted as populated
88-level code setsReference data with a mapping tableValues with no mapping silently dropped
REDEFINES variantsSubtype entitiesLayout applied without checking the discriminator
Fixed-length padded namesTrimmed stringsPadding 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.

PatternDirectionLatencyLegacy impactCaution
Batch extract and loadSource to hubHours to a dayLowMisses intraday changes
Log-based change captureSource to hubSeconds to minutesLow to mediumCaptures the hub’s own write-back unless tagged
Queue or API front doorHub to sourceSecondsMediumRequires a wrapper around the sanctioned program
Event mirrorSource to hub and consumersSecondsMediumNeeds 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.

MeasureWhat it shows
Golden record coverageShare of source records linked to a golden record; published guidance suggests targets in the high nineties
Duplicate rate before and afterWhether matching is doing its job
Unmapped code valuesLegacy values with no hub mapping
Steward queue ageWhether uncertain matches are being resolved
Sync lagTime between a change and its arrival
Write-back reject rateShare of hub updates the sanctioned program refuses
Reconciliation breaksDifferences 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.

FailureCausePrevented by
Hub values break legacy branchesStandardized values that readers do not recognizeStep 3 reader analysis; map vocabulary at the front door
Sync loopsNo change-origin taggingStep 6 origin tags
Direct writes bypass validationHub writes to files or tables directlyStep 6 sanctioned entry points
Wrong layout loadedREDEFINES discriminator never profiledStep 2 discriminator coverage
Golden values overwritten overnightUnlisted batch loadersStep 3 writer inventory
Precision lossCOMP-3 mapped to floating pointStep 4 conversion rules
Orphan master recordsDead programs and files counted as live sourcesDead 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 needEvidenceCapability
Master attribute mapLayouts, REDEFINES variants, code sets, keysEnterprise search
Authority mapWriters, readers, copybook sharersApplication dependency mapping
Unlisted batch writersJobs and programs that update master recordsJCL expansion and job mapping
Validation and derivation rulesRule logic in programsStatic code analysis and ASK AI
Live-source scopeDead and unreferenced codeLegacy modernization analysis
Vocabulary and copybook change effectsPrograms and feeds affectedStructural impact analysis
Steward and engineer questionsSource-linked answers in plain languageASK 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.