In Terraform HCL, when is the ${ ... } interpolation syntax actually required, and why does writing "${var.name}" as an entire argument value produce a deprecation warning?

## Two languages in one file Every `.tf` file mixes two grammars. The outer one is the **expression language**: the right-hand side of `argument = ...` is parsed as an expression, so a reference, a function call, an arithmetic operator or a literal all work there directly. The inner one is the **string template language**, which is what lives *inside* a quoted string or a heredoc. `${ ... }` belongs exclusively to the second grammar. It means "stop treating this as literal text, evaluate the expression inside, convert the result to a string, and splice it in". That is the whole rule. If you are already in expression context, you do not need it: ```hcl bucket = var.bucket_name # idiomatic instance_type = var.big ? "m5.large" : "t3.micro" tags = merge(var.common_tags, { Name = var.name }) ``` If you need the value embedded in surrounding text, you do: ```hcl bucket = "${var.env}-${var.app}-logs" ``` ## Why the whole-value form is deprecated In Terraform 0.11 and earlier the language had no first-class expressions — every non-constant value had to be smuggled through a string, so `"${var.name}"` and even `"${count.index}"` were the only way to write anything. Terraform 0.12 rewrote the language on HCL2 and made expressions first-class. The old form still parses, but the config loader emits a warning along the lines of "Interpolation-only expressions are deprecated", because it is pure noise: the value is converted to a string and then converted back to whatever type the argument wants. That round trip can actually change behaviour when the value is not a string — a number, a bool, a list or an object forced through a string template loses its type, and for complex types Terraform will refuse or produce something unusable. A related trap: `${ }` **outside** quotes is a syntax error. `name = ${var.x}` does not parse. The sigil only has meaning inside a template. ## Directives and escaping Templates support more than substitution. Two directives exist, both written with `%{ }`: ```hcl user_data = <<-EOT #!/bin/bash %{ for pkg in var.packages ~} yum install -y ${pkg} %{ endfor ~} %{ if var.debug }set -x%{ endif } EOT ``` The `~` marker trims the whitespace and newline adjacent to it, which is how you keep generated files from filling with blank lines. `<<-EOT` is the *indented* heredoc: the closing marker's indentation is stripped from every line, so the block can sit at the code's indentation level without pushing spaces into the rendered output. When you want a literal dollar-brace or percent-brace in the output — shell parameter expansion, a Jenkins or Prometheus template, a `${}` in a JSON policy consumed by something else — double the sigil: ```hcl script = "echo $${HOME}" # renders: echo ${HOME} fmt = "%%{ literal }" # renders: %{ literal } ``` Forgetting this is one of the most common causes of a confusing "Invalid template interpolation value" or "Unknown variable" error in a shell script rendered by Terraform. ## Where interpolation is not allowed Not every part of the config is an expression context. The `terraform` block — including `backend` and `required_providers` — is evaluated before variables exist, so `${var.bucket}` there is rejected; backend settings are supplied with partial configuration on the command line or a backend config file instead. Similarly you cannot interpolate a resource *type* or a block label: those are part of the language's structure, not values. Candidates who believe "anything can be interpolated" walk straight into this in an interview. ## What to actually say Write the bare expression in argument position; reach for `"..."` and `${ }` only when there is literal text around the value. Prefer `jsonencode()` and `yamlencode()` over hand-built JSON or YAML strings — they handle quoting and escaping for you and cannot produce invalid output. Keep templates for genuinely free-form text such as scripts and config files, and reach for `templatefile()` once the text outgrows a heredoc.