The Open Source
IaC Orchestrator
Platform Teams Trust

I use Terragrunt—and I never look back. Some say Terragrunt is overkill. Some say it's only for “advanced use cases.” I say: if you're serious about Infrastructure as Code, it's a must-have.

If you're managing multiple Terraform environments and things feel brittle or duplicated—Terragrunt is not just “nice to have”, it's a game-changer.

Using Terragrunt to organize my Terraform files using DRY standards. Highly recommend it if you're repeating your code in your project.

When it comes to managing and deploying multiple copies of the same infrastructure to the same or different AWS account, an additional tool is needed. And that tool has the name Terragrunt.

Terragrunt is a game-changer for handling state files and modules!

Terragrunt shines with its 'before' and 'after' hooks, allowing you to automate repetitive tasks such as logging, monitoring setup, or even policy enforcement checks before applying changes.

Terragrunt is really a cutting edge IaC technology.

Terragrunt is actually sweet, makes environment handling easy, DRY- Don't repeat yourself.

If you are using Terraform to setup your infrastructure and you're not also using Terragrunt you should take a look at it.

I've been using Terragrunt for a year now as the only SRE in early stages startup that required to build everything from Scratch and It truly gave me peace of mind

Personally, I can't imagine a terraform setup without terragrunt anymore. I love that I can have common inputs defined in one place, with ability to generate resource name prefixes and value overrides (e.g. for subscription IDs) based on a stack's file path. With that, very few inputs need to be passed explicitly, which makes it super-easy to scale and to make changes across stacks.

Terragrunt helps manage those pesky repetitive tasks you don't even realize are sucking up your time. Think of it as Terraform's cooler, more organized sibling. I spent an afternoon cleaning up a setup where each team had cooked up their own deployment scripts. A total mess! Terragrunt's module inheritance saved the day - one config to rule them all.

It's safe to say it's earned a permanent spot in my DevOps toolkit. While Terraform is already a powerful tool for defining infrastructure as code, Terragrunt builds on it - especially when you're managing multiple environments like dev, staging, and prod.

We've found that Terragrunt not only shortens our codebase by a few thousand lines, it also greatly simplifies our infrastructure code. We no longer need to repeat our provider, state, or dependency configurations, so the logic of our code is now focused exclusively on what it should be focusing on: the terraform resources our developers want.

The integration of Terragrunt into our Infrastructure as Code workflows brought about a remarkable reduction in code complexity. Previously, managing a large-scale infrastructure demanded around 20,000 lines of code, leading to challenges in code readability, maintainability, and increased likelihood of errors. Terragrunt's modular structure and the elimination of code repetition drastically streamlined our codebase, reducing it to a mere 2,000 lines. Moreover, the burden of handling variables was similarly alleviated, with the number of variable lines plummeting from 50,000 to a concise 3,000. This reduction not only enhances code maintainability but also minimizes the risk of errors, making the entire IAC process more efficient and developer-friendly. Terragrunt's ability to handle resource dependencies seamlessly meant that we no longer needed to painstakingly manage multiple backend.tf files. The hassle of coordinating and maintaining dependencies across different components of our infrastructure was significantly mitigated, leading to a more streamlined and error-resistant deployment process.

Terragrunt didn't just handle complexity; it actively simplified the process of writing and managing IaC, thanks to its emphasis on modularity. Terragrunt is not just a tool for complex projects, but a game-changer in simplifying and optimizing the way we approach Infrastructure as Code. Terragrunt has become an integral part of my toolkit in the realm of cloud architecture. Modularity in Terragrunt is not just a feature; it's a paradigm shift, enhancing the organization and reusability of code. This approach starkly contrasts with Terraform's methodology, where, although modules are used, the level of integration and reusability is not as inherently streamlined.

Gruntwork's Terragrunt makes managing our infrastructure across providers and environments consistent, safe, and easy to understand.

Terragrunt has resolved some of our crucial blockers: it enabled us to use dynamic backends and dynamic providers, allowed to execute code on errors, to setup migration and emergency cleanup scripts, and to keep the code clean and consistent. Our OpenTofu modules have never looked better. Some recent changes even allowed us to leave workspaces behind. Thanks to Terragrunt's smart structuring and features, our average time of deployment went down from 30 minutes to just 3. Let Terragrunt deal with all the init work. Multiple backends? Try generating them. Huge monoliths of code that take hours to deploy? Create a stack. Repetitive code? Reuse configurations via Terragrunt.

I just finished a full nested Terragrunt Stacks rewrite of our entire setup and it's so clean. This is going to do wonders for our users that aren't necessarily DevOps folks. Seriously great stuff.

Terragrunt enabled our segmentation of Terraform state so we could move fast and scale.

Terragrunt has allowed us to keep our code dry, speed up our deployment times, simplify our code. If you are not using Terragrunt to deploy your infrastructure you are doing it wrong.