dbt-Analytics-Engineering dbt Analytics Engineering Certification Exam Question and Answers

The correct answer is B: Refer to a manifest and utilize the --defer and --state flags.

According to dbt’s official documentation, the --defer flag enables developers to defer the resolution of model references (ref(), source()) to an existing manifest—commonly the one generated from a production run. When this flag is used along with --state, dbt reads the prior project state and uses the already-built production models instead of rebuilding upstream dependencies. This is essential because production models are typically large and compute-intensive. By deferring to production artifacts, developers can test only the models they have modified, dramatically reducing warehouse costs and speeding up development cycles.

This approach is foundational to dbt’s recommended development workflow, especially when working with CI/CD or large DAGs. It preserves the integrity of the dependency graph while avoiding unnecessary recomputation.

Option A violates dbt best practices by removing dependency awareness. Option C is unnecessary operational overhead and does not integrate with dbt’s state management. Option D is incomplete because --state alone does not prevent upstream model execution—--defer is required to substitute those models with existing artifacts.

The correct answer is A: The freshness check can be disabled with freshness: null.

In dbt, freshness checks are controlled by the freshness configuration block within a source definition. If a project includes a default freshness configuration, but you want to turn off freshness checking for a specific table, you can explicitly set freshness: null. This overrides inherited settings and tells dbt not to compute or evaluate freshness for that object.

Option B is incorrect because dbt evaluates all configured sources before finishing; it does not exit after the first failure. Instead, it completes the run and reports pass/warn/error statuses according to the configured thresholds.

Option C is incorrect because the placement of freshness checks is flexible. Some teams run dbt source freshness first to validate data arrival before running models; others run it separately or at the end of a workflow. There is no requirement that it always be last.

Option D is incorrect because dbt build does not automatically run freshness checks. Freshness checks are performed only when dbt source freshness is executed explicitly or configured in a dbt Cloud job step.

Therefore, A is the only statement that correctly describes the behavior of source freshness checks.

In dbt, grants can be configured globally, at the project level, or directly inside a model using the config() function. When a grant is set in dbt_project.yml, it becomes a base definition, and individual models may extend (append to) or override that configuration.

According to dbt documentation, prefixing a grant with a plus sign (+) means “extend the list defined in higher-level configurations.”

Thus, if the project-level config already sets:

select: ['reporter']

…and a model needs to add an additional role (here, bi) without removing the existing one, the correct syntax is:

{{ config(grants = { '+select': ['bi'] }) }}

This tells dbt: “Take the existing grant list (reporter) and append bi to it.”

Option B is incorrect because '+bi' is not a valid grants syntax.

Option C is invalid because grants do not use an inherits parameter.

Option D is invalid because include: is not a grants configuration key.

Therefore, Option A correctly applies dbt’s documented merging behavior for grants.

Execute the last dbt command from the node point of failure.

Answer: retry

The --retry flag in dbt is specifically designed to re-execute a dbt command starting from the node where execution previously failed. In large DAGs, rebuilding all upstream models repeatedly is inefficient, especially when a downstream transformation is the only point of failure. dbt includes retry logic to support resiliency within orchestrated pipelines and CI/CD processes.

Using --retry allows dbt to leverage the metadata stored in the run_results.json to determine which model triggered the failure. Instead of re-running the entire DAG, dbt intelligently continues execution from the failed node, speeding up recovery and making iterative debugging far more efficient. This is particularly valuable in production pipelines where minimizing runtime is critical.

This behavior aligns with dbt’s philosophy of incremental, test-driven, modular development: failures should be isolated, reproducible, and simple to resume. By re-running only the subset of affected models, dbt improves developer productivity and orchestration reliability.

**Create a copy of an existing database object in a sandbox environment.

Answer: clone

The clone capability in dbt refers to creating a zero-copy clone (Snowflake) or snapshot-like duplicated object using the data platform's native features. This is extremely useful when developers or analysts need a safe sandbox environment to test transformations, experiment, or validate logic without affecting production data.

A clone operation duplicates the table or view metadata instantly without physically copying data, which is both cost-efficient and fast. dbt leverages this through commands such as dbt clone (dbt Cloud) or through adapters that support cloning.

Sandboxes created via cloning allow engineers to develop safely by ensuring that testing and prototyping has no impact on production tables. Because cloned objects share underlying data blocks, they are nearly storage-free unless mutated—keeping warehouse costs low.

This practice is aligned with modern analytics engineering best practices where separation of environments (dev/test/prod) is essential for governance, data quality, and reproducibility.

**Run a subset of models or tests in a sandbox environment without having to first build their upstream parents.

Answer: defer

The --defer flag allows dbt to reference already-built objects from another environment—commonly production—so that developers can run only the models they are modifying, without recreating all upstream dependencies.

When combined with --state, dbt compares the working branch’s DAG with previously generated artifacts and determines which nodes should be rebuilt. Any upstream nodes not modified in the current branch are deferred, meaning dbt will point to the existing production-built version instead of materializing them again.

This dramatically speeds up development because staging layers or intermediate models, which may take significant computation time, do not need to be rebuilt for every developer iteration.

The mechanism also prevents accidental overwrites of production objects because deferred references always point to a safe, isolated schema established by state comparison.

This concept is central to dbt’s “safe development via deferral,” enabling rapid experimentation while ensuring consistency between dev and prod environments.

**Compare nodes against a previous version of the same nodes.

Answer: state

The --state flag allows dbt to compare the current project against a previously generated manifest. This enables dbt to determine which models have changed, which tests must be re-run, and how the DAG differs between two versions.

State comparison is foundational to features such as Slim CI, deferred builds, and change-aware testing. dbt reads the state directory—typically containing artifacts from a production run—and examines differences in SQL, configurations, macros, or schema definitions.

This allows dbt to selectively build only modified nodes, increasing efficiency in CI/CD pipelines and reducing unnecessary warehouse costs. Additionally, state comparison is used for validating backward compatibility, testing versioned models, or enforcing governance rules such as model contracts.

By comparing nodes to their historical equivalents, teams can adopt modern engineering strategies such as impact analysis, regression detection, and selective deployment. This capability aligns with dbt’s focus on modular analytics engineering and automated change management.

In dbt, the Directed Acyclic Graph (DAG) is created from model dependencies, which dbt identifies only through two mechanisms: the ref() function for referencing dbt models and the source() function for referencing declared sources. These functions are explicitly designed to tell dbt how models relate to each other so that dbt can track lineage, enforce build order, and generate documentation.

Option A, {{ source('source', 'table') }}, correctly references a declared source. Any model using source() establishes an upstream dependency on that source table. dbt will therefore draw a lineage line in the DAG from the source to the model.

Option B, {{ ref('stg_jaffle_shop__customers') }}, is the canonical way to reference another dbt model. ref() ensures dbt determines dependencies at compile time, and thus creates a DAG edge between this model and its parent.

The remaining options do not create lineage:

C directly references a database object, which dbt cannot interpret as a dependency.

D uses a Jinja variable unrelated to lineage.

E is invalid, because source() requires two arguments: a source name and table name, not a dotted string.

Therefore, A and B are the only valid answers.

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 --fail-fast flag changes dbt’s execution behavior by immediately stopping the scheduling of any further models as soon as the first failure occurs. This is true regardless of the number of threads; in this case, the environment uses one thread, meaning models run strictly in sequence based on dependency order.

In the DAG provided, model_d is downstream of model_b, and model_f depends on model_d. The execution sequence when using a single thread would be something like:

model_a runs

model_c runs

model_e runs

model_b runs

model_d runs → fails

Once model_d fails:

With normal dbt run, dbt would attempt to continue running any unrelated models (though in this DAG, there are no more independent nodes left anyway).

With --fail-fast, dbt immediately stops scheduling any additional work, halting the run.

Therefore, no further models—including model_f or any other—will run. dbt does not drop models, retry them, or attempt related branches. It simply stops.

The correct answers are B and E.

The dbt retry command was introduced to help developers quickly re-run only what failed in the prior dbt invocation. According to dbt documentation, dbt retry examines metadata from the previous execution, including the run results and the manifest.json, to determine which nodes failed. This aligns with Option E, as dbt uses the manifest to identify the models, tests, and other nodes that errored or were not executed successfully.

Option B is also correct because dbt retry works only when the previous run failed due to execution errors (e.g., a warehouse failure or a logic error in SQL). If the failure was due to a syntax error that prevented dbt from compiling, there will be no valid manifest produced, so retry cannot execute. Thus, dbt retry can only re-run models when the previous failure occurred after successful compilation.

Options A and C are incorrect because retry does not run all nodes nor does it automatically pick up exactly where an execution stopped — instead, it runs failed and downstream unbuilt nodes as determined by the manifest. Option D is also incorrect; retry uses the execution metadata, not selectors, to determine what should run.

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

In dbt, source freshness can be defined at the source level (affecting all tables) or overridden at the individual table level. When freshness is declared at the source root, dbt applies the freshness policy to every table within that source unless a specific table opts out. The official dbt documentation states that setting:

freshness: null

at the table level disables freshness checks for that specific table, even when the source itself defines default freshness rules. This is the only documented way to exclude an individual table from a source freshness policy.

Option B is incorrect because tables can override and disable freshness even when the parent source defines it. dbt’s configuration hierarchy supports overriding child-level settings on a per-resource basis.

Option C (loaded_at_field: null) does not disable freshness—it simply removes the loaded_at_field, which would cause dbt to error because a freshness check requires a timestamp field to operate.

Option D (error_after: null) only removes the error threshold but does not disable freshness. The table would still participate in freshness checks and could trigger warnings.

Thus, the correct and dbt-supported method to exclude a table from freshness is to explicitly set:

freshness: null

making A the correct answer.

The goal in this scenario is:

Select only models, tests, and snapshots that were modified in development, using:state:modified

Use already-built production objects whenever possible, so development does not need to rebuild everything. This is done with:--defer

Compare development code against production artifacts, which requires:--state

Run everything (models + tests + snapshots) in a single command. This is exactly what dbt build does.

dbt build = run models + run tests + run snapshots + run seeds.

Putting it all together, the correct command is:

dbt build --select state:modified --defer --state

This single command satisfies all requirements:

It runs only modified resources.

It uses the production state artifacts for comparison.

It defers to production-built models where possible.

It runs all resource types automatically.

Why the other options are incorrect:

A → Missing --state, so state:modified cannot function.

B → Splits run + test separately; question asks which single command you will invoke.

D → Missing --defer, which defeats the purpose of using production objects.

E → Also missing --defer.

Thus, Option C is the only correct answer.

The correct answer is A: dbt test --select "orders" --indirect-selection=empty".

In dbt, the --indirect-selection flag controls how dbt handles indirectly related resources during selection, such as tests whose parent models may or may not be selected. By default, dbt may include related resources depending on the selection behavior.

indirect-selection=empty is the strictest form of selection. It means that dbt will not run tests whose parent models are not explicitly selected, even if the tests are indirectly related. This prevents executing tests on models that you did not intend to build or include in your workflow, ensuring test execution is tightly scoped.

Other options behave differently:

Option B (no indirect-selection flag) uses dbt’s default behavior, which does include related tests, meaning tests could run even when their parent models were not selected.

Option C: buildable includes resources that can be built (e.g., when downstream dependencies require them).

Option D: cautious runs tests if their parents are selected transitively through dependencies.

Therefore, to prevent tests from running when parent models are unselected, you must use --indirect-selection=empty, making A the correct choice.

1. There is a config block at the top of the model with materialized = 'table'

➡️ Answer: False

2. The corresponding table already exists in the data warehouse

➡️ Answer: True

3. The incremental model was executed with the --full-refresh flag

➡️ Answer: False

4. The corresponding table does not already exist in the data warehouse

➡️ Answer: False

The is_incremental() macro in dbt is used within an incremental model to determine whether the current invocation should perform an incremental update or a full rebuild. It evaluates to True only during an incremental run when the target table already exists in the data warehouse and dbt is not performing a full refresh.

For is_incremental() to return True, two conditions must be met:

The model must be materialized as incremental, not table or view.Therefore, if the config specifies materialized = 'table', the model is not incremental, and the function evaluates to False.

The table already exists in the target schema.In this case, dbt will run the model in incremental mode, making is_incremental() return **True`.

If the incremental model is run with --full-refresh, dbt intentionally rebuilds the entire table, meaning is_incremental() evaluates to False, even if the table exists.

Lastly, if the target table does not exist yet, dbt must create it from scratch, so the run is treated as a full rebuild, not an incremental update, causing is_incremental() to evaluate to False.

Thus, the only scenario where is_incremental() returns True is when the table exists and the model is actually incremental.

The behavior described—dbt running the orders model as a view despite being explicitly configured as a table—indicates that dbt is not correctly detecting or applying the model-level configuration during compilation. dbt relies heavily on the target-path directory to write compiled SQL, manifest files, and run artifacts. If the target-path is misconfigured, pointing to a location that dbt does not handle correctly or that overlaps with another folder used internally, dbt may fail to load the correct configuration from the merged project settings.

When dbt cannot locate the compiled configuration for a model, it defaults to its standard materialization type, which is view. This explains why the logs show:

“Finished running 1 view model”

even though the dbt_project.yml clearly declares:

materialized: table.

Additionally, the logs indicate no warnings or parsing errors, meaning dbt ran successfully but with incorrect settings—another indicator of configuration metadata being overridden or misplaced due to an incorrect target-path.

By resolving the target-path issue, dbt will successfully load the model configuration and materialize the orders model as a table as intended.

The correct answers are A: schema and C: tags.

In dbt, the dbt_project.yml file is the central configuration file that defines model-level settings. Under the models: section, you can specify a wide range of model configurations such as schema, materialized, tags, alias, and custom meta fields. The schema configuration allows you to control which database schema a model should be built in, giving analytics engineers the flexibility to organize models by domain or environment. The tags configuration is also valid under models: and is widely used to group models logically for selection, documentation, or orchestration workflows.

Option B (source) is incorrect because sources are defined under YAML files in the sources: section, not under models: in dbt_project.yml. Option D (test) is incorrect because tests must be defined in model or source YAML files, not inside the project configuration. Option E (target) is not a configuration that applies to models; rather, it refers to dbt runtime environments and cannot be configured under the models: block.

dbt's project configuration system ensures that model-level behavior is managed centrally and consistently, and schema and tags are two of the officially supported configuration keys under models:.

This test is a singular test, meaning it is defined as a standalone SQL file placed inside the /tests directory (not attached through YAML like generic tests). dbt executes singular tests by running the SQL query, and the test fails if the query returns any rows. In this case, the test selects all records from fct_orders where status_code = 13. That means if even one row in fct_orders has a status code of 13, the test will fail, because dbt interprets returned rows as evidence of a data-quality issue.

The configuration block at the top sets severity='error', meaning the test raises an error when it fails, rather than a warning. This setting overrides default severity behavior, so option B is incorrect. Singular tests do not need to be attached in YAML because they run automatically when placed under /tests → making option A incorrect. Meanwhile, generic tests live in /tests/generic, but singular tests should live directly under /tests (option C incorrect).

Therefore, the only correct statement is that records with status_code = 13 will cause the test to fail, because the test query is explicitly written to identify such rows.