Easygo scales AWS 10x, cuts maintenance by 90 percent

Key results

• Scaled from 10 to over 100 AWS accounts while maintaining consistent governance
• Reduced pipeline maintenance by about 90 percent, from weekly effort to periodic updates
• Increased deployment accuracy from 70% to 95% with clear plan and apply workflows
• Replaced custom pipeline logic with a system that requires minimal ongoing maintenance
• Enabled 20 engineers to safely work in parallel without state conflicts or direct production access

“Terragrunt helped us scale from 3 engineers to 20, and everyone can work independently. They all work in parallel, and no one’s stepping on each other.”
‍
— Steven Tseng, Staff DevOps Engineer

‍

Easygo builds some of the fastest-growing consumer platforms in the world, including Kick, Stake, and Easygo Games, serving hundreds of millions of users globally. Behind the scenes, that growth depends on a cloud infrastructure that can scale rapidly, remain secure, and support constant product development without introducing operational risk.

Steven Tseng, Staff DevOps Engineer at Easygo, is responsible for making that possible. As the company expanded its AWS footprint and engineering team, Tseng focused on building an infrastructure foundation that could scale without slowing the business down or creating unnecessary complexity.

That challenge became more urgent as Easygo’s AWS environment grew from a handful of accounts to dozens, and eventually more than one hundred. Maintaining consistency, visibility, and control across that footprint required a new approach.

Scaling AWS infrastructure from 10 to 100+ accounts without scaling complexity

In 2023, Easygo relied on Terraform to manage infrastructure. Terraform worked well for provisioning resources within a single environment, but it did not address the challenge of managing shared configurations across many AWS accounts. As the business rapidly expanded, so did the number of AWS accounts to manage — Easygo quickly jumped from 10 accounts to 40 within a single year. 

At the time, much of Easygo’s AWS account setup was managed by hand. As new accounts were created, the team had to manually replicate IAM roles, policies, and governance controls across each environment. That approach worked when the footprint was small, but quickly became unmanageable as the number of accounts grew. The team faced a clear tradeoff: either duplicate configurations across environments or find a way to centralize them.

The team hit the limits of managing shared configurations with Terraform alone. Easygo’s DevOps team evaluated alternatives including Pulumi and AWS CDK, but chose Terragrunt because Terragrunt offered scale without forcing the team to relearn its infrastructure workflow. Terragrunt was close enough to Terraform to adopt quickly, but structured enough to keep configurations DRY (Don’t Repeat Yourself) across a rapidly growing number of AWS accounts.

“There was no way we could hand-roll configuration across dozens of AWS accounts. We found Terragrunt, went all in and could immediately scale IAM, SCPs, policies and resources. The way you structure your code with Terragrunt, allowed us to scale exponentially without increasing complexity”
‍
— Steven Tseng, Staff DevOps Engineer

Terragrunt allowed Easygo to define shared infrastructure logic once and reuse across accounts with a structured hierarchy of configurations. Account-level settings, such as regions and policies, could be defined centrally and inherited downstream. Modules could be updated in one place and applied consistently across environments. This eliminated the need to duplicate Terraform code and reduced the risk of configuration drift.

The Easygo team was able to move significantly faster. Instead of updating the same resource across multiple environments, engineers could make a single change and apply it everywhere. New Easygo DevOps engineers were onboarded in just a week — without previous Terraform experience — by following a clear structure rather than reverse-engineering existing configurations.

Easygo scaled beyond 100 AWS accounts and the Terragrunt-backed structure held without issue. They have saved “hundreds of hours” managing their global CloudFlare DNS configurations with Terragrunt in a single file. And they’ve cut at least five minutes of processing time out of a 30-minute deployment workflow.

Replacing custom pipelines with a high-performance deploy workflow

Terragrunt solved the problem of structuring infrastructure, leading Easygo to build a reliable, high-performance way to run changes across accounts.

Initially, the team used AWS CodePipeline and later GitHub Actions with CodeBuild. Both approaches created constant friction and headaches, requiring at least 2 hours every week spent on maintenance. When a deployment failed, logs lived inside individual AWS accounts, forcing engineers to jump between accounts and dig through large volumes of output just to find the issue.

The team tried to improve visibility by moving logs into GitHub Actions, but ran into a different problem. Terraform plan output was buried inside noisy logs, making it difficult to review changes before applying them. They attempted to parse the output with custom regex and build their own approval workflows, but these efforts were unreliable and added more maintenance overhead. 

“We were trying to extract the plan from the logs and make sense of it,” Tseng said. “It was always a bit messy.” More importantly, the workflow itself lacked clarity. Engineers often had to rely on apply-first workflows or manually inspect changes, which reduced confidence in deployments.

Easygo adopted Terragrunt Pipelines shortly after its release. With Terragrunt Pipelines, Easygo’s DevOps team introduced a structured workflow separating `plan` and `apply` steps and surfaced results directly in pull requests. This capability allowed engineers to clearly see what Terraform would do before approving changes, without digging through logs or switching between systems.

The team replaced its custom pipeline logic with a Pipelines-based CI/CD system that worked consistently out of the box, giving engineers far more confidence in the deployment process. That shift gave Easygo’s DevOps team a level of confidence they didn’t have before. Instead of hoping deployments would work or second-guessing the pipeline, they could rely on it to behave predictably and focus on the Terragrunt code being shipped. Tseng adds: “With Terragrunt Pipelines, I know our pipelines will work. If something fails, it’s because of the code, not the system.”

“We’re making far fewer mistakes because of Terragrunt. Before, we were around a 70% accuracy mark. With Terragrunt Pipelines, we’re at 95% accuracy. No more late night work, no more unexpected failures, and we are way, way more secure.”
‍
— Steven Tseng, Staff DevOps Engineer

Improving security and productivity at scale

As Easygo’s DevOps team grew from 3 engineers to 20, the ability to work concurrently became critical.

Before adopting Terragrunt and Pipelines, concurrent work was a frustrating experience. Terraform state locking, combined with less predictable execution patterns, meant engineers had to coordinate changes carefully to avoid conflicts. In practice, this slowed down development and required engineers to check whether others were working in the same environment before making changes.

With Terragrunt and Pipelines, changes are scoped to specific parts of the infrastructure, allowing multiple engineers to work in parallel without interfering with each other. “Terragrunt and Pipelines lets us have 20 people running multiple pull requests at the same time. Everyone can work independently all in the same environment without worrying about state or asking who’s working in a specific folder,” Tseng said.

Shifting to Terragrunt Pipelines addressed a separate issue: access control. Previously, engineers needed direct access to AWS accounts and the AWS Console to view logs or make changes, especially when debugging pipeline failures. This created a broader permission model than the team wanted, particularly for production environments.

With Terragrunt Pipelines, logs and plan outputs are surfaced directly in pull requests, removing the need for engineers to access individual AWS accounts in most cases. For example, when an engineer needed to remove a production resource, they no longer required direct deletion permissions. Instead, they removed the resource from the codebase and let the pipeline execute the change through the approved workflow.

Managing infrastructure-as-code through Terragrunt Pipelines reduced the need for broad production access while maintaining a clear audit trail of changes.

“Using Terragrunt and Pipelines, we’ve eliminated the need for direct production access by handling all changes through infrastructure as code”
‍
— Steven Tseng, Staff DevOps Engineer

Building a foundation for continued growth

With a scalable infrastructure model in place, Easygo is now focused on strengthening its internal standards, including module versioning and testing practices.

The combination of Terragrunt and Pipelines shifted how the team approaches infrastructure. Instead of maintaining pipelines or troubleshooting deployments, engineers can focus on building and improving systems. The return is not just time savings, but the confidence and security which come from knowing deployments will behave predictably.

Tseng is still mindful of the relief he’s found in Terragrunt and Pipelines:

“We adopted Terragrunt while the environment was still small and avoided the need to refactor infrastructure at scale later. When you quantify the cost of running code and pipelines in AWS, the commercial cost is not that much. The biggest ROI we’ve seen is the security and confidence we’ve had as we scaled to 20 devops engineers.”

For Easygo, the biggest win has been the ability to scale without adding friction. Infrastructure can grow alongside the business, engineers can work independently, and deployments happen with a high degree of confidence. Tseng adds: “Terragrunt Pipelines allows us to build with confidence, ship accurately and deploy securely.”