dbt Analytics Engineering Certification Exam — Questions and Answers

Question 1: Which dbt-utils test checks that a numeric column never decreases over time within a partition?

monotonic_increase (Correct answer)
expression_is_true
recency
not_decreasing

Correct answer: monotonic_increase

`dbt_utils.monotonic_increase` asserts that values in a column are always greater than or equal to the previous row's value.

Question 2: Which dbt feature allows you to define custom generic tests in the `macros/` directory?

Schema YAML overrides
Jinja macros with test_ prefix (Correct answer)
Singular tests
Packages

Correct answer: Jinja macros with test_ prefix

A macro named `test_<name>` in the macros folder is automatically recognized by dbt as a reusable generic test.

Question 3: Which file defines top-level project configuration such as model paths, project name, and version in dbt?

dbt_project.yml (Correct answer)
schema.yml
profiles.yml
packages.yml

Correct answer: dbt_project.yml

`dbt_project.yml` is the required project-level configuration file that defines project name, version, model directories, and global configurations.

Question 4: How can you add a description to a source table in dbt?

Run dbt docs add-description
Use the description: key in the source YAML block (Correct answer)
Edit the catalog.json artifact directly
Add a -- comment above the source SQL

Correct answer: Use the description: key in the source YAML block

The `description:` field in the source YAML becomes part of the dbt documentation site and catalog.

Question 5: How do you pass a runtime variable override when running dbt?

dbt run --set key=value
dbt run --vars '{key: value}' (Correct answer)
dbt run --config key=value
dbt run --env key=value

Correct answer: dbt run --vars '{key: value}'

The `--vars` flag accepts a YAML dictionary string that overrides project variables for the duration of the run.

Question 6: Which dbt artifact file contains a summary of test results after `dbt test` runs?

sources.json
manifest.json
catalog.json
run_results.json (Correct answer)

Correct answer: run_results.json

`run_results.json` records the status (pass/fail/warn/error), timing, and row counts for every node executed.

Question 7: What built-in dbt test verifies that a column contains no NULL values?

relationships
not_null (Correct answer)
accepted_values
unique

Correct answer: not_null

The `not_null` test fails if any row in the column contains a NULL, enforcing completeness.

Question 8: Which dbt materialization type reduces query execution time by persisting data in tables rather than views?

Table (Correct answer)
Ephemeral
View
Seed

Correct answer: Table

The 'table' materialization type in dbt creates a permanent table in your data warehouse for the model's output. Unlike views, which re-execute the underlying query every time they are accessed, tables store the processed data, significantly reducing query execution time for downstream consumers. This is ideal for models that are frequently queried or involve complex transformations, as it pre-computes and persists the results.

Question 9: Which snapshot strategy compares a hash of all specified columns to detect row changes?

timestamp
check (Correct answer)
merge
diff

Correct answer: check

The `check` strategy hashes the values of listed columns and records a new snapshot row when the hash changes, useful when no reliable updated_at column exists.

Question 10: What happens to an incremental model on its very first run when the target table does not yet exist?

dbt raises an error
It runs as a full table build, ignoring the is_incremental() filter (Correct answer)
It prompts the user to run --full-refresh first
It creates an empty table and exits

Correct answer: It runs as a full table build, ignoring the is_incremental() filter

On the first run, `is_incremental()` returns false because the table doesn't exist, so dbt executes the full query and creates the table.

Question 11: What is the purpose of writing descriptions in dbt models and columns?

To describe data models for users and developers (Correct answer)
To clean old logs
To format code
To speed up query performance

Correct answer: To describe data models for users and developers

Writing clear descriptions for dbt models and columns is essential for data governance and collaboration. These descriptions provide context and meaning to the data, making it easier for both technical and non-technical users to understand what each model represents and what data each column contains. This significantly improves data discoverability, trust, and usability across the organization.

Question 12: Which dbt command creates the compiled SQL files and saves them in the target directory without running them?

dbt build
dbt clean
dbt snapshot
dbt compile (Correct answer)

Correct answer: dbt compile

The `dbt compile` command processes your dbt project, including models, tests, and macros, and generates the compiled SQL files. These compiled SQL files are saved in the `target/` directory. This command is useful for reviewing the final SQL that dbt will execute without actually running it against your data warehouse, aiding in debugging and understanding the generated queries.

Question 13: What does the node selection syntax `dbt run --select +my_model` do?

Runs my_model and all its upstream parent models (Correct answer)
Runs only my_model, excluding any dependencies
Runs all models except my_model
Runs my_model and all models downstream of it

Correct answer: Runs my_model and all its upstream parent models

The `+` prefix in the selector syntax means 'include all upstream parents,' so `+my_model` runs my_model and every model it depends on.

Question 14: In a dbt Cloud job, what does enabling 'Generate docs' do?

Publishes docs to a public URL automatically
Adds doc() blocks to all models
Runs `dbt docs generate` to refresh the catalog artifact after the run (Correct answer)
Sends documentation to Confluence

Correct answer: Runs `dbt docs generate` to refresh the catalog artifact after the run

The 'Generate docs' toggle appends a `dbt docs generate` step to the job, refreshing the catalog.json and making docs available in dbt Cloud.

Question 15: Which file defines the target warehouse connection details for a dbt Core project?

sources.yml
dbt_project.yml
profiles.yml (Correct answer)
connections.yml

Correct answer: profiles.yml

`profiles.yml` (stored in `~/.dbt/` by default) holds named targets with adapter type, credentials, and warehouse-specific settings.

Question 16: What does the `dbt compile` command do?

Executes all models and writes results to the data warehouse
Validates tests defined in schema.yml files
Installs all packages listed in packages.yml
Generates compiled SQL files without executing them against the database (Correct answer)

Correct answer: Generates compiled SQL files without executing them against the database

`dbt compile` resolves Jinja templating and `ref()` calls to produce compiled SQL in the `target/compiled/` directory without running any queries.

Question 17: Which command verifies that your dbt project YAML and SQL are syntactically valid without connecting to a warehouse?

dbt parse (Correct answer)
dbt validate
dbt check
dbt lint

Correct answer: dbt parse

`dbt parse` reads all project files and builds the internal graph, catching YAML syntax errors and reference issues without running queries.

Question 18: Which command is used to validate the structure and syntax of a dbt project?

dbt seed
dbt debug (Correct answer)
dbt compile
dbt check

Correct answer: dbt debug

The `dbt debug` command is used to validate the structure and syntax of a dbt project, as well as test the connection to your data warehouse. It provides detailed output about your profile configuration, project setup, and any potential issues that might prevent dbt from running successfully. This helps in troubleshooting and ensuring your environment is correctly configured.

Question 19: What happens if you call `{{ var('my_var') }}` and `my_var` is not defined anywhere?

It returns an empty string
dbt raises a compilation error (Correct answer)
It returns None
It returns the string 'my_var'

Correct answer: dbt raises a compilation error

If a variable is referenced without a default and is not defined in dbt_project.yml or via `--vars`, dbt raises a compilation error.

Question 20: What is the primary purpose of the `ref()` function in dbt?

To define a variable that can be reused across models
To reference external database tables not managed by dbt
To reference another dbt model and build the DAG dependency graph (Correct answer)
To call a dbt macro within a SQL model

Correct answer: To reference another dbt model and build the DAG dependency graph

The `ref()` function references another dbt model and allows dbt to infer dependencies, building the correct DAG execution order automatically.

Question 21: What information does `run_results.json` contain after a dbt invocation?

A list of all tests that passed during the most recent test run
Execution metadata such as model status, timing, and row counts from the last dbt invocation (Correct answer)
The model selection criteria used for the current run
The connection credentials used during the run

Correct answer: Execution metadata such as model status, timing, and row counts from the last dbt invocation

`run_results.json` is generated after every dbt invocation and records execution status, timing, and results for each node that was processed.

Question 22: Which command is used to install dbt packages listed in `packages.yml`?

dbt update
dbt deps (Correct answer)
dbt install
dbt init

Correct answer: dbt deps

`dbt deps` reads `packages.yml` and downloads all listed dbt packages into the `dbt_packages/` directory.

Question 23: Which SQL technique improves performance by reducing the size of result sets before joins?

Avoid WHERE clauses
Use SELECT * in subqueries
Remove indexes
Filter rows before joins (Correct answer)

Correct answer: Filter rows before joins

Filtering rows before performing joins is a critical SQL technique for improving query performance. By reducing the number of rows in each table before the join operation, you minimize the amount of data the database needs to process and compare. This leads to smaller intermediate result sets, faster join execution, and overall more efficient queries, especially with large datasets.

Question 24: Where are source definitions typically stored in a dbt project?

In YAML files within the models/ directory (Correct answer)
In dbt_project.yml
In the macros/ directory
In a dedicated sources.yml at the project root

Correct answer: In YAML files within the models/ directory

Sources are declared in any YAML file inside the models/ directory tree (e.g., sources.yml or staging/sources.yml).

Question 25: Where are dbt model SQL files typically stored inside a dbt project structure?

seeds/
logs/
data/
models/ (Correct answer)

Correct answer: models/

In a dbt project structure, dbt model SQL files are typically stored inside the `models/` directory. This directory is where you define all your data transformation logic, organized into subdirectories as needed. Keeping models in this dedicated location helps maintain a clean and organized project structure, making it easy to locate and manage your transformations.

Question 26: When using dbt Core, which directory stores compiled SQL and run artifacts by default?

logs/
target/ (Correct answer)
artifacts/
compiled/

Correct answer: target/

dbt writes compiled SQL, run results, and other artifacts to the `target/` directory by default, which is configurable in `dbt_project.yml`.

Question 27: What is a primary advantage of incremental models in dbt for performance optimization?

Skip model compilation
Run entire dataset each time
Disable logging
Update only new or modified records (Correct answer)

Correct answer: Update only new or modified records

Incremental models in dbt are designed to optimize performance by processing only new or modified data since the last run, rather than rebuilding the entire dataset. This significantly reduces the amount of data processed and the time required for model execution, especially for large datasets. By appending or merging new records, incremental models save computational resources and speed up data transformations.

Question 28: What does the `--full-refresh` flag do when running incremental models?

Resets the incremental model's unique key column to null
Clears the dbt cache and recompiles all Jinja templates
Refreshes only the most recent partition of the incremental model
Forces dbt to drop and recreate the incremental model as a full table (Correct answer)

Correct answer: Forces dbt to drop and recreate the incremental model as a full table

The `--full-refresh` flag causes dbt to drop the existing incremental table and rebuild it from scratch, identical to running it as a table materialization.

Question 29: What is the recommended way to handle secrets (e.g., database passwords) in a dbt CI pipeline?

Use environment variables injected by the CI platform (Correct answer)
Store them in a seed CSV
Store them in profiles.yml committed to the repo
Hardcode them in dbt_project.yml

Correct answer: Use environment variables injected by the CI platform

Secrets should be passed as environment variables from the CI platform (GitHub Actions, GitLab CI, etc.) and referenced in profiles.yml using `env_var()`.

Question 30: Which configuration parameter can adjust query concurrency limits in dbt Cloud runs?

Warehouse size
Models directory
Seeds config
Threads (Correct answer)

Correct answer: Threads

The `threads` configuration parameter in dbt controls the maximum number of concurrent SQL queries dbt can execute against your data warehouse. Adjusting this setting allows you to fine-tune the parallelism of your dbt runs. Increasing the number of threads can speed up execution by running more models simultaneously, but it should be balanced with your warehouse's capacity to avoid overloading it.

Question 31: What happens when you run `dbt seed --full-refresh`?

The seed table is dropped and recreated from scratch (Correct answer)
Indexes are rebuilt
Source tables are re-imported
Only new CSV rows are appended

Correct answer: The seed table is dropped and recreated from scratch

`--full-refresh` causes dbt to drop the existing seed table before recreating it, ensuring a clean load.

Question 32: What is the best practice for the `profiles.yml` target schema in a developer environment?

Use a personal schema prefixed with the developer's name (Correct answer)
Use an in-memory SQLite database
Create a separate database for each developer
Use the shared production schema

Correct answer: Use a personal schema prefixed with the developer's name

A personal schema (e.g., `dbt_alice`) isolates each developer's models and prevents overwriting shared data.

Question 33: Which practice is essential when collaborating on dbt projects using Git?

Use pull requests for code review and quality (Correct answer)
Push directly to main
Only update on weekends
Avoid committing minor changes

Correct answer: Use pull requests for code review and quality

When collaborating on dbt projects using Git, using pull requests (or merge requests) is an essential practice for maintaining code quality and ensuring proper review. Pull requests facilitate a structured review process where team members can examine proposed changes, provide feedback, and ensure that new code adheres to standards before being merged into the main branch. This prevents errors and promotes knowledge sharing.

Question 34: Which command would you run to build all models in your dbt project?

dbt seed
dbt test
dbt clean
dbt run (Correct answer)

Correct answer: dbt run

To build all models in your dbt project, you would run the `dbt run` command. This command executes the SQL defined in your dbt models, applying the specified materializations (e.g., creating tables or views) in your data warehouse. It processes models in the correct dependency order, ensuring data transformations are applied sequentially.

Question 35: Why should dbt users commit changes to version control regularly?

To speed up tests
To track project history and changes (Correct answer)
To encrypt SQL files
To reduce compile time

Correct answer: To track project history and changes

Regularly committing changes to version control, specifically Git, is crucial for maintaining a detailed history of your dbt project. Each commit acts as a snapshot, allowing you to track who made what changes, when, and why. This history is invaluable for debugging, reverting to previous states, understanding the evolution of your data models, and facilitating collaborative development.

Question 36: What does `dbt docs generate` produce?

A compiled SQL file for each model in the project
A catalog.json and manifest.json used to serve the documentation site (Correct answer)
A test results report in HTML format
A YAML schema file based on existing database tables

Correct answer: A catalog.json and manifest.json used to serve the documentation site

`dbt docs generate` creates `catalog.json` (column metadata from the warehouse) and `manifest.json` (project graph), which are used by `dbt docs serve` to render the documentation site.

Question 37: In dbt, what is an 'ephemeral' materialization?

A model that runs only once and is never refreshed
A model that is deleted from the database after each run
A model stored in a temporary table and dropped after the session ends
A model that is never written to the database and exists only as a CTE in downstream models (Correct answer)

Correct answer: A model that is never written to the database and exists only as a CTE in downstream models

Ephemeral models are not materialized in the database at all; dbt inlines them as CTEs in any downstream model that references them.

Question 38: A `relationships` test in dbt verifies what condition?

Column data types match
Column values exist in a referenced model's column (Correct answer)
Column values are unique
Column values are not null

Correct answer: Column values exist in a referenced model's column

The `relationships` test is a referential-integrity check ensuring every foreign-key value exists in the parent table.

Question 39: How do you limit `dbt test` to only tests on a specific model named `orders`?

dbt test --filter orders
dbt test --model orders
dbt test --select orders (Correct answer)
dbt test --only orders

Correct answer: dbt test --select orders

The `--select` flag (or `-s`) accepts node selectors including model names, tags, and paths.

Question 40: Why should 'SELECT *' be avoided in dbt models for performance?

Because it retrieves unnecessary columns (Correct answer)
Because it increases logging
Because it disables filters
Because it's faster

Correct answer: Because it retrieves unnecessary columns

Using `SELECT *` in dbt models, or any SQL query, is generally discouraged for performance reasons because it retrieves all columns from a table, even those that are not needed. This can lead to increased data transfer, higher memory usage, and slower query execution, especially with wide tables. Explicitly selecting only the required columns reduces the data processed, improving efficiency and clarity.

Question 41: In a dbt Cloud job schedule, what format is used to define cron-based run timing?

Natural language strings like 'every hour'
Unix epoch intervals
Standard 5-field cron expressions (Correct answer)
ISO 8601 duration strings

Correct answer: Standard 5-field cron expressions

dbt Cloud accepts standard cron expressions (e.g., `0 6 * * *`) to schedule jobs at specific times.

Question 42: Which built-in dbt macro returns a surrogate key hashed from one or more column expressions?

dbt_utils.generate_surrogate_key() (Correct answer)
dbt.hash_columns()
dbt_utils.hash_key()
dbt.surrogate_key()

Correct answer: dbt_utils.generate_surrogate_key()

`dbt_utils.generate_surrogate_key([col1, col2])` concatenates and hashes the specified columns to produce a consistent surrogate key.

Question 43: What does the `on-run-start` hook in dbt_project.yml execute?

SQL run before any model or test in the job (Correct answer)
SQL run after every model completes
A validation check before dbt installs packages
A Python script triggered when the server starts

Correct answer: SQL run before any model or test in the job

`on-run-start` hooks run arbitrary SQL statements before any models, seeds, or tests are executed in a dbt invocation.

Question 44: Which Jinja statement would you use to set a local variable inside a dbt model?

{% set my_var = 'value' %} (Correct answer)
{% var my_var = 'value' %}
{% let my_var = 'value' %}
{% assign my_var = 'value' %}

Correct answer: {% set my_var = 'value' %}

`{% set variable_name = value %}` is the Jinja statement for assigning a value to a local variable within a template.

Question 45: What Jinja delimiter is used for control flow statements like `if`, `for`, and `set` in dbt?

{$ ... $}
{% ... %} (Correct answer)
{# ... #}
{{ ... }}

Correct answer: {% ... %}

`{% %}` is used for Jinja statements such as `{% if %}`, `{% for %}`, and `{% set %}` which control logic without producing direct output.

Question 46: Which dbt artifact is essential for enabling Slim CI state comparison?

run_results.json
sources.json
catalog.json
manifest.json (Correct answer)

Correct answer: manifest.json

`manifest.json` is the compiled graph of all nodes and their checksums, which dbt diffs against to find modified nodes.

Question 47: Which materialization type creates a permanent, physically stored table in the data warehouse on every run?

table (Correct answer)
ephemeral
view
incremental

Correct answer: table

The `table` materialization drops and recreates a full physical table in the warehouse on every run, as opposed to a view which is only a stored query.

Question 48: Where are dbt connection credentials and target environment settings typically stored?

dbt_project.yml
schema.yml
profiles.yml (Correct answer)
.env file in the project root

Correct answer: profiles.yml

`profiles.yml` stores database connection credentials and target configurations, typically located in `~/.dbt/` to keep secrets out of version control.

Question 49: Which dbt selector syntax runs a model and all models downstream of it?

my_model*
my_model+ (Correct answer)
+my_model
*my_model

Correct answer: my_model+

The trailing `+` syntax (`my_model+`) selects the specified model and all models downstream of it in the DAG.

Question 50: What is a dbt adapter?

A Jinja macro that adapts SQL syntax between different models
A dbt package that provides pre-built transformations for specific industries
A plugin that allows dbt to connect to and compile SQL for a specific data platform (Correct answer)
A configuration block that adapts profile settings to different environments

Correct answer: A plugin that allows dbt to connect to and compile SQL for a specific data platform

A dbt adapter (e.g., dbt-bigquery, dbt-snowflake) is a plugin that enables dbt to translate its generic operations into platform-specific SQL and API calls.

Question 51: What is the purpose of the 'macros/' directory in a dbt project?

Manages logs
Houses reusable Jinja-based SQL snippets (Correct answer)
Holds compiled models
Stores model descriptions

Correct answer: Houses reusable Jinja-based SQL snippets

The `macros/` directory in a dbt project is used to house reusable Jinja-based SQL snippets, known as macros. These macros allow you to define custom SQL logic or functions that can be called and reused across multiple models, tests, or even other macros. This promotes code reusability, reduces redundancy, and helps maintain consistency in your transformations.

Question 52: Which selector is used in dbt to run only models that differ from a previous state manifest?

--select state:modified (Correct answer)
--select modified:true
--select diff:new
--select changed

Correct answer: --select state:modified

`state:modified` compares the project against a baseline manifest.json to identify nodes with code or config changes.

Question 53: What Jinja construct lets you loop over a list and generate repeated SQL fragments in dbt?

{% for item in list %} ... {% endfor %} (Correct answer)
{% each item %} ... {% end %}
{% loop %} ... {% endloop %}
{% repeat %}

Correct answer: {% for item in list %} ... {% endfor %}

`{% for item in list %}...{% endfor %}` iterates over a list and renders the body for each element, enabling dynamic SQL generation.

Question 54: Which YAML key is used to define generic tests on a column inside a schema.yml file?

constraints
checks
tests (Correct answer)
validations

Correct answer: tests

Under each column definition you add a `tests:` list to attach generic tests.

Question 55: What block in an incremental model filters the source data to only new records?

{% if is_new %}
{% filter new_rows %}
{% if is_incremental() %} (Correct answer)
{% when incremental %}

Correct answer: {% if is_incremental() %}

`{% if is_incremental() %}` is a dbt Jinja macro that returns true only when the model is running in incremental mode (not full-refresh), allowing you to add a WHERE clause.

Question 56: What does `{{ dbt_utils.union_relations(relations=[ref('a'), ref('b')]) }}` do?

Merges schema definitions from two YAML files
Joins two models on a common key
UNIONs all columns from multiple relations into a single result set (Correct answer)
Creates a view combining two sources

Correct answer: UNIONs all columns from multiple relations into a single result set

`dbt_utils.union_relations()` generates a UNION ALL query across a list of relations, aligning columns by name and filling missing ones with NULLs.

Question 57: Where are singular (bespoke) dbt tests stored in a standard project layout?

tests/ (Correct answer)
macros/
models/
analyses/

Correct answer: tests/

Singular tests are plain SQL SELECT files placed in the `tests/` directory; a non-empty result means the test fails.

Question 58: Which dbt source property lets you override the actual database table name that a source points to?

override
table_name
identifier (Correct answer)
alias

Correct answer: identifier

The `identifier:` property under a source table lets you specify the real table name in the warehouse when it differs from the dbt source name.

Question 59: Which YAML key defines how old source data can be before dbt warns about staleness?

freshness (Correct answer)
max_age
loaded_at_threshold
staleness

Correct answer: freshness

The `freshness:` block under a source (or table) defines `warn_after` and `error_after` thresholds for data staleness.

Question 60: How do you define a reusable macro in dbt?

Add it to dbt_project.yml under macros:
Use the def keyword in a .py file
Define it with {% macro name(args) %} ... {% endmacro %} in the macros/ folder (Correct answer)
Create a function in models/macros.sql

Correct answer: Define it with {% macro name(args) %} ... {% endmacro %} in the macros/ folder

Macros are defined with `{% macro macro_name(arg1) %}...{% endmacro %}` blocks stored in any `.sql` file inside the `macros/` directory.

Question 61: Which dbt command can be used to preview model SQL performance by compiling models without executing them?

dbt test
dbt compile (Correct answer)
dbt run
dbt docs generate

Correct answer: dbt compile

The `dbt compile` command is used to process your dbt project and generate the executable SQL for each model, saving it to the `target/` directory. This command is invaluable for previewing the exact SQL that dbt will send to your data warehouse without actually running it. By reviewing the compiled SQL, you can identify potential performance issues or logical errors before execution, aiding in optimization and debugging.

Question 62: What does a singular dbt test return to indicate a failure?

A boolean FALSE value
A NULL value
Any non-empty result set (Correct answer)
An exception

Correct answer: Any non-empty result set

dbt runs the SQL and considers any rows returned as failures; zero rows means the test passes.

Question 63: In dbt, what does a DAG (Directed Acyclic Graph) represent?

The dependency relationships and execution order between models (Correct answer)
The hierarchy of database schemas used in the project
The order of test execution across all models
The branching strategy used for version control

Correct answer: The dependency relationships and execution order between models

The DAG in dbt represents the dependency graph between models, ensuring each model is built only after all its upstream dependencies are complete.

Question 64: What does the 'persist_docs' setting do in dbt to optimize project documentation management?

Removes ephemeral models
Deletes logs
Increases incremental run frequency
Persists documentation metadata in the warehouse (Correct answer)

Correct answer: Persists documentation metadata in the warehouse

The `persist_docs` setting in dbt allows you to store model and column descriptions directly in your data warehouse as metadata. When enabled, dbt will update the comments or descriptions of tables and columns in the database itself. This makes documentation accessible directly through SQL clients and data catalog tools, improving data discoverability and governance beyond the dbt documentation website.

Question 65: Why is using CTEs (Common Table Expressions) beneficial for query performance and maintenance?

Organizes complex queries and aids optimization (Correct answer)
Increases runtime significantly
Requires more hardware resources
Disables indexes

Correct answer: Organizes complex queries and aids optimization

Common Table Expressions (CTEs) improve query performance and maintenance by breaking down complex SQL queries into smaller, more readable, and manageable logical blocks. While CTEs themselves don't always directly optimize execution plans, they allow the database optimizer to potentially reuse intermediate results and can make queries easier to understand and debug. This modularity often leads to better-structured and more efficient queries.

dbt Analytics Engineering Certification Exam

This certification validates an individual's proficiency in using dbt (data build tool) for data transformation, modeling, and analytics engineering best practices.

Questions

90 min

Time Limit

65%

To Pass

Checking for saved progress...

Exam Rules

You can skip questions and return to them later
Flag questions for review before submitting
No feedback shown until you submit the entire exam
Unanswered questions count as wrong — answer everything
10 pretest questions are mixed in and don't affect your score
Timer auto-submits when time runs out
Your progress is auto-saved every 30 seconds