dbt Analytics Engineering Certification Exam Guide + Practice Questions Updated 2026

Home / dbt Labs / dbt Analytics Engineering

Comprehensive dbt Analytics Engineering certification exam guide covering exam overview, skills measured, preparation tips, and practice questions with detailed explanations.

dbt Analytics Engineering Exam Guide

This dbt Analytics Engineering exam focuses on practical knowledge and exam application scenarios related to the subject area. It evaluates your ability to understand core concepts, apply best practices, and make informed decisions in realistic situations rather than relying solely on memorization.

This page provides a structured exam guide, including exam focus areas, skills measured, preparation recommendations, and practice questions with explanations to support effective learning.

 

Exam Overview

The dbt Analytics Engineering exam typically emphasizes how concepts are used in professional environments, testing both theoretical understanding and practical problem-solving skills.

 

Skills Measured

  • Understanding of core concepts and terminology
  • Ability to apply knowledge to practical scenarios
  • Analysis and evaluation of solution options
  • Identification of best practices and common use cases

 

Preparation Tips

Successful candidates combine conceptual understanding with hands-on practice. Reviewing measured skills and working through scenario-based questions is strongly recommended.

 

Practice Questions for dbt Analytics Engineering Exam

The following practice questions are designed to reinforce key dbt Analytics Engineering exam concepts and reflect common scenario-based decision points tested in the certification.

Question#1

How can you overwrite configurations for models within a package? Choose 1 option.

A. By specifying the configurations within the packages.yml file under the relevant package entry.
B. By adding the configurations in dbt_project.yml within the package's namespace.
C. After installing the package, you can apply configurations on the models in the ./target folder.
D. By navigating into the /dbt_packages folder and adding the configurations directly to the models.

Explanation:
The correct answer is B: By adding the configurations in dbt_project.yml within the package’s namespace.
dbt packages are installed as read-only code, meaning you should never modify files inside /dbt_packages, nor should you attempt to overwrite generated artifacts inside /target. Instead, dbt provides a clean and officially supported method for overriding or extending configurations on models from packages: using the dbt_project.yml file.
Each package comes with its own namespace, and users can override model-level configurations by referencing that namespace inside the models: section of dbt_project.yml. dbt merges project-level configurations with package-level defaults, and configurations defined in dbt_project.yml take precedence. This is the only correct and recommended way to override settings such as materializations, tags, schema, or custom config blocks on models imported through a package.
Option A is incorrect because packages.yml is used only to declare package dependencies―not to configure package models.
Option C is incorrect because the ./target folder contains compiled and ephemeral artifacts that should never be edited.
Option D is incorrect because modifying code in /dbt_packages violates dbt best practices and will be overwritten each time packages are reinstalled.
Therefore, overriding configurations must be done exclusively through dbt_project.yml.

Question#2

You want to add new columns to an existing model with a new version.
What will trigger warnings for removal of older model versions? Choose 1 option.

A. Create a new version of the model
B. Provide a configuration for deprecation_date
C. Configure the old model as enabled: false
D. Include “deprecated” in the description of the model

Explanation:
dbt includes built-in support for model versioning and controlled deprecation. When you introduce a new version of a model, dbt will only warn about the old version being removed if the old version explicitly includes a deprecation_date configuration. This parameter signals to dbt that the model is scheduled for removal after a certain date, allowing dbt to produce structured warnings to users and downstream systems. These warnings serve as a formal notice that the old version should no longer be referenced and will eventually be removed.
Option A, simply creating a new version, does not trigger warnings by itself. dbt allows multiple versions to coexist without any deprecation messaging unless you explicitly configure it.
Option C (enabled: false) disables the model entirely, which is not a graceful deprecation strategy and does not result in version-removal warnings.
Option D (adding “deprecated” in the description) is only informational text and has no functional effect on dbt’s deprecation system.
Thus, only B―setting deprecation_date on the old version―activates dbt’s official deprecation warning mechanism, making it the correct answer.

Question#3

Which two configurations can be applied to a dbt test? Choose 2 options.

A. on_schema_change
B. tags
C. enabled
D. materialized
E. persist_docs

Explanation:
The correct answers are B: tags and C: enabled.
dbt tests―both generic and singular―support a limited but clearly defined set of configurations. Two of the supported configurations are tags, which allow grouping and selecting tests using dbt’s selector syntax, and enabled, which can be set to true or false to control whether a test should run. These configurations are commonly used to manage large test suites, such as disabling slow tests in development or tagging tests for CI pipelines.
Option A (on_schema_change) is a model-only configuration and cannot be applied to tests.
Option D (materialized) applies only to models, not tests, since tests compile into queries that evaluate failures rather than physical objects.
Option E (persist_docs) applies to models and sources for documentation purposes. Tests do not support persisted documentation properties beyond what appears in test metadata. dbt’s documentation makes clear that tests inherit only a small subset of configurations compared to models―primarily enabled, tags, severity, and custom test arguments. Among the options provided, only tags and enabled are valid and supported. Thus, the correct answers are B and C.

Question#4

Examine model stg_customers_sales that exists in the main branch:
select id as customer_id , name as customer_name from {{ source('my_data','my_source') }}
A developer creates a branch feature_a from main and modifies the model as:
select id as customer_id , name as customer_name , country as customer_country from {{ source('my_data','my_source') }}
A second developer also creates a branch feature_b from main and modifies the model as:
select id as customer_id , name as customer_name , address as customer_address from {{ source('my_data','my_source') }}
The first developer creates a PR and merges feature_a into main.
Then the second developer creates a PR and attempts to merge feature_b into main.
How will git combine the code from feature_b and the code from main, which now contains the changes from feature_a as well?
Statement:
"As feature_a is already approved and merged to main, the code for the model stg_customers_sales will stay as-is and the changes from feature_b won’t be added."

A. Yes
B. No

Explanation:
Git does not automatically reject or ignore changes from the second branch (feature_b). Instead, Git attempts to merge both sets of changes, and if they modify the same lines or nearby blocks of code, Git produces a merge conflict that must be manually resolved. In this scenario, both feature_a and feature_b introduce new columns into the same SELECT statement of the same model file, meaning Git must reconcile two different edits made in parallel on branches that diverged from the same commit.
Once feature_a is merged into main, the code in main contains the new column customer_country. When developer B then tries to merge feature_b, Git compares the modified file in feature_b with the updated file in main. Since both branches changed the same section of SQL, Git cannot automatically determine the correct combined output. It will not discard feature_b’s changes; instead, Git requires the developer to manually merge both sets of additions, typically resulting in a combined SELECT clause with both customer_country and customer_address, unless the developer chooses otherwise.
This behavior is documented in Git fundamentals: when multiple developers modify the same file region, manual conflict resolution is required .
Therefore, the statement claiming feature_b’s changes “won’t be added” isincorrect.

Question#5

HOTSPOT
Match the description to the materialization.


A. 

Explanation:
Drops and recreates a definition of a query which is executed at the time it's referenced view
Inserts or updates records of an existing object in the warehouse using a delta incremental
Code belonging to the model is inserted into the places the model is referenced ephemeral
Drops and recreates an object in the warehouse as stored results when using dbt run table

Disclaimer

This page is for educational and exam preparation reference only. It is not affiliated with dbt Labs, Analytics Engineers, or the official exam provider. Candidates should refer to official documentation and training for authoritative information.

Exam Code: dbt Analytics EngineeringQ & A:  65  Q&As Updated:  2026-11-21

  Access Additional dbt Analytics Engineering Practice Resources