dbt Labs dbt Analytics Engineering Certification Exam dbt-Analytics-Engineering Exam Dumps: Updated Questions & Answers (December 2025)

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.

dbt Python models support a limited set of materializations because they rely on execution within the data platform’s Python compute engine (such as Snowpark for Snowflake, Dataproc for BigQuery, or Spark). These engines require models to materialize into actual relations—tables or views—in order to persist the results of Python-based transformations.

The ephemeral materialization, however, is fundamentally incompatible with this behavior. Ephemeral models do not create relations in the warehouse; instead, dbt inlines their SQL logic directly into downstream models. Since Python models cannot be inlined (they execute Python code, not SQL), dbt does not allow ephemeral Python models. dbt requires Python model outputs to be materialized as either:

table

view

incremental

Therefore, ephemeral is not supported for Python models, and attempting to configure a Python model as ephemeral will result in a compilation error.

The reason is straightforward: ephemeral logic depends on SQL compilation, while Python models depend on executing Python code in the data platform. Because these mechanisms are incompatible, dbt restricts Python models to relational materializations only.

Thus, the correct answer is No — ephemeral is not supported for Python models.

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” is incorrect.

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.

Here is the correct sequence:

Correct Order

sources:

- name: blue (source definition)

tables:

- name: yellow (table definition)

columns:

- name: red (column definition + tests)

In dbt, source documentation follows a strict YAML hierarchy. At the top level, the sources: key declares that you are defining source metadata. Inside this block, each source is listed as an item beginning with - name:. Therefore, the snippet describing the source (blue) must come immediately after sources:.

Next, dbt requires a tables: block inside each source to define the raw tables belonging to that source. Thus, the snippet containing tables: must follow the source definition. The table description (yellow) is then placed directly under this key because it represents a table within that source.

Finally, dbt allows column-level metadata under a columns: block inside a table definition. Therefore, columns: appears next, followed by the snippet defining a specific column (red) which includes both a description and tests (unique, not_null).

Arranging the YAML in this hierarchical order ensures dbt can correctly assign documentation to the source object, the table object, and the individual column. Misordering these snippets would break the structure and prevent dbt from generating documentation properly.

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 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: or dbt run --select +exposure:, 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.

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.

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.

The correct answers are A and C.

dbt clone is a command introduced to efficiently replicate existing relations (tables/views) from one schema/environment to another within the same warehouse without fully rebuilding them. It typically leverages warehouse-level “clone” functionality (e.g., Snowflake zero-copy clone). To know what to clone, dbt needs information about previously built models; this is stored in artifacts like manifest.json. Therefore, A is correct: it requires a reference to a previous manifest/state to know which models and locations to operate on.

C is also correct because cloning a production schema into a development schema enables you to test code changes while pointing downstream tools (like BI dashboards) at the cloned data. That way, BI or ML systems can exercise new dbt logic without impacting real production objects.

Option B describes state:modified / state comparison behavior, but dbt clone does create (or clone) objects, so B is false.

Option D is incorrect because clone works within a warehouse, not across different warehouses.

Option E is wrong: _v# suffixing is for model versioning, not cloning.

Thus, A and C correctly describe the behavior and purpose of dbt clone.