dbt Cert Prep - How To Prepare.md

How to Prepare for the dbt Analytics Engineering Certification Exam

📝 Study asset for the dbt Analytics Engineering Certification Practice Tests course on Udemy — 195 exam-style questions across 3 timed tests, updated for dbt 1.11.

The Uncomfortable Truth

Hands-on experience is not enough to pass this exam. This is the #1 takeaway from everyone who's taken it. Even engineers with 2+ years of daily dbt use have failed. The exam tests features you may have never touched in your day-to-day work — snapshots, exposures, model governance, state selectors, Python models.

You need dedicated study time, not just "I use dbt at work."

Study Plan (4-8 Weeks)

Week 1-2: Foundation

1. Complete a dbt course

2. Read the official study guide — download it here. Map every bullet point to your personal experience. Mark topics you've never used.

3. Set up a practice project — Clone jaffle_shop and use it to test every feature you study.

Week 3-4: Deep Dive into Each Domain

Go through the dbt docs, reference, and guides for every exam topic:

Domain 1 — Developing and optimizing dbt models (biggest section)

• All 4 materializations: table, view, incremental, ephemeral
• Incremental strategies and when to pick which: append, merge, delete+insert, insert_overwrite — by warehouse and dataset shape
• Microbatch materialization: event_time, begin, batch_size, lookback; first-run backfill vs subsequent runs; --event-time-start / --event-time-end overrides
• Snapshots: YAML-based config (no more models/snapshots/*.sql standalone), timestamp vs check strategy
• Python models: def model(dbt, session) syntax, when to use
• --empty flag: zero-row dry-run; what it does and doesn't catch (data tests pass vacuously)
• --sample flag: temporal-subset dry-run (e.g. --sample=last_day); propagates through the DAG
• Sources config, seeds, packages, dbt_project.yml
• Documentation lives here in v1.11: dbt docs generate, doc blocks ({% docs %}), persist_docs, descriptions in YAML
• generate_schema_name and generate_database_name macros

Domain 2 — Managing dbt models governance

• Contracts: enforced: true REQUIRES a data_type on every column under columns: (parse-time failure if missing)
• YAML column-level constraints: primary_key, not_null, check (expression: "..."); know which warehouses enforce them at insert vs treat them as informational (e.g. Snowflake enforces not_null only)
• Versions: versions: config, deprecation_date, latest_version, version-less ref() resolution

Domain 3 — Debugging data modeling errors

• Error types: Compilation Error, Database Error, Runtime Error, Dependency Error
• target/compiled/ vs target/run/ — when to check each
• YAML syntax errors (indentation, tabs vs spaces)
• Jinja compilation errors (undefined vars, missing {% endif %})
• Behavior-change flags in dbt_project.yml (flags: block) — e.g. require_explicit_package_overrides_for_builtin_materializations. Setting to False keeps v1.7 behavior; True adopts the v1.11 strict default. Use to migrate gradually.
• dbt debug command

Domain 4 — Troubleshooting and optimizing dbt pipelines

• dbt clone — zero-copy clones, supported materializations
• dbt retry — reads from run_results.json
• DAG failure management
• Job optimization (threads, selectors)

Domain 5 — Implementing dbt tests

• Generic tests: unique, not_null, accepted_values, relationships
• Singular tests (.sql files in tests/)
• Custom generic tests ({% test %} macro syntax)
• Test severity: warn_if, error_if, where config
• store_failures and store_failures_as
• Unit tests: given/expect format

Domain 6 — Implementing and Maintaining External Dependencies

• Exposures: type, maturity, depends_on, owner config
• Source freshness: loaded_at_field, warn_after, error_after
• packages.yml: hub vs git vs local packages, version pinning

Domain 7 — Leveraging the dbt state

• State artifacts: manifest.json, run_results.json
• State selectors: state:modified, state:new, state:modified.body, state:modified.configs
• Result selectors: result:error, result:fail, result:warn
• --defer and --favor-state flags
• Slim CI workflow
• dbt retry

Week 5-6: Memorize YAML Syntax

This is a closed-book exam. You must memorize:

• Source YAML config (database, schema, tables, loaded_at_field, freshness)
• Model properties YAML (columns, tests, descriptions, contracts)
• Exposure YAML (type, maturity, depends_on, owner)
• Snapshot config block (strategy, unique_key, updated_at, check_cols, target_schema)
• dbt_project.yml structure (name, version, profile, model-paths, materializations)
• Incremental model config (materialized, unique_key, strategy, on_schema_change)
• Custom generic test macro syntax

Tip from Paul Fry (certified practitioner): "Are you confident of the varying config options available for dbt sources? Would you be able to write these from scratch?" If the answer is no, keep studying.

Week 7-8: Practice Tests + Blog Posts

1. Take our practice exams under timed conditions (90 minutes per test)
2. Review every wrong answer thoroughly
3. Read these critical blog posts:
   • How we structure our dbt projects
   • Your Essential dbt Project Checklist
   • How to review an analytics pull request
   • The exact GitHub PR template we use at dbt Labs

Key Jinja Functions to Memorize

These come up repeatedly:

Function	Purpose
ref('model_name')	Reference another model, creates DAG dependency
source('source', 'table')	Reference a source table
config(...)	Set model configuration in-file
var('var_name')	Access project variables
env_var('ENV_VAR')	Access environment variables
this	Current model's relation
target	Current target (name, schema, type, threads)
is_incremental()	Check if running in incremental mode
run_query(sql)	Execute SQL during compilation
log(msg, info=True)	Print messages during compilation
adapter.dispatch()	Cross-database macro dispatch

dbt Commands to Know Cold

Command	Purpose
dbt run	Build models
dbt test	Run tests
dbt build	Run + test in DAG order
dbt compile	Compile Jinja to SQL (no execution)
dbt seed	Load CSV seeds
dbt snapshot	Run snapshots
dbt docs generate	Generate documentation
dbt source freshness	Check source freshness
dbt deps	Install packages
dbt debug	Test connection + config
dbt retry	Re-run failed nodes from last run
dbt clone	Create zero-copy clones
dbt ls	List resources matching selectors
dbt run-operation	Run a macro directly

Common Selector Syntax

Selector	Meaning
model_name	Single model
+model_name	Model + all upstream
model_name+	Model + all downstream
+model_name+	Model + all upstream + all downstream
tag:nightly	All models tagged "nightly"
source:jaffle_shop	All sources in jaffle_shop
state:modified	Models modified since last run
state:modified+	Modified models + their downstream
result:error	Models that errored on last run
exposure:weekly_report	Upstream of an exposure

Don't Forget the Non-dbt Topics

The exam is for "Analytics Engineering", not just dbt:

• Git: git pull vs git fetch, branching strategies, PR workflows
• SQL: CTEs, window functions, aggregations, joins
• Jinja: Control structures ({% if %}, {% for %}), filters, variable scope
• General software principles: DRY vs WET, modularity, naming conventions

Final Tips

1. Read questions twice — Extra details are intentionally added to make you second-guess
2. Watch out for DOMC format — You see options one at a time and must decide yes/no without seeing others
3. Time management — 65 questions in 120 minutes = ~1.8 minutes per question. Skip and return to hard ones
4. The exam includes unscored research questions — Some questions don't count toward your score, but you can't tell which ones
5. 65% to pass — You can miss up to 23 questions and still pass. Don't panic

Updated to the 2026 dbt v1.11 Certification