Fine-Tuning LLMs on a Budget: Full Cost Breakdown by Model Size and Adapter Type

TL;DR

Most fine-tuning cost guides show you GPU hours and call it a breakdown. But GPU compute is only one line item in the real cost of a fine-tuning project. This post gives you actual compute cost numbers by model size and method, the minimum GPU requirements for each combination, and the hidden costs that routinely double project budgets. Whether you are planning a first project or trying to understand why the last one cost more than expected, these are the numbers that actually matter.

Let's start with the number that most guides give you and then talk about why it is incomplete.

A QLoRA fine-tuning run on a 7B model costs roughly $1 to $4 in GPU compute. That is true. It is also almost meaningless on its own because it assumes everything goes right on the first try, which it almost never does.

Here is the full picture.

Compute Costs by Model Size and Method

These numbers are based on current cloud GPU pricing as of 2026, a dataset of 1,000 to 5,000 examples, sequence length of 2048, and 3 epochs. They represent a single training run.

7B Models

QLoRA on a single A10G (24GB): Training time: 45 to 90 minutes GPU cost: $0.75 to $1.50 per run Minimum VRAM required: 16GB (24GB recommended for comfortable batch sizes)

LoRA without quantization on a single A10G: Training time: 40 to 75 minutes GPU cost: $0.65 to $1.25 per run Minimum VRAM required: 20GB

Full fine-tuning on 4x A100 80GB: Training time: 2 to 4 hours GPU cost: $24 to $64 per run at $3 per GPU hour Minimum VRAM required: 4 x 80GB

For most 7B fine-tuning tasks, QLoRA on a single A10G is the right call. The quality difference versus full fine-tuning is small for well-defined tasks and the cost difference is enormous.

13B Models

QLoRA on a single A100 40GB: Training time: 90 minutes to 3 hours GPU cost: $3 to $6 per run Minimum VRAM required: 24GB at very constrained settings, 40GB recommended

QLoRA on a single A10G (24GB): Possible with reduced sequence length and batch size Training time: 2 to 4 hours GPU cost: $2 to $4 per run Expect slower iteration due to memory constraints

Full fine-tuning on 4x A100 80GB: Training time: 4 to 8 hours GPU cost: $48 to $96 per run Minimum VRAM required: 4 x 80GB

70B Models

QLoRA on a single A100 80GB: Training time: 8 to 16 hours GPU cost: $24 to $64 per run at $3 to $4 per hour Minimum VRAM required: 80GB

QLoRA on 2x A100 80GB: Training time: 5 to 10 hours GPU cost: $30 to $80 per run Faster iteration but higher hourly cost

Full fine-tuning on 8x H100: Training time: 24 to 48 hours GPU cost: $250 to $600 per run This is not a budget option. Only justified when task requirements genuinely demand it.

The Iteration Multiplier

A single run at these prices looks manageable. The problem is that a realistic project is not one run.

Budget for 4 to 8 training runs per project. Some of those runs will be short diagnostic runs you kill early. Some will be full runs you evaluate and then improve on. A few will fail due to config or data issues.

For a 7B QLoRA project, multiply the per-run cost by 5 and add 20 percent for failed runs. That gives you a realistic compute budget:

• 7B QLoRA: $8 to $20 in compute for a complete project
• 13B QLoRA: $20 to $50 in compute
• 70B QLoRA: $150 to $400 in compute

These are still manageable numbers. The place where budgets actually break is not compute.

The Hidden Costs

These are the line items that do not appear in GPU pricing tables but show up in your actual project cost.

Engineer time for setup and debugging. At a conservative $100 per hour for a senior ML engineer, two days of environment setup and debugging costs $1,600 before a single training token is processed. On a first project without a clean environment, this is not an unusual number. It is the default.

Failed runs on running instances. When a training job fails on a cloud instance that you manage yourself, the instance keeps running while you diagnose the problem, update the config, and resubmit. An hour of debugging on a $3 per hour A100 instance costs $3. That sounds small. Across 10 failed runs on a complex project it adds up and the engineer time to diagnose each failure costs far more than the compute.

Data preparation. Building a clean, validated, correctly formatted dataset for the first time takes 4 to 8 hours of engineer time. For a 1,000 example dataset this might feel fast. For a 10,000 example dataset with quality filtering and deduplication it is a multi-day effort.

Evaluation time. Running a proper eval suite after each training run takes 30 minutes to 2 hours depending on how automated your process is. Across 6 training runs that is 3 to 12 hours of time that your compute bill does not capture.

Serving costs. This is the one that surprises teams most. Training is one-time. Serving is forever. A dedicated GPU instance for a 7B model in production costs $300 to $700 per month. A 13B model costs more. A 70B model costs $800 to $1,500 per month for a basic production deployment.

Over 12 months, a model that cost $15 to train can cost $5,000 to $8,000 to serve.

Where to Cut Cost Without Cutting Results

Start with 7B before considering 13B or 70B. A fine-tuned 7B on high-quality data beats a general-purpose 70B on focused tasks more often than people expect. The cost difference between 7B and 70B serving is roughly 10x over time. Do not skip to 70B without first testing whether 7B gets you there.

Use QLoRA unless you have a specific reason not to. For most tasks the quality gap between QLoRA and full fine-tuning is small. The cost gap is not. QLoRA first, full fine-tuning only when QLoRA results are definitively insufficient.

Validate your dataset before your first run. One failed run due to a dataset format issue costs $1 to $4 in compute and 30 minutes to 2 hours in engineer time to diagnose. Validating your JSONL syntax and doing a manual review of 50 examples before you start takes 20 minutes and eliminates the most common source of early failed runs.

Build a reproducible environment once. The setup tax is a one-time cost if you containerize your environment. Pay it once on the first project. Recover it across every project after.

Use spot or preemptible instances for experimentation runs. Most cloud providers offer spot instances at 50 to 70 percent discounts. For experimental runs where a failure is not catastrophic, spot pricing cuts your compute costs roughly in half. Save on-demand instances for final production runs where you cannot afford an interruption.

A Realistic Budget for a First Fine-Tuning Project

Here is what a well-planned first project on a 7B model should actually cost.

Compute across 5 to 6 training runs: $10 to $25 Engineer time for setup, data prep, debugging, and evaluation at $100 per hour: $800 to $1,600 Total first project cost: $810 to $1,625

The second project with the same infrastructure drops the engineer time by 60 to 70 percent because the environment is already built and the process is familiar.

The third project is where the investment starts to pay off clearly.