What happens when all three major clouds build their own Arm chips and quietly stop competing on the same terms? That is the question facing every team that plans infrastructure past 2026. AWS, Microsoft, and Google each now ship custom silicon, and the next generation of those chips will shape cost, portability, and lock-in for years.
Here is the honest starting point: as of published information, there is no confirmed public specification for a “Graviton5,” a “Cobalt 200,” or a named Axion successor. AWS made Graviton4 generally available in July 2024, built on Arm Neoverse V2 cores. Microsoft announced Azure Cobalt 100 in November 2023 and shipped it through 2024 on Neoverse N2-class cores. Google announced Axion in April 2024, also Neoverse V2 based, with general availability rolling out from late 2024 into 2025. Anything labeled “2027” is a projection built on those foundations, not a datasheet. Treat this article as a decision framework, and verify each claim against primary vendor announcements before you commit a migration budget. (Aws vs azure architecture decisions that matter 2027)
Why these three chips exist at all
The strategic logic is identical across all three clouds, even though the products differ. Each company licenses core designs from Arm’s Neoverse platform, adds its own memory controllers, interconnects, and accelerators, and then sells the result as an instance type. Nobody is designing an instruction set from scratch. That single fact explains most of what follows.
The practical consequence is that the three chips are cousins, not strangers. They share the Armv9 baseline and the Neoverse family tree. A workload that runs well on one will usually run on the others after a recompile, provided the software stack is clean. The differences that matter are in core selection, memory bandwidth per vCPU, instance sizing, and how deeply each cloud integrates the chip with its own networking and storage fabric.
The core-type decision: V-series versus N-series

Arm splits Neoverse into families. The V-series targets performance, with wider out-of-order execution and more aggressive single-thread throughput. The N-series targets balance, trading peak per-core speed for density and efficiency. The E-series pushes efficiency further still.
Graviton4 and Axion both sit on Neoverse V2. Cobalt 100 sits on N2-class cores. That is not a marketing detail; it predicts which workloads will feel fast and which will feel disappointing.
| Chip | Announced | Core family | Best-fit workloads | Watch out for |
|---|---|---|---|---|
| AWS Graviton4 | Nov 2023, GA July 2024 | Arm Neoverse V2 | Web tiers, Java services, databases, bursty compute | Per-core licensing costs on wide instances |
| Azure Cobalt 100 | Nov 2023, GA 2024 | Arm Neoverse N2-class | Scale-out microservices, containers, batch | Single-thread-sensitive legacy apps |
| Google Axion | April 2024, GA from late 2024 | Arm Neoverse V2 | Web serving, analytics, in-memory caches | Regional availability during rollout |
A team running a latency-sensitive trading API will care about the V-series advantage. A team running ten thousand small container replicas will often find the N-series density wins on cost per request. This is the same trade-off that shows up in the broader cloud architecture debate, and it rarely resolves the same way twice. (Aws vs azure vs gcp gpu cloud pricing architecture decisions)
Software portability is the real migration cost
The silicon is the easy part. The bill arrives when someone discovers a native dependency with no Arm build, a JIT that behaves differently, or a profiling tool that silently returns wrong numbers.
Arm’s SystemReady certification program exists precisely to reduce this friction. It defines compliance bands so that operating systems and hypervisors can boot on compliant Arm servers without bespoke patches. When you evaluate a 2027 migration, ask two questions: are your base images and agents certified, and is the CPU fast?
Practical experience from teams that have already moved production workloads to Arm instances points to a consistent pattern. The workloads that port cleanly are interpreted or bytecode-based: Java, Go, Python, Node.js, and anything running in a managed runtime. The workloads that hurt are those with hand-tuned native libraries, aging C extensions, or vendor-supplied binaries with no source. Audit those first. A single blocked dependency can stall an entire migration.
The other common mistake is benchmarking on the wrong instance shape. Comparing a 16-vCPU Arm instance against a 16-vCPU x86 instance assumes vCPUs are equivalent. They are not. Measure cost per unit of completed work, not cost per core.
Where the architecture decisions actually diverge
Three decision axes separate these platforms in any realistic 2027 planning exercise.
Memory bandwidth and instance granularity
Custom silicon lets each cloud tune the memory subsystem to its own instance ladder. Some shapes offer more bandwidth per vCPU than others, and the gaps widen at the high end. For in-memory databases and caches, bandwidth per core matters more than clock speed. Pull the published specs for the exact shapes you intend to buy and model your workload against them rather than trusting a headline number.
Networking and storage integration
The chip is one layer in a stack. AWS pairs Graviton with its Nitro system, Microsoft ties Cobalt into its own accelerated networking, and Google integrates Axion with its Andromeda network fabric. In practice, the instance family you choose constrains which storage and network features you can use. A chip comparison that ignores the surrounding fabric is incomplete. This is the same lesson that shows up when teams compare container platforms: the runtime decision and the infrastructure decision are entangled.
Pricing model and commitment structure
Arm instances are generally priced below comparable x86 instances, but the discount varies by family, region, and commitment term. Spot and savings-plan mechanics differ across clouds. Model total cost using the hourly rate plus the engineering hours for porting. A 20 percent instance discount that requires two engineer-months of work is often a loss in year one.
What a sensible 2027 evaluation looks like
Rather than waiting for a product announcement, teams can build the decision now and slot in specifications later. A workable sequence:
- Inventory every workload and flag native dependencies, licensing terms tied to core count, and anything with no Arm build path.
- Benchmark the three or four workloads that dominate your bill on current-generation Arm instances from each cloud.
- Compare cost per completed transaction or per request, not per vCPU-hour.
- Confirm that your observability, security agents, and CI runners all support Arm.
- Negotiate commitment terms only after the benchmark data is in hand.
That approach survives whatever the 2027 silicon actually looks like. If Graviton5, a Cobalt successor, or a new Axion generation arrives with different core counts or memory configurations, the framework still holds; only the numbers change.
For teams weighing broader platform choices alongside silicon, the same discipline applies to runtime and database decisions. The reasoning behind cloud architecture trade-offs and the logic behind database architecture choices follow the same rule: measure against your workload, not against a spec sheet.
The lock-in question nobody asks out loud
Custom chips create a subtle form of gravity. Once a workload is tuned for one cloud’s Arm instance, moving it means re-benchmarking, re-certifying, and possibly re-architecting. The portability story is better than it was five years ago, but it is not free.
The mitigation is architectural, not contractual. Keep workloads containerized and infrastructure defined as code. Avoid depending on instance-specific accelerators unless the performance gain justifies the coupling. Prefer managed services with portable interfaces. Teams that treat the CPU as a swappable layer keep their options open; teams that tune to the metal pay for it later.
There is also a governance angle. If your organization already runs a multi-cloud posture, standardizing on Arm across providers reduces the surface area of your build matrix. One Arm build pipeline serving three clouds is a real operational saving. Three bespoke pipelines are not.
Conclusion
The 2027 comparison between AWS Graviton5, Azure Cobalt 200, and Google Axion is, for now, a comparison of design philosophies rather than confirmed products. What is confirmed is the pattern: all three clouds build on Arm Neoverse, all three choose between performance-first and efficiency-first cores, and all three sell the result wrapped in their own networking, storage, and pricing structures. The teams that navigate this well will not be the ones with the best benchmark spreadsheet. They will be the ones who audited their native dependencies early, measured cost per unit of work instead of cost per core, and kept their workloads portable enough to move when the next generation lands. Start the inventory now. The silicon will catch up to your plan faster than your plan will catch up to the silicon.
Frequently Asked Questions
Is AWS Graviton5 officially announced?
No confirmed public specification for a Graviton5 exists in published information. Graviton4 was announced in November 2023 and reached general availability in July 2024 on Arm Neoverse V2 cores. Any Graviton5 details circulating before an official AWS announcement should be treated as speculation and verified against primary sources.
How does Azure Cobalt 200 compare to Cobalt 100?
Cobalt 100 was announced in November 2023 and shipped through 2024 on Neoverse N2-class cores. A “Cobalt 200” has not been confirmed in public documentation. If a successor arrives, the meaningful questions will be which Neoverse generation it uses and whether Microsoft shifts from N-series toward V-series cores for higher single-thread performance.
What is Google Axion built on?
Axion was announced at Google Cloud Next in April 2024 and is based on Arm Neoverse V2 cores, the same family used by Graviton4. General availability rolled out from late 2024 into 2025. Because it shares a core family with Graviton4, performance differences between the two tend to come from memory subsystem design and instance sizing rather than the core itself.
Will my existing software run on Arm instances?
Usually yes, after a recompile, if your stack runs on a managed runtime like Java, Go, Python, or Node.js. Problems concentrate in native libraries, vendor binaries without source, and licensing models tied to x86 core counts. Audit those dependencies before committing to a migration timeline, and check whether your base images carry Arm SystemReady certification.
Should I compare Arm and x86 instances by vCPU count?
No. A vCPU on an Arm instance and a vCPU on an x86 instance are not equivalent units of work. Comparing them one-to-one produces misleading conclusions. Benchmark cost per completed transaction, per request, or per batch job instead, and include the engineering time required to port the workload.
What is the biggest risk in a 2027 Arm migration plan?
Lock-in through tuning. Once a workload is optimized for one cloud’s specific Arm instance, moving it requires re-benchmarking and re-certification. The mitigation is to keep workloads containerized, define infrastructure as code, and avoid instance-specific accelerators unless the measured gain clearly justifies the coupling.
That risk is manageable, but only if it is treated as an architectural constraint from day one rather than a cleanup task after the fact. The teams that get this right usually adopt a simple rule: if a workload cannot be rebuilt and redeployed on a different Arm instance family within a sprint, it is not ready for production. That rule forces portability into the design instead of bolting it on later. It also makes the annual re-benchmark a routine exercise rather than a crisis. In 2027, the winning posture will not be loyalty to one vendor’s silicon. It will be a build pipeline, a dependency inventory, and a cost model that can absorb whichever Neoverse generation lands next. The clouds will keep shipping faster chips. Your job is to make sure your workloads can follow them without a rewrite. That is the decision that actually compounds.


