Terraform Variable Block Generator

Input variables are the public interface of a Terraform module. They let the same code serve many environments by parameterising names, regions, sizes and flags. The Terraform Variable Block Generator writes one valid variable block from a small form, so you never mistype the schema or forget a required attribute.

You set the variable name and type, choose an optional default formatted as the correct HCL literal, add a description, and toggle the sensitive and nullable flags. Names are validated as Terraform identifiers before any output is produced. Everything runs locally in your browser; nothing is uploaded and no cloud connection is made.

The result is a clean, formatted variable block you can paste into variables.tf or a module inputs file. Because the type is emitted verbatim, even complex object and collection types come out correct the first time, which keeps terraform validate happy. This removes a common source of friction where engineers hand-edit HCL and introduce subtle indentation or quoting mistakes that only surface during a later plan.

Variables also power composition: a root module can pass variables into child modules, and a good variable block makes that contract explicit and self-documenting. By generating blocks consistently, teams avoid drift between modules that were written by different people at different times, which is one of the most common causes of confusing module interfaces.

• Rich type support - string, number, bool, list(any), map(any), set(string) and a custom type you type yourself.
• Typed default literals - the default is emitted as the right HCL literal for its chosen type, so strings are quoted and numbers stay bare.
• Description field - document each input so terraform docs and editors show helpful text.
• Sensitive flag - mark secret values to redact them in plan and apply output.
• Nullable flag - control whether the variable may be null, matching Terraform 1.0 behavior.
• Identifier validation - variable names are checked against Terraform naming rules.
• Custom types - paste any type expression such as object({ name = string }).
• Nullable clarity - explicitly setting nullable documents whether callers may pass null.
• Formatted output - the block is indented to match terraform fmt conventions.
• Consistent style - every generated block uses the same ordering of attributes, making diffs easier to read in review.
• No quoting errors - the literal formatter handles quotes for you, so a default never breaks the file.
• Copy and download - export the block as HCL, a file or printed output.

1. Name the variable - type an identifier such as region or instance_count.
2. Pick a type - choose from the common types or select custom to type your own.
3. Set a default - optionally enter a default and choose its type so it is formatted correctly.
4. Add a description - write a short sentence explaining what the variable controls.
5. Toggle flags - mark the variable sensitive for secrets and set nullable as needed.
6. Generate the block - press "Generate HCL" to validate the name and assemble the block.
7. Export it - Copy the HCL, Download variables.tf, or Print the result.
8. Reuse the pattern - generate each module input the same way to keep a uniform variables file across the project.

Example - string with default. name=region, type=string, default="us-east-1", description="The AWS region" yields a variable block with type, default and description set.

Example - sensitive password. name=db_password, type=string, sensitive=true produces a variable whose value Terraform redacts in output.

Example - custom object. A custom type such as object({ name = string, count = number }) is emitted verbatim, enabling strongly typed module inputs.

Example - number port. name=port, type=number, default=8080 yields type = number and default = 8080 without quotes, exactly as Terraform expects.

• Correct schema - the block follows the variable specification exactly.
• Typed defaults - defaults are emitted as valid HCL literals, never as raw text.
• Validated names - bad identifiers are caught before output is generated.
• Secret safe - the sensitive flag keeps credentials out of logs.
• Private - the entire tool runs in your browser.
• Reusable modules - well-typed variables make modules safe to share across teams.
• Instant export - copy, download or print the block in one click.
• Easier reviews - uniform blocks make pull requests quicker to approve and audit.