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#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.
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.