How dbt works (SQL + Jinja + YAML) - Visual Walkthrough

Concept Flow - How dbt works (SQL + Jinja + YAML)

Start: User writes YAML config

↓

User writes SQL model with Jinja

↓

dbt parses YAML for metadata

↓

dbt renders SQL by processing Jinja

↓

dbt compiles final SQL query

↓

dbt runs SQL on database

↓

Results stored as tables/views

↓

User queries transformed data

dbt uses YAML for config, SQL with Jinja for models, compiles SQL, runs it on the database, and stores results.

Execution Sample

dbt

version: 2
models:
  - name: customers
    description: 'Customer data'

-- customers.sql
select * from raw.customers where active = true

This example shows YAML config for a model and a SQL file selecting active customers.

Execution Table

Step	Action	Input	Output/Result
1	Read YAML config	version: 2 models: - name: customers description: 'Customer data'	Metadata loaded: model 'customers' with description
2	Read SQL model with Jinja	select * from raw.customers where active = true	SQL template loaded
3	Render Jinja in SQL	SQL template	Final SQL: select * from raw.customers where active = true
4	Compile SQL	Final SQL	Compiled SQL ready for execution
5	Run SQL on database	Compiled SQL	Data extracted: active customers
6	Store results	Query results	Table/view 'customers' created/updated
7	User queries transformed data	Table/view 'customers'	User gets filtered active customer data

💡 All steps complete, transformed data ready for use

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
YAML config	empty	Loaded with model metadata	Loaded	Loaded	Loaded
SQL template	empty	Loaded	Rendered to final SQL	Rendered	Rendered
Compiled SQL	empty	empty	Compiled SQL ready	Executed SQL	Executed SQL
Database table/view	none	none	none	Created/updated	Available for queries

Key Moments - 3 Insights

Why does dbt use YAML files alongside SQL?

YAML files hold metadata and configuration like model names and descriptions, which dbt reads first (see execution_table step 1). This separates config from SQL logic.

What happens when dbt processes Jinja in SQL?

dbt replaces Jinja placeholders with actual values or logic before running SQL (see execution_table step 3). This lets you write dynamic SQL.

How does dbt store the results of SQL execution?

After running the compiled SQL on the database (step 5), dbt saves the results as tables or views (step 6) so you can query transformed data easily.

Visual Quiz - 3 Questions

Look at the execution table, what is the output after step 3?

A Final SQL with Jinja placeholders

B Raw YAML config loaded

C Final SQL with Jinja rendered

D Data stored in database

💡 Hint

Check the 'Output/Result' column for step 3 in the execution_table

At which step does dbt run the SQL query on the database?

A Step 4

B Step 5

C Step 2

D Step 6

💡 Hint

Look for the step mentioning 'Run SQL on database' in the execution_table

If the YAML config is missing, what will happen in the execution flow?

A dbt will not load model metadata, causing errors before SQL runs

B dbt will run SQL without any changes

C dbt will skip SQL rendering

D dbt will store results without running SQL

💡 Hint

Refer to step 1 in execution_table where YAML config is loaded

Concept Snapshot

dbt workflow:
1. Write YAML for model config
2. Write SQL with Jinja templates
3. dbt reads YAML metadata
4. dbt renders SQL by processing Jinja
5. dbt compiles and runs SQL on DB
6. Results saved as tables/views
7. Query transformed data easily

Full Transcript

dbt works by combining YAML, SQL, and Jinja. First, you write YAML files to configure your models, giving names and descriptions. Then, you write SQL files that can include Jinja templates for dynamic parts. dbt reads the YAML to get metadata, then processes the SQL files by rendering the Jinja templates into final SQL queries. It compiles these queries and runs them on your database. The results are stored as tables or views. Finally, you can query these transformed tables easily. This flow separates configuration, logic, and execution cleanly.