dbt Labs dbt-Analytics-Engineering - dbt Analytics Engineering Certification Exam

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.

The only correct statement is Option C, because dbt allows you to override the schema for a package’s models directly within your project’s dbt_project.yml file. Packages behave just like subfolders within your own project, and therefore the standard configuration pattern applies:

models:

timeformat:

+schema: timeseries

This correctly overrides the package’s default schema, allowing all models within the timeformat package to be built into the timeseries schema.

Why the other options are incorrect

Option A

Local packages can be added using a path reference, but that is not what a private Git repository refers to. A private repo must be added using git: plus SSH/HTTPS URL, not local: unless the developer literally cloned the repo into a local directory. The question specifically describes a private repository, so this is not the correct statement.

Option B

Packages are installed using dbt deps, not dbt build.

dbt build only runs models, tests, and snapshots; it does not install dependencies.

Option D

Including a version or revision is allowed for private Git-based packages. You can specify branches, tags, or commit hashes safely in packages.yml.

Hook 1

on-run-end: "{{ macro_x() }}"

Answer: macro_1

Hook 2

models:

:

post-hook: "{{ macro_x() }}"

Answer: macro_2

Hook 3

on-run-start: "{{ macro_x() }}"

Answer: macro_3

Hook 4

{{

config(

pre-hook: "{{ macro_x() }}"

)

}}

Answer: macro_4

dbt supports run-level hooks and model-level hooks. Run-level hooks fire once per invocation, while model-level hooks fire around each individual model.

on-run-end is a run-level after hook that executes once after the entire dbt command completes. Because macro_1() must run after every dbt run, it correctly belongs here.

The post-hook configured under the models: section runs after each model in that scope finishes building. This matches the requirement for macro_2() to execute after a model runs.

on-run-start is a run-level before hook and fires once before dbt begins executing any models for that command, making it the right place for macro_3() which must run before every dbt run.

Finally, the pre-hook specified inside a model’s config() block runs before that specific model is built. Since macro_4() must execute before a model runs, it belongs in the pre-hook configuration.

Thus the correct mapping is:

on-run-end → macro_1

model post-hook → macro_2

on-run-start → macro_3

model pre-hook → macro_4.

The correct answer is A: Information is gathered from the use of source and ref macros.

dbt determines the dependency graph — the DAG — by analyzing calls to ref() and source() inside model SQL files. These macros explicitly declare relationships between models. When a developer writes ref('orders'), dbt interprets this as: “the current model depends on the orders model.” Similarly, source() indicates dependencies on upstream raw data sources. This declarative approach allows dbt to build a structured and deterministic DAG without scanning SQL for implicit table references.

Option B is incorrect because dbt does not query database objects to infer dependencies; it resolves dependencies at compile time through metadata generated from model files. Option C is incorrect because dbt intentionally does not parse SQL to detect table names—this would be brittle and error-prone across warehouses. Instead, dbt requires explicit references to maintain reliability. Option D is incorrect because YAML files define metadata about models and sources but do not create dependency relationships between them.

Thus, the dependency graph is built exclusively by reading ref() and source() macro calls, which ensures clarity, correctness, and maintainability within the analytics engineering workflow.

The --fail-fast flag tells dbt to stop scheduling any new nodes as soon as one node fails. Importantly, dbt does not kill models that are already running; in-flight nodes are allowed to finish.

Here’s what happens step by step with 2 threads:

Roots model_a and model_b start first.

model_a finishes successfully. That makes model_c eligible to run.

dbt now runs model_b and model_c in parallel.

While they are running, model_b fails.

Because --fail-fast is set, dbt immediately stops scheduling any additional models (like model_d, model_e, or model_f).

model_c was already running when model_b failed, so it is allowed to complete successfully.

Downstream models of either branch (model_d, model_e, and model_f) never start, because fail-fast prevents any further nodes from being queued after the first failure.

So, the only models that successfully build during this run are:

model_a (completed before model_b failed)

model_c (already running at the time of failure and allowed to finish)

Hence the correct choice is B: model_a, model_c.

(branch)

(commit)

(pull request)

In dbt development workflows, version control using Git is essential for ensuring collaborative, safe, and trackable changes to analytics code. The correct first step when making updates—such as adding new models—is to create a new Git branch. This isolates development work from the production (main) branch, preventing incomplete or experimental logic from affecting deployed transformations. Branching supports dbt’s modular development approach and aligns with best practices for analytics engineering.

Once the branch is created, the developer modifies SQL models, tests, macros, or documentation as required. To permanently record these modifications in Git, the developer must commit the changes. A commit serves as a snapshot of progress and creates an auditable history of transformations made to the project, enabling rollbacks, diffs, and peer review.

After development is complete, the developer submits a pull request (PR). The pull request triggers CI checks—often including dbt build, schema tests, and contract validations—to ensure code quality and identify impacts on downstream models. PRs allow team members to review and comment before changes merge into the main branch, enforcing governance, consistency, and reliability. This workflow embodies the engineering rigor dbt encourages: modular development, testing, versioning, and peer review.

The correct answer is E: They are written using the {% macro %} wrapper.

Generic tests in dbt are implemented as macros, which means they must be defined using the {% macro %} Jinja syntax. These macros return a SQL query that evaluates to rows representing test failures. dbt executes these queries and marks the test as failed if any rows are returned. This requirement is explicitly documented: all generic tests are macros located in a test directory or within a package.

Option A is partially correct but not universal. Generic tests typically accept arguments such as model or column_name, but dbt does not require both or either. Custom tests can accept any parameters defined by the user. Option B is incorrect because tests do not require ref(); dbt injects the model relation for you when the test is executed. Option C is false because generic tests must be declared in YAML under a model or source for dbt to run them. Option D is incorrect because tests do not always need a column_name (e.g., relationship tests, row-count tests, table-level validations).

Therefore, the defining and universally required characteristic is that generic tests are written as macros, making E the correct answer.

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.

The requirement is:

Select all models that have been modified → this uses the state selector:state:modified

But only those modified models that are materialized as views → this uses the config selector:config.materialized:view

Then include upstream and downstream dependencies of those models → this requires adding + around the selectors.

To combine both selectors, dbt uses a comma-separated list within --select, meaning both selectors must match simultaneously.

The correct syntax is:

dbt build --select +state:modified, +config.materialized:view+

This command:

Finds models whose state is modified.

Filters them to only those materialized as views.

Includes upstream (+) and downstream (+) dependencies.

Runs and tests the selected nodes because dbt build includes running models, tests, seeds, and snapshots.

Why the other options are wrong:

A and C use invalid selector syntax (config.materialized:view+ must be prefixed with +).

B only selects modified models but does not filter by materialization type.

D uses materialized:view, which is invalid without the config. prefix.

Thus, only Option E satisfies all conditions and uses correct dbt selector syntax.