Snap CD vs Spacelift
Both Snap CD and Spacelift solve the same core problem: orchestrating Terraform deployments across multiple states with proper dependency management, approval workflows, and access control. They take notably different approaches to architecture, policy enforcement, and how much they expect you to change your existing Terraform workflows.
This guide walks through the key differences to help you decide which fits your team better.
Architecture
Spacelift
Spacelift is primarily a SaaS platform. Your Terraform runs execute in Spacelift's cloud infrastructure by default. You can optionally deploy "private workers" inside your own network for runs that need access to internal resources. A self-hosted option is also available for organisations that need the entire platform — control plane included — on their own infrastructure.
Snap CD
Snap CD separates orchestration from execution. The control plane (self-hosted, or as a managed service on snapcd.io) handles configuration, scheduling, and state tracking. The actual terraform plan and terraform apply commands run on Runners — lightweight agents you deploy wherever you need them (a Kubernetes pod, a VM, a container on your laptop). Runners connect back to the control plane via authenticated WebSocket connections. See Self-Hosted Terraform Runners with Credential Isolation for the full deployment model.
The practical difference: with Spacelift, you send your code and credentials to their infrastructure (or set up private workers). With Snap CD, your code and credentials never leave your environment — the Runner pulls jobs and pushes results, but the execution happens on machines you control. See Non-invasive Orchestration for how Runners execute standard Terraform commands.
Organising your infrastructure
Spacelift
Spacelift organises work into stacks. Each stack maps to a Terraform root module with its own state. You configure stacks with a source repo, branch, working directory, and environment variables. Stacks can be grouped into spaces for organisational purposes.
Dependencies between stacks are declared using stack dependencies — you specify that stack B depends on stack A, and Spacelift will trigger B after A completes. Output-to-input wiring is handled through output references that pass values between stacks.
Snap CD
Snap CD uses a three-level hierarchy: Stacks contain Namespaces, which contain Modules. A Module is analogous to a Spacelift stack — it points to a Terraform root module and manages one state file.
Dependencies are declared with snapcd_module_input_from_output resources. See Modular Deployments for a detailed walkthrough:
resource "snapcd_module_input_from_output" "vpc_id" {
module_id = snapcd_module.compute.id
input_kind = "Param"
name = "vpc_id"
output_module_id = snapcd_module.networking.id
output_name = "vpc_id"
}
When networking's outputs change, compute automatically re-plans — see Event-driven Continuous Deployment. The dependency graph is explicit in code, not configured through a UI.
The Namespace layer lets you scope permissions and group related Modules. For example, prod/networking and prod/application can have different owners with different access levels, while both live under the prod Stack.
Policies and access control
Spacelift
Spacelift uses Open Policy Agent (OPA) for policy enforcement. You write Rego policies that evaluate against plan output, push events, or approval requirements:
- Plan policies inspect the Terraform plan and can warn, deny, or require additional approval.
- Push policies control which Git events trigger runs.
- Approval policies define who can approve a run and under what conditions.
- Login policies control who can access your Spacelift account.
- Notification policies route and filter notifications.
- Trigger policies select which stacks should be triggered for runs.
Access control was previously handled by access policies, but these have been deprecated in favour of Spacelift's Spaces-based access model.
This is powerful and flexible, but it means learning Rego and maintaining a separate policy codebase.
Snap CD
Snap CD splits this into two systems that Spacelift combines into one.
Policies inspect the plan. For Terraform and OpenTofu they are OPA/Rego evaluated with conftest against the plan's JSON representation, the same language as Spacelift's plan policies, so Rego skills transfer in both directions and an existing conftest repo works unchanged. For Pulumi they are CrossGuard packs, enforced inside the preview.
Policies attach to a Module or a Namespace (additively, with no Module-level override), and come inline, remote (a git directory pinned to a tag, branch or commit, carrying its own tests) or local. Severity is a convention rather than a setting: deny and violation rules are hard and refuse the job as Policy Denied; warn rules are soft and surface on the approvals screen. Destroy jobs evaluate policies exactly as apply jobs do, so protecting resources from deletion is a first-class case.
Two differences from Spacelift worth weighing:
- Policies run on the Runner, and the plan document never leaves it. Spacelift evaluates plan policies in its own infrastructure, so the plan and its values go to Spacelift. For teams whose plan output is itself sensitive, that is the deciding difference.
- Snap CD has no equivalent to Spacelift's push, login, notification or trigger policies. Spacelift lets you write Rego against those decisions too. Snap CD covers the same ground with configuration and RBAC rather than policy code, which is less flexible and less to maintain.
RBAC handles who may do what. Roles (Owner, Contributor, Reader, Approver) are assigned to principals (users, service principals, groups) at any scope: organisation, Stack, Namespace, Module, Runner or State Store. See A Permission System Built for Infrastructure. Approval gates are configured per Module: you set how many approvals an apply needs, and anyone with Approver at that scope or above can give one.
Drift detection
Spacelift
Spacelift lets you configure drift detection per stack with a schedule. When drift is detected, it can automatically trigger a reconciliation run or notify you. Spacelift can auto-reconcile without approval.
Snap CD
Snap CD offers configurable drift check intervals per Module. When drift is detected, a new plan is created and routed through the normal approval workflow before any changes are applied. Snap CD always routes drift-triggered plans through approval gates — no changes happen without review. See Detecting and Managing Terraform Drift for a detailed walkthrough.
Runner and worker model
Spacelift
Spacelift runs Terraform in its own cloud by default. For access to private networks, you deploy private workers — Docker containers that poll Spacelift for jobs. Workers need outbound HTTPS access to Spacelift's API. You can configure worker pools and assign stacks to specific pools.
Snap CD
Snap CD Runners are self-hosted by design — there is no managed execution environment. Runners connect to snapcd.io via authenticated, bi-directional WebSocket connections. You control where they run, what credentials they have, and which Modules can use them (via RBAC on the Runner resource). See Self-Hosted Terraform Runners with Credential Isolation for the deployment model.
The Runner is source-available and maintained as part of the Snap CD monorepo, so you can inspect exactly what it does or build custom images.
If you prefer a fully managed environment where you don't operate any infrastructure for running Terraform, Spacelift's default execution model is simpler. If you want full control over the execution environment and credentials, Snap CD's Runner model gives you that without the complexity of setting up private workers.
Execution model
Spacelift
Spacelift integrates into your workflow in several ways. It manages its own state backend — injecting backend configuration into each run automatically — and provides environment variables, contexts, and mounted files that configure your Terraform execution. Your Terraform code doesn't need Spacelift-specific constructs, but the execution context is shaped by the platform.
Snap CD
Snap CD takes a non-invasive approach. When a Runner picks up a job, it clones your repo and runs standard terraform init, terraform plan, and terraform apply in a shell session. Inputs are provided via standard .tfvars files and environment variables. Your Terraform code has no Snap CD-specific constructs — you can run the same code with terraform apply on your laptop.
You can SSH into a Snap CD Runner, navigate to the working directory, and execute commands manually. Nothing is hidden behind abstractions.
Reorganising an existing estate
Spacelift
There is no native workflow for moving resources between stacks. The documented route is to enable external state access on the source stack, pull the state locally, work out which addresses to move, and run terraform state mv with -state and -state-out by hand. Splitting a stack is the same operation repeated. Nothing proves the result first, and the receiving stack is not consulted.
Snap CD
State migrations are jobs, run against a paused Module. Four work on one Module - import, move, remove, and a lookup reporting which addresses are really in the state. Two rewrite several at once: split carves a monolith into Modules that each own part of the original state, and transfer moves resources between two existing Modules with different repositories, runners and backends.
Both prove before writing: the plan is built against the state as it will look afterwards, every affected Module is checked to have nothing left to change, and only then is approval requested. A transfer additionally needs the receiving Module's consent, since it is the only job that writes to a Module's state on another's behalf; either side refusing ends it with nothing written. The two halves run on separate runners that never share a working directory, with the carved state passing through the server encrypted and deleted afterwards.
Every step is cancellable, the write included. The matching code change comes from demonolith, a separate open-source CLI.
Managing the platform with Terraform
Spacelift
Spacelift has the spacelift provider, which lets you define stacks, policies, contexts, and integrations in Terraform.
Snap CD
Snap CD has the snapcd provider (Terraform Registry), covering stacks, namespaces, modules, runners, role assignments, and dependency wiring. Snap CD also supports a "module-within-module" pattern where a Snap CD Module can deploy additional Snap CD Modules.
Pricing
Spacelift
Spacelift prices by tier, with each tier including a set number of workers (concurrent execution slots). The free tier includes one public worker and two users. Private workers, SSO, and audit logs are available on higher tiers — the entry paid tier (Starter+) starts at $20,000/year.
Snap CD
Snap CD prices based on usage — Modules managed, users, and Module jobs. There is no per-Runner cost; you can deploy as many Runners as you need. The pricing is consumption-based rather than seat-based.
Comparison table
| Dimension | Spacelift | Snap CD |
|---|---|---|
| Architecture | SaaS (default) or self-hosted, runs in Spacelift cloud or private workers | Orchestration SaaS or self-hosted, execution on self-hosted Runners |
| Execution environment | Managed (default) or private workers | Self-hosted runners only |
| Organisation model | Spaces → Stacks | Stacks → Namespaces → Modules |
| Dependencies | Stack dependencies + output references | snapcd_module_input_from_output resources |
| Policy engine | OPA/Rego (plan, push, approval, login, notification, trigger), evaluated server-side | OPA/Rego plan policies via conftest + CrossGuard, evaluated on the Runner; RBAC and approval thresholds for the rest |
| Drift detection | Scheduled, optional auto-reconcile | Scheduled, always routes through approval |
| Terraform integration | Managed state backend, injected contexts | Standard .tfvars, no Snap CD-specific constructs |
| IaC self-management | spacelift Terraform provider |
snapcd Terraform provider |
| Runner/worker source | Closed-source workers | Source-available runner |
| Pricing model | Tier-based (workers included per tier) | Per module/user/job usage |
When to choose which
Spacelift may be a better fit if:
- You want a fully managed execution environment and prefer not to operate runners.
- You want Rego over push, login, notification and trigger decisions, not just plans.
- Auto-remediation of drift without human approval is important to your workflow.
- You run CloudFormation, Ansible or Kubernetes alongside Terraform and want one platform for all of them.
Snap CD may be a better fit if:
- You need full control over where Terraform runs and what credentials it can access.
- Your plan output is sensitive and must not leave your network, policy evaluation included.
- You expect to reorganise: splitting a monolith, moving resources between states, changing Module boundaries as things grow.
- You want your Terraform code to remain completely portable — no platform-specific constructs.
- Your access control maps well to hierarchical roles scoped to Stacks, Namespaces, and Modules.
- You want to inspect or customise the Runner (it's source-available).
- You prefer consumption-based pricing over tier-based pricing.
See also
- Modular Deployments — deep dive into Snap CD's Module, input, and dependency system
- Self-Hosted Terraform Runners with Credential Isolation — how Runners keep credentials in your environment
- Non-invasive Orchestration — how Snap CD runs standard Terraform commands without wrappers
- A Permission System Built for Infrastructure — hierarchical RBAC vs OPA policy engines
Intelligent GitOps for Infrastructure as Code. Automate, orchestrate, and scale your infrastructure deployments with confidence.
© 2026 Snap CD. All rights reserved.