Moving a live game backend to AWS Graviton: what it took, and how it saved $500k a year

For a game client, our team runs a set of critical services that never switch off. They keep millions of players connected at the same time, around the clock. In 2025 we moved them from x86 to AWS Graviton, Amazon's ARM based processors.
The monthly bill for those services went from about $120k to about $75k. That is roughly $500k a year. A year later the savings are still there.
Below we describe what the move involved, the parts we did not plan for, and what we would tell anyone looking at the same migration.
The fleet we started with
At peak, the services ran on more than 250 nodes. Instance types ranged from 2xlarge to 12xlarge, across the c5 and m5 families.
Graviton was the obvious place to look, for two reasons.
- Lower price per hour. A Graviton instance costs about 20% less per hour than an x86 instance of the same size. An m6g.8xlarge has the same vCPUs and memory as an m5.8xlarge, for less.
- More work per vCPU. On x86, a vCPU is a hyperthread, half of a physical core. On Graviton, every vCPU is a full core. For a busy, CPU bound workload, the same traffic can fit on fewer or smaller nodes.
Cheaper hours, and fewer of them. The question was what it would take to get there.
What the services had in common
Before writing any code, we looked at what the services shared. Two things stood out.
- All of them ran on the same language runtime, several major versions behind.
- All of them used the same build pipeline.
That was good news and bad news. Good, because one plan would cover the whole fleet. Bad, because that runtime version was the wrong starting point.
The runtime could run on ARM, but the performance that makes the move pay off comes from its JIT compiler, and our version had no JIT for ARM. That only arrived four major versions later. Moving to Graviton on the old version would have meant cheaper hours, slower code, and most of the savings gone.
So the migration was really three projects:
- A separate golden image for ARM, prepared by the client's security team.
- A runtime upgrade of four major versions, across every service. The upgrade had to happen sooner or later anyway, for security and to reduce tech debt, so the migration killed two birds with one stone.
- A CI/CD pipeline that could build and ship ARM releases.
Putting a number on it first
Nobody asked us to look at Graviton. The team spotted the opportunity while working on the services day to day.
So before committing time, we estimated the savings and took it to the client: around $35k a month. That number turned a technical idea into a business decision the client could make in one meeting. They said yes, and we got to work.
We knew from the very beginning what the savings would be. Concrete dollars made the decision simple for the client. Without that number, they wouldn't have gone for it.
The hurdles we did not plan for
Three things added work on top of the plan.
A newer operating system. The new golden image only supported a newer version of Amazon Linux. So we moved to that too, and checked every service against it.
Two architectures from one pipeline. Part of the platform runs outside AWS, where x86 stays. That part still needed x86 builds. The pipeline had to produce the same release for both architectures, from the same source, every time.
Load testing. A runtime jump of four major versions and a new CPU architecture is not something you push to millions of players on trust. We ran extensive load tests before anything reached production: the same production like load against the old and the new architecture, so we could compare like for like.
Rolling it out
We moved staging first, then production, gradually. Every step could be rolled back.
Once production ran on Graviton, we right sized. The new instances did more work per node, so we sized the fleet to the new performance, not the old one. That step is easy to skip, and a large part of the saving came from it.
The result

Before the migration, the services cost about $120k a month on average. After the rollout and right sizing, about $75k. That is around $45k a month, more than a third of the bill, and above the $35k we estimated at the start.
The lower bill has held for a full year since the rollout.
What we would tell anyone planning the same move
- Start with what your services share. A common runtime and a common pipeline turned one migration into a template for the whole fleet.
- Check the runtime before the hardware. Whether ARM pays off depends on how well your language runtime supports it, and from which version.
- Double check external dependencies. If other teams deliver part of the migration, such as base images, plan their time in from the start.
- Right size after you migrate. Cheaper hours are only part of the saving. The rest comes from needing fewer, smaller nodes.
- Estimate before, measure in the bill after. A number agreed up front is what gets a migration like this approved.
Why this kind of saving waits
Graviton has been available for years, and the price difference is public. Yet fleets like this one still run on x86, because the migration belongs to nobody. It is not a feature, no player will notice it, and it touches security, the build pipeline and the runtime at once.
It happens when engineers who know the system see the opportunity, put a number on it, and are trusted to deliver it in small, safe steps. That is how this saving happened, and how we look at infrastructure cost on every game we work on.
At Appliscale we build and run backend services and infrastructure for game studios at scale. If your fleet still runs on x86 and you want to know what moving would save, we are happy to talk.