Friday, 5:40 p.m. A platform engineer runs terraform apply from a laptop to fix one security group rule. At the same moment the CI/CD pipeline deploys a change to the same environment. Nobody configured state locking because “there are only three of us”. Two processes write the state file one after the other, and the second overwrites the first. On Monday the plan shows Terraform wanting to delete a database that, according to state, it no longer knows about, and to create it again. The code in the repository is fine. The problem is somewhere else.
Stories like this rarely come from picking the wrong tool. They come from companies starting infrastructure as code by writing modules and thinking about the state file only when something in it breaks. Meanwhile, for three years now, the industry has been running a loud “Terraform or OpenTofu” debate that draws attention as if everything depended on it.
This article is for DevOps leads and platform teams that are starting or cleaning up infrastructure as code, whether they run it in-house or buy cloud infrastructure management services from a partner. The position we will defend may sound contrarian: choosing between Terraform and OpenTofu is an afternoon’s decision that you can still reverse today, while deciding where state lives, who can read it and how it is split is a decision for years, and the most expensive one to undo. So start with state, not with the tool. And in a company that already runs cloud environments, the first step is not beautiful greenfield modules but adopting what already exists.
Where does infrastructure as code really begin?
Infrastructure as code (IaC) means describing servers, networks, databases, permissions and cloud services in text files that you keep in a repository, review like application code and deploy through an automated pipeline. In the declarative flavour used by Terraform and OpenTofu, you describe the target state (“there must be a VPC with three subnets”) and the tool works out what to create, change or delete.
To work that out, the tool needs three things: what is in the code, what exists in the cloud, and which cloud objects correspond to which blocks of code. The third piece of information lives in the state file. Without it, Terraform does not know that instance i-0abc is the aws_instance.api resource in your repository. Code describes intent, the cloud is reality, and state is the map that links them.
That leads to a practical conclusion for anyone starting out. Before the team writes its first module, it should answer five questions:
- Where will state live, and does the backend support locking against concurrent writes and versioning?
- How will state be split: by environment, by component, by team?
- Who can read and write state, and are they the same people who hold cloud administrator rights?
- Who runs
apply, and from where: only the pipeline, or engineers’ laptops too? - What happens to what already exists: do we import it, rebuild it or leave it outside code?
The tool is the fifth question on that list, not the first. It matters, but less than the trade press suggests. If you are still sorting out delivery, our step-by-step CI/CD pipeline implementation guide is a useful companion, because IaC without a pipeline quickly slides back to “apply from a laptop”.
Why is state, not code, the most valuable artefact? You can rebuild infrastructure code: it sits in the repository, has history and reviews, and copies exist on every engineer’s machine. State is different. It holds the identifiers of real resources, their attributes at the last read and the dependencies between them. Lose it or corrupt it and the code still exists, but the tool no longer knows which cloud objects it manages. The next plan proposes creating everything from scratch, and the infrastructure that is actually serving customers becomes orphaned.
The second property of state is less obvious: it is a highly sensitive document. The Terraform documentation states plainly that secrets written into configuration are stored in state and plan files, and with local state they sit in a plaintext file. More importantly, anyone with access to state can read those values, including those marked sensitive. The sensitive flag hides a value in console output, not in state.
The third property: state is a shared resource that can conflict. Two concurrent writes, a hand edit of the file, terraform state rm run against the wrong address, an apply interrupted halfway through: any of these can leave the map out of step with the territory. That is why mature teams treat state like a production database, with backups, locks, restricted access and a restore procedure. Adopt that view and many decisions become simpler. Before we get to them, though, we need to clear up the context that has clouded every IaC conversation since 2023.
What did the 2023 BSL switch change, and who does it really affect?
On August 10, 2023, HashiCorp announced that future releases of its products, Terraform included, would move from the Mozilla Public License 2.0 to the Business Source License 1.1 (BSL, labelled BUSL in licence files). APIs, SDKs and almost all libraries stayed on MPL 2.0. According to write-ups published after the change, the last MPL release of Terraform was 1.5.7 on September 7, 2023, and the first BUSL release was 1.6.0. The licence file in the Terraform repository covers version 1.6.0 and later.
What does the licence actually restrict? The key part is the Additional Use Grant. In its current wording it permits production use provided that your use does not include offering the licensed work to third parties in order to compete with the licensor’s paid versions. The licence also has a change date: each release converts to MPL 2.0 four years after publication. The earliest BSL releases therefore become open source again only in 2027, and every later release four years after its own launch.
For a typical company managing its own infrastructure on AWS, Azure or Google Cloud, the conclusion is reassuring: internal use of Terraform remains permitted and free. HashiCorp’s 2023 announcement said explicitly that end users could keep copying, modifying and redistributing the code for non-commercial and commercial use, except when providing a competitive offering. The restriction hits mainly vendors of automation platforms that had built managed services on top of Terraform.
Grey areas appear in two places. The first is firms selling cloud infrastructure management services to clients, especially when they wrap Terraform in their own portal or product. The second is organisations whose policy requires licences approved by the Open Source Initiative, which the BSL is not. In both cases the decision stops being technical and moves to legal. If your company has a process for reviewing software licensing, this is a good moment to put IaC tools on its list, next to the libraries your applications ship.
It is also worth naming what the licence did not change. Terraform providers, the plugins for AWS, Azure, Kubernetes and hundreds of SaaS services, are separate projects with their own licences and overwhelmingly remained open. The HCL language, the state format and the way of working did not change either. What changed is who may build a business on the core of the tool, and that was enough to produce a fork.
What is OpenTofu three years on, and who stands behind it?
Exactly three years ago, on September 20, 2023, the Linux Foundation announced OpenTofu (previously OpenTF) as an open, community-driven response to Terraform’s licence change. The announcement cited pledges from more than 140 organisations and 600 individuals, and a commitment to fund at least 18 full-time developers for at least five years. Named backers included Harness, Gruntwork, Spacelift, env0, Scalr and Terramate, largely the platform vendors whose business model the BSL hit directly.
The first stable release, OpenTofu 1.6, shipped in January 2024. On April 23, 2025, the project was accepted into the Cloud Native Computing Foundation at the Sandbox level, the foundation’s entry maturity tier. That is a meaningful governance signal: the project has a neutral home, but it has not yet travelled the path that, say, Kubernetes did.
More telling than declarations is the pace of development. Since its first release OpenTofu has shipped features that Terraform either lacks or gained later:
- 1.7 (April 2024): client-side state encryption independent of the backend, the
removedblock, and loopable import blocks for bulk adoption. - 1.10 (June 2025): native S3 state locking without DynamoDB, distribution of providers and modules through OCI registries (useful in air-gapped environments), and deprecation markers for variables and outputs.
- 1.11 (December 2025): ephemeral resources, write-only attributes, and an
enabledmeta-argument as a cleaner alternative tocount = 0/1. - 1.12 (May 2026): dynamic
prevent_destroydriven by variables, adestroy = falselifecycle setting that drops a resource from state without destroying the remote object, and fuller provider checksums.
Two conclusions follow. First, OpenTofu is no longer “Terraform 1.5 under a different licence”; it is an independently developed tool. Second, and more important for our thesis: every such feature reduces the reversibility of your choice. As long as you stay within the shared subset of the language, you can move either way. Once you enable OpenTofu state encryption, which Terraform does not support, or build processes around features available only in HCP Terraform, going back becomes a separate project.
What does IBM’s acquisition of HashiCorp change for Terraform users?
IBM announced its intent to acquire HashiCorp on April 24, 2024, at USD 35 per share in cash, an enterprise value of USD 6.4 billion. The deal closed on February 27, 2025, after regulatory clearances including the US FTC and the UK CMA. IBM said Terraform and Vault would be offered as part of its automation software portfolio.
For a team that simply runs the Terraform CLI, little changed in the short term. The licence file in the repository now names International Business Machines Corporation as licensor, but the BSL terms stayed the same, and the use grant now refers to IBM’s paid versions. There has been no sign of a return to MPL, although part of the community hoped for one after the deal.
Another signal is worth noting when planning for years ahead: portfolio pruning. CDK for Terraform (CDKTF), which let teams write Terraform configuration in TypeScript, Python or Java, was sunset and archived on December 10, 2025. Its README recommends migrating to standard HCL (with the help of cdktf synth --hcl) and, for AWS-centric users, moving to AWS CDK. Teams that had chosen CDKTF as “Terraform for developers” had a few months to plan a migration they had not budgeted for.
None of this means Terraform is at risk. It is a mature, widely used product around which IBM is building an enterprise offering. It does mean that vendor risk in IaC is not just about the licence but also about the direction of the product and its add-ons. The core tool and HCL are safe in both projects. The most exposed parts are the layers around them: managed platforms, experimental SDKs, features that exist only in a paid plan. Design so that whatever is hard to replace stays as small as possible.
Terraform or OpenTofu: how do you decide in one afternoon?
Since both tools read the same language, use the same providers and share a similar workflow, the decision comes down to a few questions about your organisation rather than about technology. The table below collects the criteria worth walking through in a single meeting with the DevOps lead, an architect and whoever owns compliance.
| Criterion | Points to Terraform | Points to OpenTofu |
|---|---|---|
| Execution platform | You use or plan to buy HCP Terraform or Terraform Enterprise | You run your own CI/CD pipeline or a platform independent of HashiCorp/IBM |
| Licence policy | Legal accepts the BSL | Policy requires an OSI-approved licence (OpenTofu is MPL 2.0) |
| Business model | You manage only your own infrastructure | You sell cloud infrastructure management services or build a product on IaC |
| Commercial support | You need a support contract with the tool’s vendor | Foundation, community and independent platform vendors are enough |
| Required features | You need integrations only available in the HCP ecosystem (e.g. Sentinel policies, vendor-hosted workspace management) | You need client-side state encryption or OCI registries in an air-gapped network |
| Team and hiring | You hire people who know Terraform (same HCL) | Same as left: skills transfer almost entirely |
| Reversibility | Preserved if you avoid HCP-only features | Preserved if you defer state encryption to a deliberate decision |
How should you read it? If your organisation buys or intends to buy HCP Terraform or Terraform Enterprise, the choice is simple: stay on Terraform, because the value of those platforms assumes it. If you do not buy the vendor’s platform and build the pipeline yourself (GitHub Actions, GitLab CI, Atlantis or a third-party platform), OpenTofu is a sensible default: it has an open licence, a neutral foundation and state security features that carry real value when you manage the backend yourself.
The recommendation is deliberately firm, because “Terraform or OpenTofu” meetings tend to drag on for weeks. From the perspective of state, modules and code review, the difference today is small. What matters more is recording the decision and its rationale in an architecture decision record (ADR), defining what would trigger a review (a licence change, a platform purchase, an audit requirement) and moving on to the things that are genuinely hard to change later. If you want a broader tool-by-tool comparison (including CloudFormation) and a suggested repository layout, our earlier infrastructure as code implementation checklist covers that ground; this article deliberately focuses on the decisions that checklist treats briefly: licensing, reversibility and state.
One practical condition applies whichever way you go: pin your versions. Declare the required tool and provider versions in code, commit the provider lock file (.terraform.lock.hcl) and upgrade deliberately rather than incidentally. Most surprises when moving between tools, and between versions of the same tool, come from unpinned versions, not from licensing differences.
When are Pulumi, AWS CDK or CloudFormation better choices than HCL?
The Terraform-versus-OpenTofu debate obscures the fact that these are not the only options. Before committing to HCL, it is worth testing three alternatives honestly.
Pulumi lets you write infrastructure in general-purpose languages: TypeScript, JavaScript, Python, Go, .NET and Java, plus YAML. It is licensed under Apache 2.0. It works well where application developers write most of the infrastructure and want unit tests, real loops and library abstractions. Pulumi has state too, and it needs care: the default backend is Pulumi Cloud, but you can keep state in S3, Azure Blob Storage, Google Cloud Storage, PostgreSQL or the local filesystem. Secrets in state are encrypted with your chosen encryption provider regardless of backend, which is a genuine advantage over Terraform’s default behaviour.
AWS CDK is a framework for defining infrastructure in TypeScript, JavaScript, Python, Java, C# and Go that synthesises CloudFormation templates and deploys them through that service. The upside: CloudFormation handles state and rollback on error, so the team does not manage a state file itself. The downside: it covers AWS only, and SaaS services, DNS at another provider or clusters outside AWS need a separate tool.
CloudFormation, Azure Bicep and other native tools make sense when an organisation is committed to one cloud and wants the cloud provider to hold state. You pay for that with portability and confinement to one ecosystem.
The deciding criterion is usually one question: who will maintain this code three years from now? Declarative HCL has limited expressiveness, and that is a strength in review: the plan shows what will change, and the reviewer does not need to trace program logic to understand the result. Pulumi or CDK code is more flexible, but that flexibility demands engineering discipline that infrastructure teams do not always have time to enforce. The CDKTF story also shows that “programming language on top of another tool” layers carry an additional risk of being discontinued.
If your organisation is forming a platform team that will provide ready-made modules to other teams, the platform engineering model fits HCL well: the platform publishes tested modules, and product teams compose their environments from them without writing low-level resources.
Where should state live, and how do you lock it against concurrent writes?
A local terraform.tfstate on a laptop is acceptable only for experiments. On the first day of real work, state must move to a remote backend that meets four conditions: it supports write locking, versions every revision of the file, encrypts data at rest and lets you restrict access precisely.
On AWS the standard is the S3 backend. For years locking required a separate DynamoDB table, a frequent source of misconfiguration (“we have the bucket, we’ll add the table later”). That has changed. Since Terraform 1.11.0, released on February 27, 2025, native S3 locking via the use_lockfile argument is generally available, and the DynamoDB arguments are deprecated; the documentation says they will be removed in a future minor version. The lock is a file next to the state with a .tflock suffix. OpenTofu introduced native S3 locking in version 1.10 in June 2025. One detail matters: in Terraform’s documentation S3 locking is opt-in and defaults to off, so you have to switch it on explicitly.
A minimal healthy backend on AWS looks like this:
terraform {
backend "s3" {
bucket = "acme-iac-state-prod"
key = "network/terraform.tfstate"
region = "eu-west-1"
encrypt = true
kms_key_id = "arn:aws:kms:eu-west-1:111122223333:key/..."
use_lockfile = true
}
}
Add a bucket with versioning enabled (so you can roll back to a previous state revision after corruption), public access blocked, an access policy limited to the pipeline role and a small group of administrators, and a copy in another region or account if your continuity plan requires it. Credentials should not go into the backend block or -backend-config parameters; the documentation warns they can end up in the .terraform directory and in plan files. For teams serving EU customers, keeping state buckets in an EU region is also a simple way to avoid awkward questions in data protection reviews, since state can contain configuration values and identifiers that auditors will ask about.
On Azure the equivalent is the azurerm backend, which locks through blob leases; on Google Cloud, the gcs backend. The alternative is a managed platform: HCP Terraform (priced by resources under management) or independent vendors that support both Terraform and OpenTofu. A platform takes work off the team but moves state to a third party, which belongs in your vendor risk assessment.
The single most important rule, whatever the backend: apply against shared environments is run by the pipeline, not by a person. Engineers can run plan locally with read-only credentials, but state writes and cloud changes go through a reviewed process with an audit trail. This one rule removes most of the scenarios from the opening of this article.
How do you split state so one mistake doesn’t hit the whole company?
The most common mistake of enthusiastic teams is one giant state for the whole estate. At first it is convenient, because everything appears in one plan. A year later the plan takes a quarter of an hour, every apply touches hundreds of resources, the state lock makes teams wait for each other, and a mistake in one module can schedule the destruction of resources the change author never touched.
A good split follows two principles. The first is blast radius: how much can break as a result of one bad change. The second is rate of change: resources changed daily should not share state with resources changed once a quarter. In practice that gives a split along two axes:
- Environments: separate state for production, staging and development, ideally in separate cloud accounts or subscriptions with separate permissions. A mistake on staging must be physically unable to touch production.
- Layers: foundation (accounts, networking, DNS, identity), platform (clusters, databases, queues), applications (individual teams’ services). The foundation changes rarely and needs the narrowest access; applications change often and can be owned by product teams.
Splitting raises the question of how layers communicate when an application needs a network ID from the foundation layer. The easiest answer, the terraform_remote_state data source, has a serious drawback. Terraform’s documentation notes that its user must have access to the entire state snapshot, which often includes sensitive information, and that reading outputs effectively grants access to the whole file. The recommended alternative is to publish shared data explicitly in a separate location, such as AWS Systems Manager Parameter Store, objects in a bucket, DNS records or Kubernetes ConfigMaps, each with its own access control. The application team gets the network ID but not the foundation state.
How many states is too many? There is no universal number. A sign that the split is too fine: one business change requires a coordinated apply across five states in a strict order. A sign that it is too coarse: a plan nobody reads to the end because it runs to several hundred lines. Tools such as Terragrunt or Terramate help manage many states, but they do not replace the decision about where the boundaries run.
How do you protect secrets when state stores them in plaintext?
For most of Terraform’s history the answer was: “protect the state, because you cannot keep secrets out of it.” A database password passed into aws_db_instance landed in state even if it came from a secrets manager. The only defence was backend encryption and narrow access.
In 2024–2025 that changed in both tools, along different routes.
Terraform introduced ephemeral values in version 1.10: an ephemeral argument on variables and module outputs, and an ephemeral block that fetches data (for example a secret from a secrets manager) only for the duration of a run, without writing it to state or plan. Version 1.11 added write-only arguments on managed resources, usually suffixed _wo and paired with a _wo_version argument, which pass a value to the provider without persisting it. The catch: the provider must support write-only arguments for the resource in question.
OpenTofu first took a different route: version 1.7 in April 2024 added client-side encryption of the entire state and plan, with keys from PBKDF2 (a passphrase), AWS KMS, GCP KMS, Azure Key Vault, OpenBao or an external program. Encryption works independently of the backend, so even someone with bucket access sees only an encrypted blob. In version 1.11, in December 2025, OpenTofu added ephemeral resources and write-only attributes as well.
OpenTofu state encryption has a cost that its documentation describes candidly: without the right key, state and plan files become unrecoverable. You need key backups, a tested disaster recovery plan and a temporary unencrypted copy of state during rollout. Migrating an existing project requires the unencrypted method and a fallback block, and renaming key providers after encryption is not allowed. It is a mechanism for teams with mature key management, not a first step in a project where nobody yet knows who owns KMS.
A recommended order for a team starting out:
- A remote backend with encryption at rest and access limited to the pipeline and a handful of people.
- Secrets in a secrets manager (AWS Secrets Manager, Azure Key Vault, HashiCorp Vault, OpenBao), never in
.tfvarsfiles committed to the repository. - Ephemeral values and write-only arguments wherever the provider supports them, especially for database passwords and tokens.
- OpenTofu client-side state encryption as a deliberate decision once key management procedures are in place.
IaC security does not end with state: scanning configuration for misconfigurations and reviewing the pipeline role’s permissions belong to a broader practice that our maturity model covers under security. To see where your organisation stands today, use our DevOps maturity model with a self-assessment checklist.
How do you adopt existing infrastructure instead of building everything from scratch?
Nearly every company that is “starting IaC” already runs environments created by hand in the console, by scripts or by a previous team. It is tempting to leave them alone and build a new environment from scratch, “properly”. That is often a mistake: the new environment gets built, the old one keeps running, and the company now has two estates, only one of which is in code, while production traffic runs on the other.
That is why we argue that the first IaC project should be adopting an existing component, not building a new one. Since Terraform 1.5.0, released on June 12, 2023, the tool has import blocks that declare in code that a given cloud object should be adopted at a specific address. Import is plannable: terraform plan shows what will be imported before anything reaches state. The -generate-config-out flag generates resource blocks for imported objects that have no configuration yet; the changelog advises reviewing and editing that generated code. Since version 1.7, OpenTofu supports loopable imports, which simplifies adopting dozens of similar resources.
Adopting one component in practice:
- Pick a low-risk component with clear boundaries, such as static asset buckets or a test environment’s network. Do not start with the production database.
- Inventory the resources with the identifiers you will need in
importblocks. - Generate configuration, then rewrite it: names, variables, modules. Generated code is a starting point, not a product.
- Get to an empty plan. A component is adopted only when
planafter import shows no changes. Every difference is either a bug in the code or drift that has to be resolved deliberately. - Lock out manual changes for that component: remove console write permissions from everyone except the emergency procedure.
Refactoring comes after adoption, and that is where moved blocks (changing a resource’s address in code without destroying it) and removed blocks (dropping a resource from state without deleting it from the cloud) earn their keep. OpenTofu 1.12 added a destroy = false lifecycle setting that achieves the latter declaratively. With these mechanisms, restructuring modules no longer requires manual state mv operations, one of the main sources of corrupted state.
Adopting existing infrastructure is also a natural stage of migration projects. If you are selecting a partner to move systems to the cloud, write into the scope that the deliverable is infrastructure in code with handed-over state; we cover how to put that into the contract and pricing model in our piece on choosing a cloud migration partner.
How do you detect drift and stop people clicking in the console?
Drift is the difference between what code and state describe and what actually exists in the cloud. It has three sources: manual console changes (“just for a moment, there’s an incident”), changes made by other tools or by the cloud provider itself, and changes someone deployed from another branch and never merged. Drift is dangerous because the next apply may revert a change production depends on, or fail halfway through on a conflict.
Detecting drift does not require expensive tooling. A scheduled pipeline job that regularly (say, nightly) runs plan with -detailed-exitcode for each state is enough. Exit code 0 means no changes, 1 an error, and 2 a plan with differences. Exit code 2 on a main branch nobody has touched is drift, and it should land in the team’s channel as a ticket to resolve.
Resolution has two paths. If the manual change was a mistake, apply restores the state described in code. If it was intentional (someone raised a limit during an incident, for example), it has to be moved into code and state reconciled with reality. That is what -refresh-only mode is for: it updates state and outputs to match changes made outside the tool without changing infrastructure. Terraform’s documentation also warns against routine use of -target, which can lead to undetected drift, and against skipping refresh (-refresh=false), which makes the plan ignore external changes.
Technique is half the job. The other half is access policy. If every engineer holds administrator rights in the production console, drift will accumulate faster than the team can remove it. A mature model looks like this: day-to-day work happens with read-only permissions, changes go through code and the pipeline, and for emergencies there is a break-glass procedure with time-limited elevation, logged and reviewed after the incident, including an obligation to move the changes into code within a day or two. In regulated industries, such as EU financial services under DORA or companies preparing for SOC 2 audits in the US, this kind of traceable change process is exactly the evidence auditors look for.
These rules matter as much as tool choice and are harder in many organisations, because they change habits. That is why so much depends on the people implementing IaC. When hiring or assessing engineers, test not only their HCL but how they approach state, drift and permissions; you will find a list of such questions in our article on assessing DevOps engineer skills.
What does a first 90-day infrastructure as code plan look like?
Theory helps, but a DevOps lead needs a plan to present to the team and to management. Below is a proposal for the first quarter for an organisation that runs environments in one or two clouds and has a small share of its infrastructure in code.
| Period | Goal | Concrete outputs | Exit criterion |
|---|---|---|---|
| Weeks 1–2 | Foundational decisions | ADRs: tool (Terraform or OpenTofu), state backend, state split, permission model | Decisions recorded and accepted by architecture and security |
| Weeks 2–3 | State foundation | State bucket/container with versioning, encryption, locking, backup, access policy | Test: concurrent apply from two places is blocked |
| Weeks 3–4 | Pipeline | plan on every pull request, apply only from main via the pipeline, pinned versions | No apply against a shared environment comes from a laptop |
| Weeks 4–7 | First adoption | One low-risk component imported, code refactored into modules | Plan after import is empty, manual write permissions removed |
| Weeks 7–10 | Secrets and drift | Secrets in a secrets manager, ephemeral values where possible, nightly drift detection | No secrets in the repository or in new state revisions; drift report reaches the team |
| Weeks 10–13 | Scaling | Further components by risk, break-glass procedure, training for product teams | Share of production resources in code measured and reported monthly |
Two notes on this plan. First, the progress metric is not lines of HCL or number of modules but the share of production resources managed by code with an empty plan. You can calculate it by comparing the cloud inventory with the contents of your states, and it is the number that shows whether the company is actually regaining control. Second, order matters more than speed. A team that adopts three components in a quarter with empty plans and a locked console is in a better position than a team that wrote forty modules for a new environment nobody uses yet.
The plan also assumes someone on the team has done this kind of adoption before. Imports, refactoring with moved blocks and splitting state are operations where a mistake can cost a day of work or, worse, a service outage. If no such person is available, consider reinforcing the team for the first quarter instead of learning in production. Whether you hire, contract or buy cloud infrastructure management services, ask candidates and vendors the same question: show us how you would get one existing component to an empty plan.
What are the key takeaways, and where do you start on Monday?
Infrastructure as code is a standard today, not an experiment, yet it is still often implemented from the wrong end: tool choice and module writing first, instead of state decisions and adopting what already runs. The BSL, the birth of OpenTofu and IBM’s acquisition of HashiCorp reshaped the tool market, but they did not change what decides whether an implementation succeeds.
Remember six things. First, the state file is the most valuable and most sensitive IaC artefact: treat it like a production database, with backups, locking, encryption and narrow access. Second, Terraform or OpenTofu is a one-meeting decision: if you buy the HCP platform, stay on Terraform; if you build the pipeline yourself, OpenTofu is a sensible default. Record it in an ADR and move on. Third, the reversibility of that decision shrinks with every tool-specific feature, so adopt them deliberately. Fourth, split state by blast radius and rate of change, and publish data between layers explicitly instead of sharing whole state files. Fifth, keep secrets out of state with ephemeral values and write-only arguments, and switch on state encryption only once key management is mature. Sixth, start by adopting one existing component and take it to an empty plan and a locked console.
On Monday, do one thing: find out where every state file in your organisation lives today, who can access it, and whether the backend has locking and versioning enabled. That single inventory usually reveals more than weeks of debate about tools.
If you need people who have already done imports, state splits and pipeline rollouts, see how ARDURA DevOps engineers work. We place senior DevOps engineers experienced with Terraform, Kubernetes and CI/CD within 2 weeks as standard, with a 2-week free replacement guarantee and a 30-day notice period. For designing the account structure, networking and foundation layer beneath IaC, our cloud architects can help too. If you would rather talk through your situation first, get in touch.