AboutTeamsPricing
New content added weeklyLive

Master Terraform with Adaptive AI.

Master Terraform across 24 topics - Foundations, Modules and State, and Advanced Terraform - guided by Leyaa's adaptive intelligence.

3Parts
24Topics
194Patterns
50hEst. duration
Start Learning Free
Terraform
Terraform Course
3 - part learning journey
Beginner
Foundations
8 topics · 65 patterns
Beginner
Intermediate
Modules and State
8 topics · 66 patterns
Intermediate
Advanced
Advanced Terraform
8 topics · 63 patterns
Advanced
Begin Part 1: Foundations
✦ Course Structure

Your Terraform Journey in 3 Parts

Each part builds on the last - a deliberate progression from beginner to advanced.

Beginner
Beginner
Part 1: Foundations
Covers Infrastructure as Code Fundamentals, Configuration Language (HCL), Providers and 5 more topics.
8Topics
65Patterns
View topics
Intermediate
Intermediate
Part 2: Modules and State
Covers Data Sources, Expressions and Functions, Resource Meta-Arguments and 5 more topics.
8Topics
66Patterns
View topics
Advanced
Advanced
Part 3: Advanced Terraform
Covers Workspaces, Complex Type System, State Operations and 5 more topics.
8Topics
63Patterns
View topics
Curriculum

Everything You'll Learn

Explore every topic and pattern in the course.

Terraform

3 parts · 24 topics · 194 patterns
Beginner
Part 1: Foundations8 topics · 65 patterns
Beginner
01
Infrastructure as Code Fundamentals
8 patterns
What is Infrastructure as Code
Why IaC over manual provisioning
Declarative vs imperative IaC
Terraform's declarative approach
Terraform vs CloudFormation vs Pulumi
Terraform provider ecosystem
Installing Terraform
Terraform CLI overview
02
Configuration Language (HCL)
8 patterns
Why HCL matters as Terraform's language
Block syntax and structure
Arguments and expressions
String interpolation
Comments in HCL
File naming conventions (.tf files)
Terraform file organization
JSON configuration alternative
03
Providers
8 patterns
Why providers connect to cloud APIs
Provider configuration block
AWS provider setup
Azure provider setup
GCP provider setup
Provider versioning constraints
Multiple provider configurations
Provider aliases for multi-region
04
Resources
8 patterns
Why resources are Terraform's core
Resource block syntax
Resource types and names
Resource arguments and attributes
Resource dependencies (implicit)
Creating your first resource
Resource documentation reference
Meta-arguments overview
05
Terraform Workflow
9 patterns
Why the workflow matters
Terraform init for initialization
Terraform plan for preview
Terraform apply for execution
Terraform destroy for cleanup
Plan output reading
Auto-approve flag and its danger
Terraform validate for syntax check
Terraform fmt for formatting
06
State Management Fundamentals
8 patterns
Why state is essential
State file purpose and structure
Local state behavior
Terraform show for state inspection
Terraform state list command
State and real infrastructure mapping
Why state should not be edited manually
State file sensitivity and security
07
Variables
9 patterns
Why variables make configurations reusable
Variable declaration syntax
Variable types (string, number, bool, list, map)
Default values
Variable validation rules
Input variable precedence order
Terraform.tfvars file
Environment variables (TF_VAR_)
Sensitive variables
08
Outputs
7 patterns
Why outputs expose useful information
Output declaration syntax
Output values after apply
Terraform output command
Sensitive output values
Outputs for module communication
Outputs as documentation
Intermediate
Part 2: Modules and State8 topics · 66 patterns
Intermediate
01
Data Sources
8 patterns
Why data sources query existing infrastructure
Data source block syntax
Querying existing resources
Data source vs resource difference
AMI lookup data source example
Availability zones data source
Remote state data source
Data source dependencies
02
Expressions and Functions
9 patterns
Why expressions add logic
Conditional expressions (ternary)
For expressions for transformation
Splat expressions
String functions (join, split, format)
Numeric functions (min, max, ceil)
Collection functions (length, flatten, merge)
Type conversion functions
File functions (file, templatefile)
03
Resource Meta-Arguments
9 patterns
Why meta-arguments control resource behavior
Count for multiple instances
For_each for map-based instances
Count vs for_each decision
Depends_on for explicit dependencies
Lifecycle customization
Prevent_destroy lifecycle rule
Create_before_destroy lifecycle rule
Ignore_changes lifecycle rule
04
Modules
10 patterns
Why modules enable reusability
Module structure and conventions
Root module concept
Creating a child module
Module inputs (variables)
Module outputs
Module sources (local, registry, git)
Terraform Registry modules
Module versioning
Module composition patterns
05
Remote State
8 patterns
Why remote state matters for teams
S3 backend configuration
Azure Storage backend
GCS backend configuration
State locking with DynamoDB
Backend initialization and migration
Partial backend configuration
State encryption at rest
06
Provisioners
8 patterns
Why provisioners run scripts on resources
Local-exec provisioner
Remote-exec provisioner
File provisioner
Connection blocks for SSH
Creation-time vs destruction-time
Provisioner failure behavior
Why provisioners are a last resort
07
Dynamic Blocks
7 patterns
Why dynamic blocks reduce repetition
Dynamic block syntax
Iterator variable
Dynamic blocks in security groups
Dynamic blocks in ingress rules
Nested dynamic blocks
Dynamic blocks vs for_each decision
08
Terraform Import
7 patterns
Why importing existing resources matters
Terraform import command
Import block syntax (Terraform 1.5+)
Writing configuration for imported resources
Import state verification
Bulk import strategies
Import limitations and considerations
Advanced
Part 3: Advanced Terraform8 topics · 63 patterns
Advanced
01
Workspaces
8 patterns
Why workspaces separate environments
Default workspace
Creating and switching workspaces
Workspace naming conventions
Terraform.workspace interpolation
Workspaces vs directory-based separation
Workspaces and remote state
When workspaces are appropriate
02
Complex Type System
8 patterns
Why complex types matter
Object type definition
Tuple type definition
Optional attributes in objects
Type constraints in variables
Any type for flexibility
Null values handling
Type conversion behavior
03
State Operations
8 patterns
Why state operations are needed
Terraform state mv for refactoring
Terraform state rm for removing resources
Terraform state pull and push
State replace-provider
Terraform taint and untaint (deprecated)
Terraform apply -replace flag
State disaster recovery
04
Testing and Validation
8 patterns
Why testing infrastructure matters
Variable validation blocks
Preconditions and postconditions
Check blocks for assertions
Terraform test framework (1.6+)
Test file structure
Mock providers in tests
Integration testing strategies
05
CI/CD Integration
8 patterns
Why automated Terraform matters
Terraform in GitHub Actions
Terraform in GitLab CI
Plan and apply separation in pipelines
Terraform Cloud overview
Remote execution model
Sentinel policy as code
Drift detection in CI/CD
06
Advanced Patterns
7 patterns
Why patterns solve common problems
Remote state data source for cross-project
Terraform_remote_state usage
Dependency inversion with modules
Blue-green infrastructure pattern
Immutable infrastructure concept
Zero-downtime deployment pattern
07
Security and Best Practices
8 patterns
Why security matters in IaC
Sensitive variable handling
State file encryption
OIDC authentication for CI/CD
Least privilege for Terraform service accounts
Code review for infrastructure changes
Terraform security scanning tools
Secret management integration (Vault, Secrets Manager)
08
Terraform at Scale
8 patterns
Why scaling Terraform matters
Monorepo vs multi-repo for Terraform
Module registry for organization
Terragrunt for DRY configurations
Terraform Cloud/Enterprise features
State file performance at scale
Provider caching and mirrors
Team workflows and collaboration
Why Leyaa

Not just a course. A learning intelligence.

Leyaa doesn't just deliver content - it understands where you are, what you need, and how to get you there fastest.

Adaptive Diagnostics
Adaptive Diagnostics
Leyaa identifies which of the 194 patterns you've mastered and which need work - before you waste time on what you already know.
Pattern-Level Precision
Pattern-Level Precision
Every pattern gets a verdict - Learn, Practice, or Skip - so your study time goes exactly where it counts.
Intelligent Pacing
Intelligent Pacing
Leyaa reads your velocity across the whole course and adapts your focus list dynamically, keeping you in the optimal learning zone.
Before & After Visibility
Before & After Visibility
Every assessment creates a snapshot. Retake anytime to see exactly how much you've grown - topic by topic, pattern by pattern.
Learner Autonomy
Learner Autonomy
Leyaa recommends, never restricts. Override any suggestion and explore at your own pace - the system tracks everything regardless.
Clear Learning Path
Clear Learning Path
Foundations → Modules and State → Advanced Terraform - a structured journey where each part sets you up perfectly for the next.
Terraform

Ready to master Terraform?
Start your journey today

Start your diagnostic now. Build mastery across all 24 topics in under 15 minutes.

24 Topics
194 Patterns
Personalized roadmap
Leyaa Swift Bird