004 — HashiCorp Certified: Terraform Associate Study Plan

A practical 7-day, 14-day, 30-day, and 60/90-day study plan for the HashiCorp Certified: Terraform Associate (004) exam.

Study plan orientation

This Study Plan is for candidates preparing for the HashiCorp Certified: Terraform Associate (004) exam, exam code 004. It is designed for practical preparation: learn the Terraform workflow, practice with realistic configuration tasks, review missed questions, and build enough command-line fluency to answer exam scenarios confidently.

Use the plan that matches your remaining time. If you already use Terraform professionally, you may move faster, but do not skip timed practice. The exam rewards both concept knowledge and accurate interpretation of Terraform behavior.

Which plan should you use?

Time remainingBest fitMain goalWhat to avoid
7 daysFinal review or emergency sprintIdentify weak areas, drill commands and state behavior, take timed practiceTrying to learn every topic from scratch
14 daysFocused catch-up planCover all major objectives once and review missed questions twiceSpending too long on broad IaC theory
30 daysBalanced planBuild Terraform fluency with hands-on labs, domain drills, and mock examsReading only without running Terraform
60/90 daysFull preparation pathLearn deeply, practice incrementally, and retain details through spaced reviewDelaying practice exams until the final week

Core exam areas to schedule

Use the current HashiCorp exam objectives as your source of truth. Organize your study around these practical Terraform skill areas:

AreaWhat to knowPractice tasks
Infrastructure as Code conceptsDeclarative configuration, idempotence, Terraform’s role, provider-based automationExplain why Terraform tracks state and how it differs from manual changes
Terraform workflowinit, fmt, validate, plan, apply, destroyRun the workflow on a small configuration and predict each command’s result
Configuration languageBlocks, arguments, expressions, variables, outputs, locals, dependenciesWrite and modify simple HCL without relying on copy-paste
ProvidersProvider requirements, configuration, versions, aliases, provider pluginsAdd a provider, initialize it, inspect lock file behavior
Resources and data sourcesManaged resources vs read-only data lookupsDistinguish when to use a resource and when to use a data source
StatePurpose of state, local and remote state, state locking concepts, state commandsUse safe read-only state inspection commands; explain risks of direct state edits
ModulesRoot modules, child modules, inputs, outputs, module sources, reuseConvert repeated configuration into a small module
Variables and outputsTypes, defaults, validation concepts, sensitive values, precedence basicsPass values through variables and expose outputs intentionally
Terraform Cloud / Enterprise conceptsWorkspaces, remote runs, collaboration, policy and governance conceptsKnow what problems managed remote workflows solve
TroubleshootingValidation errors, provider errors, dependency issues, drift, formattingDiagnose a failed plan from the error message and configuration context

Daily practice rhythm

Use this rhythm for most study days, whether you are on the 7-day or 90-day path.

SegmentTimeAction
Warm-up recall10 minutesWrite commands, key definitions, and state/module rules from memory
Focused study30-60 minutesStudy one objective area using documentation, notes, or a course
Hands-on practice30-60 minutesRun Terraform commands, edit HCL, inspect plans, fix errors
Exam-style drill20-40 minutesAnswer targeted questions for the same topic
Missed-question review20-30 minutesLog why each miss happened and what rule fixes it
Closeout5 minutesPick tomorrow’s weak-area target

If you have only 45 minutes on a weekday, use this compressed version:

  1. 10 minutes: recall commands and concepts.
  2. 20 minutes: answer focused questions.
  3. 15 minutes: review misses and update notes.

Missed-question review method

Do not just mark a question as “wrong.” Classify the miss so your next study block fixes the cause.

Miss typeWhat it meansFix
Command confusionYou mixed up Terraform CLI commands or flagsCreate a command table and run the commands in a small project
State misunderstandingYou misunderstood what state stores or how Terraform compares desired vs actual infrastructureReview state purpose, remote state, locking concepts, and state inspection commands
HCL syntax issueYou misread blocks, arguments, expressions, variables, or outputsRewrite the configuration by hand and validate it
Provider/module issueYou confused provider configuration, provider versions, module inputs, or module outputsBuild a small module and call it from a root module
Workflow ordering issueYou chose the wrong next step in init / plan / apply / destroy flowDiagram the workflow and note what each command reads or writes
Concept wording trapYou knew the topic but missed the wordingRephrase the rule in your own words and add one example
GuessYou did not know the topicSchedule a focused review block within 48 hours

Use this review log format:

DateTopicMiss reasonCorrect ruleFollow-up task
ExampleStateThought state is only a backupState maps configuration to real infrastructure and supports planningRun terraform state list and review state concepts

Terraform hands-on baseline lab

For most candidates, a small local Terraform project is enough to reinforce the exam workflow. You do not need a complex cloud architecture to study the fundamentals.

Practice these actions repeatedly:

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.0"
    }
  }
}

resource "local_file" "example" {
  filename = "${path.module}/example.txt"
  content  = "Terraform Associate practice"
}

output "file_path" {
  value = local_file.example.filename
}

Run and understand:

terraform init
terraform fmt
terraform validate
terraform plan
terraform apply
terraform output
terraform state list
terraform state show local_file.example
terraform destroy

Focus less on memorizing the sample and more on answering:

  • What changes after terraform init?
  • What does terraform plan compare?
  • What does state contain?
  • What does terraform apply do that plan does not?
  • Why should formatting and validation happen before review?
  • What happens if configuration changes after resources already exist?
  • When would a module make this configuration easier to reuse?

7-day final review plan

Use this path if the exam is one week away. The goal is not to learn everything from zero. The goal is to find weak areas, review high-value concepts, and practice under time pressure.

DayPrimary focusStudy actionsPractice actions
1Diagnostic and planTake a timed diagnostic set. Review every miss. Rank weak areas.Build a “top 10 weak rules” list
2Core workflow and CLIReview init, fmt, validate, plan, apply, destroy, outputs, workspace basics if relevant to your materialsRun commands in a clean project and explain each result
3Configuration, variables, outputsDrill HCL blocks, expressions, variables, locals, outputs, sensitive values, dependenciesRewrite a simple configuration using variables and outputs
4Providers, resources, data sourcesReview provider requirements, version constraints, provider configuration, resources vs data sourcesIdentify what must be managed vs read from existing infrastructure
5State and modulesReview state purpose, remote state concepts, locking, state commands, modules, inputs, outputsInspect state and build a small child module
6Timed mock and weak-area sprintTake a timed mock. Do a full missed-question review.Re-study only topics that caused misses
7Light final reviewReview notes, command table, state/module rules, and common trapsNo heavy new material; do short confidence drills only

7-day rules

  • Stop adding new broad resources after Day 5.
  • Do not spend the final day building large labs.
  • Prioritize state, workflow, modules, variables, providers, and Terraform Cloud/Enterprise concepts.
  • For every missed question, write the correct rule in one sentence.
  • If two mock exams show the same weak area, study that area before taking another mock.

14-day focused plan

Use this path if you have two weeks and need structured coverage with enough time for correction.

DayFocusDeliverable
1Diagnostic practiceScore by topic and create a weak-area list
2IaC and Terraform purposeExplain declarative IaC, providers, state, and Terraform’s role
3Terraform workflowRun init, fmt, validate, plan, apply, destroy; document what each command does
4HCL basicsPractice blocks, arguments, expressions, comments, dependencies
5Variables, locals, outputsCreate variables with types/defaults, use locals, expose outputs
6ProvidersReview provider source, version constraints, configuration, aliases, initialization
7Resources and data sourcesDrill managed resources vs data lookups; review dependencies
8StateReview local/remote state, locking concepts, state inspection, drift concepts
9ModulesBuild and call a child module; pass inputs and consume outputs
10Terraform Cloud / Enterprise conceptsReview remote execution, workspaces, collaboration, governance concepts
11Troubleshooting drillFix validation errors, provider initialization issues, variable mistakes, and plan surprises
12Timed mock examTake a full timed mock and complete missed-question review
13Weak-area sprintRe-study the lowest two or three domains; redo targeted questions
14Final reviewLight command review, state/module summary, short drill, rest

14-day study emphasis

If your diagnostic weakness is…Spend extra time on…
CLI sequenceRunning commands and explaining side effects
Configuration syntaxWriting HCL from scratch and using terraform validate
StatePlan/apply behavior, state inspection, remote state concepts
ModulesInput/output flow between root and child modules
ProvidersRequired providers, initialization, versions, aliases
Terraform Cloud conceptsRemote workflows, workspaces, collaboration and governance use cases

30-day balanced plan

Use this path if you want a realistic schedule that combines concept review, hands-on practice, and timed assessment.

Weekly overview

WeekThemeOutcome
Week 1Foundation and workflowYou can explain Terraform’s purpose and run the standard workflow confidently
Week 2Configuration, providers, variablesYou can read and modify HCL and understand provider setup
Week 3State, modules, remote workflowsYou can explain state behavior, module reuse, and managed workflow concepts
Week 4Timed practice and weak-area repairYou can answer exam-style questions under time pressure and correct recurring misses

30-day schedule

DayFocusPractice
1Diagnostic set and exam objective reviewCreate topic scorecard
2IaC concepts and Terraform purposeWrite short definitions from memory
3Terraform project structureCreate a clean practice directory
4init, provider installation, lock file conceptsInitialize and re-initialize after edits
5fmt, validate, planPredict validation and plan results
6apply, outputs, destroyApply and destroy a small resource safely
7Review and targeted quizReview all Week 1 misses
8HCL blocks and expressionsRewrite configuration by hand
9Input variablesAdd types, defaults, and variable files if used in your materials
10Locals and outputsRefactor repeated expressions
11Resource dependenciesIdentify implicit and explicit dependencies conceptually
12Providers and versionsReview required providers and version constraints
13Resources vs data sourcesComplete scenario drills
14Week 2 quiz and reviewUpdate weak-area log
15State purposeExplain how Terraform maps config to real objects
16State inspection commandsPractice safe state read commands
17Remote state and locking conceptsCompare local and remote collaboration workflows
18Drift and plan interpretationReview what Terraform detects during planning
19Modules: structure and inputsBuild a small child module
20Modules: outputs and reuseCall the module and consume outputs
21Week 3 quiz and reviewRedo missed module/state questions
22Terraform Cloud / Enterprise conceptsReview workspaces, remote runs, collaboration, governance
23Troubleshooting drillFix intentionally broken HCL and initialization issues
24Mixed topic practiceComplete a timed question set
25Mock exam 1Full timed mock and deep review
26Weak-area sprint 1Re-study two lowest areas
27Mock exam 2 or timed section setCompare results against Day 25
28Weak-area sprint 2Redo missed topics; avoid broad new sources
29Final review sheetCommands, state, modules, providers, workflow
30Light review and readiness checkShort drill only; rest before exam

60/90-day full preparation path

Use this path if you are starting early, are new to Terraform, or want durable skill rather than short-term memorization. For 60 days, complete each phase in about two weeks. For 90 days, stretch each phase to about three weeks and add more hands-on repetition.

Phase60-day pace90-day paceFocusExit criteria
1Days 1-14Days 1-21Foundations and workflowYou can run and explain the basic Terraform workflow
2Days 15-28Days 22-42Configuration, providers, variablesYou can read, edit, and validate HCL confidently
3Days 29-42Days 43-63State, modules, remote workflowsYou can explain state and build a reusable module
4Days 43-54Days 64-81Mixed practice and troubleshootingYou can diagnose common errors and plan behavior
5Days 55-60Days 82-90Final mocks and reviewYou can complete timed practice and explain all misses

Phase 1: foundations and workflow

TaskWhat to do
Learn IaC conceptsExplain declarative configuration, desired state, repeatability, and version-controlled infrastructure
Install and run Terraform in a practice environmentUse a safe local or sandbox setup
Practice the core workflowRun init, fmt, validate, plan, apply, output, and destroy
Build a command tableNote what each command reads, writes, and changes
Take a small quiz every few daysReview misses immediately

Phase 2: configuration and providers

TaskWhat to do
HCL reading practiceIdentify blocks, arguments, labels, expressions, and references
VariablesPractice defaults, types, variable assignment methods, and sensitive value handling concepts
Locals and outputsUse locals to simplify expressions and outputs to expose values
ProvidersReview required providers, source addresses, version constraints, aliases, and initialization
Resources and data sourcesExplain managed creation vs reading existing information

Phase 3: state, modules, and remote workflows

TaskWhat to do
State conceptsLearn why state exists and how Terraform uses it during planning
State commandsPractice safe inspection commands such as listing and showing state
Remote state conceptsUnderstand collaboration, locking, and why teams use remote state
ModulesBuild a simple child module with inputs and outputs
Terraform Cloud / Enterprise conceptsReview remote execution, workspace collaboration, policy/governance concepts, and team workflows

Phase 4: mixed practice and troubleshooting

TaskWhat to do
Mixed topic setsStop studying in only one-topic blocks; practice switching contexts
Broken configuration drillsFix formatting, validation, provider, variable, and reference errors
Plan interpretationRead planned changes and identify what Terraform will create, update, or destroy
Scenario questionsChoose the best Terraform feature or workflow for a described problem
First full timed mockTake a timed mock before the final phase, not on the final day

Phase 5: final mocks and readiness

TaskWhat to do
Mock exam reviewReview every wrong and guessed question
Weak-area sprintRe-study only the lowest-scoring topics
Final command reviewRehearse CLI purpose, workflow order, state, modules, and providers
Light final dayNo heavy new material; short review and rest

When to use timed mock exams

Timed mocks are most useful after you have covered the main objectives at least once.

PlanFirst timed mockSecond timed mockFinal timed practice
7 daysDay 1 diagnostic or Day 2Day 6Short drill only on Day 7
14 daysDay 1 diagnosticDay 12Short targeted set on Day 14
30 daysDay 1 diagnostic, untimed or lightly timedDay 25Day 27 or 28
60/90 daysEnd of Phase 2 or start of Phase 4Phase 4Final phase

After each mock, spend at least as much time reviewing as you spent testing. A mock without review is mostly a stamina exercise.

Domain-by-domain drill plan

Use targeted drills when a diagnostic shows a weak topic.

TopicDrillMastery check
WorkflowPut Terraform commands in order for different scenariosYou can explain what must happen before planning, applying, or destroying
ProvidersIdentify provider requirements and configuration needsYou can explain why terraform init is needed after provider changes
VariablesPredict how values enter configurationYou can read a variable block and know what value is expected
OutputsInterpret output values and sensitivity conceptsYou can explain why outputs are used between modules or after apply
StateExplain what Terraform compares during a planYou can distinguish configuration, state, and real infrastructure
ModulesTrace inputs and outputs through root and child modulesYou can refactor repeated code into a module
Data sourcesChoose between resource and data sourceYou can identify read-only lookup scenarios
Terraform Cloud conceptsMatch feature to collaboration or governance needYou can explain why a team might use remote runs or workspaces
TroubleshootingRead error text and identify likely causeYou can fix simple syntax, provider, reference, and variable errors

Final-week rules

During the final week, preparation should become narrower and more deliberate.

Keep doing

  • Review missed-question notes daily.
  • Practice command purpose and workflow order.
  • Drill state, modules, providers, variables, and outputs.
  • Take timed practice early enough to review it.
  • Re-run small labs only when they clarify a weak concept.
  • Summarize each weak topic in one or two sentences.

Stop doing

  • Stop collecting new courses, long videos, or unrelated tutorials.
  • Stop building large cloud architectures that are not needed for the exam.
  • Stop memorizing provider-specific cloud service limits.
  • Stop taking mock after mock without reviewing misses.
  • Stop adding new material in the final 24 hours unless it fixes a specific known gap.

Exam-readiness checks

You are closer to ready when you can do the following without notes:

Readiness checkYes/No
Explain what Terraform does and why state is required
Describe the standard workflow from initialization through destroy
Read a small HCL configuration and identify resources, data sources, variables, locals, and outputs
Explain provider requirements, provider configuration, and why initialization matters
Distinguish resources from data sources in a scenario
Explain local state, remote state concepts, and locking at a high level
Use safe state inspection commands conceptually
Explain how modules receive inputs and expose outputs
Identify common causes of validation, provider, variable, and reference errors
Describe why teams use Terraform Cloud or Enterprise workflow features
Complete timed practice without rushing the final questions
Review every missed or guessed question and state the correct rule

If several checks are still “No,” do not spend your next session on general review. Pick the weakest two checks and drill them directly.

Practical next step

Choose your timeline first: 7, 14, 30, or 60/90 days. Then take a diagnostic practice set and build a missed-question log. Your next study session should be based on that evidence, not on the topic that feels most comfortable.