Speed, simplicity, cost savings: Experience the dbt Fusion engine

Data teams today face three daunting challenges: improving data quality, improving velocity, and managing costs.

As an industry, we’ve made significant progress in building pipelines and accessing compute resources. However, organizations struggle with data quality issues, ambiguous ownership, and stakeholder literacy. Overcoming these challenges requires more than incremental improvements to existing tools.

The solution lies in rethinking the foundation of how data transformation works. The dbt Fusion engine, a complete rewrite of the dbt engine built in Rust with SQL comprehension capabilities, represents a fundamental shift in analytics engineering.

By understanding SQL at a deeper level and introducing state management, Fusion delivers dramatic performance improvements, substantial cost savings, and a developer experience that fundamentally changes how teams build and maintain data pipelines.

Why we rewrote dbt from scratch

While dbt's authoring layer has evolved to provide developers with increasingly sophisticated functionality, the original dbt Core engine has remained built on the same technology and design principles from 2016. This created two fundamental problems that couldn't be solved iteratively.

First, dbt Core's Python-based architecture became a performance bottleneck. For larger projects, parse times and compilation could become unworkable. Even smaller projects needed step-change improvements to power truly excellent developer experiences.

Second, dbt Core renders SQL but doesn't comprehend it. The engine treats SQL as text to be templated and passed to the warehouse, but lacks understanding of SQL semantics. This meant any functionality requiring deep knowledge of SQL code structure—like impact analysis or intelligent optimization—was impossible to build.

The solution required rebuilding the engine entirely.

The dbt Fusion engine is fully rewritten in Rust and incorporates SQL compiler technology from SDF (recently acquired by dbt). Not a single line of code is shared between dbt Core and Fusion, aside from adapter macros. The result is an engine built for speed, one that truly understands code, and one that powers next-generation developer experiences.

Performance that transforms workflows

The speed improvements in Fusion are immediately noticeable. Parse times are up to 30 times faster than dbt Core, and full-project compilation is twice as quick. The Visual Studio Code extension can recompile entire projects in the background with near-instant turnaround for individual files.

This performance leap changes how developers work. Instead of running a model to check for errors, developers get real-time feedback as they type. There's no more cycle of writing code, running dbt build, discovering a typo, fixing it, and running again. The development loop tightens dramatically.

The Rust architecture enables this performance without requiring any cloud connectivity or compute charges during development. Everything happens locally, instantly, without a round-trip to the warehouse.

SQL comprehension unlocks developer experience innovations

Fusion's SQL compiler represents a fundamental advancement. Unlike dbt Core, which treats SQL as templated text, Fusion parses and understands SQL syntax and semantics across data platforms. It knows about columns, functions, type signatures, and how transformations propagate through data lineage.

The VS Code extension powered by Fusion introduces capabilities that fundamentally change the development experience.

At its most basic level, Fusion catches simple errors without round-tripping. For example, without Fusion, if you use a SQL window function in an incorrect context (i.e., outside of SELECT, QUALIFY, or ORDER BY clauses), you’d have to check it into source control, run your Continuous Integration (CI) pipeline, wait for the failure, fix it, and then check in a new change.

By contrast, the VS Code extension catches both simple and complex SQL errors immediately, so you can fix them before ever typing git add. That shaves significant time off of your development cycles.

But that’s not all. Common Table Expression (CTE) Preview lets developers preview the output of CTEs without commenting out downstream code. Fusion understands the CTE lineage and runs only those models and downstream models that need to be run.

The Compare Changes feature, currently in alpha testing, performs data diffs during development. It computes the exact impact of code changes on production data before deployment.

Compare Changes shows removed records, modified values at the column level, and changes to column metadata. This enables developers to detect changes that might compile and seem harmless but that could have a significant impact on the data.

For example, removing the LEFT keyword from the JOIN below might seem innocuous. However, Compare Changes can reveal that it eliminates 99.7% of rows.

Local compilation in Fusion does more than just look at one file. Impact analysis runs continuously across dbt projects as devs make changes. Fusion highlights all downstream models that break when upstream changes occur. This keeps the mental load manageable—developers don't need to remember every dependency chain in their heads.

This also means you can leverage Fusion to perform refactoring. For example, if you rename a column in one model, Fusion will rename it automatically in all downstream models.

Cross-platform compatibility checking leverages SQL comprehension in a unique way. Developers can switch the target warehouse in their project configuration, and Fusion immediately identifies models that use platform-specific functions. For organizations maintaining vendor flexibility or planning migrations, this makes multi-warehouse support practical.

State-aware orchestration drives 29% cost savings

One of Fusion's most significant innovations is state-aware orchestration. The engine understands the current state of data sources and can optimize execution based on what's actually changed. When sources have no new data, Fusion skips building downstream models that would simply recompute the same results.

Take the example of a data model, represented here by a directed acyclic graph (DAG), with seven tables.

src_orders has no new data since the last run. It’s stale. src_customers has new data - it’s fresh.

The models that depend on src_customers - e.g., stg_customers - are also out of date, since they’re dependent on src_orders, and need to be run. However, all of the models depending on src_orders don’t need to be recalculated. They would just be computing the same result unnecessarily.

This is where state-aware orchestration comes in. Fusion can detect this state and reuse the models for everything dependent on src_orders instead of re-running those models. That’s money in your pocket.

This aspect of Fusion simplifies scheduling. Now, you don’t have to worry about timing your data pipeline runs around data arrival times. You can run your pipelines on a set schedule, confident that Fusion will only process what needs to be changed.

Early testing shows that this basic capability alone delivers an average 10% cost reduction. But Fusion goes further with advanced configurations that enable fine-grained control.

In practice, this delivers substantial cost savings. Simply enabling state-aware orchestration provides approximately 10 percent cost reduction on average. Adding advanced configurations like updates_on and build_after adds another 15 percent. These configurations let teams specify precisely when models should update—whether when all upstream dependencies have fresh data, any upstream has fresh data, or specific sources reach defined freshness thresholds.

Test optimization provides additional savings. Fusion can aggregate multiple tests per column into a single query, reducing testing costs significantly. It also performs intelligent column-level lineage analysis to skip redundant tests. If a column is simply copied from one model to another without transformation, Fusion recognizes that testing it in both locations is unnecessary and skips the downstream test.

Combined, these optimizations can deliver up to a 29% reduction in deployment costs - 10% from state-aware orchestration, 15% from advanced configurations, and 4% from testing savings.

Rich context for AI-ready data

Fusion's SQL comprehension and metadata capabilities position it as an ideal foundation for AI-assisted development. Traditional approaches to AI coding assistance lack context about SQL semantics, leading to lower-quality outputs and requiring expensive query execution to validate changes.

Fusion provides AI agents with rich metadata about column lineage, type signatures, and impact analysis. An AI renaming a column can immediately understand which downstream assets are affected without executing queries. This reduces both the cost of AI-assisted development and increases the fidelity of generated code.

The speed and rigor of Fusion help produce higher-quality AI-generated code. Developers can vet, validate, and comprehend AI suggestions more efficiently when the development environment provides instant feedback about correctness and impact.

Open data infrastructure and vendor flexibility

By abstracting SQL from specific dialects and understanding it semantically, Fusion enables truly platform-independent data workloads. Combined with open table formats like Apache Iceberg, this creates an ideal architecture for organizations that want to avoid vendor lock-in while maintaining sophisticated data transformation capabilities.

Fusion works identically whether deployed locally on the CLI or used on the dbt platform. Core users can adopt Fusion without any contracts or cloud requirements. The engine runs anywhere, on any supported platform, maintaining the open-source principles that have defined dbt since its inception.

Real-world impact at DPG Media

The benefits of Fusion extend beyond technical specifications.

DPG Media, a major media company in Belgium and the Netherlands with more than 80 print publications, has been a dbt customer for years. DPG analytics engineer Sonja Strempel says dbt reduced data quality issues, consolidated repetitive data preparation tasks, and enabled users to self-service ad hoc questions.

Strempel says the company has been using Fusion in production for several months. Their analytics teams work across multiple dbt projects, each with its own repository, all centrally managed through Terraform.

The most immediate impact was the elimination of the constant context switching between VS Code and dbt. Previously, developers would write code locally, then switch to dbt to run and validate changes. With Fusion's VS Code extension, everything happens in a single environment.

Live error detection proved particularly valuable. Small mistakes like typos or incorrect column references get caught immediately, rather than after running dbt build and waiting for results. This saved significant time across both small tasks and large refactoring projects.

For schema redesigns and table refactoring, the combination of impact analysis and column lineage visualization made complex changes much safer. Developers could see exactly which downstream models would be affected by changes and ensure all references were updated correctly before creating pull requests.

The column-level lineage feature transformed how teams onboard new members and collaborate on existing code. When explaining models to colleagues, developers can interactively show where columns originate and how they transform through the DAG. The ability to command-click through to source definitions makes exploring unfamiliar codebases intuitive.

From a business perspective, these developer experience improvements translate directly to faster time-to-insights. When stakeholders request new metrics or analysis, analytics teams can deliver more efficiently. The reduced error rate and better impact analysis also increase trust in data quality.

Getting started with Fusion

The dbt Fusion engine is currently in preview, with expanding availability across hosted dbt projects. dbt Core users can install Fusion locally and begin using it immediately. The VS Code extension is available in the VS Code extension marketplace and automatically installs the Fusion-powered CLI.

For organizations with existing dbt projects, migration tooling helps address the changes required. The dbt-autofix helper automatically handles many common migration tasks. While any major version upgrade requires some code changes, the goal is maximal compatibility with existing dbt code.

Fusion represents the future of dbt—faster, smarter, and built for the AI-driven analytics landscape ahead. Early adopters are already seeing significant benefits in developer productivity, cost optimization, and data quality.

The technology that seemed impossible with dbt Core is now becoming a reality, one deployment at a time.