dbt Analytics Engineering Exam Preparation Material | dbt Analytics Engineering Certification Exam

Explanation:
Check your terminal or log file for the output from the most recent dbt run.
Look for specific error messages associated with the models that failed.
3 Isolate the problem by dbt run --select model_name to run a single model and confirm whether the issue is localized to that model.
4 Use dbt run --select model_name+ to run the model and its downstream dependencies, ensuring that your fix works across the DAG.
Brief Explanation
First, you always inspect the latest run output (step 1).
Then, identify the exact failing models and error messages (step 2).
Next, you reproduce the issue on the individual model to be sure the fix works locally (step 3).
Finally, you re-run the model plus its downstream dependencies to validate the fix across the DAG (step 4).

Explanation:
The correct answers are C: Exposures describe a downstream use of your dbt project and E: You can run, test, and list resources that feed into your Exposure. Exposures in dbt are documentation constructs that describe how the outputs of your dbt project are used downstream―such as dashboards, machine learning models, applications, reporting layers, or external tools. They exist to provide visibility into the final layer of the analytics workflow, making it easier to track lineage from raw data models downstream consumers.
Option C is correct because the official dbt documentation explicitly states that exposures define the downstream use cases of dbt models. They create transparency about dependencies outside the dbt DAG itself.
Option E is also correct. Using commands like dbt ls --select +exposure:<name> or dbt run --select +exposure:<name>, dbt enables users to run, test, and inspect the upstream resources feeding into the exposure. This is extremely valuable for impact analysis and CI workflows.
Option A is incorrect because exposures are downstream, not upstream―meaning models feed into exposures, not the other way around.
Option B is incorrect because exposures are not materialized in the warehouse; they are metadata stored in YAML.
Option D is incorrect because exposures are defined in YAML files, not SQL files.
Thus, C and E are the correct statements.

Explanation:
Operation
Correct Location
Aggregations (booked_hotel, booked_ride)
In a model dedicated to pre-aggregate data for reporting
Standardizing customer_id
In the first layer of models
Selecting customer_name
In the first layer of models
Joining employees
In a model between the first layer and final layer of models
In dbt’s recommended modeling framework, transformations should be centralized according to their purpose and level of abstraction. Basic cleaning and column standardization―such as shortening customers.id using left(customers.id, 12)―belongs in the first layer of models, commonly known as staging models. This layer is responsible for producing clean, consistent, analytics-ready fields. Selecting raw descriptive fields like customers.name also belongs in this layer.
Joins that enrich a dataset by combining cleaned staging outputs across domains―such as joining customers with employees―belong in intermediate models. These models unify business logic that sits between the raw staging layer and the final aggregations used for reporting.
Finally, aggregations like counting types of accommodations (booked_hotel and booked_ride) belong in marts or reporting models, especially when they involve summarization that downstream tools (dashboards, BI reports) will consume. This keeps heavy business logic centralized and reusable.

Explanation:
The correct answer is A: Add model groups and set access to private.
dbt’s access control system is designed to restrict which models may reference others purely within the dbt project itself, independent of data warehouse permissions. This system uses model groups and an access property, which can be set to public, protected, or private. Setting a model to private means that only models within the same group are allowed to reference it. Any attempts to reference the model from outside the group will cause a compilation error, enforcing strong boundaries between domains or data products within a dbt project.
Option C (protected) is incorrect because protected allows references from other groups but requires explicit configuration―the intention is stewardship, not restriction. It does not fully restrict referencing.
Option B is incorrect because dbt model access control is not tied to warehouse permissions. Warehouse-level grants cannot control dependency references inside the dbt DAG.
Option D is irrelevant to access control. Versioning does not restrict references; it only manages updates to published models.
Therefore, the only correct way to restrict which models can reference another model is by placing it into a model group and marking it as private, which enforces strict internal usage boundaries.

Explanation:
The correct answer is D: dbt run --select +1 my_model.
In dbt’s selection syntax, the + operator is used to include parents (upstream) and/or children (downstream) of a given node. When used as +my_model or my_model+, it means “include all ancestors” or “all descendants” respectively, with no limit on depth.
To limit how many levels of parents or children are included, dbt allows a numeric depth between the + and the resource name. +1 my_model (or my_model+1) means:
Select my_model
Plus only its first-degree parents (direct dependencies), and no further ancestors.
Because you want to materialize the models, you must use dbt run, not dbt compile. dbt compile only compiles SQL and does not create or update relations in the data platform .
So:
Option A (dbt run --select +my_model) would include all upstream ancestors, not just first-degree parents.
Options B and E use compile, so they don’t materialize.
Option C is just syntactically wrong.
Therefore, the only command that both runs models and limits selection to my_model plus its first-degree parents is dbt run --select +1 my_model.