{"id":79846,"date":"2026-11-11T01:34:45","date_gmt":"2026-11-11T01:34:45","guid":{"rendered":"https:\/\/www.devopsschool.com\/blog\/?p=79846"},"modified":"2026-11-11T01:34:46","modified_gmt":"2026-11-11T01:34:46","slug":"understanding-the-hardware-requirements-of-modern-llms","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/blog\/understanding-the-hardware-requirements-of-modern-llms\/","title":{"rendered":"Understanding the Hardware Requirements of Modern LLMs"},"content":{"rendered":"\n

Ask ten engineers how much hardware a large language model<\/a> needs, and you will get ten answers, most of them starting with “it depends.” That answer is honest, but it is not useful when you are about to sign a purchase order or commit to a cloud contract.<\/p>\n\n\n\n

The good news is that the dependencies are predictable. Once you understand where memory goes, why bandwidth matters more than raw speed, and how training differs from serving, you can size a system with a spreadsheet instead of a guess.<\/p>\n\n\n\n

Start With Memory, Not Compute<\/strong><\/h2>\n\n\n\n

Most people shopping for AI hardware<\/a> look at compute figures first. For language models, that is usually the wrong place to start.<\/p>\n\n\n\n

The first question is whether the model fits. If the weights, the working data, and the overhead do not fit in GPU<\/a> memory, the job either fails or slows to a crawl as data shuttles across slower links. Compute only matters once the model is resident.<\/p>\n\n\n\n

That is why GPU memory capacity, measured in gigabytes of high-bandwidth memory (HBM), tends to drive LLM hardware decisions more than any other spec.<\/p>\n\n\n\n

The Simple Math of Model Weights<\/strong><\/h2>\n\n\n\n

Model weights follow straightforward arithmetic. Each parameter takes a fixed number of bytes depending on its numeric precision.<\/p>\n\n\n\n

At 16-bit precision (FP16 or BF16), each parameter uses 2 bytes. A 7-billion-parameter model needs roughly 14 GB just for its weights, and a 70-billion-parameter model needs roughly 140 GB.<\/p>\n\n\n\n

Quantization shrinks that footprint. At 8-bit precision the same 70B model drops to around 70 GB, and at 4-bit it lands near 35 GB. Quality trade-offs vary by model and method, so test on your own workload before committing to an aggressive format.<\/p>\n\n\n\n

Keep in mind that weights are the floor, not the total. Every running model needs extra memory on top of them.<\/p>\n\n\n\n

Why Context Length Changes Everything<\/strong><\/h2>\n\n\n\n

The biggest source of that extra memory during inference is the key-value (KV) cache. As a model processes a prompt and generates text, it stores intermediate attention data for every token so it does not have to recompute it.<\/p>\n\n\n\n

The KV cache grows with context length, with the number of simultaneous requests, and with the size of the model. A model that fits comfortably with short prompts can run out of memory once users start pasting in long documents or you raise the batch size to serve more people at once.<\/p>\n\n\n\n

This is one reason serving frameworks have invested heavily in memory management. The Paged Attention technique introduced with vLLM treats KV cache like virtual memory pages, cutting waste so more requests fit on the same card. Smart software can buy real headroom, but it cannot make a model fit where the math says it will not.<\/p>\n\n\n\n

Training Is a Different Problem Than Inference<\/strong><\/h2>\n\n\n\n

Serving a model and training one place very different demands on hardware, and mixing them up is one of the most expensive sizing mistakes a team can make.<\/p>\n\n\n\n

Training needs to hold far more than the weights. A common rule of thumb for mixed-precision training with the Adam optimizer is about 16 bytes per parameter once you count weights, gradients, a full-precision master copy, and optimizer states. By that math, fully fine-tuning a 7B model needs over 100 GB before activations are even counted.<\/p>\n\n\n\n

If your roadmap includes full fine-tuning or pretraining, it pays to look at higher-memory accelerators early, and the secondary market has made options like H200s for training larger language models<\/a> far easier to budget for than they were at launch. With 141 GB of HBM3e per GPU, versus 80 GB on the H100, each card holds more of the model and its training state, which means fewer GPUs to split the job across.<\/p>\n\n\n\n

Parameter-efficient methods change the equation for smaller teams. Techniques such as LoRA train a small set of added weights while the base model stays frozen. The QLoRA paper showed a 65B-parameter model being fine-tuned on a single 48 GB GPU by combining this approach with 4-bit quantization.<\/p>\n\n\n\n

When One GPU Stops Being Enough<\/strong><\/h2>\n\n\n\n

Eventually most serious workloads outgrow a single card. At that point the model, the data, or both get split across several GPUs.<\/p>\n\n\n\n

Tensor parallelism splits individual layers across GPUs. Pipeline parallelism assigns different layers to different GPUs. Data parallelism runs copies of the model on separate batches and syncs the results.<\/p>\n\n\n\n

Each approach adds communication overhead. The more GPUs that need to talk to each other, the more the speed of the connections between them starts to matter.<\/p>\n\n\n\n

Bandwidth Is the Hidden Bottleneck<\/strong><\/h2>\n\n\n\n

For text generation, memory bandwidth often matters more than peak compute. Each new token requires reading a large share of the model’s weights from memory, so the speed of that memory sets a ceiling on how fast tokens come out.<\/p>\n\n\n\n

This is why newer accelerators advertise bandwidth so prominently. The H200, for example, is rated at 4.8 TB\/s of memory bandwidth, a meaningful jump over the H100’s 3.35 TB\/s.<\/p>\n\n\n\n

Between GPUs, the same logic applies. High-speed links like NVLink inside a server, and InfiniBand or fast Ethernet between servers, keep multi-GPU jobs from stalling while cards wait on each other. A cluster with fast GPUs and slow interconnects will underperform its spec sheet.<\/p>\n\n\n\n

Power, Cooling, and the Rest of the Server<\/strong><\/h2>\n\n\n\n

Data center GPUs in this class can each draw up to around 700 watts. An eight-GPU server can pull on the order of 10 kilowatts at full load, which is more than many standard office racks or older colocation contracts were designed to handle.<\/p>\n\n\n\n

Before buying, confirm that your facility can deliver the power and remove the heat. Some newer configurations call for liquid cooling, which is a facilities project, not just a hardware purchase.<\/p>\n\n\n\n

The supporting components matter too. Fast NVMe storage keeps training data flowing, enough system RAM prevents bottlenecks when loading checkpoints, and a capable CPU keeps data pipelines from starving the GPUs.<\/p>\n\n\n\n

A Practical Way to Size Your Hardware<\/strong><\/h2>\n\n\n\n

Start with the largest model you realistically plan to run in the next year or two, not the one you are testing today. Calculate its weight footprint at the precision you intend to use.<\/p>\n\n\n\n

Next, add headroom for the KV cache based on your expected context length and concurrent users. For training, apply the per-parameter rule of thumb, or plan around parameter-efficient methods if full fine-tuning is out of reach.<\/p>\n\n\n\n

Then decide how many GPUs that total implies, and check whether your interconnect, power, and cooling can support them. Run a pilot on rented capacity if you can, because real workloads rarely match back-of-envelope estimates exactly.<\/p>\n\n\n\n

Hardware for LLMs is expensive, but it is not mysterious. Get the memory math right first, and most of the other decisions fall into place.<\/p>\n","protected":false},"excerpt":{"rendered":"

Ask ten engineers how much hardware a large language model needs, and you will get ten answers, most of them starting with “it depends.” That answer is… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_joinchat":[],"footnotes":""},"categories":[11138],"tags":[],"class_list":["post-79846","post","type-post","status-publish","format-standard","hentry","category-best-tools"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/79846","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=79846"}],"version-history":[{"count":1,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/79846\/revisions"}],"predecessor-version":[{"id":79847,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/79846\/revisions\/79847"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=79846"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=79846"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=79846"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}