Why does column-level lineage matter?

It lets you trust and debug a number. When a figure looks wrong, lineage shows exactly which source produced it, so you can find the bad join or stale file instead of guessing. It also makes the impact of a schema change obvious: you can see everything downstream that depends on a column.

How is column-level lineage different from table-level lineage?

Table-level lineage says 'this result used tables A and B.' Column-level lineage says 'this revenue column came from B.amount, filtered by A.region.' The column view is what you need to actually debug a specific value or assess the blast radius of a change.

Varan Join the beta →

Varan › Column-level lineage

What is column-level lineage?

A number on your dashboard looks wrong. Which source produced it? Column-level lineage answers that instantly — it maps every column back through the joins and transformations to the exact table and file it came from.

Column-level, not just table-level

Plenty of tools show table-level lineage: "this result used tables A and B." That's a start, but it doesn't tell you which column fed which output. Column-level lineage is precise:

-- result column        ← where it came from
revenue   ← SUM(pg_orders.total)      (PostgreSQL)
tier      ← segments.tier             (segments.csv)
country   ← customers.country         (customers.csv)

That level of detail is the difference between "something in this query is off" and "the revenue is wrong because it's summing pg_orders.total, which is stale."

The Varan workspace running a cross-source query whose result columns trace back to a PostgreSQL table and two CSV files — Every column in this result traces back to its source — PostgreSQL or a specific CSV.

Why it matters

Trust. Before you ship a number, you can see exactly how it was built.
Debugging. When a value is wrong, follow the column to the bad join or stale source instead of guessing.
Impact analysis. Before renaming or dropping a source column, see everything downstream that depends on it.

Why it's hard across sources

Lineage is hard enough inside one database. When a query joins a PostgreSQL table to a MySQL table to a CSV, most tools lose the thread — the sources don't share a catalog, so there's nothing tracking how a column crossed from one system to another.

How Varan does it

Varan resolves cross-source queries through one local engine, so it can trace each result column back through every join and transformation to the exact source table or file — even when the query spans PostgreSQL, MySQL, DuckDB and spreadsheets. It works alongside anomaly detection and version history, so you can trust a number, trace it, and revert it if it's wrong.

Trace any number to its source

Column-level lineage across your databases and files. Free during the beta.

Request beta access →

FAQ

What's the difference between column and table lineage?

Table lineage names the tables involved; column lineage names the exact source columns and transformations behind each output column — what you need to debug a specific value.

Does it work across different databases?

Yes — Varan traces lineage through cross-source joins spanning PostgreSQL, MySQL, DuckDB and files.