Some gaps a mapping can’t close. The model says Customer. The source offers three tables, a join nobody ever recorded, and not a foreign key in sight.

That’s the moment projects reach for paint: a diagram that claims the source fits the model, wishful documentation stretched over a structural hole.

The model meets source posts made the model real metadata, in Stop Asking Data Engineers to Paint, and the mapping real, in The Mapping Is the Deliverable. What’s left is the holes, and how the bridge across them gets built rather than painted.

The AI proposes foreign keys and you dismiss the bad ones in one read

Plenty of source systems never declared a foreign key. Flat file drops land that way, and so does any database whose constraints came off for load performance years ago and never went back on. So how do you find relationships between tables without foreign keys? By hand, you read column names and guess at parents for hours.

Let the AI propose them instead. You keep the decision. Here’s what good foreign key discovery looks like. It starts with a deterministic pre-filter that rules out table pairs that can’t be parent and child on structural grounds. And it works before your key design does. On a freshly imported schema it falls back to key-shaped columns, a column named id, names ending in id, endings like code, key, number, and reference.

The AI then weighs the survivors using names, types, and the profiling signals your catalog already holds: value distributions, cardinality, how far sample data overlaps between two columns. Every candidate comes back with a confidence score, the two columns behind it, and a short written reason.

Some will be wrong, and the review assumes it. You read the reason, judge the score, and dismiss the bad ones in a single read. Accepting is the only write, and it lands on your branch. Accepted relationships are promoted forward to the staging layers, each layer previewed before it lands.

Then, build the view that holds the model’s shape

With the joins recovered, the bridge itself is a view.

  1. Select the tables, and work out the joins from the relationships you accepted, temporal overlap on effective-dated ranges included. Every join is editable when the suggestion needs a human correction.
  2. Pick the columns the business shape needs, then rename and reorder them.
  3. Add computed columns as SQL expressions.

The full SQL for the view builds live in front of you. What you save is what runs.

Or skip the assembly and describe it. The AI takes a plain-language request for a view, resolves the table names against your catalog rather than inventing them, and parks the result as a proposal. Accepting opens those same steps, already filled in. The AI writes nothing. The view doesn’t exist until you save it.

How does column-level lineage keep the translation from being lost?

Here’s what makes the bridge trustworthy rather than one more artifact to doubt. Every projected column records exactly which source columns feed it, computed expressions included. So the source to target mapping is part of the view itself. Each expression resolves back to the columns it reads, and even calculated fields carry column-level lineage.

Pick any column and you can trace its whole path, every ancestor and every descendant, across as many hops as the pipeline has. That data lineage isn’t a report generated after the fact. It’s part of the metadata, committed alongside everything else.

Ask the same of any object you build. Which source tables stand behind this, and which columns identify it?

The conceptual model was never the problem. Neither were the engineers who couldn’t make sources match it by force of will. The problem was the medium: a painting on one side, a warehouse on the other, and the translation between them living in nobody’s system.

So put the translation in a system. Recover the missing joins as proposals you review, build the model’s shape as a view you save, and record each column’s sources when you derive it. The only lineage you’ll ever have is the lineage written at creation, because nobody funds the project to reconstruct it later.

  1. Pick one source with no declared keys, and have the AI propose its missing joins.
  2. Read the reasons, judge the scores, and dismiss the bad ones.
  3. Build the view on the joins you kept, and the bridge gets built.

Nobody has to paint.

Selecting a built object opens its detail pane, listing the source tables behind it and the business key columns that identify it

In DeltaVault, the relationship pass draws each proposed join as a dashed edge on the canvas, and Ask AI on the same canvas drafts a view as a proposal.