Read a Paradime State run

Private preview. Paradime State is in private preview. To get early access for your workspace, reach out to the Paradime team at support@paradime.io.

Every state-aware dbt run, dbt build, and dbt snapshot ends with a Paradime State summary: what the run built, skipped, and cloned, and how much compute it saved. Find it at the end of the Bolt run logs and in the Code IDE terminal.

The summary

=========== Paradime State ===========
  command  : <command>
  executed : <count>  <nodes>
  skipped  : <count>  <nodes>
  state    : <seconds>s  (network time in the state layer)
  probe    : <seconds>s  (warehouse metadata, <calls> call(s), fetched in the background ...)
  cloned   : <count>  <nodes>
  precloned: <count>  <nodes>  (incrementals/snapshots)
  rejudged : <count>  <nodes>  (decided again after their upstreams built)
  tests replayed from cache: <count>  (<failed> failed)
  passes   : snapshots and models ran together (a snapshot reads a model this build rebuilds)
  not built: <count>  <nodes>  (the dbt step failed them or never ran them)
  not attempted (upstream failed): <count>  <nodes>
  compute saved (est.): <duration>
=============================================

Line	What it tells you	Shown
`command`	`run`, `build`, or `snapshot`.	Always
`executed`	The nodes dbt™ built in this run. A test counts once it has run, whether it passed or failed.	Always
`skipped`	The nodes reused without running.	Unless Paradime State stood aside
`state`	Time spent talking to the state service. When Paradime State stood aside and your command ran as plain dbt™, this line replaces `skipped` and gives the reason, such as a compile failure or an unsupported warehouse.	When above zero, or when Paradime State stood aside
`probe`	Time spent reading warehouse metadata, which happens in the background, and how long nodes waited for it.	When metadata was read
`warning`	A metadata read took longer than 15 seconds (with a suggested fix), or DuckDB or MotherDuck sources have no freshness column.	When it applies
`cloned`	Tables copied from another environment instead of rebuilt.	When above zero
`precloned`	Incremental models and snapshots copied from the deferred environment before they built. See `pre_clone`.	When above zero
`rejudged`	Nodes downstream of a node that built in this run, decided again after it built so that they could be cloned instead of rebuilt. Only on Snowflake, BigQuery, Databricks, and Redshift, while clones are allowed.	When above zero
`tests replayed from cache`	Tests whose previous result was reused. Each replayed failure is listed as `FAIL (cached)` and still fails the run.	When above zero
`passes`	Snapshots and models ran as one pass, because a snapshot reads a model this build rebuilt, so the snapshot ran after that model.	When it applies
`not built`	Nodes that were due to build but that dbt™ didn’t report as built, because their dbt™ step failed them or never ran them.	When above zero
`not attempted (upstream failed)`	Nodes that didn’t run because something upstream of them failed.	When above zero
`compute saved (est.)`	An estimate of the build time avoided, based on how long the skipped and cloned nodes took when they last built.	Always

A line that lists more than 20 nodes shows the first 20, followed by how many more there are (+N more). In the Code IDE, paradime-state explain lists them all.

What dbt™‘s own output shows

Paradime State only asks dbt™ to build the nodes that need it, so dbt™‘s own log lines cover those nodes and no others:

The project compiles first.
dbt™ then builds the nodes that need it, which the summary lists under executed, or under not built if they failed. Clones show up as dbt clone output, and snapshots that run in one pass with models show up as dbt build output.
Skipped nodes don’t appear at all. When every node is skipped, dbt™ builds nothing, and the summary is the only record of the run.

Notices

When something affects the run, Paradime State prints a line that starts with paradime-state:. The most common:

The notice says	What happened
`proceeding without state optimization`	Paradime State couldn’t use its service for the rest of the run, so the remaining nodes built normally. The next run tries again.
`rejected this run as UNAUTHENTICATED`	The state service didn’t accept the run’s access. In the Code IDE, your access has expired: see The Code IDE stopped skipping after a day.
`no warehouse probe for adapter`	Your warehouse isn’t supported, so the run used plain dbt™.
`compile failed`	The project didn’t compile, so Paradime State stood aside and ran your command as plain dbt™. See If the project fails to compile.
`wrote no run results`	A dbt™ step ended without writing its results, so Paradime State records nothing from that step.
`built instead of cloned`	A clone wasn’t possible for the listed nodes, so they were built. The notice says why.
`still pending after`	Warehouse metadata didn’t arrive within `PARADIME_STATE_PREBUILD_WAIT_S`, so the listed nodes built without it and rebuild on the next run.
`confirm(s) not delivered`	Some results weren’t recorded, so those nodes rebuild on the next run.
`another run had already advanced`	Another run changed the recorded state while this one was running, so some decisions may be conservative and build more than needed.
`--full-refresh`	How a full refresh interacts with Paradime State. See Force a rebuild.

Explain a run in the Code IDE

paradime-state explain shows why each node was skipped, cloned, or built in the last run you made in your Code IDE. Run it in the terminal, from your dbt™ project directory:

paradime-state explain                      # summary of your last run
paradime-state explain --node fct_orders    # one node's full decision trail
paradime-state explain --all --sort node    # every decision, skips included
paradime-state explain --json               # machine-readable output

By default you get a summary: the total for each decision with the compute it saved, the nodes that saved the most, and every node that was built or cloned, with the reason. Skips are counted rather than listed; add --all to list them.

Option	What it does
`--node <name>`	One node in full: its decision, the reason, the clone source, and each check along the way.
`-s`, `--select <node> ...`	Only these nodes.
`--decision SKIP`, `CLONE`, or `EXECUTE`	Only decisions of one kind.
`--sort saved`, `node`, or `decision`	Row order. The default, `saved`, lists the most compute saved first.
`--top <n>`	How many top savers to list. The default is 10.
`--all`	Every decision, skips included.
`-v`, `--verbose`	Every selected node in full.
`--json`	Machine-readable output, for scripts.

explain reads runs made in your own Code IDE. For Bolt runs, use the summary in the run logs.

Foundations

Automate with AI agents

Set up & configure

Orchestrate data pipelines

Optimize builds with Paradime State

Migrate to Paradime

Develop in Paradime

Learn dbt™

Read a Paradime State run

The summary

What dbt™‘s own output shows

Notices

Explain a run in the Code IDE

Next steps

Troubleshoot Paradime State

Configuration reference

​The summary

​What dbt™‘s own output shows

​Notices

​Explain a run in the Code IDE

​Next steps

Troubleshoot Paradime State

Configuration reference

The summary

What dbt™‘s own output shows

Notices

Explain a run in the Code IDE

Next steps