A note on scope and staleness before anything else: GPU models, VRAM capacities and cloud rental prices change every few months, and this page will not be updated to track them. What follows describes durable categories and the trade-offs between them, not specific current products or prices — treat any dollar figures as order-of-magnitude and check a vendor's current listing before buying or renting anything.
Training, fine-tuning and pretraining are different asks
"Minimum hardware for training an LLM" has no single answer because "training" covers very different workloads:
- Inference / running a model — loading a pretrained model and generating text from it. Cheapest by far; a quantized small model can run on a laptop CPU.
- Parameter-efficient fine-tuning (LoRA, QLoRA, adapters) — adjusting a small fraction of a pretrained model's weights on your own data. This is what "fine-tune an LLM on a consumer GPU" articles are usually describing, and it's realistic on modest hardware because the base model's weights stay frozen and quantized.
- Full fine-tuning — updating all of a pretrained model's weights. Needs to hold gradients and optimizer state for every parameter, which multiplies memory needs several times over LoRA for the same model size.
- Pretraining from scratch — training a model's weights from random initialization on a large corpus. Even for a "small" language model (SLM) this needs far more compute and data-pipeline engineering than fine-tuning; pretraining a frontier-scale LLM from scratch is a multi-node, multi-million-dollar undertaking and out of scope for a "minimum hardware" post.
The tiers below are organized around the first two — the workloads an individual or small team can actually run — with a note on where full fine-tuning and small-scale pretraining fit.
The tiers
| Tier | What it looks like | Realistic for | Cost shape |
|---|---|---|---|
| Consumer / hobbyist | One modern consumer GPU with mid-to-high VRAM (the kind sold for gaming), in a normal desktop. | Local inference of small-to-mid models (quantized); LoRA/QLoRA fine-tuning of small models (roughly single-digit billions of parameters, quantized to 4-bit). | One-time purchase; hundreds to low thousands of currency units. Runs indefinitely at the cost of electricity. |
| Prosumer / workstation | One high-VRAM "workstation-class" GPU, or two-to-four consumer/prosumer GPUs in one machine. | LoRA fine-tuning of larger models; full fine-tuning of small models; small-scale architecture experiments; comfortably running larger quantized models for inference. | One-time purchase; low-to-mid thousands, scaling with GPU count. Same ongoing electricity cost, now non-trivial. |
| Cloud rental | Pay-by-the-hour access to one or many data-center-class GPUs (much higher VRAM per card than consumer parts), from a cloud or GPU-rental provider. | Anything above, without the upfront cost; the only realistic option for full fine-tuning of large models or pretraining an SLM, since it lets you rent many GPUs for a short burst instead of owning them. | No upfront cost; billed per GPU-hour. A single card runs a small fraction of a currency unit to a few units per hour depending on the card and provider; a multi-GPU pretraining run can still add up to a meaningful sum over days. |
The lever that matters most: quantization
Across all three tiers, the single biggest factor in what fits is quantization — representing model weights (and sometimes optimizer state) in fewer bits than the 16 or 32 bits they were trained in. Loading a model in 4-bit roughly quarters its memory footprint against a 16-bit load, which is why techniques like QLoRA make it possible to fine-tune models on consumer GPUs that would otherwise need a data-center card just to load. The trade-off is a small amount of quality loss, which is usually acceptable for fine-tuning and often negligible for inference.
What actually constrains you
- VRAM, not raw compute, is usually the wall. A card can be fast and still unable to fit the model, its activations, gradients and optimizer state in memory at once. This is why "how much VRAM" is the first question, and why quantization and parameter-efficient methods matter more than raw FLOPS for getting started.
- Multi-GPU needs fast interconnect to scale well. Two GPUs in one desktop can split a model, but training throughput across GPUs (and across machines) depends heavily on how fast they can exchange data — a detail that matters far more once you move past a single card.
- Data engineering, not hardware, is usually the actual bottleneck for anyone starting out — sourcing, cleaning and formatting training data (see Data Operations) — regardless of which hardware tier you're on.
Where to start
For most people asking this question, the practical path is: start with parameter-efficient fine-tuning of a small, openly-licensed model on whatever consumer GPU you already have or can afford, using an established fine-tuning library rather than writing a training loop from scratch. Move to a prosumer machine or cloud rental only once you've validated that the approach works and you specifically need more scale — renting compute for a focused run is usually cheaper and faster than buying hardware for an unproven workload.
This page is deliberately light on specific model names and prices, since both go stale fast — ML Engineering & Platform and Model Lifecycle Management cover the durable practices around building and operating models once you're past the hardware question. Something missing or wrong here? Use the Feedback tab on the right.