Snap CD vs HCP Terraform (Terraform Cloud)
HCP Terraform (formerly Terraform Cloud) is HashiCorp's managed platform for running Terraform at scale. It bundles state management, remote execution, policy enforcement, and a private registry into a single SaaS offering. It's the most widely adopted Terraform orchestration platform, and for good reason — it works well for teams that want a fully managed, opinionated workflow.
Snap CD takes a different approach. It separates orchestration from execution, leaves the choice of state backend to you, and focuses on the cross-state dependency problem that grows as infrastructure scales. It also treats reorganising an existing estate, splitting a monolith or moving resources between states, as a governed operation rather than something you script by hand. This guide walks through the key differences to help you decide which fits your team.
Architecture
HCP Terraform
HCP Terraform runs terraform plan and terraform apply on HashiCorp-managed infrastructure. Your Terraform code is uploaded to their platform, and execution happens in their environment. This is convenient — no runners to manage, no compute to provision — but it means:
- Credentials leave your network. Cloud provider credentials (AWS keys, Azure service principals, GCP service accounts) must be configured in HCP Terraform so its workers can authenticate. Dynamic credentials via OIDC federation mitigate this, but not all providers support it.
- Network access requires configuration. If your Terraform code needs to reach private endpoints (a database, an internal API, a private registry), you need HCP Terraform agents — self-hosted workers that run inside your network. At that point you're managing infrastructure to run your infrastructure tool.
- Compliance constraints. Some organisations can't send infrastructure code or credentials to a third-party cloud, full stop. HCP Terraform's answer is Terraform Enterprise — a self-hosted version with a significant price tag.
Snap CD
Snap CD separates orchestration from execution by design. The snapcd.io Server handles configuration, dependency tracking, and logging. Self-hosted Runners handle the actual terraform plan and terraform apply execution. See Self-Hosted Terraform Runners with Credential Isolation for the full deployment model.
- Credentials stay where you put them. Runners run in your environment — a Kubernetes pod, a VM, a container — with whatever credentials you assign them. Nothing leaves your network.
- Network access is natural. Runners connect outbound to snapcd.io via authenticated WebSocket. They already have access to your private endpoints because they run inside your network.
- Execution is non-invasive. Runners run standard Terraform commands in a shell session — your code has no Snap CD-specific constructs. See Non-invasive Orchestration.
- No separate "enterprise" tier for self-hosting. The Runner is source-available. The Server itself is available for self-hosting under the source-available license.
State management
HCP Terraform
HCP Terraform provides managed remote state storage. This is one of its strongest features — you don't need to set up S3 buckets, DynamoDB tables, or Azure storage accounts for state. It handles locking, versioning, and encryption out of the box.
Snap CD
Snap CD gives you both options, and neither is an upsell.
State Stores provide managed state over the standard HTTP backend. Every Organization is pre-seeded with a default store, state is encrypted at rest with AES-256-GCM, each Module gets its own State File keyed by Module name, and locking is enforced with a configurable auto-expiry. Access is controlled by role assignments on the State Store itself, so who may read a given state is part of the same permission model as everything else. You can create additional State Stores to separate environments or teams.
Or bring your own backend. Your code can use S3, Azure Blob Storage, GCS, Consul or anything else the engine supports, and Snap CD does not ask you to change it. If state must stay in a specific region or account for compliance, that stays true.
The difference from HCP Terraform is not whether state is managed but whether managing it is the price of entry. The backend is a normal terraform block in your own code either way, so moving between the two is a backend change rather than a platform migration.
Cross-workspace dependencies
This is where the two tools diverge most sharply.
HCP Terraform
HCP Terraform has run triggers — you can configure workspace B to trigger a run when workspace A completes. This gets the sequencing right, but it doesn't handle the data flow:
- Run triggers fire the downstream workspace, but they don't pass outputs. Workspace B still needs to use
terraform_remote_stateor some other mechanism to read workspace A's outputs. terraform_remote_staterequires workspace B to know the backend configuration of workspace A. This creates tight coupling between workspaces.- There's no automatic re-plan when upstream outputs change. If workspace A's VPC ID changes, workspace B gets triggered, but it has to discover the change through the remote state data source during its own plan.
Snap CD
Snap CD makes cross-state dependencies a first-class concept. You declare them with snapcd_module_input_from_output resources:
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"
}
With this in place:
- Snap CD knows the full dependency graph and enforces correct apply order.
- When networking's
vpc_idoutput changes, compute automatically re-plans with the new value — noterraform_remote_stateneeded. - Your Terraform code uses plain
variableblocks. No backend configuration leaks between modules. - The dependency graph is visible and auditable, not buried in workspace settings.
This is the fundamental difference. HCP Terraform treats cross-workspace dependencies as a notification mechanism. Snap CD treats them as a data pipeline. See Modular Deployments and Event-driven Continuous Deployment for detailed walkthroughs.
Reorganising an existing estate
Neither tool's dependency handling matters much if you cannot change the shape of what you already have. Module boundaries that made sense at ten resources rarely survive to five hundred.
HCP Terraform
There is no workflow for this. Moving resources between workspaces means terraform state mv with -state and -state-out against pulled state files, locally, by hand, after backing both up. Splitting a workspace is the same operation repeated. Nothing proves the result before you commit to it, nothing asks the receiving workspace whether it agrees, and nothing records who did it.
Snap CD
State migrations are jobs, run against a paused Module so nothing else touches it while they run. Four operate on one Module - import, move, remove, and a lookup that reports which addresses are actually in the state. Two rewrite more than one Module at once:
- split - a monolith becomes several Modules, each with its own state carved out of the original.
- transfer - resources move between two existing Modules, each with its own repository, runner and backend.
Both prove before they write: the plan is built against the state as it will look afterwards, each affected Module is checked to have nothing left to change, and only then is approval requested. Nothing is written until someone answers.
A transfer also needs the receiving Module's consent, since it is the only job that writes to a Module's state on another Module's behalf. Either side refusing ends it with nothing written. The two halves run as separate jobs on separate runners that never see each other's working directory; the carved state and the output values travel through the server, encrypted the way state is, and are deleted once neither job is running.
Every step can be cancelled, the write included. The code change that a split or transfer migrates the state for is produced by demonolith, a separate open-source CLI.
Policy enforcement
HCP Terraform
HCP Terraform has Sentinel (HashiCorp's own policy-as-code language) and OPA (Open Policy Agent) integration. These let you write policies like "no public S3 buckets" or "all resources must have tags" and enforce them before apply. Sentinel in particular is mature and well-documented.
The trade-off: Sentinel is proprietary to HashiCorp. If you leave HCP Terraform, your Sentinel policies don't come with you. OPA is open, but on the Free tier you're limited to one policy set of up to five policies — full VCS-integrated policy management requires Standard or Premium.
Snap CD
Snap CD has Policies using each engine's native framework: OPA/Rego evaluated with conftest for Terraform and OpenTofu, and CrossGuard packs for Pulumi. There is no proprietary policy language to learn and nothing to rewrite if you leave: an existing conftest repo works unchanged, and a Snap CD policy still runs under plain conftest in CI.
Policies attach to a Module or to a Namespace, and come from three sources: inline (stored in Snap CD), remote (a directory in a git repo, pinned to a tag, branch or commit, so policies get their own reviews and their own conftest verify tests), or local (a directory on the Runner host).
Severity follows each framework's own convention rather than a setting on the resource. In Rego, deny and violation rules are hard and refuse the job; warn rules are soft and record a warning that shows up on the approvals screen. A hard violation finalizes the job as Policy Denied, which is a refusal rather than a failure.
Two details worth knowing, because both are easy to get wrong elsewhere: destroy jobs evaluate policies exactly like apply jobs, so blocking deletion of protected resources is a first-class use case; and a policy that defines no rules at all faults the job rather than passing. conftest reports success for a zero-rule policy, so a typo like denny gates nothing while looking green.
Policies are evaluated on the Runner, against the plan the job produced. The plan document never leaves the Runner. With HCP Terraform, Sentinel and OPA both run server-side, which means the plan and the values in it go to HashiCorp.
Alongside policies:
- Approval gates require a configurable number of human approvals before an apply proceeds.
- RBAC controls who can trigger plans, approve applies, and manage configuration — scoped to the Stack, Namespace, Module, or Runner level. See A Permission System Built for Infrastructure.
- Runner isolation ensures that a Module can only execute on Runners you've explicitly allowed, so the blast radius is bounded by the Runner's credentials.
Pricing
HCP Terraform
HCP Terraform charges per resource under management. As your infrastructure grows, the bill grows proportionally, even if you're not making changes. The free tier covers 500 managed resources; past that, paid tiers bill per resource per month, rising with the tier. The legacy free plan reached end of life in March 2026 and organizations on it were moved to the current one.
Snap CD
Snap CD charges per Module. A Module with 5 resources costs the same as a Module with 500 resources. You pay for the units of deployment you manage, not the resources inside them.
For large infrastructure (thousands of resources across many states), this difference is significant. A team managing 5,000 resources across 20 Modules would see very different bills.
Engine support
HCP Terraform
HCP Terraform runs Terraform. It does not support OpenTofu.
Snap CD
Snap CD's Engine is set per Namespace or per Module, and the Runner executes whichever binary you have installed:
- OpenTofu (
tofu) - the default - Terraform (
terraform) - tested up to the final release under the Mozilla Public License - Pulumi (
pulumi) - a Preview Feature, opted into per Organization
You supply the binaries. A Namespace can set a default and individual Modules can override it, so a migration can run Module by Module rather than all at once.
Self-hosting
HCP Terraform
HCP Terraform's self-hosted option is Terraform Enterprise. It provides the same features as the cloud version but runs on your infrastructure. It requires a separate license, and pricing is typically enterprise-contract — not publicly listed, but significantly more expensive than the SaaS offering.
Snap CD
Snap CD's Runner is self-hosted by default — that's the standard architecture, not an upsell. The Server component is available under a source-available license for organisations that need to self-host the entire stack. There is no separate "enterprise" product with different features.
Private registry
HCP Terraform
One area where HCP Terraform has a clear advantage is its private module registry. Teams can publish versioned Terraform modules internally and consume them across workspaces. This is a polished, well-integrated feature.
Snap CD
Snap CD doesn't include a private registry. You'd use Git repositories (with tags for versioning), a self-hosted registry, or the public Terraform registry. For most teams this works fine, but if a managed private registry is important to your workflow, it's worth noting.
Comparison table
| Dimension | HCP Terraform | Snap CD |
|---|---|---|
| Execution | HashiCorp-managed (or agents) | Self-hosted Runners |
| Credentials | Configured in HCP / OIDC federation | Stay on your Runners |
| State management | Managed, built-in | Managed State Stores, or bring your own backend |
| Cross-state dependencies | Run triggers + terraform_remote_state |
snapcd_module_input_from_output |
| Policy enforcement | Sentinel, OPA (server-side) | OPA/Rego via conftest, CrossGuard (on the Runner) |
| Pricing model | Per resource under management | Per Module |
| Engines | Terraform only | OpenTofu, Terraform, Pulumi (preview) |
| Self-hosting | Terraform Enterprise (separate license) | Runner self-hosted by default; Server source-available |
| Private registry | Built-in | Not included |
| State migrations | terraform state mv by hand |
Import, move, remove, split, transfer as approved jobs |
| IaC management | Workspace API / Terraform provider | Full Terraform provider |
When to choose HCP Terraform
- A private module registry is a core part of your workflow.
- You are already invested in Sentinel and are comfortable with the lock-in.
- You want HashiCorp to run the execution environment as well, and nothing in your estate needs private network access.
- Your resource count is low enough that per-resource pricing is cheaper than per-Module.
When to choose Snap CD
- You have cross-state dependencies and want them managed declaratively, not through triggers and remote state.
- You expect to reorganise: splitting a monolith, moving resources between states, changing Module boundaries as the estate grows.
- Your credentials must stay in your network, and you don't want to manage agents to make that happen.
- Your plans must not leave your network, policy evaluation included.
- You're managing large infrastructure where per-resource pricing becomes expensive.
- You want to use OpenTofu, or keep the option open.
- You want self-hosting without an enterprise contract.
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 network
- A Permission System Built for Infrastructure — granular RBAC across the Stack/Namespace/Module hierarchy
- Non-invasive Orchestration — how Snap CD runs standard Terraform commands without wrappers
- Event-driven Continuous Deployment — how output changes cascade through the dependency graph
Intelligent GitOps for Infrastructure as Code. Automate, orchestrate, and scale your infrastructure deployments with confidence.
© 2026 Snap CD. All rights reserved.