Real-World IaC Migration: Lessons from Moving a Mid-Sized Estate from Terraform to Pulumi

A recent article from 72Technologies details a significant Infrastructure as Code (IaC) migration, where a team moved a mid-sized AWS and Vercel infrastructure from Terraform to Pulumi. The migration, which involved approximately 40,000 lines of Terraform code across 14 stacks, was driven by a desire to leverage Pulumi's support for general-purpose programming languages (TypeScript in this case) to overcome the perceived limitations of HashiCorp Configuration Language (HCL). The team initially targeted greenfield projects, isolated stacks, and particularly painful Terraform modules for the transition. However, the process was not without its complexities, leading to a partial rollback for some components. This real-world account is crucial for practitioners grappling with IaC tool selection and migration strategies. It moves beyond theoretical comparisons to expose the tangible benefits and drawbacks encountered during a live transition. The experience underscores that while the promise of using familiar programming languages for infrastructure can significantly improve developer experience, reduce boilerplate, and enable stronger abstractions, it also introduces new operational considerations. Practitioners need to understand that the 'language argument' is often secondary to issues like provider maturity, state management, and the intricacies of running multiple IaC tools concurrently. The article provides a candid look at how such a migration impacts team dynamics, onboarding, and incident management, making it highly relevant for platform and DevOps engineers. The broader context for this migration reflects a long-standing trend in cloud engineering towards increasing developer velocity and reducing cognitive load. The initial rise of IaC tools like Terraform addressed the need for reproducible, version-controlled infrastructure. However, as cloud environments grew in complexity, and as application development increasingly adopted modern programming paradigms, the limitations of domain-specific languages (DSLs) like HCL became apparent for some teams. The emergence of tools like Pulumi, which allow infrastructure to be defined using languages like Python, TypeScript, or Go, represents an evolution in IaC, aiming to bridge the gap between application and infrastructure code. This shift is also influenced by the growing adoption of platform engineering principles, where internal developer platforms seek to abstract infrastructure complexity for application developers. In practice, this migration story offers several concrete implications. First, organizations considering a similar move should avoid 'big-bang' migrations, instead opting for a phased approach focusing on greenfield projects or isolated, problematic areas. Second, strict resource boundaries are paramount when running Terraform and Pulumi in parallel; shared resources between the two tools can lead to significant friction, such as provider version drift and unintended configuration corrections. Third, while Pulumi can reduce lines of code and improve abstractions, teams must be prepared to address new challenges, particularly around secret management and access models, as Pulumi's default behaviors (e.g., encrypted state) require a more robust access strategy. Finally, the article implicitly suggests that while the developer experience can be enhanced by using familiar languages, the maturity of providers (especially for niche services) and the established ecosystem of Terraform remain strong considerations. Practitioners should carefully evaluate their team's existing skill sets, the complexity of their infrastructure logic, and the long-term support for specific cloud services before committing to a wholesale change.