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 remaining | Best fit | Main goal | What to avoid |
|---|---|---|---|
| 7 days | Final review or emergency sprint | Identify weak areas, drill commands and state behavior, take timed practice | Trying to learn every topic from scratch |
| 14 days | Focused catch-up plan | Cover all major objectives once and review missed questions twice | Spending too long on broad IaC theory |
| 30 days | Balanced plan | Build Terraform fluency with hands-on labs, domain drills, and mock exams | Reading only without running Terraform |
| 60/90 days | Full preparation path | Learn deeply, practice incrementally, and retain details through spaced review | Delaying 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:
| Area | What to know | Practice tasks |
|---|---|---|
| Infrastructure as Code concepts | Declarative configuration, idempotence, Terraform’s role, provider-based automation | Explain why Terraform tracks state and how it differs from manual changes |
| Terraform workflow | init, fmt, validate, plan, apply, destroy | Run the workflow on a small configuration and predict each command’s result |
| Configuration language | Blocks, arguments, expressions, variables, outputs, locals, dependencies | Write and modify simple HCL without relying on copy-paste |
| Providers | Provider requirements, configuration, versions, aliases, provider plugins | Add a provider, initialize it, inspect lock file behavior |
| Resources and data sources | Managed resources vs read-only data lookups | Distinguish when to use a resource and when to use a data source |
| State | Purpose of state, local and remote state, state locking concepts, state commands | Use safe read-only state inspection commands; explain risks of direct state edits |
| Modules | Root modules, child modules, inputs, outputs, module sources, reuse | Convert repeated configuration into a small module |
| Variables and outputs | Types, defaults, validation concepts, sensitive values, precedence basics | Pass values through variables and expose outputs intentionally |
| Terraform Cloud / Enterprise concepts | Workspaces, remote runs, collaboration, policy and governance concepts | Know what problems managed remote workflows solve |
| Troubleshooting | Validation errors, provider errors, dependency issues, drift, formatting | Diagnose 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.
| Segment | Time | Action |
|---|---|---|
| Warm-up recall | 10 minutes | Write commands, key definitions, and state/module rules from memory |
| Focused study | 30-60 minutes | Study one objective area using documentation, notes, or a course |
| Hands-on practice | 30-60 minutes | Run Terraform commands, edit HCL, inspect plans, fix errors |
| Exam-style drill | 20-40 minutes | Answer targeted questions for the same topic |
| Missed-question review | 20-30 minutes | Log why each miss happened and what rule fixes it |
| Closeout | 5 minutes | Pick tomorrow’s weak-area target |
If you have only 45 minutes on a weekday, use this compressed version:
- 10 minutes: recall commands and concepts.
- 20 minutes: answer focused questions.
- 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 type | What it means | Fix |
|---|---|---|
| Command confusion | You mixed up Terraform CLI commands or flags | Create a command table and run the commands in a small project |
| State misunderstanding | You misunderstood what state stores or how Terraform compares desired vs actual infrastructure | Review state purpose, remote state, locking concepts, and state inspection commands |
| HCL syntax issue | You misread blocks, arguments, expressions, variables, or outputs | Rewrite the configuration by hand and validate it |
| Provider/module issue | You confused provider configuration, provider versions, module inputs, or module outputs | Build a small module and call it from a root module |
| Workflow ordering issue | You chose the wrong next step in init / plan / apply / destroy flow | Diagram the workflow and note what each command reads or writes |
| Concept wording trap | You knew the topic but missed the wording | Rephrase the rule in your own words and add one example |
| Guess | You did not know the topic | Schedule a focused review block within 48 hours |
Use this review log format:
| Date | Topic | Miss reason | Correct rule | Follow-up task |
|---|---|---|---|---|
| Example | State | Thought state is only a backup | State maps configuration to real infrastructure and supports planning | Run 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 plancompare? - What does state contain?
- What does
terraform applydo thatplandoes 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.
| Day | Primary focus | Study actions | Practice actions |
|---|---|---|---|
| 1 | Diagnostic and plan | Take a timed diagnostic set. Review every miss. Rank weak areas. | Build a “top 10 weak rules” list |
| 2 | Core workflow and CLI | Review init, fmt, validate, plan, apply, destroy, outputs, workspace basics if relevant to your materials | Run commands in a clean project and explain each result |
| 3 | Configuration, variables, outputs | Drill HCL blocks, expressions, variables, locals, outputs, sensitive values, dependencies | Rewrite a simple configuration using variables and outputs |
| 4 | Providers, resources, data sources | Review provider requirements, version constraints, provider configuration, resources vs data sources | Identify what must be managed vs read from existing infrastructure |
| 5 | State and modules | Review state purpose, remote state concepts, locking, state commands, modules, inputs, outputs | Inspect state and build a small child module |
| 6 | Timed mock and weak-area sprint | Take a timed mock. Do a full missed-question review. | Re-study only topics that caused misses |
| 7 | Light final review | Review notes, command table, state/module rules, and common traps | No 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.
| Day | Focus | Deliverable |
|---|---|---|
| 1 | Diagnostic practice | Score by topic and create a weak-area list |
| 2 | IaC and Terraform purpose | Explain declarative IaC, providers, state, and Terraform’s role |
| 3 | Terraform workflow | Run init, fmt, validate, plan, apply, destroy; document what each command does |
| 4 | HCL basics | Practice blocks, arguments, expressions, comments, dependencies |
| 5 | Variables, locals, outputs | Create variables with types/defaults, use locals, expose outputs |
| 6 | Providers | Review provider source, version constraints, configuration, aliases, initialization |
| 7 | Resources and data sources | Drill managed resources vs data lookups; review dependencies |
| 8 | State | Review local/remote state, locking concepts, state inspection, drift concepts |
| 9 | Modules | Build and call a child module; pass inputs and consume outputs |
| 10 | Terraform Cloud / Enterprise concepts | Review remote execution, workspaces, collaboration, governance concepts |
| 11 | Troubleshooting drill | Fix validation errors, provider initialization issues, variable mistakes, and plan surprises |
| 12 | Timed mock exam | Take a full timed mock and complete missed-question review |
| 13 | Weak-area sprint | Re-study the lowest two or three domains; redo targeted questions |
| 14 | Final review | Light command review, state/module summary, short drill, rest |
14-day study emphasis
| If your diagnostic weakness is… | Spend extra time on… |
|---|---|
| CLI sequence | Running commands and explaining side effects |
| Configuration syntax | Writing HCL from scratch and using terraform validate |
| State | Plan/apply behavior, state inspection, remote state concepts |
| Modules | Input/output flow between root and child modules |
| Providers | Required providers, initialization, versions, aliases |
| Terraform Cloud concepts | Remote 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
| Week | Theme | Outcome |
|---|---|---|
| Week 1 | Foundation and workflow | You can explain Terraform’s purpose and run the standard workflow confidently |
| Week 2 | Configuration, providers, variables | You can read and modify HCL and understand provider setup |
| Week 3 | State, modules, remote workflows | You can explain state behavior, module reuse, and managed workflow concepts |
| Week 4 | Timed practice and weak-area repair | You can answer exam-style questions under time pressure and correct recurring misses |
30-day schedule
| Day | Focus | Practice |
|---|---|---|
| 1 | Diagnostic set and exam objective review | Create topic scorecard |
| 2 | IaC concepts and Terraform purpose | Write short definitions from memory |
| 3 | Terraform project structure | Create a clean practice directory |
| 4 | init, provider installation, lock file concepts | Initialize and re-initialize after edits |
| 5 | fmt, validate, plan | Predict validation and plan results |
| 6 | apply, outputs, destroy | Apply and destroy a small resource safely |
| 7 | Review and targeted quiz | Review all Week 1 misses |
| 8 | HCL blocks and expressions | Rewrite configuration by hand |
| 9 | Input variables | Add types, defaults, and variable files if used in your materials |
| 10 | Locals and outputs | Refactor repeated expressions |
| 11 | Resource dependencies | Identify implicit and explicit dependencies conceptually |
| 12 | Providers and versions | Review required providers and version constraints |
| 13 | Resources vs data sources | Complete scenario drills |
| 14 | Week 2 quiz and review | Update weak-area log |
| 15 | State purpose | Explain how Terraform maps config to real objects |
| 16 | State inspection commands | Practice safe state read commands |
| 17 | Remote state and locking concepts | Compare local and remote collaboration workflows |
| 18 | Drift and plan interpretation | Review what Terraform detects during planning |
| 19 | Modules: structure and inputs | Build a small child module |
| 20 | Modules: outputs and reuse | Call the module and consume outputs |
| 21 | Week 3 quiz and review | Redo missed module/state questions |
| 22 | Terraform Cloud / Enterprise concepts | Review workspaces, remote runs, collaboration, governance |
| 23 | Troubleshooting drill | Fix intentionally broken HCL and initialization issues |
| 24 | Mixed topic practice | Complete a timed question set |
| 25 | Mock exam 1 | Full timed mock and deep review |
| 26 | Weak-area sprint 1 | Re-study two lowest areas |
| 27 | Mock exam 2 or timed section set | Compare results against Day 25 |
| 28 | Weak-area sprint 2 | Redo missed topics; avoid broad new sources |
| 29 | Final review sheet | Commands, state, modules, providers, workflow |
| 30 | Light review and readiness check | Short 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.
| Phase | 60-day pace | 90-day pace | Focus | Exit criteria |
|---|---|---|---|---|
| 1 | Days 1-14 | Days 1-21 | Foundations and workflow | You can run and explain the basic Terraform workflow |
| 2 | Days 15-28 | Days 22-42 | Configuration, providers, variables | You can read, edit, and validate HCL confidently |
| 3 | Days 29-42 | Days 43-63 | State, modules, remote workflows | You can explain state and build a reusable module |
| 4 | Days 43-54 | Days 64-81 | Mixed practice and troubleshooting | You can diagnose common errors and plan behavior |
| 5 | Days 55-60 | Days 82-90 | Final mocks and review | You can complete timed practice and explain all misses |
Phase 1: foundations and workflow
| Task | What to do |
|---|---|
| Learn IaC concepts | Explain declarative configuration, desired state, repeatability, and version-controlled infrastructure |
| Install and run Terraform in a practice environment | Use a safe local or sandbox setup |
| Practice the core workflow | Run init, fmt, validate, plan, apply, output, and destroy |
| Build a command table | Note what each command reads, writes, and changes |
| Take a small quiz every few days | Review misses immediately |
Phase 2: configuration and providers
| Task | What to do |
|---|---|
| HCL reading practice | Identify blocks, arguments, labels, expressions, and references |
| Variables | Practice defaults, types, variable assignment methods, and sensitive value handling concepts |
| Locals and outputs | Use locals to simplify expressions and outputs to expose values |
| Providers | Review required providers, source addresses, version constraints, aliases, and initialization |
| Resources and data sources | Explain managed creation vs reading existing information |
Phase 3: state, modules, and remote workflows
| Task | What to do |
|---|---|
| State concepts | Learn why state exists and how Terraform uses it during planning |
| State commands | Practice safe inspection commands such as listing and showing state |
| Remote state concepts | Understand collaboration, locking, and why teams use remote state |
| Modules | Build a simple child module with inputs and outputs |
| Terraform Cloud / Enterprise concepts | Review remote execution, workspace collaboration, policy/governance concepts, and team workflows |
Phase 4: mixed practice and troubleshooting
| Task | What to do |
|---|---|
| Mixed topic sets | Stop studying in only one-topic blocks; practice switching contexts |
| Broken configuration drills | Fix formatting, validation, provider, variable, and reference errors |
| Plan interpretation | Read planned changes and identify what Terraform will create, update, or destroy |
| Scenario questions | Choose the best Terraform feature or workflow for a described problem |
| First full timed mock | Take a timed mock before the final phase, not on the final day |
Phase 5: final mocks and readiness
| Task | What to do |
|---|---|
| Mock exam review | Review every wrong and guessed question |
| Weak-area sprint | Re-study only the lowest-scoring topics |
| Final command review | Rehearse CLI purpose, workflow order, state, modules, and providers |
| Light final day | No 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.
| Plan | First timed mock | Second timed mock | Final timed practice |
|---|---|---|---|
| 7 days | Day 1 diagnostic or Day 2 | Day 6 | Short drill only on Day 7 |
| 14 days | Day 1 diagnostic | Day 12 | Short targeted set on Day 14 |
| 30 days | Day 1 diagnostic, untimed or lightly timed | Day 25 | Day 27 or 28 |
| 60/90 days | End of Phase 2 or start of Phase 4 | Phase 4 | Final 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.
| Topic | Drill | Mastery check |
|---|---|---|
| Workflow | Put Terraform commands in order for different scenarios | You can explain what must happen before planning, applying, or destroying |
| Providers | Identify provider requirements and configuration needs | You can explain why terraform init is needed after provider changes |
| Variables | Predict how values enter configuration | You can read a variable block and know what value is expected |
| Outputs | Interpret output values and sensitivity concepts | You can explain why outputs are used between modules or after apply |
| State | Explain what Terraform compares during a plan | You can distinguish configuration, state, and real infrastructure |
| Modules | Trace inputs and outputs through root and child modules | You can refactor repeated code into a module |
| Data sources | Choose between resource and data source | You can identify read-only lookup scenarios |
| Terraform Cloud concepts | Match feature to collaboration or governance need | You can explain why a team might use remote runs or workspaces |
| Troubleshooting | Read error text and identify likely cause | You 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 check | Yes/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.