Where do ARM Graviton cost savings actually come from?
Graviton is AWS's family of ARM-based (arm64) processors, offered as EC2 instance types and as Kubernetes nodes. Teams adopt them because they cost less per hour than comparable x86 instances. That price gap is not your savings figure, though. You pay per node, and the number of nodes you need depends on how much traffic each one handles at your latency target.
Effective savings combine price and per-workload throughput:
savings = 1 − (ARM price/hr × ARM nodes needed) / (x86 price/hr × x86 nodes needed)
Illustrative estimate (assumed numbers, not a benchmark or measured result): assumed x86 node price of $1.00/hr, assumed ARM node price of $0.80/hr, and an assumed 10 x86 nodes needed today. The two scenarios below are hypothetical inputs to show how the formula behaves.
- Illustrative scenario A, assuming ARM sustains the same throughput per node: you need 10 ARM nodes. Cost is $8.00/hr, an illustrative 20% saving.
- Illustrative scenario B, assuming ARM sustains 90% of the throughput per node: you need 12 nodes (11.1 rounded up). Cost is $9.60/hr, an illustrative 4% saving.
Neither figure is a measurement. Your own per-node throughput, measured as described in the benchmarking section below, determines which case you are in. Some services gain little or regress, particularly when p99 latency is the constraint rather than average throughput.
Compare the migration against cheaper compute-cost levers before committing:
| Lever | Engineering effort | Why it saves money | Main risk |
|---|---|---|---|
| Rightsizing | Low | Removes idle CPU and memory you already pay for | Under-provisioning at peak |
| Autoscaling tuning | Low–medium | Tracks demand instead of provisioning for peak | Scale-up lag on traffic bursts |
| Commitments / reserved capacity | Low (financial) | Discounts a steady baseline | Lock-in if usage falls |
| Spot | Medium | Deep discount on interruptible capacity | Interruptions need graceful handling |
| ARM migration | Medium–high | Lower price per unit of work | Build, dependency, and performance regressions |
These levers stack. Rightsize first so you are not migrating waste to ARM.
How do you model migration cost against real savings?
Treat the migration as an investment with a payback period. The model needs four inputs:
- Monthly compute spend in scope (S): only the services you will actually move.
- Achievable savings rate (r): price difference adjusted by measured throughput per instance. Use your own benchmark figure, not list-price deltas.
- One-time effort (E): engineering days times loaded daily cost.
- Ongoing overhead (O): extra CI minutes, multi-arch image storage, and maintenance per month.
Payback months = E ÷ (S × r − O)
If S × r is close to O, payback stretches toward never. If it is below O, the migration loses money.
Illustrative estimate (assumed numbers, not a benchmark). Assumptions: r = 20%, loaded engineering cost of $800/day.
| Scenario | S (monthly) | E (one-time) | O (monthly) | Net monthly savings | Payback |
|---|---|---|---|---|---|
| Large API fleet | $40,000 | 30 days = $24,000 | $1,000 | $7,000 | ~3.4 months |
| Small service | $3,000 | 10 days = $8,000 | $500 | $100 | ~80 months |
| Large fleet, 60% under x86 commitment for 8 months | $40,000 | $24,000 | $1,000 | $2,200, then $7,000 | ~9 months |
Existing commitments and reserved capacity are the factor teams most often overlook. You keep paying for x86 capacity you have already bought, so moving those workloads early produces no savings. Schedule migrations to match commitment expiry dates.
Development cost is not only the one-time E. Mixed-architecture fleets add ongoing friction:
- Architecture-specific bugs.
- Slower debugging when local machines differ from production.
- Reviewers who need to understand two build targets.
If this friction pulls even one engineer away from feature work each sprint, include that time in O. In the small-service row above, it is enough to make the result negative.
Which backend services migrate cheaply and which should you avoid moving?
Whether that time is worth spending depends mostly on your dependency graph, not your own code.
| Service profile | Migration effort | Why |
|---|---|---|
| JVM, Node.js, Python or Ruby with pure-language deps | Low | Runtime ships arm64 builds; your code is architecture-neutral |
| Go without cgo | Low | Cross-compiling is a target-architecture setting |
| Native modules (image codecs, DB drivers, crypto bindings) | Medium | Need arm64 prebuilt packages or a source build toolchain |
| Vendored binaries, x86 SIMD or inline assembly | High | Must be replaced, ported or rewritten |
| Closed-source agents | Blocked | You wait on the vendor |
A single missing arm64 artifact blocks the whole service. A container runs one architecture, so you cannot ship 95% native and 5% emulated. Emulation works for CI experiments but is too slow and fragile for production.
Even after it builds, watch for subtle behavioral changes:
- Floating point: compilers may fuse multiply-add operations, and math libraries can differ in the last bits. Tests that assert exact equality on computed floats will fail.
- Memory ordering: ARM's weaker memory model can expose data races that x86's stronger ordering happened to hide.
- Performance cliffs: hand-tuned AVX paths often fall back to generic scalar code on ARM, which can be much slower.
Dependency audit checklist
- Base images: arm64 variant published for every tag you pin
- OS packages: available in the arm64 repository
- Language native modules: arm64 wheels, gems or prebuilt binaries available
- Sidecars: every injected container is multi-arch
- Observability agents: tracing, logging and security agents support arm64
- Service-mesh components: proxies and init containers are multi-arch
#!/usr/bin/env bash
set -uo pipefail
fail=0
images=(
"registry.example.com/base/python:3.12-slim"
"registry.example.com/platform/log-shipper:2.4.1"
"registry.example.com/platform/tracing-agent:1.9.0"
"registry.example.com/mesh/proxy:1.22.3"
"registry.example.com/mesh/proxy-init:1.22.3"
)
for img in "${images[@]}"; do
# A multi-arch tag lists one manifest per platform; look for arm64.
if docker manifest inspect "$img" | grep -q '"architecture": *"arm64"'; then
echo "OK image $img"
else
echo "MISS image $img (no arm64 manifest)"; fail=1
fi
done
if ! pip download -q -r requirements.txt -d /tmp/arm64-wheels \
--only-binary=:all: --platform manylinux2014_aarch64 --python-version 3.12; then
echo "MISS wheels (at least one package has no aarch64 wheel)"; fail=1
fi
go list -deps -f '{{if .CgoFiles}}CGO {{.ImportPath}}{{end}}' ./... 2>/dev/null
grep -rlE 'immintrin\.h|xmmintrin\.h|__asm__|_mm256_' --include='*.[ch]' --include='*.cc' --include='*.cpp' . \
&& echo "REVIEW x86-specific code above"
exit $fail
A pre-migration audit script that checks every pinned image for an arm64 manifest, verifies that aarch64 Python wheels exist, lists Go packages that use cgo, and flags x86 intrinsics or inline assembly in the source tree.
How do you build multi-arch Docker images without slowing CI?
A multi-arch image is a manifest list, also called an OCI image index: one tag that points to separate per-platform manifests. When a node pulls api:1.4.2, the container runtime reads the index, picks the entry matching its own OS and architecture, and fetches only those layers. Deployments therefore keep a single image reference, and the same tag runs on amd64 and arm64 nodes without per-architecture manifests.
Buildx produces the index in one invocation: docker buildx build --platform linux/amd64,linux/arm64 -t registry.example.com/api:1.4.2 --push .. It builds each platform, then pushes the platform images and the index that ties them together. The open question is how the arm64 half gets built.
| Approach | CI build time | Operational cost | Best fit |
|---|---|---|---|
| QEMU emulation | Slow for compile-heavy steps, because every instruction is translated | None beyond enabling binfmt handlers | Thin images, interpreted languages |
| Native arm64 builders | Comparable to amd64 | Runner fleet to patch, scale and pay for | C/C++ extensions, Rust, large dependency compiles |
| Toolchain cross-compilation | Near amd64 speed | None | Go, and Rust with a configured target |
For Go, use FROM --platform=$BUILDPLATFORM in the build stage and set GOARCH=$TARGETARCH with CGO_ENABLED=0. The compiler then runs natively and emits an arm64 binary, so emulation only touches the final stage's trivial copy steps.
Pair this with a registry-backed layer cache (--cache-to type=registry / --cache-from). Dependency layers then rebuild only when lockfiles change, which keeps the second architecture from doubling every pipeline run.
FROM --platform=$BUILDPLATFORM golang:1.22 AS build
ARG TARGETOS
ARG TARGETARCH
WORKDIR /src
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod go mod download
COPY . .
RUN --mount=type=cache,target=/go/pkg/mod \
--mount=type=cache,target=/root/.cache/go-build \
CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
go build -trimpath -o /out/api ./cmd/api
FROM scratch
COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=build /out/api /api
USER 65534:65534
ENTRYPOINT ["/api"]
A Go Dockerfile that cross-compiles for each target architecture on the native build platform, shown with the buildx command that pushes one multi-arch tag and keeps a registry-backed layer cache.
How do you run arm64 workloads on a mixed-architecture Kubernetes cluster?
Kubernetes schedules by node labels, not by inspecting images. The kubelet sets kubernetes.io/arch on every node (amd64 or arm64), and that label is your main lever. Most teams run separate x86 and ARM node pools so each can scale and be drained on its own.
To place a service on ARM, add a required node affinity on kubernetes.io/arch: arm64. Affinity only attracts pods, so it does not stop other workloads from landing on ARM nodes. For that, taint the ARM pool (for example arch=arm64:NoSchedule) and add the matching toleration only to services whose images are verified multi-arch. Anything not yet migrated stays on x86 by default.
DaemonSets need attention. They target every eligible node, and custom taints block them unless they tolerate those taints. Logging, metrics, and security agents therefore need a toleration and an arm64 image. A pod that pulls a single-arch image on the wrong node fails in one of two ways:
- If the image is a manifest list without an arm64 entry, you get a pull error with no matching platform.
- If the image is a plain single-platform image, it pulls successfully and then crashes with
exec format error.
The second failure is the confusing one, because it looks like an application bug.
The operational cost is real. You maintain duplicate node pools and more scheduling rules, and every incident adds the question "which architecture?" Capacity also varies. ARM instance families are not offered in every region or availability zone, and spot capacity is often thinner than for x86. That limits autoscaler choices and spot diversification, so keep an x86 fallback path for latency-critical services.
apiVersion: apps/v1
kind: Deployment
metadata:
name: orders-api
spec:
replicas: 3
selector:
matchLabels:
app: orders-api
template:
metadata:
labels:
app: orders-api
spec:
affinity:
nodeAffinity:
# Hard requirement: only schedule on arm64 nodes (label set by the kubelet).
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: kubernetes.io/arch
operator: In
values: ["arm64"]
tolerations:
# Opt in to the tainted ARM pool; unmigrated workloads lack this and stay on x86.
- key: arch
operator: Equal
value: arm64
effect: NoSchedule
containers:
- name: api
# Must include an arm64 entry, or the pull fails / the binary hits exec format error.
image: registry.example.com/orders-api:1.4.2
ports:
- containerPort: 8080
A Deployment that requires arm64 nodes through kubernetes.io/arch node affinity and tolerates the ARM pool's NoSchedule taint, so only this verified multi-arch service lands there.
How should you benchmark ARM vs x86 for a backend API?
Synthetic CPU benchmarks measure a narrow slice of work: integer throughput, compression, or a single hot loop. A backend API spends its time on JSON serialization, TLS, allocator churn, garbage collection, lock contention, and waiting on the network. A chip that wins a microbenchmark can still lose once those costs dominate, and averages hide the tail latency your users actually feel.
Compare cost per request at a fixed latency SLO instead. Pick the target, for example p99 under 150 ms, and replay production-shaped traffic against a single node of each architecture, with the same instance size class, runtime flags, and container limits. Raise load in steps until p99 breaches the SLO or the error rate climbs. The last stable step is the node's maximum sustainable throughput. Then divide the hourly node price by requests per hour.
Illustrative estimate. Prices and throughput are assumed inputs, not measured results:
| Metric | x86 node | arm64 node |
|---|---|---|
| p99 SLO held | 150 ms | 150 ms |
| Max sustainable RPS (assumed) | 1,800 | 1,650 |
| Assumed hourly price | $0.200 | $0.160 |
| Cost per million requests (derived from assumed inputs) | $0.031 | $0.027 |
With these assumed inputs, the list price gap is 20%, but the illustrative effective saving is about 13% because the assumed ARM throughput at the same tail latency is lower. That gap is the reason to rerun this test for every service. A CPU-bound Go service and a JVM service tuned for x86 can land in very different places, so a fleet-wide percentage taken from one service will mislead your migration plan.
What does a safe phased rollout to Graviton look like?
Start with one stateless, high-replica API. A wrong guess costs little: many replicas spread the risk, there is no data to migrate, and a bad pod is replaced in seconds. Add an arm64 node pool with a taint so nothing lands there by accident. Then give the canary Deployment a toleration and a kubernetes.io/arch affinity. Keep the x86 pool sized to absorb the full load. Rollback then means scaling the arm64 Deployment to zero and letting x86 replicas take the traffic, not rebuilding anything.
| Phase | Scope | Go criteria | No-go triggers |
|---|---|---|---|
| Pilot | One service, small share of replicas | Error rate and p99 latency match the x86 baseline | Any arch-specific crash or library fault |
| Canary | Half the replicas, full traffic mix | Cost per request lower at equal SLO | Latency regression under peak load |
| Expand | Service by service | Same test passes for each service | Savings below the effort you spent |
| Default | New services build arm64-first | Shared templates in place | Exceptions tracked, not silent |
Time each move around your existing commitments. Compute Savings Plans apply across instance families, so shifting usage to Graviton does not strand them. Reserved Instances and EC2 Instance Savings Plans are tied to an instance family. Expand onto Graviton as those commitments expire, and don't buy new x86 family commitments mid-migration.
Most of the effort is a one-time cost. Do these once and every later service gets them for free:
- the multi-arch build pipeline
- the taint/toleration convention
- the benchmark harness
- the cost-per-request dashboard
After that, migrating a service mostly means running the test and flipping placement.
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 arm graviton cost savings, 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.