Mock Dbt Project: A Quick Start Guide

Alex Johnson

-Oct 25, 2025

Creating a mock dbt (data build tool) project is an excellent way to familiarize yourself with dbt's functionalities, experiment with different configurations, and test various data transformation techniques without impacting production environments. This guide will walk you through setting up a basic dbt project that you can use for learning and testing purposes.

Why Create a Mock dbt Project?

There are several compelling reasons to set up a mock dbt project:

Learning dbt: A mock project provides a safe space to learn dbt's syntax, commands, and best practices without the pressure of affecting real data pipelines. You can experiment with different dbt features and understand how they work in a controlled environment.
Testing Configurations: dbt projects often involve intricate configurations, such as profiles, data sources, and target schemas. A mock project allows you to test these configurations thoroughly before deploying them to production, ensuring that everything works as expected.
Experimenting with Transformations: Data transformations are at the heart of dbt. A mock project lets you try out various transformation techniques, such as filtering, aggregating, and joining data, without the risk of corrupting your actual data.
Reproducible Testing: With a mock project, you can easily reproduce errors or unexpected behaviors, making it easier to debug and resolve issues. This is particularly useful when collaborating with other team members.
Isolation from Production: The most crucial advantage is the isolation from your production environment. Any mistakes or misconfigurations in your mock project won't affect your live data or critical systems.

Prerequisites

Before you start creating your mock dbt project, make sure you have the following prerequisites in place:

Python: dbt is a Python package, so you'll need Python installed on your machine. It's recommended to use Python 3.7 or higher.
pip: pip is the package installer for Python. It's usually included with Python installations. Make sure you have pip installed and updated.
dbt: Install dbt using pip. Open your terminal and run the following command:
```
pip install dbt-core
```
Note: You may need to install a dbt adapter depending on the database you plan to use. For example, if you're using Snowflake, you'll need to install dbt-snowflake. The command would be pip install dbt-snowflake.
Text Editor or IDE: Choose a text editor or Integrated Development Environment (IDE) for writing and editing dbt code. Popular options include VSCode, Sublime Text, and Atom.

Step-by-Step Guide to Creating a Mock dbt Project

Step 1: Initialize a New dbt Project

Open your terminal and navigate to the directory where you want to create your dbt project. Then, run the following command:

dbt init mock_dbt_project

dbt will prompt you to choose a database adapter. For a mock project, you can select postgres or snowflake. If you don't have a real database connection, you can still proceed by entering dummy connection details. dbt will create a project structure with several files and directories.

Step 2: Configure Your dbt Project

The dbt_project.yml file is the heart of your dbt project. It contains essential configurations, such as the project name, models path, and profile name. Open dbt_project.yml in your text editor and ensure the following configurations are set correctly:

name: 'mock_dbt_project'
version: '1.0.0'
config-version: 2

profile: 'mock_dbt_project'

model-paths: ["models"]
seed-paths: ["data"]
test-paths: ["tests"]

clean-targets:
  - "target"
  - "dbt_packages"

models:
  mock_dbt_project:
    +\materialized: view

name: The name of your dbt project.
version: The version of your project.
profile: The name of the dbt profile that dbt will use to connect to your data warehouse.
model-paths: The directory where your dbt models are located.
seed-paths: The directory where your seed data files are located.
test-paths: The directory where your dbt tests are located.

Step 3: Configure Your dbt Profile

The profiles.yml file contains the connection details for your data warehouse. dbt uses this file to authenticate and connect to your database. The location of this file varies depending on your operating system. Typically, it's located in ~/.dbt/profiles.yml.

Open profiles.yml and add the connection details for your chosen database. If you don't have a real database, you can enter dummy details for now. Here's an example of a profiles.yml configuration for a mock Snowflake database:

mock_dbt_project:
  target: dev
  outputs:
    dev:
      type: snowflake
      account: your_account
      user: your_user
      password: your_password
      database: your_database
      warehouse: your_warehouse
      schema: your_schema
      threads: 1
      client_session_keep_alive: False
      query_tag: dbt

target: The target environment (e.g., dev, prod).
type: The type of database (e.g., snowflake, postgres).
account, user, password, database, warehouse, schema: The connection details for your database.

Step 4: Create Mock Data

To work with dbt, you'll need some data. Create a data directory in your dbt project and add a CSV file containing sample data. For example, you can create a file named raw_orders.csv with the following data:

order_id,customer_id,order_date,amount
1,101,2023-01-01,100.00
2,102,2023-01-02,200.00
3,101,2023-01-03,150.00
4,103,2023-01-04,300.00
5,102,2023-01-05,250.00

Step 5: Create dbt Models

Now, let's create some dbt models to transform our mock data. Create a models directory in your dbt project. Inside the models directory, create a SQL file named orders.sql with the following code:

{{ config(materialized='view') }}

SELECT
    order_id,
    customer_id,
    order_date,
    amount
FROM {{
    ref('raw_orders')
}}
WHERE amount > 100

This model selects data from the raw_orders seed file and filters orders with an amount greater than 100.

Step 6: Seed Your Data

Before running your dbt models, you need to seed your data. Seeding uploads the CSV file to your data warehouse as a table. Run the following command in your terminal:

dbt seed

dbt will upload the raw_orders.csv file to your database as a table named raw_orders.

Step 7: Run Your dbt Models

Now, you can run your dbt models to transform the data. Run the following command in your terminal:

dbt run

dbt will execute the orders.sql model and create a view (as specified in the model configuration) in your database.

Step 8: Test Your dbt Models

Testing is an essential part of the dbt workflow. Create a tests directory in your dbt project. Inside the tests directory, create a YAML file named orders.yml with the following code:

version: 2

models:
  - name: orders
    columns:
      - name: order_id
        tests:
          - unique
          - not_null
      - name: amount
        tests:
          - not_null

This test checks that the order_id column is unique and not null, and the amount column is not null. Run the following command in your terminal to execute the tests:

dbt test

dbt will execute the tests and report any failures.

Advanced Tips for Your Mock dbt Project

Use Jinja: dbt uses Jinja, a templating language, to write dynamic SQL code. Explore Jinja's features, such as variables, loops, and conditionals, to create more complex and reusable dbt models.
Implement Snapshots: Snapshots capture the state of your data over time. Implement snapshots in your mock project to understand how dbt handles historical data and change tracking.
Explore Packages: dbt packages are reusable components that you can install in your dbt project. Explore different packages to add functionality, such as data quality checks, data profiling, and more.
Use Macros: Macros are reusable code snippets that you can define in your dbt project. Use macros to encapsulate common logic and avoid code duplication.
Integrate with CI/CD: Integrate your mock dbt project with a Continuous Integration/Continuous Deployment (CI/CD) pipeline to automate the testing and deployment of your dbt models.

Conclusion

Creating a mock dbt project is an invaluable exercise for anyone looking to learn dbt, test configurations, or experiment with data transformations. By following the steps outlined in this guide, you can quickly set up a basic dbt project that you can use for learning and testing purposes. Remember to leverage dbt's advanced features, such as Jinja, snapshots, and packages, to take your dbt skills to the next level. Happy transforming!

For more information on dbt, visit the dbt official documentation. This resource provides comprehensive guides, tutorials, and best practices for using dbt effectively.