Stackorder vs Terragrunt: applying dependent Terraform and OpenTofu stacks in order

In short

Both
Plan and apply many OpenTofu or Terraform stacks in dependency order, and pass one stack's outputs to the next.
Terragrunt
An MIT-licensed CLI that wraps OpenTofu and Terraform: dependency blocks order units and read their outputs, and run --all runs them in order wherever you call it. Terragrunt Scale, from Gruntwork, adds pull request plans and applies in your CI.
Stackorder
An Apache-2.0 GitHub App and server for plain Terraform or OpenTofu stacks: a graph that plans downstream stacks on each pull request and applies in waves.

Terragrunt and Stackorder both plan and apply dependent Terraform and OpenTofu stacks in order, at different layers. Terragrunt is an MIT-licensed CLI that wraps OpenTofu and Terraform: each unit's terragrunt.hcl names the units it depends on, and terragrunt run --all apply applies them in dependency order, on a laptop or in any CI. Pull request automation comes from the CI scripts you write or from Gruntwork's commercial Terragrunt Scale.

Stackorder is a pull request workflow: a GitHub App and a small server that plan every stack a change reaches, apply in dependency waves from a comment or on merge, and keep locks and history. Its jobs run the terraform or tofu binary in directories with a backend "s3" block. Stackorder does not run Terragrunt configurations, so it cannot take over a Terragrunt repository as it stands.

Updated . Last reviewed against Terragrunt's own repository, documentation or pricing page.

Stackorder and Terragrunt side by side

Numbers link to the sources. A dash means we haven't verified it, not that it's missing.

FeatureStackorderTerragrunt
LicenseApache-2.0, open source35MIT2
DeploymentSelf-hosted; setup mode creates the GitHub App from a manifest26, 31A CLI you run yourself; Terragrunt Scale runs in your GitHub Actions or GitLab CI9, 16
PricingFree and open source; you run the server35CLI free. Terragrunt Scale: free up to 25 units; Team from $500 a month for 200 units, on an annual contract; Enterprise custom20
Maturityv0.6.0, released 2026-11-15; first released as v0.1.0 on 2026-09-3033, 34v1.2.1 on 2026-10-23; 1.0 on 2026-03-30, with no breaking changes to the CLI or HCL in 1.x minor releases, experimental features excepted3, 4, 6
Where Terraform runsYour GitHub Actions runners, GitHub-hosted or self-hosted; it manages no runners or agents22Wherever you run the CLI; Terragrunt Scale runs it on your GitHub Actions or GitLab CI runners9, 17
State backendBring your own S3; never takes or releases the state lock22Any backend OpenTofu or Terraform supports; remote_state generates the backend block and, with --backend-bootstrap, can create S3, GCS or Azure storage8
ModulesNo registry; lists each module's consumers, and for git modules the version each pins and how far behind it is22No registry; each unit's terraform.source points at a module, with module source syntax8
Self-hosted footprintOne container of about 30 MB and Postgres; actions that use no Docker22No server to run: the CLI, and Pipelines as a binary in your CI; Gruntwork hosts the Gruntwork.io GitHub App and the developer portal that manages it16, 18
Cross-stack dependenciesA graph of stacks and modules from depends_on, module sources, and terraform_remote_state and stackorder_outputs reads, including cross-repository edges; applies in waves23, 24, 30dependency blocks order units and expose their outputs, dependencies blocks only order them; run --all runs dependencies first, and destroys in reverse8, 10
Sharing outputs between stacksShared outputs, off by default: the producer lists its readers in outputs.readers, and each reader uses the stackorder_outputs data source or ephemeral resource. The server returns only the outputs, sensitive ones only if the producer shares them, so the reader's role needs no access to the producer's state; a reader's plan fails while the server is unreachable25, 30dependency.<name>.outputs, read from the dependency's remote state by default since v1.2.0, so the job needs access to that state; mock_outputs stand in before it applies8, 9
Cloud credentialsNot held by the server: each job assumes your IAM role with its own GitHub OIDC token. Shared outputs, off by default, give the server a read-only role on the state objects you list25Terragrunt Scale: the Pipelines binary in your CI assumes your roles through OIDC, with temporary credentials per environment17, 18
Human sign-inGitHub OAuth through the App, read:org scope only; the AWS Terraform module can also require OIDC or Cognito sign-in at the load balancer, in front of the UI26, 32—not verified
Git hostsGitHub only, by design22Terragrunt Scale: GitHub and GitLab; self-hosted GitHub Enterprise and GitLab on the Enterprise tier; the free tier, GitHub and AWS only16, 20
OpenTofuYes, with tool: tofu; tested end to end with OpenTofu 1.1229, 33Yes; it runs tofu by default and falls back to terraform9
Drift detectionScheduled per stack with drift.schedule; with open_issue, one GitHub issue per drifted stack, closed when the drift is gone; never applies to fix drift27Terragrunt Scale, Team and up: terragrunt plan on a schedule, opening a pull request for the drifted units19, 20
Policy checksNot a policy engine; run OPA, conftest, Checkov or Infracost in hooks, and stackorder check records a named check the apply gate honors28—not verified
Pull request workflowA check per stack, one sticky comment, and stackorder plan, apply and unlock comments; applies before merge by default, or on merge23Terragrunt Scale's Pipelines posts plans as pull request comments and applies in dependency order on merge17

Key differences

A wrapper and a workflow

Terragrunt wraps the tool: you run terragrunt instead of tofu or terraform, and run --all runs a whole tree of units in order. When and where that happens is up to your CI scripts or Terragrunt Scale. Stackorder is the workflow around plain terraform or tofu: plans on every pull request, an apply gate, waves, stack locks and a record of every run.

Ordering and approval

Terragrunt orders units from the dependency and dependencies blocks in each terragrunt.hcl, and run --all apply adds -auto-approve, since the units share standard input. Stackorder orders stacks from depends_on and terraform_remote_state and stackorder_outputs reads, while module sources decide which stacks a change reaches, and it applies the plans reviewed in the pull request, from a comment or on merge.

What a change plans

Terragrunt's --filter-affected selects the units that changed between the default branch and HEAD, and graph expressions such as ...vpc add a unit's dependents. Stackorder plans the changed stacks, every stack that uses a changed local module, and their dependents, by default.

Outputs between stacks

A Terragrunt dependency reads the other unit's outputs from its remote state, so the job reading them needs access to that state, and a plan fails before the dependency has been applied unless it sets mock_outputs. Stackorder stacks read each other with terraform_remote_state, or with shared outputs, where the server returns only the outputs the producer shares and the reader's role needs no access to its state.

Keeping configuration DRY

DRY configuration is Terragrunt's core: include blocks share configuration, and remote_state and generate write backend and provider files. In Stackorder, one directory deployed per environment becomes several stack instances, each with its own var files and backend configuration.

Pull requests on a Terragrunt repository

For pull request automation on a Terragrunt repository, look at Terragrunt Scale, or at tools that run Terragrunt, such as Terramate, Stategraph and OpenTaco. Stackorder fits when your stacks are plain Terraform or OpenTofu root modules with S3 backends.

Where Terragrunt is strong

  • Keeps configuration DRY, manages dependencies and runs one command across many units at once.7
  • Stable: 1.0 came out on 2026-03-30, with no breaking changes to the CLI or HCL in 1.x minor releases, experimental features excepted, and v1.2.1 on 2026-10-23.3, 4, 6
  • dependency blocks that read outputs straight from remote state, with mock_outputs for plans before a dependency exists.8, 9
  • Works with any backend, and generates backend configuration for every unit from one remote_state block.8
  • Terragrunt Stacks, generally available since v0.78.0, generate many units from one terragrunt.stack.hcl.11, 12
  • Git filters select the units changed between two refs, and graph expressions add their dependents or dependencies.13, 14
  • OpenTofu by default, and Terraform when only terraform is installed.9
  • Terragrunt Scale runs in your own GitHub Actions or GitLab CI with OIDC credentials per environment, free for up to 25 units on GitHub and AWS.16, 17

When to choose which

Choose Stackorder when

  • Your code is on GitHub and you want Terraform or OpenTofu to run on your own GitHub Actions runners, under AWS roles the runner assumes with its own GitHub OIDC token.
  • You have many stacks that depend on each other or on shared modules, and you want a change planned everywhere it lands and applied in dependency waves.
  • You want a small open-source server you host yourself, which stores no state. By default it has no cloud access, and an outage pauses applies but not pull request plans.

Choose Terragrunt when

  • Your infrastructure is already in Terragrunt, or you want shared configuration and generated backends and providers across many units.
  • You want to plan and apply a whole tree of units in order from a laptop or any CI, with no server.
  • Your state is not in S3, or your code is not on GitHub.
  • You want pull request automation built for Terragrunt by its maintainers: Terragrunt Scale, in GitHub Actions or GitLab CI.
  • You want a tool with more production use: Stackorder's first release, v0.1.0, came out on , and the current version is v0.6.0.

Try Stackorder on your own repositories

Free and open source under the Apache License 2.0. The getting started guide takes one repository from nothing to a first stackorder apply; the local demo runs on one machine with no GitHub App and no AWS account.

Frequently asked questions

Is Stackorder an alternative to Terragrunt?

Not as a drop-in replacement. Both apply dependent stacks in order, but Terragrunt is a CLI wrapper with its own configuration, and Stackorder is a GitHub pull request workflow for plain Terraform or OpenTofu stacks. A team that writes plain root modules with S3 backends can use Stackorder for the ordering Terragrunt's run --all provides, plus plans on every pull request and applies in waves.

What replaced terragrunt run-all?

terragrunt run --all, as in terragrunt run --all plan and terragrunt run --all apply. Terragrunt v0.78.0 deprecated run-all, along with graph, in favor of run --all and run --graph; the CLI redesign migration guide maps the old commands to the new ones.

How does Terragrunt pass outputs between units?

A dependency block names another unit's directory, and dependency.<name>.outputs holds its outputs. Since v1.2.0 Terragrunt reads them from the dependency's remote state by default on S3, GCS and Azure Storage, and runs tofu output elsewhere. A plan before the dependency has been applied needs mock_outputs. Stackorder stacks read outputs with terraform_remote_state or Stackorder's shared outputs.

What does Terragrunt Scale cost?

On 2026-11-08, Terragrunt Scale was free for up to 25 units, on GitHub and AWS; Team started at $500 a month for 200 units, on an annual contract; and Enterprise was priced by quote. A unit is any directory with a terragrunt.hcl. The Terragrunt CLI is free under MIT, and Stackorder is free under Apache-2.0.

More comparisons