Last week at dbt Summit, dbt Labs launched Charts. One week later and now you can publish those Charts to MotherDuck! Your dashboard definitions can live in git right next to your dbt pipelines. On MotherDuck, the dashboard experience is even better: your Charts become Dives that refresh live! Setting it up is incredibly simple and takes just 2 config changes.
So why dbt Charts? Charts provide a declarative syntax for dashboards. Sure those are fun words (SQL is declarative too after all!), but why does that help? It makes it easy for agents to write and humans to interpret at a glance. You can manage your dashboards in git just like your SQL, so you can update your visuals in the same PR that your data changes to keep things nicely in sync. Plus even though they are declarative, they still provide powerful interactivity.
How did we build this so quickly? In a word: Claude. In a few more words: the MotherDuck platform is so flexible, you can build just about anything. MotherDuck Dives are full React apps. We automatically host them for you in a sandbox with direct access to your MotherDuck data. That means they support a superset of what dbt Charts can provide and give you a blank canvas to build on. Customers create full apps in Dives, but they still work great for dashboards too.
As an example of a dbt board running on MotherDuck, have a look at this Dive:
I apologize for the pie chart - avert your eyes! This was one of their examples…
The next time you build your project, your Charts will be published as MotherDuck Dives.
How does the dbt package work?
All of the complexity is nicely abstracted away thanks to dbt’s extensible package approach, but here is a bit of detail about what is going on under the hood.
Three core components across SQL, Python, and TypeScript
There are 3 main pieces to the puzzle: SQL to kick things off in an on-run-end hook, Python that runs in MotherDuck’s serverless Flights runtime, and the TypeScript that powers the Dive visualization. There are a few other files in the package, but all are helpers for these 3 core tasks. For example, the Vega Lite plotting library needs to be bundled up before it is loaded into the TypeScript powering the Dive. All of that is nicely abstracted away by the dbt package.
This architecture mirrors MotherDuck’s architecture as well and is part of why this was straightforward to implement. Core data processing in MotherDuck tends to happen in SQL on our compute ducklings. Orchestration and integrating data from a variety of sources (including running dbt!) happens in Python with Flights. Visualization is TypeScript territory, and Dives use React to make that incredibly simple yet flexible. In an AI era where converting between languages is easier than ever, you can pick the right tool for the job all within the MotherDuck platform.
Let’s dig (Dive?) a little deeper into the flow of what happens when you kick off a dbt build.
What happens at runtime?
First, your dbt DAG runs to update your data. When that run is about to complete, dbt kicks off an on-run-end hook to start the rest of this process.
That hook runs a SQL statement that ships in the dbt package. It loads your chart configurations into a MotherDuck table, along with the logic that is needed to transform those charts into Dives. That allows all of the logic to be encapsulated within the dbt package to make it easy to set up. Once the configurations are in MotherDuck, the on-run-end hook uses several other SQL statements to create and run a MotherDuck Flight. A Flight is a Python script that is run in a serverless fashion.
That Flight uses the Python logic within dbt-charts itself to convert your YAML configs into Vega Lite configs. The Flight then creates one Dive for each dashboard and publishes them to MotherDuck using our Dive management SQL functions.
Once the Flight is finished, the dbt job detects its completion and ends.
Then, any authorized user can visit each Dive in their browser and see your dashboards, freshly populated with the latest data.
The beauty of this approach is that it reuses the good work done by the fine folks behind dbt Charts - especially the compilation from YAML to a full dashboard.
dbt Charts 🤝 MotherDuck Dives
So if you want a dbt-governed approach to charts, we’ve got you covered! Your dashboard configuration can be as simple as a YAML file and can be version controlled in git alongside your dbt models. The same dbt build command that runs your pipeline will update your MotherDuck Dive visualizations as well. You can run those dbt models anywhere, including right on MotherDuck with a Python Flight. Thanks to Dives, you get the added benefit of live data refreshes.
The September 2026 DuckDB Ecosystem Newsletter: DuckLabs joins AWS and MotherDuck acquires Tower, DuckDB v2.0-alpha lands, table functions in pure Java, bulk loads into SQL Server, Zarr stores as SQL tables, an infinite canvas for your data, plus a community spotlight on Vladimir Gribanov.
Classify text in SQL with prompt_jev(), powered by TypeSafe's Jev. 100,000 rows labeled in 40 seconds for $0.50 at frontier-LLM accuracy. Live on paid plans.