Three decisions made at the moment you create a machine will follow you for
months: the type, the processor architecture and the size. This lesson
explains what you actually buy behind a name like c7g.xlarge, why a machine
with an ARM processor costs about 19% less at equal size on the AWS Paris price list, and how to size from
measurements rather than out of caution.
What you will learn
- Decode an instance type name and know what it promises.
- Compare ARM and x86 on real price and on the compatibility of your stack.
- Rule out the compute models that the workload cannot support (kernel, duration).
- Size from measurements, rather than out of caution.
- Recognise the resource that saturates first, which is often not the one you think.
What you really buy
An instance is most often virtualised capacity on shared infrastructure, not a machine of your own. The nuance explains most performance surprises: your resources are guaranteed to a certain extent, and the neighbourhood exists.
This is not systematic: dedicated offers exist at all the major providers, such as the dedicated host, the dedicated instance and even the physical server with no hypervisor (the software that shares a server between several virtual machines). They cost more and serve specific needs, often compliance or licensing.
Concretely, you reserve three things that are billed separately.
| What you reserve | Billed | Keeps going after shutdown |
|---|---|---|
| Compute (processor and memory) | per second or per hour | no |
| The attached disk | per gigabyte per month | yes, as long as it exists |
| The reserved public address | per hour, often even when unused | yes |
This third column is the source of a frequent bad surprise. You switch the test machines off on Friday, you think you have stopped the spend, and on Monday the bill has kept running on the disks and the addresses. Switching off suspends the compute; the rest continues as long as these resources exist.
They are also handled separately: a volume detaches and is deleted without touching the machine, and a reserved address is released in the same way. It is this decoupling that makes possible the cleanup described in governance and costs (in French).
Machine, container or function: the choice that comes before the size
Before choosing a size, check that the workload can run under the model you are aiming for. The Cloud compute module (in French) compares the three options, and two constraints are enough to rule out some models right away.
The first constraint is the system. A workload that needs a module loaded into the kernel, or a system setting, can only run on a virtual machine (the kernel is then the VM's own) or on the nodes of a managed Kubernetes with node groups, which gives access to those nodes. A serverless container or a function does not expose the kernel.
The second is the duration. A function imposes a maximum duration per execution, specific to each provider and to be checked in its documentation: a request longer than this limit rules out the function. If several models remain possible, keep the cheapest to operate, then move on to the size.
Reading an instance type
Names vary from one provider to another, and most encode the same information: a family, a generation, a size. Once the principle is understood, most price lists become readable, even though the exact convention should always be checked in the provider's documentation.
m7i.xlarge reads in three parts: m for the general-purpose family,
7i for the generation and the processor maker (here Intel), xlarge for the size. The common
families are t (economy, credit-based), m (general purpose), c (compute),
r (memory), i (fast storage), g and p (graphics accelerators).
Standard_D4s_v5: D for the general-purpose family, 4 for the number of
cores, s for premium storage, v5 for the generation. The families
follow the same logic: B (economy, credit-based), D (general purpose),
F (compute), E (memory), N (accelerators).
n2-standard-4: n2 for the generation, standard for the profile,
4 for the number of virtual processors. The profiles are highcpu,
standard and highmem, which makes the memory-per-core ratio explicit in
the name, where other providers leave you to guess.
The format is the most explicit of all: tinav6.c4r8p2 announces generation
v6, 4 cores, 8 GB of memory and the performance flag p2. You
compose the machine rather than choosing from a catalogue, which is covered
in detail in TINA instances and
sizing (in French).
The memory-per-core ratio is the real selection criterion. The common orders of magnitude are around 2 GB per core on a compute family, 4 GB on a general-purpose one, 8 GB or more on a memory family, with gaps from one provider to another that must be checked on the current price list. Choosing the wrong family amounts to paying for cores to get memory, or the reverse.
ARM or x86: which should you choose?
On the AWS Paris price list, a machine with an ARM processor costs about 19% less than its x86 equivalent of the same generation and the same size. It is a sizing trade-off that is often profitable, and it sometimes requires no code change. The x86 architecture is that of Intel and AMD processors; ARM is another family of processors, which providers also offer (Graviton at AWS).
The table below compares instances of the same generation and the same
size, 4 vCPU (virtual processors) and the same usage family, on the AWS public price list for the
Paris region (eu-west-3, Linux, on-demand, on-demand pricing page), retrieved on 14 November 2026. These are generation 7 instances; AWS offers more recent generations in the Paris region (c8g, m8g, m8i in the list of instance types by Region), with different prices.
| Instance | Processor | Hourly price | Per month (730 h) |
|---|---|---|---|
c7g.xlarge | ARM (Graviton3) | 0.1717 USD | 125.34 USD |
c7i.xlarge | x86 (Intel Xeon) | 0.2121 USD | 154.83 USD |
m7g.xlarge | ARM (Graviton3) | 0.1904 USD | 138.99 USD |
m7i.xlarge | x86 (Intel Xeon) | 0.2352 USD | 171.70 USD |
The price gap is only half of the story: at a comparable generation, these processors can offer a better performance-per-watt ratio, which would also improve the cost per request served: measure it on your workload.
What still prevents the switch
The question is no longer price, it is the compatibility of your stack. Three points to check before migrating, in this order:
- Container images. An image built for
amd64does not start on ARM. The remedy is the multi-architecture manifest, which bundles both variants under a single name: your build chain must producelinux/amd64andlinux/arm64. - Binary dependencies. An interpreted or just-in-time compiled language generally goes through without effort. What gets stuck are compiled native extensions, proprietary drivers and agents supplied as binaries by a vendor that only publishes x86.
- Software licences. Some vendors bill differently, or simply do not support the architecture.
Sizing without oversizing
Oversizing out of caution is a common source of savings on a cloud bill, and it comes from an understandable reflex: you provision as in the hardware days, when a mistake cost a purchase order and six weeks.
In the cloud, a machine is resized or recreated quickly. Changing size generally takes a restart, which you schedule, but a bad choice no longer costs six weeks. The right method therefore reverses the old one: instead of aiming wide from the start, you start small and adjust on the measurement. Sizing means choosing the size (cores and memory) that holds the real load, in four steps:
-
Start small, deliberately
Take the size below your hunch. If it is enough, you have roughly halved the compute cost of this machine, every month.
-
Measure over a meaningful period
A full week at minimum, to catch Monday morning and the weekend batch. Look at the 95th percentile (the value under which 95% of the measurements fall) rather than the average, which hides the peaks. The maximum is misleading: a one-second spike does not justify doubling the machine for the year.
-
Decide on the resource that saturates first
It is often memory, more rarely the processor. A machine whose processor tops out at 30% and whose memory reaches 90% does not call for a size up: it calls for a memory family.
-
Redo the exercise every quarter
Usage drifts. A quarterly resize is a profitable cost-control action, because it degrades nothing.
Size on the 95th percentile, increased by the expected growth. If usage is to grow within the year, multiply the measured value by this growth before choosing the machine, otherwise it will be too tight from the first months. Among the sizes that hold this demand, keep the cheapest, provided your native dependencies have been tested on the chosen architecture.
A benchmark to trigger the review, and not a universal threshold: a machine whose processor stays under 30% at the 95th percentile for a week deserves a close look. Go down one notch, measure again, and keep the size that holds the real load.
Put it into practice
The lab provides the profile of a continuous workload, a week of measurements and a machine catalogue with a relative cost. You write a compute-decision.json file that names the compute model, the processor architecture, the machine profile retained and the demand used to size it, with a short justification. The validation recomputes these values from the brief. The model must accept the workload's runtime constraints, and the architecture must be one where the native dependency is tested. The demand must come from the week's 95th percentile and the expected growth, not from the few-second peak, and the machine must be the cheapest that holds this demand. The costs in the exercise are relative, and no cloud resource is created.
Key points
- Rule out first the models the workload cannot support: a kernel need imposes a virtual machine, a duration that is too long rules out the function.
- An instance type name reads in three parts: the family, the generation and the size.
- ARM costs less at equal size (about 19% on the AWS Paris price list retrieved), provided your stack is compatible; the trial costs almost nothing.
- Start small and measure for a week at the 95th percentile before deciding.
- The resource that saturates first is often memory, hence choosing a memory family rather than a size up.
- Redo the exercise every quarter: usage drifts.
Knowledge check
Check that the essentials of this guide are in place. The questions only cover what has just been explained here.
Knowledge check
Check what you have learned with this interactive quiz
How it works
- The timer starts when you click Start
- Multiple choice, true/false and short answer questions
- You can move between questions
- Detailed results are shown at the end
Starts the quiz and the timer
Review
(0/0)Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.
Weak areas
No topic below the pass mark.
Recommended next
Hints before you try again?
Continue the course: Paying for compute: commitments, autoscaling and interruptible instances
A new full quiz with random questions
Work again only on the questions you missed