Mary Mutua

Posted on Apr 30

How I Prepared for the Terraform Associate Exam with Practice Questions

Day 28 of my 30-Day Terraform Challenge was different from the previous days.

There was no new infrastructure to deploy, no AWS resource to troubleshoot, and no module to refactor. The focus shifted from building to proving. After weeks of hands-on Terraform work, I wanted to know whether the concepts were actually sticking under pressure.

So I treated the day like an exam simulation.

The plan was simple:

take two full practice exams
answer 57 questions in each exam
work under timed conditions
avoid looking anything up mid-exam
review every wrong answer properly afterward

This was not casual revision. It was a deliberate test of recall, reasoning, and speed.

GitHub reference:

https://github.com/mary20205090/30-day-Terraform-Challenge/tree/main/day_28

My Scores

I completed two full practice exams.

Practice Exam 1

Score: 54/57
Accuracy: 94.7%

Practice Exam 2

Score: 56/57
Accuracy: 98.2%

What I found interesting was not just that both scores were strong, but that the second one was slightly better.

That told me something useful about how I perform under repetition. Instead of fading, I seemed to settle into the exam rhythm. The warm-up effect was real.

Still, the scores were only part of the story.

The real value of the day came from reviewing the misses.

The Most Valuable Part Was the Wrong-Answer Review

After each exam, I did not want to stop at “correct” or “incorrect.” I wanted to understand the reasoning behind every miss.

For each wrong answer, I reviewed it using this structure:

question topic
what I answered
correct answer
why I was wrong
what I needed to reinforce

That last part mattered a lot.

It is easy to read the correct answer and move on. It is much harder, and much more useful, to identify the real gap in your thinking.

Sometimes the gap is a missing concept.
Sometimes it is misreading the wording.
Sometimes it is mixing up two Terraform features that sound similar but behave differently.

That kind of review is what makes practice exams useful instead of just repetitive.

What I Got Wrong

Across both exams, I only missed a few questions, but they were interesting misses because they were not about broad fundamentals. They were about precision.

Exam 1

I missed questions related to:

immutable infrastructure
CloudFormation vs Terraform provider scope
provider alias syntax

Exam 2

I missed one question related to:

terraform state mv

That pattern actually gave me confidence.

I was not struggling with the main Terraform workflow. I was not missing modules, state concepts, or core CLI usage at a high level. What I needed to sharpen were the finer distinctions that often appear in certification exams.

Those are the kinds of questions that can catch you off guard if you rely only on familiarity instead of understanding.

What Surprised Me

The biggest surprise was not my score. It was which topics felt easiest and which ones still created small mistakes.

My stronger areas were:

Terraform CLI
core workflow
state basics
modules
HCP Terraform / Terraform Cloud
general configuration structure

The weaker spots were much narrower:

immutable vs mutable infrastructure thinking
cloud-specific tooling vs provider-agnostic tooling
exact provider alias usage
state subcommands during refactoring

That was a good reminder that exam readiness is not only about knowing the “big ideas.”

Sometimes the harder questions are the ones that test whether you can clearly separate two concepts that look similar on the surface.

The Hands-On Reinforcement That Helped

I did not want my review to be passive.

Instead of just rereading the answers, I used small practical reinforcements to close the gaps.

Provider alias syntax

One of my misses came from confusing alias declaration with alias usage.

To reinforce it, I went back to the exact pattern:

provider "aws" {
  region = "us-east-1"
}

provider "aws" {
  alias  = "west"
  region = "us-west-2"
}

resource "aws_s3_bucket" "west_bucket" {
  provider = aws.west
  bucket   = "example-west-bucket-12345"
}

That helped lock in the difference between:

declaring alias = "west" in the provider block
using provider = aws.west inside a resource

That is a small distinction, but it is exactly the kind of thing that can cost points if your memory is fuzzy.

State command review

Another useful review point was around terraform state mv.

That made me revisit the difference between:

terraform import
terraform state mv
terraform state rm

The distinction became much clearer once I framed them by purpose:

terraform import brings existing infrastructure into Terraform state
terraform state mv changes the address of an object Terraform already tracks
terraform state rm removes an object from state without deleting the real resource

That is not just exam trivia. It is practical Terraform knowledge that matters when refactoring real infrastructure.

What This Taught Me About Exam Prep

The biggest lesson from Day 28 was this:

A practice exam is only as valuable as the review that follows it.

A high score can be encouraging, but it is not enough on its own.

What really improves exam readiness is being able to say:

this is what I misunderstood
this is why I misunderstood it
this is how I will stop making the same mistake

That turns a wrong answer into a useful learning asset.

Without that step, practice questions can become little more than scorekeeping.

What Helped Me Most

A few things made this study session much more effective:

answering under timed conditions
not interrupting the exam to look things up
taking two separate full-length practice runs
reviewing the misses immediately afterward
paying attention to whether my second score improved or dropped

That last point was especially helpful.

If the second score had been significantly worse, it would have suggested fatigue. Since it improved, it suggested that a short warm-up before the real exam might actually help me perform better.

That is the kind of insight I would not get from doing random untimed questions here and there.

Final Takeaway

Day 28 was one of the most useful preparation days in the whole challenge because it forced me to move from learning Terraform to testing my command of it.

It reminded me that exam readiness is not just about memorizing commands.

It is about being able to:

reason quickly
separate similar concepts accurately
stay calm under time pressure
review mistakes honestly

The scores were strong, but the biggest win was getting clarity on the few areas that still need sharper recall.

DEV Community