Terraform introduction

Introduction to Terraform Learn the infrastructure as code basics — provision, manage, and scale cloud infrastructure with confidence

Have you ever spent hours manually configuring cloud infrastructure — only to have to do it all over again for the next environment, the next region, or the next project?

There's a better way. Modern technology teams don't build their infrastructure by hand — they write it as code. One configuration file, written once, can create an entire environment in minutes — identically, repeatably, and auditably, every single time.

The tool at the centre of that transformation is Terraform. Created by HashiCorp, Terraform has become the industry standard for infrastructure as code — used by organisations of every size, across every major cloud provider, to define and manage everything from a single server to entire global platforms. It is one of the most in-demand skills in cloud engineering, DevOps, and platform roles today — and this course is where you learn it.

What this course is about

Infrastructure as code can sound intimidating if you've never worked with it before — but the core idea is beautifully simple: instead of clicking through consoles to build infrastructure manually, you describe what you want in code, and Terraform makes it real.

This course gives you a practical, hands-on introduction to that way of working. You will learn the core concepts that everything in Terraform is built on, write real configurations that provision real cloud resources, and develop the workflows and habits that make infrastructure as code safe, repeatable, and scalable in professional environments.

By the end of this programme, you won't just understand what Terraform does — you'll be writing, planning, and applying your own infrastructure code with confidence.

Why Terraform skills matter right now

As organisations scale their cloud environments, manual infrastructure management simply stops working. It's slow, error-prone, impossible to audit, and creates environments that drift apart from each other in ways nobody can track. Infrastructure as code solves all of that — and Terraform is the tool the industry has standardised on.

What makes Terraform especially valuable is that it works across every major platform — AWS, Microsoft Azure, Google Cloud, Kubernetes, and hundreds of other providers — through a single, consistent language and workflow. Learn Terraform once, and you can manage infrastructure anywhere.

That's why Terraform appears in the requirements of almost every modern DevOps, cloud engineering, platform engineering, and site reliability role — and why professionals who know it well are consistently among the most sought-after in the market.

What you will learn

• What infrastructure as code is, why it matters, and how Terraform implements it
• The core Terraform building blocks: providers, resources, variables, outputs, and data sources — what each one does and how they fit together
• How to write clear, well-structured Terraform configurations using best-practice file organisation
• The Terraform workflow: writing configuration, running plan to preview changes, applying changes safely, and destroying resources cleanly when they're no longer needed
• How Terraform state works — why it exists, what it tracks, and how to manage it safely using remote backends and state locking
• How to build reusable, shareable infrastructure components using Terraform modules
• How to integrate Terraform into CI/CD pipelines — running infrastructure changes through automated, validated workflows
• How to handle secrets and sensitive values responsibly within Terraform configurations
• How to detect and manage configuration drift — keeping your real infrastructure aligned with your code
• How to troubleshoot common Terraform issues and follow the naming, structure, and workflow conventions used in professional environments

How you will learn it

Terraform is a practical tool, and this is a practical course. You will be writing and running real Terraform code from the very first session — provisioning actual cloud resources, working through the full plan and apply workflow, breaking things deliberately, and learning how to fix them.

Every concept is introduced with clear explanation before being applied hands-on — so you always understand not just how to do something, but why it works the way it does and where it fits in a professional workflow.

Every session is delivered by an active industry professional with real-world experience using Terraform in production environments.

Flexible delivery — designed around your life

We offer multiple training formats so you can learn in the way that works best for you:

One-to-one (1:1) Private, personalised sessions scheduled around your availability. 

Group training (cohort) Prefer to learn alongside others? Our weekend cohort sessions bring motivated learners together in a structured, collaborative environment — ideal if you enjoy working through practical exercises with a group and want to build connections with like-minded professionals along the way.

What's included

• Personalised Introduction to Terraform training plan
• Hands-on labs provisioning real cloud infrastructure throughout
• Access to an expert trainer before, during, and after every session
• Guidance on study materials, practice environments, and next steps
• A clear pathway toward advanced infrastructure as code and DevOps certifications

Who this is for

This course is designed for anyone who wants to learn infrastructure as code properly — from complete beginners through to experienced professionals filling a gap in their skill set. It is particularly well suited to:

Absolute beginners to infrastructure as code If you've never written a line of infrastructure code before, this course starts from first principles and builds your knowledge step by step. No prior experience with Terraform, DevOps tooling, or automation is assumed.

Developers who want to manage their own infrastructure If you build applications and want a reliable, repeatable way to provision the environments they run in, Terraform gives you that capability — and this course teaches it in the most direct, practical way possible.

Operations engineers and system administrators moving toward DevOps If you currently manage infrastructure manually and want to transition into modern, automated workflows, learning Terraform is one of the most valuable steps you can take — and a core requirement for almost every DevOps role.

Cloud engineers expanding their skill set If you already work with AWS, Azure, or Google Cloud and want to manage those environments as code, Terraform's provider-agnostic approach means everything you learn here applies across all of them.

Teams preparing to adopt Terraform If your organisation is moving toward infrastructure as code — whether for new projects, team workflows, or cloud migrations — this course gives you the foundation to contribute from day one.

Recommended prior experience: Basic familiarity with at least one cloud platform (AWS, Azure, or Google Cloud) and general comfort with command-line tools is helpful, but not essential. If you've completed any of our cloud architecture or engineering programmes, you are well prepared to begin. If you're unsure, speak to one of our advisers and we'll give you an honest assessment.

Your outcome

You will complete this course with a genuine, working understanding of Terraform and infrastructure as code — not just the theory, but the hands-on ability to write, plan, and apply real infrastructure configurations safely and confidently. You will understand the workflows used in professional environments, know how Terraform fits into the broader DevOps and cloud ecosystem, and have a clear path toward the certifications and advanced skills that build on this foundation.

In an industry where infrastructure as code has become a baseline expectation, this course gives you the starting point that everything else builds on.

Not sure if this is the right starting point, or want to understand how it fits into your broader learning goals? Speak to one of our advisers — no commitment, no pressure, just an honest conversation about where you want to go and the best way to get there.

Course curriculum

Introduction to Terraform

Infrastructure as code and Terraform fundamentals

Before writing any Terraform, you need to understand the problem it solves and the way of thinking it's built around. This module sets that foundation — explaining what infrastructure as code is, why the industry has adopted it so completely, and how Terraform approaches it.

You will start by examining how infrastructure has traditionally been managed — manually, through consoles and scripts — and why that approach breaks down as environments grow: inconsistency between environments, no audit trail, no repeatability, and changes that nobody can track or reverse. From there you will learn how infrastructure as code solves these problems by treating infrastructure the same way developers treat application code — written, versioned, reviewed, and applied through a controlled process.

The module then introduces Terraform itself: where it came from, how its declarative model works — you describe the end state you want, and Terraform works out how to get there — and why its provider-based architecture lets a single tool manage infrastructure across AWS, Azure, Google Cloud, and hundreds of other platforms. You will install Terraform, explore the command-line interface, and understand the structure of a Terraform project before writing your first configuration.

Core building blocks: providers, resources, variables, and outputs

Every Terraform configuration, no matter how complex, is built from the same small set of building blocks. This module teaches you each of them — what they do, how they fit together, and how to use them correctly from the start.

You will begin with providers — the plugins that connect Terraform to the platforms it manages — learning how to configure a provider, authenticate it securely, and understand provider versioning. From there you will move to resources, the heart of every configuration: the actual infrastructure components you want Terraform to create, from virtual machines and networks to storage and DNS records. You will learn how to read provider documentation to find the resource types and arguments you need — one of the most important practical skills any Terraform practitioner develops.

The module then covers variables and outputs — how variables make your configurations flexible and reusable rather than hard-coded, the different ways to supply variable values, and how outputs expose useful information from your infrastructure once it's been created. You will also learn about data sources — how to reference existing infrastructure that Terraform didn't create, allowing your configurations to integrate with what's already there.

By the end of this module you will be able to read and write real Terraform configurations using all of the core language constructs.

The Terraform workflow: plan, apply, and destroy

Terraform's workflow is one of its greatest strengths — a controlled, predictable process that shows you exactly what will change before anything actually does. This module teaches you that workflow in depth, building the safe working habits that professional environments depend on.

You will work through each stage of the core workflow: writing or modifying configuration, running terraform init to initialise your working directory and download providers, running terraform plan to preview exactly what Terraform intends to create, change, or destroy, and running terraform apply to make those changes real. You will learn how to read plan output properly — understanding what the symbols and change types mean, and how to spot unintended changes before they happen.

The module also covers terraform destroy — cleanly removing infrastructure when it's no longer needed — and the discipline of treating destroy as carefully as apply. You will learn how Terraform decides what to change through its dependency graph, why resources are sometimes replaced rather than updated in place, and how to use lifecycle arguments to control that behaviour when it matters.

By the end of this module the plan-and-apply rhythm will feel natural — and you will understand why this controlled workflow is what makes infrastructure as code safe at scale.

Understanding and managing Terraform state

State is the concept that separates people who use Terraform from people who understand it. This module demystifies state completely — what it is, why Terraform needs it, and how to manage it safely in both individual and team environments.

You will learn what the Terraform state file actually contains — Terraform's record of every resource it manages and how that record maps your configuration to real infrastructure. You will understand why state exists, what happens when it gets out of sync with reality, and why protecting it matters so much: the state file is the single source of truth for everything Terraform manages.

The module then covers remote backends — storing state centrally rather than on a local machine — and why this is essential the moment more than one person works with the same infrastructure. You will learn how state locking prevents two people from applying conflicting changes at the same time, and how to configure a remote backend with locking enabled. The module also covers practical state operations: inspecting state, moving resources within it, importing existing infrastructure into Terraform management, and what to do when state and reality drift apart.

Modules: building reusable infrastructure

Writing the same configuration over and over is no better than clicking through a console over and over. Modules are how Terraform solves that — packaging infrastructure patterns into reusable, shareable components. This module teaches you how to use them and how to build your own.

You will start by understanding what a module is — any folder of Terraform configuration — and how every configuration you've written so far has technically been one. From there you will learn how to consume existing modules: pulling well-tested infrastructure patterns from the public Terraform Registry, configuring them through input variables, and reading their outputs, rather than building everything from scratch.

The module then covers writing your own modules — structuring them with clear inputs and outputs, organising files following community conventions, and designing modules that are genuinely reusable across projects and environments rather than tied to one specific use case. You will learn how module versioning works and why pinning module versions matters for stability, along with the file and folder structure conventions used in professional Terraform codebases — including how teams typically organise configurations across multiple environments such as development, staging, and production.

Terraform in the real world: CI/CD, secrets, and best practices

The final module bridges the gap between learning Terraform and using it the way professional teams do — covering the automation, security, and operational practices that production environments demand.

You will start with Terraform in CI/CD pipelines — why teams run Terraform through automated pipelines rather than from individual laptops, what a typical pipeline looks like from plan through review to apply, and how automated validation tools like terraform fmt and terraform validate keep codebases consistent and correct before changes ever reach an environment.

The module then covers one of the most important topics in any infrastructure as code practice: secrets handling. You will learn why credentials, keys, and other sensitive values must never be written into configuration files or committed to version control, how to mark values as sensitive in Terraform, and the patterns teams use to inject secrets safely — from environment variables through to dedicated secrets management tools.

From there the module covers drift detection — what happens when someone changes infrastructure outside of Terraform, how to detect it, and how to bring reality and code back into alignment. The module closes with a consolidated tour of professional best practices: naming conventions, code organisation, the troubleshooting techniques you'll use most often, and the habits that distinguish well-run Terraform codebases from ones that become liabilities over time.

A note on certification

This course is designed to give you a solid, practical introduction to Terraform and infrastructure as code. While it provides the essential foundation, a one-day introduction is not sufficient preparation for the HashiCorp Certified: Terraform Associate exam on its own — certification requires deeper study, extensive hands-on practice, and dedicated exam preparation beyond what a single introductory course can provide. If certification is your goal, speak to one of our advisers and we will map out the full learning path to get you there.

Where this course can take you

Terraform is a foundation that opens doors across the entire cloud and DevOps landscape. Once you've completed this introduction, several valuable paths follow naturally:

HashiCorp Certified: Terraform Associate The official Terraform certification — validating your understanding of infrastructure as code concepts and your ability to use Terraform in real workflows. This course provides the foundational knowledge that certification preparation builds on.

AWS Certified DevOps Engineer — Professional Extend your Terraform skills into the full AWS DevOps ecosystem — CI/CD pipelines, infrastructure automation, and enterprise-scale delivery on the world's leading cloud platform.

Google Cloud Professional DevOps Engineer Apply your infrastructure as code knowledge within the Google Cloud ecosystem — combining Terraform with Google Cloud's operations and delivery toolchain.

Advanced infrastructure as code and platform engineering Deepen your skills with advanced Terraform patterns — workspaces, complex module design, policy as code, and managing infrastructure across large, multi-team organisations.