The way we manage infrastructure has changed a lot over the years.
Not too long ago, provisioning servers meant clicking through dashboards, running manual commands, and hoping nothing broke in the process. It worked… until it didn’t.
Today, Infrastructure as Code (IaC) changes that entire approach.
This is my Day 1 of the 30-Day Terraform Challenge, and I’m starting with the fundamentals, understanding what IaC is, why it matters, and why Terraform is such a big deal in modern DevOps.
What is Infrastructure as Code (IaC)?
Infrastructure as Code is the practice of managing and provisioning infrastructure using code instead of manual processes.
Instead of:
Clicking around in AWS console
Manually configuring servers
Writing one-off scripts
You define everything in code files.
That includes:
Servers (EC2)
Networks (VPCs, subnets)
Load balancers
Databases
And the best part?
You can version it, review it, and reuse it — just like application code.
The Problem IaC Solves
Manual infrastructure management comes with real issues:
Inconsistency — what works in dev may break in prod
Lack of traceability — no clear record of changes
Human errors — one wrong click, everything breaks
Scaling problems — repeating the same setup is painful
IaC solves this by making infrastructure:
Repeatable
Version-controlled
Automated
Predictable
If it works once, it works every time.
Declarative vs Imperative Approach
This was one of the most important concepts for me today.
Imperative (How to do it)
You define every step needed to reach a result.
Example mindset:
Create a server → install dependencies → configure networking → start service
You control the process step-by-step.
Declarative (What you want)
You define the final state, and the tool figures out how to get there.
Example mindset:
I want 2 EC2 instances with these configurations
Terraform handles the rest.
Why Declarative Wins
- Less code to manage
- Easier to understand
- More reliable outcomes
- Focus on intent, not steps
This shift in thinking is a big part of modern DevOps.
Why Terraform?
Terraform is one of the most popular IaC tools, and after just Day 1, it's easy to see why.
Key reasons:
Cloud-agnostic: works with AWS, Azure, GCP, and more
Declarative syntax: simple and readable
Execution plan: shows what will change before applying
State management: tracks infrastructure automatically
Strong ecosystem: modules, providers, community support
Terraform basically becomes the single source of truth for your infrastructure.
My Environment Setup (Day 1)
I already had Terraform and AWS CLI installed before starting the challenge, but I still updated everything to the latest versions.
What I’m using:
- Terraform (latest version)
- AWS CLI (configured)
- VS Code + Terraform Extension + AWS Toolkit
Updating Terraform (Windows)
Since I already had Terraform installed, I:
Downloaded the latest Windows AMD64 binary
Extracted the .exe file
Replaced the old Terraform binary with the new one
Tip for First-Time Setup
If you're installing Terraform for the first time:
- Create a dedicated folder (e.g., C:\terraform)
- Move the terraform.exe file into that folder
- Add the folder path to your System Environment Variables (PATH)
- Important: Add the folder path, not the .exe file itself.
This ensures you can run terraform from anywhere in your terminal.
Verification
Make sure everything is working:
terraform version
aws sts get-caller-identity
If both run without errors, you're good to go.
Key Learnings from Day 1
A few things really stood out to me:
Infrastructure can (and should) be treated like code
Declarative tools reduce complexity significantly
Terraform abstracts away a lot of low-level operational work
Proper setup early saves a lot of time later
Also, actually running commands and verifying setup made things stick way more than just reading.
My Goals for This 30-Day Challenge
By the end of this challenge, I want to:
Become confident writing Terraform configurations from scratch
Build real-world infrastructure on AWS using best practices
Understand modules, state management, and remote backends deeply
Combine Terraform with DevOps workflows (CI/CD, automation)
Document everything publicly to track my growth
Consistency is the main goal here.
Final Thoughts
Day 1 was more about mindset than code.
Understanding why Infrastructure as Code exists makes learning Terraform much easier. It’s not just another tool — it’s a different way of thinking about infrastructure.
We’re not just creating servers anymore.
We’re designing systems in code.
Follow the Journey
This is just Day 1. More hands-on builds coming next.
If you're also learning Terraform or DevOps, feel free to connect always good to learn alongside others.
Top comments (0)