Terraform Module Documentation Generator

Good Terraform modules are only as useful as their documentation, yet writing a README by hand is tedious and drifts from the code. The Module Documentation Generator reads the variable and output blocks from your module HCL and produces a terraform-docs style Markdown README with Inputs and Outputs tables. It is a fast, private alternative to installing and running terraform-docs on every change.

You paste the contents of variables.tf and outputs.tf, optionally give the module a name, and the tool parses the HCL in your browser with a built-in parser. It extracts each variable description, type, default, and sensitivity, and each output description and sensitivity, then lays them out as clean Markdown tables. Nothing is uploaded and no CLI is executed, so your module source stays on your machine while you get consistent, review-ready documentation you can commit. This keeps docs honest: because they come from the same blocks the module uses, the tables cannot silently fall out of date the way hand-written notes do, and reviewers see exactly what the module exposes. Because the generator reads attributes directly, it also reflects nested detail such as list and map types, giving a faithful picture of each variable rather than a vague summary.

• Inputs table - name, description, type, default, and sensitive flag for every variable block.
• Outputs table - name, description, and sensitive flag for every output block.
• Custom title - set the module name and it becomes the README heading.
• Built-in parser - HCL is parsed locally, so terraform-docs is not required.
• Live counts - stats show how many inputs and outputs were documented as you generate.
• Private - the pasted HCL never leaves your browser at any point.
• Sample loader - one click fills a realistic variables and outputs example to learn the shape.
• Copy, download, print - export README.md in the format your repository expects.
• Required flags - variables without defaults are clearly listed so consumers know exactly what they must supply.
• Clean Markdown - tables use standard pipe syntax that renders on GitHub, GitLab, and the Terraform Registry.

1. Enter a module name in the title field, or leave the sensible default placeholder.
2. Paste your .tf containing the variable and output blocks you want documented.
3. Click Generate README to parse the HCL and build the tables.
4. Review the counts to confirm every variable and output was picked up correctly.
5. Copy the Markdown into your README.md, or download it as a ready file.
6. Print or commit the result so the documentation ships with the module in version control.
7. Regenerate whenever the variables or outputs change to keep the docs accurate and current.
8. Diff in review - when the README changes, the pull request diff shows exactly which inputs or outputs moved, making review faster.

Example 1 - simple storage module. Paste a variables.tf with a region variable (string, default us-east-1) and a create_bucket boolean, plus an outputs.tf with a bucket_arn output. The tool yields a README whose Inputs table lists region and create_bucket with their types and defaults, and whose Outputs table lists bucket_arn, so a consumer immediately sees what to pass in and what to read out. Sensitive flags render as yes or no, which helps reviewers spot values that should never be printed in logs.

Example 2 - required inputs. Paste a variable with no default, such as db_username of type string. The Inputs table shows it without a default value, signalling to consumers that they must provide it, while optional variables with defaults are listed alongside it for contrast. This makes the contract of the module unambiguous at a glance.

• Zero install - no CLI or external tooling is needed to produce documentation, which lowers the barrier for occasional contributors.
• Consistent docs - predictable tables that match terraform-docs conventions reviewers already expect across modules.
• Safe - nothing leaves the browser, so private module sources stay private on your machine at all times.
• Accurate - docs are generated from the real blocks, which reduces drift between code and prose over the module lifetime.
• Fast - generate a full README in a couple of seconds instead of hand-editing tables for every variable.
• Review-ready - paste the Markdown straight into a pull request for an easy, line-by-line review of contract changes.
• Onboarding - new consumers understand inputs and outputs from one page without reading the implementation.