Dynamic state sizing

Plan the slice, not the whole state.

Terraform reads and walks your entire state on every plan, whether your change touched it or not. Stategraph dynamically sizes each plan to just the slice your change affects, so the same plan drops from over a minute to two seconds.

Sized to your change 1m13s → 2s Same HCL, same plan

Get Started See it run

Working the whole state is the tax

Every Terraform plan reads and walks the entire state, O(n) in total resources, no matter how small your change is. Touch one value and it still processes everything and calls every provider. On big states, that whole-state pass is the bottleneck.

// Terraform / OpenTofu

edit one resource

load and walk the whole state

process every resource, every plan

wait the same time, every time

→ one-line change, full-state wait

// Stategraph

edit one resource

size the plan to that change

untouched state never loads

wait scales with your change

→ one-line change, one-line wait

Same command. Whole state vs. your slice.

Two independent tracks plus one deliberately slow (60s) data source. The first plan has to size up the whole state. Then we change one value in Track A and run the exact same plan: it sizes to just that slice.

stategraph — dynamic state sizing

# first plan: sizes up the whole state
❯ time stategraph plan
Loading 41 resources…  (incl. data.http.slow, a 60s source)
No changes. Infrastructure is up to date.
real   1m12.7s

# change ONE value in Track A, then run the exact same plan
❯ time stategraph plan
Sizing to 1 resource…  data.http.slow never loads (outside your change)
  ~ terraform_data.track_a   input: "v1" → "v2"
Plan: 0 to add, 1 to change, 0 to destroy
real    2.0s

First plan: 1m 12.7s · sized plan: 2.0s · the 60s source never loads

1m 13s

full-state plan, load everything

2.0s

sized plan, only your change

~36×

faster, same command

Why it's fast

State sized to your change

The dependency graph tells Stategraph exactly which resources your change can affect. It sizes the plan to those and leaves the rest of the state untouched.

O(your change), not O(state)

Plan time scales with the size of your change, not the size of your infrastructure. Big states stop being a tax.

Fewer provider calls

Untouched resources aren't loaded or re-read from the provider every plan, so you stop paying for API round-trips you don't need.

Parallel where it's safe

Independent slices of the graph are evaluated at the same time. Disjoint work doesn't wait in line. See resource-level locking →

Same HCL, same plan

It's the identical plan output you already trust, just produced without touching the state your change didn't.

Drop-in CLI

Replace terraform with stategraph. Same commands, same workflow, dramatically faster execution.

Speed is downstream of the substrate. Dynamic state sizing isn't a flag or a cache, it falls out of storing state as a graph. The graph already knows what your change touches. Setup docs →

Stop processing your whole state

Import an existing state and watch your plans collapse from minutes to seconds. See all features →

Get Started Read the Docs