dbt Analytics Engineering Certification Exam — Questions and Answers

Question 1: What column does dbt automatically add to a snapshot table to mark the time a record became current?

dbt_created_at
dbt_updated_at
dbt_valid_from (Correct answer)
snapshot_start

Correct answer: dbt_valid_from

`dbt_valid_from` is automatically populated with the timestamp when a snapshot row became the current version of the record.

Question 2: Which dbt command generates a freshness report for all sources that have a freshness block defined?

dbt test --freshness
dbt source freshness (Correct answer)
dbt run --freshness
dbt docs generate

Correct answer: dbt source freshness

`dbt source freshness` scans each source table's `loaded_at_field` and writes results to `sources.json` in the target/ directory.

Question 3: 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 that is never written to the database and exists only as a CTE in downstream models (Correct answer)
A model stored in a temporary table and dropped after the session ends

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 4: When using dbt Core, which directory stores compiled SQL and run artifacts by default?

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

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 5: Which Jinja statement would you use to set a local variable inside a dbt model?

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

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 6: Which materialization type creates a permanent, physically stored table in the data warehouse on every run?

view
table (Correct answer)
ephemeral
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 7: Which dbt materialization type reduces query execution time by persisting data in tables rather than views?

Ephemeral
View
Table (Correct answer)
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 8: In dbt, what does a DAG (Directed Acyclic Graph) represent?

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

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 9: Which dbt macro is used to generate a cross-database compatible date-trunc expression?

dbt.date_trunc() (Correct answer)
dbt_utils.date_trunc()
dbt_utils.trunc()
dbt.trunc_date()

Correct answer: dbt.date_trunc()

`dbt.date_trunc(datepart, date)` is a built-in cross-database macro that adapts the date_trunc SQL function for each supported adapter.

Question 10: What does the `var()` function do in a dbt model?

Retrieves an environment variable
Declares a Jinja variable
Creates a SQL variable
Reads a project variable defined in dbt_project.yml or passed via --vars (Correct answer)

Correct answer: Reads a project variable defined in dbt_project.yml or passed via --vars

`{{ var('name', default) }}` reads variables from the `vars:` section of dbt_project.yml or those overridden at runtime with `--vars`.

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

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
A compiled SQL file for each model in the project

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 12: What does the `+schema` config in dbt_project.yml do when set for a model folder?

Renames the model
Locks the schema from future changes
Sets the source schema to read from
Appends a custom suffix to the target schema for that folder's models (Correct answer)

Correct answer: Appends a custom suffix to the target schema for that folder's models

`+schema` defines a custom schema suffix that dbt appends to the target schema, allowing logical separation (e.g., `dbt_<user>_staging`).

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

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

Correct answer: tests/

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

Question 14: Which dbt Core command compiles SQL without executing it against the warehouse?

dbt compile (Correct answer)
dbt validate
dbt dry-run
dbt parse

Correct answer: dbt compile

`dbt compile` resolves all Jinja and ref/source calls and writes the compiled SQL to the `target/compiled/` directory without running queries.

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

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

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 16: Why is using CTEs (Common Table Expressions) beneficial for query performance and maintenance?

Increases runtime significantly
Organizes complex queries and aids optimization (Correct answer)
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.

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

Because it increases logging
Because it disables filters
Because it retrieves unnecessary columns (Correct answer)
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 18: What is a dbt adapter?

A plugin that allows dbt to connect to and compile SQL for a specific data platform (Correct answer)
A Jinja macro that adapts SQL syntax between different models
A dbt package that provides pre-built transformations for specific industries
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 19: Which dbt command is used to preview generated documentation in a local browser?

dbt debug
dbt run
dbt seed
dbt docs serve (Correct answer)

Correct answer: dbt docs serve

After generating the documentation files with `dbt docs generate`, the `dbt docs serve` command launches a local web server. This server hosts the generated documentation website, allowing you to view and interact with your project's documentation in a web browser. It provides an accessible way to explore your data models, lineage, and tests without needing to deploy the documentation externally.

Question 20: What dbt Cloud feature lets a CI job use prod table results for unmodified models instead of rebuilding them?

State comparison
Model caching
Run bypass
Deferral (Correct answer)

Correct answer: Deferral

Deferral (`--defer`) tells dbt to use a different environment's tables for refs that are not being rebuilt in the current run.

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

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

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 22: What node selector prefix lets you run `dbt test` on only source tests?

raw:*
source:*
src:*
sources:* (Correct answer)

Correct answer: sources:*

The `sources:` selector prefix targets source nodes, so `dbt test --select sources:` runs only source-defined tests.

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

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

Correct answer: dbt deps

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

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

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

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 25: What Jinja construct lets you loop over a list and generate repeated SQL fragments in dbt?

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

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 26: What built-in dbt test verifies that a column contains no NULL values?

not_null (Correct answer)
accepted_values
relationships
unique

Correct answer: not_null

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

Question 27: What does the `vars` block in `dbt_project.yml` enable?

Specifying environment-specific database connection settings
Listing all test types available for schema validation
Declaring Jinja macros reusable across all models
Defining project-wide variables accessible via the `var()` function (Correct answer)

Correct answer: Defining project-wide variables accessible via the `var()` function

The `vars` block defines project-level variables accessible via `var('variable_name')` in models and macros, and can be overridden at runtime with `--vars`.

Question 28: What environment variable or flag tells dbt where to find the baseline manifest for state comparison?

--baseline-dir
--state or DBT_STATE (Correct answer)
DBT_MANIFEST
--manifest-path

Correct answer: --state or DBT_STATE

The `--state` flag (or `DBT_STATE` env var) specifies the directory containing the `manifest.json` to use as the comparison baseline.

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

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)
Clears the dbt cache and recompiles all Jinja templates
Resets the incremental model's unique key column to null

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 30: What does `dbt debug` do?

Displays the full DAG for the current project
Shows detailed SQL output for each model as it runs
Tests all data quality constraints defined in schema.yml
Validates the project configuration and database connection (Correct answer)

Correct answer: Validates the project configuration and database connection

`dbt debug` checks that the project configuration is valid and that dbt can successfully connect to the target data warehouse using the current profile.

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

dbt run --set key=value
dbt run --env key=value
dbt run --vars '{key: value}' (Correct answer)
dbt run --config 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 32: 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
Create a function in models/macros.sql
Define it with {% macro name(args) %} ... {% endmacro %} in the macros/ folder (Correct answer)

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 33: Which command is used to validate the structure and syntax of a dbt project?

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

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 34: Which dbt Jinja function safely reads an environment variable and supports a default value?

{{ get_env('VAR_NAME') }}
{{ os.environ['VAR_NAME'] }}
{{ var('VAR_NAME', 'default') }}
{{ env_var('VAR_NAME', 'default') }} (Correct answer)

Correct answer: {{ env_var('VAR_NAME', 'default') }}

`env_var('NAME', 'default')` reads a process environment variable and returns the default if the variable is not set.

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

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

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 36: What does `dbt test --store-failures` do at the command-line level?

Creates a test results JSON artifact
Sends results to dbt Cloud
Writes failures to a local CSV
Enables store_failures for all tests in the run (Correct answer)

Correct answer: Enables store_failures for all tests in the run

Passing `--store-failures` at runtime overrides individual test configs to persist failing rows for every test in that run.

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

Run entire dataset each time
Skip model compilation
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 38: What is the purpose of the `manifest.json` file generated by dbt?

Stores the raw SQL output of every compiled model
Logs execution times and row counts for each model run
Defines the schema and column types for all target tables
Contains a complete representation of the dbt project including all nodes and their relationships (Correct answer)

Correct answer: Contains a complete representation of the dbt project including all nodes and their relationships

`manifest.json` is a comprehensive artifact capturing all project resources (models, tests, sources, macros) and their metadata, used by dbt docs and CI tooling.

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

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

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 40: Why should dbt users commit changes to version control regularly?

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

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 41: Which dbt artifact file contains a summary of test results after `dbt test` runs?

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

Correct answer: run_results.json

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

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

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

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 43: Which dbt Cloud concept separates the environment where CI tests run from where production runs land?

Tenants
Namespaces
Environments (Correct answer)
Workspaces

Correct answer: Environments

dbt Cloud Environments (e.g., 'CI', 'Production') hold distinct connection credentials, dbt versions, and custom schemas for isolation.

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

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

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 45: Which built-in dbt generic test checks that all values in a column are unique?

unique (Correct answer)
not_null
accepted_values
relationships

Correct answer: unique

The `unique` generic test asserts that every row in a column has a distinct value.

Question 46: Which command generates documentation for dbt models, tests, and sources?

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

Correct answer: dbt docs generate

The `dbt docs generate` command scans your dbt project, including models, sources, tests, and their descriptions, to create a comprehensive documentation website. This command produces static HTML files that provide a detailed overview of your data lineage, model definitions, and column descriptions. It's the first step in creating human-readable documentation for your data warehouse.

Question 47: Which Git command is used to create a new branch for feature development?

git commit -m
git merge main
git checkout -b (Correct answer)
git stash

Correct answer: git checkout -b

The `git checkout -b <branch-name>` command is used to create a new branch and immediately switch to it. This is a fundamental practice in Git for feature development, as it allows developers to work on new features or bug fixes in isolation without affecting the main codebase. Once the work is complete, the branch can be merged back into the main branch.

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

run_results.json
catalog.json
sources.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 49: Which command executes all dbt models in a project?

dbt run (Correct answer)
dbt execute
dbt build
dbt deploy

Correct answer: dbt run

`dbt run` executes all models in the project, materializing them in the target data warehouse according to their configured materialization type.

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

dbt raises a compilation error (Correct answer)
It returns None
It returns an empty string
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 51: In dbt, what is a 'model' primarily used for?

Transform data using SQL (Correct answer)
Send API requests
Configure server settings
Store user permissions

Correct answer: Transform data using SQL

In dbt, a 'model' is primarily a SQL file that defines a specific data transformation. These models take raw data from source tables and apply SQL logic to clean, combine, aggregate, or reshape it into a more usable format. They are the core building blocks for creating a structured and transformed data layer in your data warehouse.

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

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

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 53: Which configuration parameter can adjust query concurrency limits in dbt Cloud runs?

Threads (Correct answer)
Warehouse size
Models directory
Seeds config

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 54: What does `dbt run --full-refresh` do to an incremental model?

Appends all historical records again
Rebuilds the table from scratch, ignoring the existing data (Correct answer)
Skips the model entirely
Converts it to a view temporarily

Correct answer: Rebuilds the table from scratch, ignoring the existing data

`--full-refresh` drops and recreates an incremental model's table from the ground up, equivalent to the initial build.

Question 55: Which dbt package is the most widely adopted for extending the set of generic tests beyond the four built-in ones?

dbt-utils (Correct answer)
dbt-audit-helper
dbt-codegen
dbt-expectations

Correct answer: dbt-utils

`dbt-utils` ships dozens of reusable macros and generic tests such as `expression_is_true` and `recency`.

Question 56: Which command initializes a new dbt project in your working directory?

dbt start
dbt create
dbt new-project
dbt init (Correct answer)

Correct answer: dbt init

The `dbt init` command is used to initialize a new dbt project in your current working directory. When executed, it sets up the basic directory structure and essential configuration files, such as `dbt_project.yml`. This command provides a foundational template, allowing you to quickly start building your data transformation pipeline.

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

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

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 58: In a dbt snapshot using the `check` strategy, what must you specify under `check_cols`?

The list of columns whose changes should be tracked (Correct answer)
The timestamp column to compare
All columns in the source table
The primary key column only

Correct answer: The list of columns whose changes should be tracked

`check_cols` lists the specific columns dbt should hash and compare; if any of them change, a new snapshot row is created.

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

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

Correct answer: --select state:modified

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

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

expression_is_true
not_decreasing
recency
monotonic_increase (Correct answer)

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 61: Which directory stores dbt snapshot files by default?

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

Correct answer: snapshots/

Snapshot `.sql` files are placed in the top-level `snapshots/` directory of a dbt project.

Question 62: What built-in dbt variable returns the current target name (e.g., 'dev' or 'prod')?

{{ target.name }} (Correct answer)
{{ env_var('DBT_TARGET') }}
{{ run_started_at }}
{{ this.schema }}

Correct answer: {{ target.name }}

`{{ target.name }}` returns the name of the active target as defined in profiles.yml, commonly used to branch logic between environments.

Question 63: What config key specifies the column(s) used to match existing rows in an incremental merge strategy?

match_on
unique_key (Correct answer)
primary_key
merge_key

Correct answer: unique_key

`unique_key` tells dbt which column(s) to use as the join condition when merging new rows into the existing incremental table.

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

checks
validations
constraints
tests (Correct answer)

Correct answer: tests

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

Question 65: Which `incremental_strategy` inserts all new rows without checking for duplicates, suitable for append-only event streams?

delete+insert
merge
upsert
append (Correct answer)

Correct answer: append

The `append` strategy simply inserts new rows without any deduplication or updating, ideal for immutable event logs.

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