Teams get locked into complex IaC tool stacks (Terragrunt, CDK, Pulumi) and migrating off is painful enough that consultants build entire practices around it
AST-based parser that reads Terragrunt/Terraform configs and auto-generates equivalent plain Terraform, OpenTofu, or Pulumi code with state migration scripts
Freemium - free for small repos, paid tiers for large estates and state migration support
The pain signal is loud and real — consultants literally build careers around this single problem. A Terragrunt-to-Terraform migration at a mid-size company can take 3-6 months of engineer time. The Reddit signals confirm frustration. However, it's episodic pain (you migrate once), not daily chronic pain, which slightly limits intensity.
TAM is narrower than it looks. Target is platform engineering teams at companies with 50+ Terraform modules AND using Terragrunt/CDK who want to migrate. Estimated ~10,000-30,000 companies globally fit this profile. At $5,000-50,000 per migration event, TAM is roughly $150M-500M — decent but not massive. This is a tools-for-tools market, which is inherently niche. The OpenTofu fork expanded the addressable market meaningfully.
Strong signal: companies already pay $50K-200K+ to consultants for manual migrations. An automated tool at $5K-20K is an easy sell against that baseline. Platform engineering teams have budget authority. However, many teams will attempt DIY with scripts first, and the free open-source converters set a low price anchor. Enterprise sales cycle could be long since migration is a considered purchase, not impulse.
This is where it gets brutal. Terragrunt's dependency resolution, generate blocks, and run_cmd hooks create edge cases that are extremely hard to handle generically. HCL parsing is doable (HashiCorp's hclwrite library), but semantic understanding of module relationships, conditional logic, and provider-specific quirks requires deep domain modeling. State migration is the hardest part — one wrong move and you destroy production infrastructure. A solo dev could build a working demo for simple cases in 4-8 weeks, but production-grade coverage for real-world estates with complex Terragrunt hierarchies is a 6-12 month effort minimum. The long tail of edge cases is brutal.
The gap is genuinely wide. Nobody offers automated Terragrunt-to-plain-Terraform conversion with state migration. Pulumi's converter ignores Terragrunt entirely. The IaC management platforms punt to professional services. Open-source tools are fragmented and narrow. The specific combination of AST-based code transformation + state migration + Terragrunt understanding is unaddressed. This is a clear whitespace.
This is the idea's Achilles heel. Migration is inherently a one-time event — once you've migrated, you cancel. You could layer on ongoing value (drift detection between IaC flavors, continuous compliance, version upgrade automation), but the core value prop is transactional. Usage-based pricing (per module/resource migrated) or annual platform licensing for large estates with ongoing IaC health monitoring would be necessary to avoid pure one-shot revenue.
- +Clear, painful, expensive problem with proven willingness to pay (consultants charge $100K+ for this work)
- +Wide competition gap — no automated tool handles Terragrunt-to-Terraform with state migration
- +OpenTofu fork created a timely new migration wave beyond just Terragrunt dissatisfaction
- +Natural enterprise sales motion — platform teams have budget and the ROI math is straightforward
- +Could become an acquisition target for IaC platforms (env0, Spacelift, Scalr, even HashiCorp/IBM)
- !Technical complexity is severe — the long tail of Terragrunt edge cases could eat your roadmap alive and erode trust if migrations fail on real-world configs
- !One-shot revenue problem: customers migrate once and churn, making CAC recovery difficult without bolting on recurring value
- !LLM-based code generation (Copilot, Claude) may become 'good enough' at IaC conversion, commoditizing the AST-based approach before you reach scale
- !Small addressable market means you need high ACV to build a real business — this may cap out as a solid lifestyle business ($1-5M ARR) rather than a venture-scale outcome
- !State migration errors can destroy production infrastructure — liability and trust are existential concerns
Official Pulumi CLI tool that converts Terraform HCL to Pulumi code in TypeScript, Python, Go, or C#. Handles basic resource mappings and provider translations.
Reverse-engineers existing cloud infrastructure into Terraform code by reading cloud provider APIs. Generates HCL and state files from live resources.
Platform engineering tools that orchestrate Terraform/OpenTofu/Pulumi runs, manage state, enforce policy, and provide drift detection. Some offer migration assistance as professional services.
The company behind Terragrunt offers a Reference Architecture and module library. They also provide professional services for IaC setup and migration.
Collection of open-source tools for specific IaC conversions: CloudFormation-to-Terraform
Start with the narrowest, highest-demand conversion: Terragrunt-to-plain-Terraform (no Pulumi, no CDK, no state migration in v1). Build an AST parser that handles the top 80% of Terragrunt patterns (dependency blocks, generate blocks, inputs/locals, includes) and outputs clean, idiomatic Terraform with a migration plan document. Ship as a CLI tool. Charge nothing for open-source repos under 20 modules, then gate on estate size. Deliberately exclude state migration from MVP — output a step-by-step state migration guide instead of automating it, to avoid the liability of touching production state. Let users validate the generated code in a sandbox before cutting over.
Free CLI for small repos (<20 modules) to build trust and community -> Paid CLI/SaaS ($500-2,000/migration) for large estates with detailed migration plans -> Enterprise tier ($10K-50K) with state migration automation, dry-run sandboxes, and rollback support -> Expand conversion paths (CDK-to-TF, Pulumi-to-TF, TF-to-OpenTofu) -> Layer on recurring revenue via IaC health monitoring, version upgrade automation, and compliance scanning -> Potential acquisition by IaC platform (env0, Spacelift) or cloud provider
8-12 weeks to a working CLI that handles common Terragrunt patterns. First paying customer likely at 3-4 months if you engage DevOps communities (Reddit r/devops, r/terraform, HashiCorp forums) early with a free beta. Enterprise deals would take 6-9 months from first contact. Realistic path: $10K-30K revenue in first 6 months from early adopter teams willing to pay for a tool that saves them weeks of manual work.
- “I made a living off of migrating OFF of terragrunt”
- “I don't see the point of ever using Terragrunt - do you really need a tool to write config for your tool”