# See Your dbt YAML Descriptions and Tests Next to the Lineage Graph

> Read your dbt schema.yml files with the graph: model and column descriptions, tests per model, and which models have no documentation. No dbt run needed.

Page: https://datautility.in/blog/see-dbt-yaml-descriptions-and-tests-in-your-lineage-graph
This is the Markdown copy of the page. The tool itself runs in the browser: your files are processed on your own device and are not uploaded.

Published 2026-11-17 · Analyze & protect · dbt yaml descriptions, dbt schema.yml viewer, dbt tests overview, dbt documentation coverage, dbt model descriptions, dbt lineage with descriptions

A lineage graph tells you how models connect. It does not tell you what they mean, or whether anyone is testing them. In dbt that information lives in YAML, in files that are easy to forget and hard to review at a glance. Showing the two together answers a question I ask on every project audit: where is the graph busy and the documentation empty?

Open the tool: [SQL Lineage Analyzer](https://datautility.in/sql-lineage-analyzer)

## What is read

Drop your project, including the .yml files, onto the [SQL lineage analyzer](https://datautility.in/sql-lineage-analyzer), or load it from GitHub. The YAML files are read with a proper YAML parser, and for each model and source the tool picks up:

- The model description and each column description.

- The tests declared on the model and on its columns, such as unique, not_null, accepted_values and relationships, including custom generic tests.

These then appear in three places: the details panel of a table, the Description and Tests columns of the Tables tab, and next to each column in the Columns tab.

## The summary line

Above the tabs you get one line, for example "8 of 10 tables described, 12 tests". It is a crude measure, but it is a useful one: it takes seconds to read and tells you whether the project has any documentation habit at all.

## Why I like seeing it on the graph

Documentation coverage is not evenly important. A model with eight dependants and no description is a bigger risk than a leaf model with none. When descriptions and tests sit next to the graph, you can sort out priorities: start with the models that feed the most others and have no tests.

The same goes for tests. A mart model with no unique test on its key is the kind of thing that produces a duplicated row in a dashboard six months later. Seeing "0 tests" on a model that sits upstream of five others is a concrete, defensible item for a backlog.

## Messy YAML is handled

Real projects are not tidy. A few cases the reader deals with:

- Files such as dbt_project.yml, packages.yml and profiles.yml are recognised as configuration and skipped quietly, instead of being reported as unreadable.

- A long description wrapped onto a less-indented line, which dbt accepts, is repaired and read.

- A YAML file with no models, sources or macros in it is ignored.

If a file cannot be read, the tool says which one and why, rather than silently dropping it.

## Limits

- It shows what is declared, not what happened. There are no test results, no pass or fail, no freshness, because dbt was never run.

- Docs blocks ({% docs %}) are not expanded, so a description that points to one shows as written.

- Descriptions are shown as plain text. Jinja inside a description is not rendered.

- Matching is by name. A YAML entry for a model that does not exist in the SQL files is not drawn.

For test results and rendered docs, dbt docs remains the right tool, as covered in [visualizing a dbt project without running dbt docs](https://datautility.in/blog/visualize-a-dbt-project-without-running-dbt-docs).

## A quick audit you can do in five minutes

Load the project. Read the summary line. Open the Tables tab and scan for models with no description and no tests. Click the three with the most dependants. Write those down. That list is a better starting point for a documentation sprint than "document everything".

## How to use the SQL Lineage Analyzer: step by step

1. Drop your dbt project including its .yml files, or load it from GitHub.
2. Read the summary line above the tabs.
3. Open Tables and Columns to see descriptions and tests, and start with the models that have the most dependants.

## When to use the SQL Lineage Analyzer

- Audit documentation coverage
- Find models with no tests
- Onboard to a project with its descriptions in view
- Prioritise what to document first

## Example

Input:

```
models/ folder: raw schema, staging views, marts, reports (7 .sql files)
```

Output:

```
A graph of 10 tables and views, 40 column links and the order to run the files
```

## Frequently asked questions

### Can I see dbt descriptions and tests without running dbt docs?
Yes. The SQL lineage analyzer reads your schema YAML files as text and shows model and column descriptions and the tests declared on them, next to the graph.

### Does it show test results?
No. It shows which tests are declared, not whether they pass. dbt was not run, so there are no results.

### Why does it skip dbt_project.yml?
It is a configuration file, not documentation. Configuration files are skipped quietly so they are not reported as errors.

### Are docs blocks supported?
No. A description that refers to a docs block is shown as written, not expanded.

Tip: Fix documentation in order of dependants: the model that feeds the most others is the one a missing description hurts most.

## Related tool pages

- [dbt Lineage Viewer for Your SQL Models](https://datautility.in/dbt-lineage-viewer): Drop your dbt models folder and see the lineage graph from sources through staging to marts, with column links. No dbt run, no warehouse. Free, private.
- [SQL Column Lineage Tool](https://datautility.in/sql-column-lineage-tool): See which source columns build every column of a view or table across many SQL files. Trace to the raw table or forward to dependants. Free, in your browser.
- [SQL File Dependency Analyzer](https://datautility.in/sql-file-dependency-analyzer): Find out which SQL file must run before which, from the tables each file creates and reads. Get a run order, circular dependencies and tables nothing uses.
- [SQL Impact Analysis: What Breaks If a Table Changes](https://datautility.in/sql-impact-analysis): Pick a table and see everything downstream that depends on it, and every upstream source it is built from. Works across a whole folder of SQL files, free.
- [SQL File Lineage Tool](https://datautility.in/sql-file-lineage): Free SQL file lineage tool: drop a folder of .sql files and see which file feeds which table, column by column. Nothing is uploaded.
- [SQL Query Visualizer](https://datautility.in/sql-query-visualizer): Free SQL query visualizer: paste a query or drop SQL files and see tables, joins and columns as a clear diagram. Runs in your browser, no upload.

## Also try

- [How to understand dbt model dependencies](https://datautility.in/blog/how-to-understand-dbt-model-dependencies)
- [Visualize a GitHub dbt project](https://datautility.in/blog/visualize-a-github-dbt-project-without-cloning-it)

## More guides

- [Data Profiler: Check Data Quality Before You Use It](https://datautility.in/blog/data-profiler-check-data-quality)
- [Compare Two CSV or Excel Files: Find Added, Removed and Changed Rows](https://datautility.in/blog/compare-two-csv-files-find-differences)
- [Data Masking: Hide Emails, Phones and Names Before Sharing](https://datautility.in/blog/data-masking-hide-emails-phones-pii)
