Infrastructure
Terraform Associate 004 #7 Writing Configuration: Variable Precedence, Functions, and Custom Conditions
We compress the exam view of variable types and the precedence of value sources, the actual reach of sensitive, and the roles of output and locals, then organize the built-in functions and expressions that appear most often. We also reinforce what the track covered lightly: the custom conditions strengthened in 004 — variable validation, resource precondition and postcondition, and check blocks — including how they differ and when each is evaluated.
Terraform Associate 004 #6 Modules: Source Addresses, Version Pinning, and Input/Output Syntax
Starting from the definition of a module and the distinction between root and child modules, we organize the syntax of the registry, Git, and local-path source types and the conditions under which the version argument works, all from the exam angle. We pin down inputs that pass values into a module and outputs read as module.<name>.<output>, the encapsulation principle that rules out direct access to resources inside a module, and the verified badge on the public registry.
Terraform Associate 004 #5 State Management: Backends, Locking, State Commands, and Sensitive Data
Starting from the purpose of state and its default file location, we organize the difference between local and remote backends, the incidents locking prevents, and where force-unlock fits, all from the exam angle. We pin down what the state list, show, mv, and rm commands each change and each leave alone, how they map to the moved, removed, and import blocks, and cover sensitive data in state and access control as exam points.
Terraform Associate 004 #4 Core Workflow: init, plan, apply, destroy, and Debugging
We cover the three stages of the official exam workflow — Write, Plan, Apply — what each command does, and the four situations that require running init again. Then the option-based question points: saving a plan with -out, apply with -auto-approve and -replace, the dangers of -target, the role split between fmt and validate, and enabling debug logs with the TF_LOG environment variable.
Terraform Associate 004 #3 Terraform Fundamentals: Version Constraints, the Lock File, and Provider Configuration
Starting from installation and checking with terraform version, we work through the version constraint operators the exam loves (=, ~>, >=) and how to read them, then separate the roles of the required_providers block and the .terraform.lock.hcl lock file. We cover provider configuration and multi-region setups with alias, and what actually goes into the .terraform directory — the question points of exam objective 3.
Terraform Associate 004 #2 IaC Concepts and Terraform's Purpose: Mastering Definition Questions
We organize the definition and benefits of IaC in the language the exam expects, and firm up the declarative-versus-imperative distinction and the concept of idempotency from a question-solving perspective. We also cover Terraform's position in the multi-cloud and provider ecosystem, why state exists, and the structure of Terraform's language and binary — a pass through the testing points of exam objectives 1 and 2.
Terraform Associate 004 #1 Exam Introduction: The 004 Revision, Domain Structure, and Study Strategy
An overview of the HashiCorp Terraform Associate certification as of the January 2026 004 revision: the exam format and what changed from 003. We cover the newly tested areas — ephemeral values and write-only arguments — along with the expanded HCP Terraform coverage and the domain breakdown, then build a mapping table between the exam objectives and the 26 parts of this blog's Terraform track to lay out a study path.
REST vs GraphQL vs tRPC: Choosing an API Style
The criteria for deciding what to build a new API with: the strengths of REST standing on resources and HTTP semantics and its overfetching problem, what GraphQL solves by letting clients declare the data they need and the costs it takes on in exchange, the appeal of tRPC wiring types end-to-end in a TypeScript monorepo and its clearly bounded applicability, and the decision axes of public exposure, client diversity, and team structure.
eBPF Explained: Extending the Kernel Without Recompiling It
A summary of eBPF, the technology underneath modern observability, networking, and security tools: the third road it opens between dangerous kernel modules and slow userspace, the safety model where a verifier rejects unbounded loops and invalid memory access, hook points like kprobes, tracepoints, and XDP, the tool ladder from bpftrace one-liners through bcc to libbpf, flagship uses like Cilium and Falco, and the practical constraints of kernel versions and privileges.
Why Processes Die of OOM with Memory to Spare: Overcommit, cgroups, the OOM Killer
Unraveling the paradox of processes dying of OOM while free shows memory remaining: how Linux overcommit promises memory and delivers it later, the difference between free and available and the page cache, the container-era OOM that kills against cgroup limits rather than the whole system (exit 137, OOMKilled), how oom_score picks the victim, confirming the cause of death with dmesg and kubectl, and designing limits and requests.
Recovering a Deleted terraform.tfstate: Backup File, S3 Versioning, and Re-import in Order
Starting with the symptoms of a missing state file and why you must not apply in that condition. We walk the recovery paths in priority order — checking the local terraform.tfstate.backup, the commands to restore a previous version from S3 versioning, and the last-resort path of rebuilding state with import when no backup exists — then cover the backend settings that structurally prevent the same accident.
How to Use terraform import: Bringing Existing Resources into Code with import Blocks
The procedure for bringing console-created resources under Terraform management, based on import blocks. Where to find each resource type's import ID, how to generate a code draft with -generate-config-out, how to adjust the code until plan shows no changes, the differences from the old CLI command approach, and the order to follow when importing multiple resources at once.