Terraform at a High Level: Why It Became a Go-To Tool for Infrastructure as Code

Not a member? Read it there.

Infrastructure used to be built manually: engineers clicked through cloud consoles, configured servers one by one, and documented changes after the fact — if documentation happened at all.

That approach does not scale well.

Modern infrastructure needs to be repeatable, version-controlled, auditable, and easy to reproduce across environments. This is where Infrastructure as Code, or IaC, becomes essential.

One of the most popular tools in this space is Terraform.

Terraform is an infrastructure provisioning tool created by HashiCorp. It allows teams to define infrastructure using code, then use that code to create, update, and destroy resources across cloud platforms, private data centers, SaaS tools, networking systems, databases, and more.

A quick licensing note: Terraform was originally open source under MPL 2.0, but HashiCorp relicensed Terraform and other products under the Business Source License in 2023. HashiCorp states that internal use remains permitted under the BSL, but Terraform is no longer “open source” in the traditional OSI-approved sense.

What Terraform Does

At its core, Terraform helps you manage infrastructure through configuration files.

Instead of manually creating an EC2 instance, a database, a network rule, or a DNS record, you describe what you want in code. Terraform then works out what needs to happen to make the real infrastructure match that definition.

For example, you can use Terraform to provision resources such as:

• virtual machines
• cloud databases
• storage buckets
• load balancers
• DNS records
• networking components
• Kubernetes clusters
• monitoring integrations
• identity and access resources

This makes Terraform especially useful for teams that need consistent infrastructure across development, staging, and production environments.

Multi-Platform Infrastructure Management

One of Terraform’s biggest strengths is that it is not limited to a single cloud provider.

It can manage infrastructure across public cloud platforms such as AWS, Google Cloud Platform, and Microsoft Azure. It can also work with private infrastructure platforms such as VMware vSphere, as well as SaaS and networking systems.

This flexibility is one reason Terraform became widely adopted. Many organizations do not run everything in one place. They may have AWS for some workloads, Azure for others, Cloudflare for DNS, GitHub for version control, Datadog for monitoring, and PostgreSQL or MongoDB for databases.

Terraform provides a common workflow across all of these systems.

How Terraform Works with So Many Platforms

Terraform supports different platforms through providers.

A provider is a plugin that allows Terraform to interact with an external platform’s API. For example, the AWS provider allows Terraform to create and manage AWS resources. The GitHub provider allows Terraform to manage GitHub repositories, teams, or branch protection rules. A Cloudflare provider can manage DNS records and zones.

Providers are what make Terraform extensible.

They allow Terraform to work with many categories of infrastructure and services, including:

• public clouds like AWS, Azure, and GCP
• private cloud and virtualization platforms like vSphere
• networking platforms like Cloudflare, Palo Alto Networks, F5 BIG-IP, and Infoblox
• monitoring tools like Datadog, Grafana, Wavefront, and Sumo Logic
• databases like MySQL, PostgreSQL, MongoDB, and InfluxDB
• version control systems like GitHub, GitLab, and Bitbucket
• identity and access platforms like Auth0

Because of this provider ecosystem, Terraform can manage hundreds of different resource types across a wide range of environments.

Terraform Configuration Language

Terraform uses HCL, or HashiCorp Configuration Language.

HCL is designed to be readable and declarative. Terraform configuration files usually use the .tf file extension, and inside those files you define the infrastructure resources you want Terraform to manage.

A simple Terraform configuration might describe an AWS EC2 instance, a security group, or a cloud storage bucket. The syntax is structured into blocks, making it easier for beginners to understand while still being powerful enough for large production environments.

Because Terraform configuration is code, it can be stored in version control systems like Git. This gives teams the same benefits they already expect from application code:

• change history
• peer review
• collaboration
• rollback options
• reusable modules
• standardized environments

This is one of the biggest advantages of Infrastructure as Code: infrastructure becomes reviewable, repeatable, and shareable.

Declarative Infrastructure

Terraform is a declarative tool.

That means you describe the desired end state, not every step required to get there.

For example, you do not need to write a long procedural script that says:

1. create a network
2. create a subnet
3. create a server
4. attach the server to the subnet
5. configure security rules
6. update the route table

Instead, you define what the final infrastructure should look like. Terraform compares that desired state with the current state and determines what actions are needed.

This is a powerful concept.

You tell Terraform: “This is what I want.”

Terraform figures out: “Here is what needs to change.”

The Terraform Workflow: Init, Plan, Apply

Terraform commonly works in three main phases:

1. Init

The terraform init command initializes the working directory.

During this phase, Terraform downloads the required providers, prepares the backend configuration, and sets up the local project so it can run Terraform operations.

This is usually the first command you run when working with a Terraform configuration.

2. Plan

The terraform plan command shows what Terraform intends to do.

Terraform compares the current infrastructure state with the desired configuration and produces an execution plan. This plan might show that Terraform will create new resources, modify existing ones, or destroy resources that are no longer defined.

This step is important because it gives engineers a chance to review changes before applying them.

3. Apply

The terraform apply command executes the plan.

Terraform makes the required API calls to create, update, or delete infrastructure resources so that the real environment matches the configuration.

If something later changes outside Terraform, such as a manually deleted resource, Terraform can detect the difference and attempt to bring the infrastructure back to the desired state during a future plan and apply cycle.

Resources: The Building Blocks of Terraform

In Terraform, every managed object is called a resource.

A resource could be an EC2 instance, an Azure resource group, a Google Cloud storage bucket, a DNS record, a database, or even a GitHub repository.

Terraform manages the lifecycle of these resources, including:

• provisioning
• updating
• replacing
• destroying
• tracking current state

Each resource is declared in the Terraform configuration, and Terraform uses providers to create or modify that resource through the target platform’s API.

Terraform State

Terraform keeps track of infrastructure using a state file.

The state file records what Terraform believes exists in the real environment. This allows Terraform to compare the current state of infrastructure with the desired configuration.

State is one of the most important concepts in Terraform.

Without state, Terraform would not know which real-world resources correspond to the resources defined in your code. With state, Terraform can determine whether a resource already exists, whether it needs to be changed, or whether it should be destroyed.

In small local projects, state may be stored locally. In team or enterprise environments, state is usually stored remotely using a backend such as Terraform Cloud, AWS S3, Azure Storage, or another supported backend. Remote state helps teams collaborate safely and reduces the risk of conflicting changes.

Data Sources

Terraform can also read information from existing infrastructure using data sources.

A data source allows Terraform to fetch information from a platform without directly managing that object as a resource.

For example, you might use a data source to look up:

• an existing VPC
• the latest machine image
• an existing DNS zone
• a cloud account identity
• a subnet created by another team

This retrieved information can then be used when configuring other Terraform resources.

Data sources are especially useful when Terraform needs to integrate with infrastructure that already exists.

Importing Existing Infrastructure

Not every infrastructure resource starts inside Terraform.

Many organizations already have resources that were created manually, through scripts, or by other IaC tools. Terraform can import some existing resources into its state so they can be managed going forward.

This is useful when teams want to move from manual infrastructure management to Infrastructure as Code without destroying and recreating everything.

Importing does not automatically write all configuration code for you in every case, but it does allow Terraform to associate an existing real-world object with a Terraform resource address in state.

Terraform Cloud and Terraform Enterprise

Terraform can be used locally, but HashiCorp also provides Terraform Cloud and Terraform Enterprise for teams that need more collaboration, governance, and operational controls.

These platforms add features such as:

• remote state management
• team-based access controls
• policy enforcement
• private module registries
• run history
• centralized UI
• collaboration workflows
• integration with version control systems

For larger organizations, these features can help standardize how infrastructure changes are reviewed, approved, and applied.

Why Terraform Matters

Terraform became popular because it solves a real operational problem: infrastructure needs to be consistent, repeatable, and manageable across many platforms.

It gives teams a common workflow:

1. define infrastructure in code
2. review changes before applying them
3. provision resources automatically
4. track infrastructure state
5. collaborate through version control
6. manage infrastructure across multiple platforms

This makes Terraform useful not only for cloud engineers, but also for DevOps teams, platform engineers, SREs, security teams, and infrastructure teams.

Summary

Terraform is a powerful Infrastructure as Code tool for provisioning and managing infrastructure across a broad range of platforms.

Its provider ecosystem allows it to work with cloud platforms, networking systems, monitoring tools, databases, and version control systems. Its declarative configuration language makes infrastructure easier to define, review, and reuse. Its workflow of init, plan, and apply gives teams a predictable way to move from desired state to real infrastructure.

At a high level, Terraform helps answer one of the most important questions in modern infrastructure management:

How do we make infrastructure consistent, repeatable, and scalable?

Terraform’s answer is simple: define it as code, store it in version control, and let Terraform manage the lifecycle.