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

The correct answers are B: writing and using dbt macros and D: using dbt packages.

dbt strongly encourages DRY (Don't Repeat Yourself) principles, and two of the core mechanisms that support reusable logic are macros and packages. Macros allow you to write Jinja-powered reusable functions that can generate SQL statements dynamically, reducing duplication across models, tests, and project logic. Macros can encapsulate filters, joins, auditing logic, timestamps, and more—allowing developers to centralize logic in one place while referencing it across many models.

Packages extend this concept even further by allowing entire sets of macros, models, tests, and utilities to be imported into a project. Packages like dbt-utils contain widely used generic macros that help standardize transformations and testing. Using packages ensures consistent logic across teams and eliminates the need to rewrite common transformations.

Option A contradicts DRY principles because copy/pasting increases maintenance burden. Option C is not a mechanism for reusing logic; singular tests validate logic but do not reduce duplication. Option E simply changes a model’s materialization and does not support code reuse.

Thus, macros and packages are the only correct dbt mechanisms that provide reusable, modular, DRY logic.

Create a new branch in git and switch to itB. Update the dbt code according to the new logicC. Create a Pull / Merge RequestD. Run some automated CI checks and/or manual review of the updated codeE. Merge the updated code to the main git branch

Version control best practices in dbt follow the same engineering workflow used in modern software development. The first step is always to create a new git branch and switch into it, ensuring all work is isolated from production-ready code and allowing your team to develop safely without affecting others. Once inside the feature branch, you update the dbt code according to the new logic, which may include modifying models, tests, macros, or documentation.

Next, you create a Pull Request (PR), also known as a Merge Request, to propose integrating your changes into the main branch. This is important because dbt projects are collaborative, and PRs facilitate peer review, enforce project standards, and prevent regressions. Once the PR is created, automated CI pipelines—such as running dbt build, schema tests, data quality checks, and code-style checks—are executed. Reviewers may also manually inspect code for logic correctness, naming conventions, and modeling consistency.

After all checks have passed and reviewers approve the PR, the final step is to merge the updated code into the main branch, making the new transformations part of the production dbt project. This workflow ensures governance, reliability, and auditable development practices, all of which are core principles in analytics engineering.

The selector source_status:fresher+ depends entirely on freshness metadata created by a previous dbt source freshness run. Source freshness results are stored in artifacts, and the --state flag points dbt to the location where these artifacts were previously generated. Without first running dbt source freshness, dbt has no stored freshness status and therefore cannot filter sources by “fresher” status. This makes option A required.

Additionally, source freshness checks only work when sources include a freshness block in their YAML configuration. This block specifies the loaded_at_field and the warn_after / error_after thresholds. If no freshness block exists, dbt does not compute freshness at all, meaning such sources cannot appear in the source_status:fresher+ selector. Therefore D is also required.

Options B and E are unrelated to source freshness artifacts and do not contribute to the preconditions for this selector. Option C does not impact freshness logic, as generic tests have no role in generating freshness metadata.

Thus, the two prerequisites are:

Running dbt source freshness (to create freshness metadata).

Defining a freshness configuration on the relevant sources.

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.

Will always point to the latest version of the source schema

Correct Match: ✔ defer

Allows to use objects built in the target schema with any downstream tool

Correct Match: ✔ dbt clone

3️⃣ Allows to safely modify objects built in the target schema

Correct Match: ✔ defer

4️⃣ Is a point-in-time operation

Correct Match: ✔ dbt clone

defer and dbt clone serve very different purposes in dbt, and understanding their behavior is essential for choosing the right command.

The --defer flag tells dbt to use already-built objects from a previous environment (often production) instead of rebuilding them. Because it always references the existing target schema’s most recent objects, it “always points to the latest version of the source schema.” Since no objects are overwritten when using defer, it also “allows safely modifying objects built in the target schema”—your development environment uses production objects without altering them.

By contrast, dbt clone creates a point-in-time copy of existing relations. This cloned schema is static; it does not auto-update when source data changes. Therefore, clone is classified as a “point-in-time operation.” Since clone copies physical tables/views into a new schema, downstream tools (BI dashboards, ML pipelines) can safely query the cloned environment without affecting production, making “allows to use objects built in the target schema with any downstream tool” the correct match.

Thus, defer is used for logic substitution without copies, while clone is used for replicable, point-in-time snapshots.

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

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

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.

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.

For models not stored under finance:

✔ reporter and bi

For models inside the finance folder:

✔ finance, reporter, bi, and public

In dbt, grants configured at the root level apply to all models unless overridden by a more specific folder- or model-level configuration.

The root-level grant is:

+grants:

+select: ['reporter', 'bi']

This means all models by default are selectable by:

reporter

bi

Now the finance folder contains its own override:

finance:

+grants:

+select: ['finance']

When dbt merges grants, overrides do not replace the entire list—they add onto inherited grants unless explicitly cleared. Therefore, models inside the finance folder inherit the parent grants and add the finance grant.

So models under finance are accessible to:

finance

reporter

bi

and public (implicit default in most warehouses unless denied)

Models not inside finance use only the root grants:

reporter

bi

Thus the correct dropdown answers are:

reporter and bi

finance, reporter, bi, and public

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.

Modularity in dbt means breaking transformations into small, reusable steps that are easy to reason about, test, and reuse. In this DAG, two staging models (stg_detail_categories and stg_details) feed into two mart-level models (skills_with_details and lessons_with_details). If there is repeated logic in those two mart models—such as common joins, filters, or derived fields—that logic is a good candidate to be extracted into an intermediate model.

Option E follows dbt best practices: inspect the SQL of lessons_with_details and skills_with_details and identify shared logic to move into a new intermediate model (for example, int_details_with_categories). Both downstream models can then reference this intermediate model using ref(), centralizing logic and improving maintainability.

Options A and B push joins/unions into the staging layer, which should focus on clean, 1:1 representations of sources—not combining multiple sources. Option C collapses distinct staging models into one, reducing clarity and breaking the source-to-staging contract. Option D creates an overly wide, less reusable final table instead of focusing on shared reusable logic.

Therefore, the action that truly increases modularity is Option E: creating an intermediate model based on common SQL patterns.

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.

In dbt, the source() function resolves a source by its declared source name and table name, not by the physical schema or identifier in the warehouse. The YAML block defines a source named jaffle_shop, and under that source, a table named orders. The identifier: customer_orders field tells dbt that although the logical table name is orders, the actual physical object in the warehouse is named customer_orders.

dbt always expects the syntax:

{{ source(source_name, table_name) }}

Here, the correct reference uses jaffle_shop as the source name and orders as the table name because these are the logical names assigned in the YAML. dbt internally resolves the physical table name via the identifier field, so the model should not reference customer_orders directly.

Option A and B are incorrect because the first argument is not the schema; dbt does not use schemas in the source() call. Option D is incorrect because customer_orders is the warehouse identifier, not the logical table name recognized by dbt.

Therefore, the correct reference is:

{{ source('jaffle_shop', 'orders') }}

This ensures consistent modeling, dependency tracking, and accurate documentation.