From FpML to CDM: How Rosetta’s Data Lineage Delivers Unparalleled Transparency

For financial institutions adopting the Common Domain Model (CDM), mapping existing data into the new standard is only part of the challenge. Just as important is being able to understand how and why that transformation has run.

When a mapping produces an unexpected value, the difficult question is rarely whether something is wrong. The difficult question is why. Which function ran? What data did it receive? Which branch was selected? At what point did the result begin to differ from expectations?

Rosetta Design’s Data Lineage capability helps provide the answer to those questions. 

Rosetta enables teams to map internal data models into the CDM using Rune, creating executable ingestion pipelines from existing source data. Data Lineage adds visibility into that process, showing which functions ran for a particular input, and the data entering and leaving each stage.

In practice, Rosetta becomes a live data tracing tool for a CDM or DRR pipeline, giving teams a faster, evidence-based understanding of how source data becomes a standardised CDM output and eventually a DRR report. 

This is important for firms considering CDM adoption. Existing systems producing FpML, XML or proprietary structures can be mapped into CDM, while Data Lineage makes that transformation visible and testable.

The result supports a more controlled route to safer, cheaper and faster adoption of CDM and DRR.

Making data transformations easier to understand

Even when source messages, final CDM output and mapping logic are all available, connecting the three can be time-consuming. 

Ingestion pipelines may contain nested functions, product-specific branches, object construction and reference resolution. When an unexpected value appears in the final output, teams may need to navigate through mapping functions to reconstruct the possible execution sequence.

The approach can be slow and speculative, because users can spend time investigating functions that never ran for the transaction in question.

Data Lineage simplifies that process by identifying which functions ran, which branches were selected and the exact input and output at each stage. It does not simply show how the model was designed to behave. It shows what happened in a specific execution.

Instead of investigating every piece of logic that could have applied, users can focus immediately on the logic that did apply.

Seeing an FpML-to-CDM transformation in practice

Consider an FpML confirmation containing information about a counterparty, including its identifier and internal reference. Once that message is transformed, the corresponding information appears within the resulting CDM trade structure.

Looking at the source and final output establishes the two ends of the transformation. But implementation questions often concern everything in between.

Why was a particular counterparty role assigned? Where was the party reference created? Which function populated the identifier? If the expected value is missing, did the problem originate in the source data, the mapping logic or a later reference-resolution step?

Data Lineage exposes the executed path through the ingestion pipeline.

A user can select the relevant function and inspect the data entering and leaving that invocation. They can then determine whether the function created, transformed, linked, resolved or simply passed through the value being investigated.

Just as importantly, Data Lineage helps rule out parts of the pipeline.

If a function created a reference relationship but did not populate the identifier itself, the user immediately knows to continue elsewhere in the executed path. An entire area of mapping logic can be excluded without guesswork.

A practical debugging workflow becomes straightforward and available live: start with the unexpected output, follow the executed path, inspect the relevant function boundary and continue until the first unexpected transformation is identified.

Figure 1. The source FpML party and the resulting CDM structure can be compared side by side.



Figure 2. The execution graph narrows the route to MapCounterpartyList and exposes the selected invocation.

Faster mapping validation and implementation support

The ability to inspect run-time behaviour delivers several practical benefits for implementation teams: 

• Faster investigations: Users can focus on the functions involved in a specific transaction rather than unrelated mapping logic.

• Clearer mapping validation: Comparing the exact input and output of each function makes it easier to distinguish between problems originating in source data, mapping logic or later processing.

• Faster onboarding and more self-sufficient users: New users can learn how an ingestion pipeline works by exploring real executions rather than relying solely on hidden code or specialist knowledge.

• Greater confidence: Technical and business stakeholders can see how an output was produced, supporting testing, implementation reviews and sign-off. The result is greater transparency and a faster, evidence-based understanding of data transformation.

Lowering the barrier to CDM adoption

Most organisations are not starting with perfectly standardised data. They already have established FpML messages, internal object models, legacy platforms and established integration patterns.

The practical question is how these existing sources can be transformed into CDM.

Rune DSL provides the mapping logic, while Data Lineage provides the evidence needed to understand and validate it.

Together, they allow firms to retain their existing source landscape while creating an inspectable route into a common model. Teams can validate transformations transaction by transaction, explain outcomes to stakeholders and refine mappings while retaining visibility into where each value originated.

From traceability to practical understanding

Data lineage goes beyond governance and auditability. It also serves as a development tool, an implementation support tool and a learning tool.

For existing Rosetta users, that means faster debugging and easier validation of mapping changes. For firms yet to adopt, it provides a clear picture of how they can transform their data into CDM.

The final CDM object shows where the data ended up. Data Lineage provides the complete, inspectable story of how it got there.

Explore Data Lineage in Rosetta

To see how Rosetta can make your CDM transformation easier to build, validate and support, request a demonstration: http://ui.rosetta-technology.io

For more information: clients@regnosys.com.