What does an AWS Graviton migration actually cost?

An AWS Graviton migration moves backend workloads from x86 instances to ARM (arm64) instances. Teams usually do it for price performance: equivalent Graviton instances often cost less per hour, and many workloads do the same work on them. That lower hourly rate is the recurring saving. Everything else is cost.

One-time engineering costs come before any savings: auditing dependencies for arm64 support, changing CI to produce arm64 artifacts, rebuilding images, load testing on the new instances, running a staged rollout and writing a rollback plan.

Transition costs recur while both architectures run side by side. You scan and store two sets of images, your test matrix grows, and you keep spare x86 capacity available for rollback.

Commitment timing can delay savings. Some commitment types, such as EC2 Instance Savings Plans and Standard Reserved Instances, are tied to a specific instance family. Others, such as Compute Savings Plans, apply across families. If your x86 usage is covered by a family-bound commitment, moving early can leave you paying for capacity you no longer use. Check how flexible your commitment type is before you schedule the move.

Illustrative estimate (assumed numbers, not a benchmark):

Payback months = one-time cost ÷ (monthly instance savings − monthly transition cost)

For a service with $6,000 in one-time cost, $1,500 in monthly savings and $300 in monthly transition cost, payback is 6,000 ÷ 1,200 = 5 months.

This article's position is to estimate these costs per workload and migrate in order of payback, not as a fleet-wide switch.

Who should use Graviton, and who should run this payback analysis?

Graviton fits teams that run sustained backend compute on AWS and control how their software is built: web and API services, queue consumers, batch workers, and managed databases, caches and search clusters. The more of your stack is interpreted, JIT-compiled or built from source in your own CI, the better the fit.

The per-workload payback analysis in this article is written for three groups:

  • Platform and infrastructure teams that own CI pipelines, base images and Kubernetes node groups. They carry most of the one-time cost, because multi-arch builds, admission gates and ARM node pools are shared work.
  • Service owners who need to decide whether their own service is worth moving and when. They supply the load tests and the throughput numbers that decide payback.
  • Engineering managers and FinOps owners who have to weigh engineering weeks against monthly savings and decide on commitment purchases.

Teams that run only a few small instances, or that depend mostly on closed-source x86 software, will usually find the analysis ends with "not yet."

When should you migrate a workload to Graviton?

Migrate a workload when all of these hold:

  • Payback is shorter than the workload's expected remaining life in its current form. If a service is scheduled for a rewrite or retirement within a year, a 15-month payback never arrives.
  • The dependency audit comes back as "no change" or "rebuild" only. Any "blocked" finding moves the workload to the back of the queue.
  • Spend is large enough that the savings matter. Payback depends on monthly savings, so high-spend services and large fleets go first.
  • Commitment timing works. The best window is when family-bound Reserved Instances or EC2 Instance Savings Plans on the x86 family are expiring, or when your coverage is through Compute Savings Plans that move with you.
  • You are already touching the infrastructure. A base-image upgrade, a node-group replacement, or a move to a new instance generation already pays for some of the testing and rollout work, which lowers the one-time cost.

Managed services that switch with a configuration change usually meet these conditions first, because their one-time cost is close to zero.

How do you measure price performance for ARM instances?

Hourly price and vCPU count only tell you what you pay for capacity, not how much work that capacity does. A Graviton vCPU is a physical core, while a vCPU on most x86 families is a hyperthread. So "same vCPU count" does not mean the same capacity, and the real gap depends on whether your workload is limited by compute, memory bandwidth or I/O. Measure price performance as cost per unit of work in your own load tests: requests served at a target p99 latency, batch jobs per hour, or messages processed per dollar.

Illustrative estimate. Assume an x86 fleet costing $10,000/month, equivalent Graviton instances priced 20% lower, and $30,000 of one-time migration effort. Fleet size is scaled to hold the same throughput at the same p99 target.

Assumed outcome Instances needed Monthly cost Monthly savings Payback
+10% throughput 0.91× $7,273 $2,727 ~11 months
Parity 1.00× $8,000 $2,000 15 months
−25% throughput 1.33× $10,667 −$667 Never

The price discount only sets a ceiling on savings. Throughput decides how much of it you keep. A 25% regression wipes out the 20% discount entirely.

Payback is one-time effort divided by monthly savings. Run the parity case on a $1,000/month service and it saves $200/month. Payback then takes 150 months, which is longer than the service will likely run unchanged.

Which workloads should move to Graviton first, and which should stay on x86?

Sort candidates by how much of the stack you control at the instruction-set level. Interpreted and JIT-compiled runtimes are the easiest moves because the runtime vendor has already done the porting. The same holds for Go services built from source, since cross-compiling is a flag change. Difficulty rises with every component you ship as a prebuilt x86 binary.

Workload type Migration effort Main risk
JVM, Node.js, Python, Ruby (pure) Low Native gems or wheels pulled in transitively
Go built from source Low cgo dependencies
Native extensions, vendored binaries Medium–high Missing or untested arm64 builds
Closed-source agents, hand-tuned x86 SIMD High No port, or a slower generic fallback

Managed services are often the cheapest first step. For managed databases, caches and search clusters, switching to a Graviton instance class is a configuration change. The provider owns the binaries, the build and the testing, so your one-time effort is close to zero and payback starts almost immediately. Doing this first can capture much of the savings before you touch any self-managed fleet.

Stay on x86 when:

  • The code is heavily x86-optimized. Crypto, compression and vectorized library paths can drop to slower generic code on ARM.
  • A licensed or third-party binary has no arm64 build.
  • The fleet runs mostly on Spot and ARM capacity in your region is thin. Interruptions and fallback cost can erase the discount.
  • The fleet is small. Engineering time costs more than the savings will ever return.

When should you avoid a Graviton migration?

The list above covers workload traits. Some situations argue against migrating regardless of the workload:

  • Your load tests show a throughput regression larger than the price discount. As the table in the price-performance section shows, that makes savings negative. Do not migrate and hope tuning will close the gap later. Tune first, then re-measure.
  • You are locked into family-bound x86 commitments with a long remaining term. Moving now means paying for both the unused commitment and the new instances.
  • The team cannot staff a second architecture. Mixed fleets need arm64 CI runners, two image variants, and on-call engineers who can debug ARM-specific failures such as memory-ordering races. If nobody can own that, the transition cost keeps running without a clear end.
  • The service is close to retirement, a rewrite or a platform move. Spend the effort on the replacement instead.
  • Correctness depends on bit-identical numeric output across environments and you cannot validate it. Floating-point differences between architectures can break reproducibility guarantees, for example in financial reconciliation or regulated reporting.
  • A critical vendor has no arm64 roadmap. If replacing that vendor is not on the table, the workload stays on x86 until the vendor ships a port.

Avoiding the migration for a given workload is a normal outcome of the payback analysis, not a failure of it.

How do you audit dependencies before an ARM migration?

An audit before the estimate turns unknown porting work into a list of line items. Run it per service and record each finding as no change, rebuild, replace, or blocked.

Walk the dependency tree

  • Native code in language packages. Look for Python packages that ship compiled wheels, Ruby gems with C extensions, Node modules that use node-gyp, and Go or Rust crates that use cgo or FFI. If a package has no arm64 build, it compiles from source. That slows builds and can fail when system headers are missing.
  • Base images. For every FROM line and every sidecar, run docker buildx imagetools inspect <image> and confirm that linux/arm64 appears in the manifest list. A single-platform manifest means the image only runs on the architecture it was built for.
  • Hardcoded downloads. Search Dockerfiles, entrypoint scripts, and init containers for amd64 and x86_64 in URLs, such as a curl that fetches a CLI tarball. Replace the literal with BuildKit's TARGETARCH build argument so each platform build pulls the matching binary. Some projects name their artifacts aarch64 instead of arm64, so you may need a small mapping.
  • Agents. Observability, APM, and security agents often run as DaemonSets or sidecars. They are easy to miss because no application team owns them.

Flag third-party blockers early

When a vendor ships no arm64 build of a closed-source agent or library, you cannot fix it by rebuilding. You either wait for the vendor or move to a different one, which brings procurement, re-instrumentation, and revalidation. This is the cost you can predict least. Put it at the top of the estimate with its own range instead of folding it into general porting effort.

FROM debian:bookworm-slim

ARG TARGETARCH
ARG TOOL_VERSION=1.2.3
ARG TOOL_BASE_URL

RUN apt-get update \
 && apt-get install -y --no-install-recommends curl ca-certificates \
 && rm -rf /var/lib/apt/lists/*

RUN set -eux; \
    case "${TARGETARCH}" in \
      amd64) ARCH=x86_64 ;; \
      arm64) ARCH=aarch64 ;; \
      *) echo "unsupported arch: ${TARGETARCH}" >&2; exit 1 ;; \
    esac; \
    curl -fsSL "${TOOL_BASE_URL}/v${TOOL_VERSION}/mytool-linux-${ARCH}.tar.gz" \
      | tar -xz -C /usr/local/bin mytool; \
    # Smoke test: a wrong-arch binary fails here instead of at runtime.
    mytool --version

A Dockerfile that checks the base image for linux/arm64 with imagetools inspect. It replaces a hardcoded amd64 download with BuildKit's TARGETARCH argument and maps that value to the vendor's x86_64/aarch64 artifact names.

How do multi-arch builds for arm64 Docker images work?

Build tooling is cheaper to estimate. docker buildx build --platform linux/amd64,linux/arm64 -t registry.example/app:1.4 --push . produces one image per platform and pushes a manifest list (an OCI image index) under a single tag. When a node pulls app:1.4, the container runtime reads the index, picks the entry that matches its own OS and architecture, and fetches only those layers. Deployment manifests keep one image reference, regardless of which architecture each node runs.

Flow: buildx (amd64 + arm64 builds) → registry stores the manifest list → Graviton node pulls the arm64 digest, and x86 node pulls the amd64 digest

How you produce the arm64 half is where the cost goes:

Strategy Build-time cost Infrastructure cost Best fit
QEMU emulation High: every instruction is emulated, so compile-heavy steps can run many times slower None beyond existing runners Small images, infrequent builds
Native ARM runners Native speed You provision, patch and scale a second runner pool Large C/C++ or native-extension builds
Cross-compilation Native speed on the build host None Go, Rust and other toolchains with mature cross-targets

Cross-compilation avoids emulation because the compiler runs natively on the build host and only emits arm64 code. In a Dockerfile, pin the builder stage with FROM --platform=$BUILDPLATFORM, declare ARG TARGETOS TARGETARCH, and run GOOS=$TARGETOS GOARCH=$TARGETARCH go build. Then copy the binary into a final stage that buildx resolves for each target platform. If you use cgo, you need a cross C toolchain, which takes away most of this advantage.

FROM --platform=$BUILDPLATFORM golang:1.22 AS build

ARG TARGETOS
ARG TARGETARCH

WORKDIR /src

COPY go.mod go.sum ./
RUN go mod download

COPY . .

RUN CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
    go build -trimpath -ldflags="-s -w" -o /out/app ./cmd/app

FROM scratch
COPY --from=build /out/app /app
USER 65532:65532
ENTRYPOINT ["/app"]

A Dockerfile that pins the Go builder stage to $BUILDPLATFORM and cross-compiles with TARGETOS/TARGETARCH, so a single buildx invocation produces amd64 and arm64 images under one manifest-list tag without emulating the compile step.

What changes in CI/CD and Kubernetes scheduling for mixed-architecture clusters?

Before any of that reaches a cluster, the pipeline needs to produce one tag per release that points to a multi-arch manifest list (an OCI image index), not separate -amd64 and -arm64 tags. Per-architecture tags drift: someone retags one and forgets the other, and a Deployment ends up pinned to the wrong variant. Push the index with docker buildx build --platform linux/amd64,linux/arm64 --push, and deploy by that tag or its digest.

Run the test suite on native arm64 runners as well as amd64. QEMU emulation can build images, but it is slow and can hide timing and concurrency bugs. Add a gate before deploy that runs docker buildx imagetools inspect against every image a workload references and fails if linux/arm64 is missing. Without this gate, an amd64-only image is only caught when the container starts on an ARM node and crashes with exec format error.

Scheduling

Kubernetes sets the kubernetes.io/arch label on every node. Use a nodeSelector or node affinity on that label to steer migrated workloads. During the transition, taint ARM node groups (for example arch=arm64:NoSchedule) so that only workloads with a matching toleration land there. Untested services cannot drift onto ARM by accident.

The architecture requirement covers every container in the pod: init containers, service-mesh sidecars and log shippers. DaemonSets need the same treatment. A logging or monitoring agent that is amd64-only will crash on every ARM node. Because of the taint, the agent also needs an explicit toleration to be scheduled there at all.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: orders-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: orders-api
  template:
    metadata:
      labels:
        app: orders-api
    spec:
      # Steer this migrated workload onto ARM nodes via the built-in node label.
      nodeSelector:
        kubernetes.io/arch: arm64
      # Matches the transition taint on the ARM node group (arch=arm64:NoSchedule).
      # Workloads without this toleration stay off ARM nodes.
      tolerations:
        - key: arch
          operator: Equal
          value: arm64
          effect: NoSchedule
      # Every image below must ship a linux/arm64 variant in its manifest list,
      # including init containers and sidecars, or the pod fails with exec format error.
      initContainers:
        - name: migrate-schema
          image: registry.example.com/orders-api:2.4.1
          command: ["/app/migrate"]
      containers:
        - name: app
          # One multi-arch tag per release; never a per-arch tag like :2.4.1-arm64.
          image: registry.example.com/orders-api:2.4.1
          ports:
            - containerPort: 8080
        - name: log-shipper
          image: registry.example.com/log-shipper:1.9.0

A Deployment pinned to arm64 nodes with nodeSelector on kubernetes.io/arch and a toleration for the transition taint, where every container, including init and sidecar containers, uses a multi-arch image tag.

How do you validate performance and roll out Graviton safely?

Validate each workload on its own, using load tests that replay production traffic shapes rather than synthetic microbenchmarks. Request mix, payload sizes and concurrency drive cache and memory behavior, and those are where the two architectures diverge.

Metric Compare Why it matters
Throughput per instance Requests/sec at target CPU utilization Sets how many ARM nodes replace each x86 node
Tail latency p99 and p99.9 under sustained load Averages hide GC pauses and lock contention
Memory behavior RSS, GC frequency, allocation rate Heap sizing tuned for x86 may not transfer
Runtime tuning JIT flags, GC settings, thread counts Defaults assume a core count and topology that may not match

Passing tests on x86 does not prove correctness on ARM. x86 enforces a stronger memory ordering than arm64, so a data race that never shows up on x86 can corrupt state on ARM. Floating-point results can also differ in the last bits, for example when the compiler fuses multiply-add operations or a math library uses a different implementation. Run race detectors and concurrency stress tests on ARM hardware, and compare numeric outputs against x86 for any code that depends on exact results.

Roll out in stages. Start with a canary ARM node group that takes a small share of traffic, and keep enough x86 capacity available to absorb all of it. Put a cost-per-request metric on the same dashboard as error rates. Agree on rollback triggers before the rollout starts, such as a specific p99 regression or a rise in error rate, so nobody has to debate them during an incident. Promote a workload only when its measured cost per unit of work confirms the payback estimate, then move to the next workload in the payback order.

What are the alternatives to a Graviton migration?

A Graviton move is one way to lower compute cost per unit of work. Before committing engineering time, compare it with options that need no architecture change. Run each option through the same payback formula.

Alternative What it changes One-time effort Trade-off
Rightsizing on x86 Smaller instance sizes or fewer nodes, based on measured utilization Low Savings are limited to how over-provisioned you are today
Newer x86 instance generation Same architecture, newer family Low: no rebuilds, mostly load testing Discount and performance gain vary by family; no dependency audit needed
Compute Savings Plans or Reserved Instances Pricing model, not hardware Very low Requires a usage commitment; family-bound types limit later moves
Spot capacity Pricing model for interruption-tolerant work Medium: interruption handling Only fits stateless or checkpointed workloads
Autoscaling and scheduling Capacity tracks demand; non-production environments shut down off-hours Low to medium Saves on idle time, not on cost per unit of work
Application-level optimization Less CPU per request through profiling and fixing hot paths Varies widely Benefits carry over to any architecture, including a later Graviton move

These options are not exclusive. Rightsizing before a migration gives you a smaller, more accurate baseline, so the Graviton savings you estimate are real rather than inflated by idle capacity. Compute Savings Plans apply across instance families, so they can cover x86 today and Graviton after the move. Profiling work also pays off on both architectures.

A practical order for many teams: rightsize, switch managed services to Graviton instance classes, buy flexible commitments for the remaining baseline, then migrate self-managed workloads in payback order.

How can a payback-ordered migration save engineering time?

Graviton itself saves money, not engineering hours. The approach in this article saves engineering time by stopping teams from spending it on migrations that will not pay back, and by reusing shared work across services.

  • Skipping low-payback services. The payback calculation tells you up front which services are not worth moving. A service with a 150-month payback is never started, instead of being abandoned halfway through.
  • Starting with configuration-only moves. Managed databases, caches and search clusters change instance class without any build or porting work, so the first savings arrive with almost no engineering effort.
  • Building the platform work once. Multi-arch CI, the imagetools inspect gate, ARM node groups, taints and tolerations, and arm64 builds of shared base images and agents are built by the platform team once. Each later service migration reuses them and only adds its own dependency audit and load test.
  • Catching failures in CI instead of production. The architecture gate and native arm64 test runs surface exec format error crashes, missing wheels and memory-ordering races before deploy. Debugging them after an incident costs far more time.
  • Deciding rollback criteria in advance. Pre-agreed rollback triggers keep incidents short and prevent repeated debates over whether a regression is acceptable.
  • Surfacing blockers early. Recording "blocked" findings at the top of the estimate prevents teams from finishing most of a migration before discovering a vendor agent with no arm64 build.

Illustrative estimate (assumed numbers, not a measured result): assume the shared platform work takes 4 engineer-weeks, and each service then takes 1 engineer-week on its own, compared with an assumed 2.5 engineer-weeks per service if every team built its own multi-arch pipeline and node configuration. Across 10 services, the shared approach takes 4 + 10 × 1 = 14 engineer-weeks, against 10 × 2.5 = 25 engineer-weeks done independently. If the payback ranking also drops 3 of those services as not worth moving, the shared approach falls to 4 + 7 × 1 = 11 engineer-weeks. Replace these assumed inputs with your own estimates. The structure of the calculation matters more than these particular numbers.

How OneEnv can help

Disclosure: OneEnv is the product behind this blog.

OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.

Applied to aws graviton migration, this is where it helps:

Saves time

  • Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
  • One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
  • Reviewers see the exact diff and the list of affected services up front, so approval is a decision rather than an investigation.

Saves cost

  • Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
  • Less duplicated configuration to maintain: one shared definition inherited by many services.
  • Per-service approve/reject means a bad shared value can be refused where it would break something, before it is live.
  • OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.

These are qualitative benefits, not measured results — how much you save depends on how many services share the value.

Want to try it? Start at oneenv.io.