How to Get Started with dbt Canvas

dbt Canvas is a visual, drag-and-drop interface inside dbt Cloud that lets analysts build and edit data models without writing SQL. Launched as generally available in May 2025, it works like a visual pipeline editor: you connect source tables to transformation operators (joins, filters, aggregations, formulas), preview the output at each step, and dbt automatically generates production-grade SQL that feeds into your standard version control and testing pipeline.

What dbt Canvas Does

For years, analytics engineering had a structural bottleneck: analysts who understood the business questions waited in a queue for engineers to write SQL transformations. dbt Canvas removes that queue. Analysts can now build transformations themselves, visually, without needing to know dbt syntax or SQL grammar.

The canvas works like a pipeline graph. Each node represents a transformation — a join, a filter, a calculated column, or an aggregation. You connect nodes by dragging connectors between them. The output of each node can be previewed instantly, so you see exactly how your data changes at each step.

What distinguishes Canvas from standalone BI drag-and-drop tools or Excel is governance. Everything built in Canvas generates actual dbt SQL that goes through your organization's existing code review, testing, and CI/CD process. A business analyst builds a model visually, but it ends up version-controlled and tested exactly like an engineer-written model.

Prerequisites

dbt Canvas is available on dbt Cloud Team and Enterprise plans. You need:

• A dbt Cloud account (Team plan or above)
• A connected warehouse (Snowflake, BigQuery, Databricks, Redshift, or other supported adapters)
• At least one existing dbt project with source tables defined

Canvas works inside the dbt Cloud IDE. If your project is already set up and you can run dbt run from the Cloud IDE, you are ready to start.

Opening Canvas

In the dbt Cloud IDE, open any model file. In the top-right toolbar, you will see a Canvas button alongside the standard SQL editor view. Click it to switch to the visual editor.

To start a new model, go to File > New File, name it with a .sql extension, and switch to Canvas view. Canvas and the SQL editor are synchronized — any change in one reflects in the other immediately.

Building Your First Model

The practical workflow follows four stages: source selection, transformation, preview, and commit.

Step 1: Add source tables

From the left panel, expand the Sources section. This lists all tables and models available in your project. Drag two source tables onto the canvas — for example, customers and orders. Each table becomes a node, and clicking it reveals its column list.

Step 2: Join the tables

From the Operators menu on the left, under the Transform section, drag the Join operator onto the canvas and position it to the right of your two source nodes.

Connect the sources to the Join operator by clicking the output connector (the small + circle) on customers and dragging to the Join tile's left input. Repeat for orders on the right input. Canvas labels the left and right inputs with L and R markers.

In the Join tile's configuration panel:

• Set the Join type (Inner, Left, Right, or Full)
• Map the join keys: for example, customers.customer_id = orders.customer_id

Step 3: Filter rows

Drag a Filter operator onto the canvas and connect it to the Join output. In the configuration panel, add a condition — for example, orders.status != 'cancelled'. Multiple conditions can be combined with AND or OR logic.

Step 4: Aggregate

To roll up data by customer, drag an Aggregation operator and connect it to the Filter output. In the configuration panel:

• Set Group by to customer_id
• Add metrics: COUNT(order_id) AS order_count and SUM(order_total) AS lifetime_value

Canvas presents the aggregation as a form, so you set up COUNT and SUM operations without writing SQL syntax manually — though the Code tab on any node shows the exact SQL being generated.

Step 5: Add a calculated column

Drag a Formula operator and connect it to the Aggregation output. In the formula panel, write expressions like:

CASE
  WHEN lifetime_value > 1000 THEN 'high'
  WHEN lifetime_value > 250 THEN 'medium'
  ELSE 'low'
END AS customer_segment

Formulas support standard SQL expressions. Column name autocomplete is available to reduce errors.

Step 6: Output the model

Drag the Model operator onto the canvas and connect it to your final transformation node. Name it — this becomes the table name in your warehouse. Click Save.

Previewing Data

Every operator has an Output tab in its configuration panel. Click it to run a sample query and see the first 50 rows of data at that step. This is useful for debugging: if a join produces unexpected duplicates, you can see it immediately at the Join node before adding further transformations.

Preview queries run directly against your warehouse. Canvas automatically adds LIMIT 50 so previews stay fast. Nothing is materialized at this stage.

Viewing the Generated SQL

Every transformation you build in Canvas generates dbt SQL. To inspect it, click the Code tab on any operator node, or switch the entire view back to the SQL editor using the toolbar toggle.

The generated SQL uses standard dbt syntax, including ref() calls for upstream models and source() calls for raw tables. Tests and documentation blocks are separate files managed in the normal dbt workflow — Canvas handles the transformation logic.

Using dbt Copilot in Canvas

Canvas integrates with dbt Copilot, an AI assistant that generates transformation nodes from natural language. Click the Copilot button in the Canvas toolbar and describe what you want — for example, "calculate 30-day rolling average revenue per customer grouped by region." Copilot generates a series of connected nodes you can review and adjust.

Copilot works best when your project has well-named sources and models. It uses schema and column names as context. Projects with cryptic column names will produce less accurate output, and manual configuration will be faster in those cases.

Committing and Deploying

Once your model is ready, commit it the same way as any dbt Cloud edit: click Commit and Push, write a commit message, and open a pull request on your connected Git provider (GitHub, GitLab, or Azure DevOps).

Your data engineering team reviews the generated SQL in the pull request diff. If your project uses dbt CI, the test suite runs automatically. When the pull request is approved and merged, the model deploys on the next scheduled dbt Cloud run.

This is the governance advantage of Canvas over standalone BI tools or spreadsheet transformations: the analyst builds faster, but the output is auditable and tested by the same pipeline governing all other models. According to dbt Labs, teams using Canvas have reported a measurable reduction in engineering ticket volume for analyst-driven transformation requests.

When Canvas Fits and When It Does Not

Canvas works well for:

• Analysts who need to build new aggregation tables or segmentation models without engineering support
• Ad hoc work where the end goal is a governed, reusable model rather than a one-time report
• Teams onboarding new analysts unfamiliar with dbt syntax

Canvas is less suited for:

• Complex window functions or recursive CTEs that go beyond the available operators
• Projects where transformation logic is heavily abstracted into Jinja macros or packages

For quick exploratory analysis where you want to ask questions about existing data without setting up a full transformation pipeline, tools like VSLZ let you upload a file or connect a data source and query it in plain English — faster for one-off questions that do not need a governed dbt model behind them.

Summary

dbt Canvas gives analysts a governed path into data transformation without requiring SQL expertise or engineering queue time. The core workflow is: add sources, connect transformation operators, preview output at each step, and commit the generated SQL through a standard pull request review. The result is a version-controlled, testable model built in a fraction of the time a traditional engineering ticket cycle requires.