Quick answer: a LoRA fine-tune costs about $3–$30 of rented GPU time per run at July 2026 prices; the data and testing work around the run is where a project's budget goes.
Dataset preparation, evaluation and deployment are most of the budget: complete projects usually land at $5K–$15K.
The answer-sheet reader I built for an Istanbul middle school runs a custom-trained open-source vision-language model in production on vLLM. The GPU bill for that kind of work is small. This page shows where the money actually goes, with current rental prices and a calculator you can adjust.
LoRA Fine-Tuning Costs: July 2026 Update
In July 2026, a LoRA/QLoRA fine-tune of a 7–8B model costs $3–$10 in GPU time (2–4 hours on a rented A100, or under $3 on an RTX 4090). A 70B QLoRA run lands at $15–$30. The GPU is no longer the expense — dataset preparation and evaluation are, which is why complete projects still land in the $5K–$15K range.
| Run | Hardware | Time | GPU cost |
|---|---|---|---|
| 7–8B QLoRA | 1× A100 80GB ($1.19–1.39/hr) | 2–4 hrs | $3–$10 |
| 7–8B QLoRA (budget) | 1× RTX 4090 (~$0.34/hr) | 6–8 hrs | ~$2.70 |
| 13B QLoRA | 1× A100 80GB | 4–6 hrs | <$15 |
| 70B QLoRA | 1× H100 ($1.99–2.69/hr) | 8–12 hrs | $15–$30 |
| 70B full fine-tune | 8× H100 | 24–48 hrs | $380–$1,000+ |
Prices verified July 2026 against RunPod, Lambda and Vast.ai public rates (A100 80GB from $1.19/hr; H100 from $1.99/hr; RTX 4090 from ~$0.31/hr). Managed alternatives: Together AI LoRA SFT $0.48/M tokens (≤16B), Fireworks $0.50/M — a typical 50M-token 8B job is ~$25 managed vs $3–$10 DIY.
LoRA Cost Calculator (2026 Pricing)
Estimate your training cost with current rental rates. Defaults mirror a typical 50M-token supervised fine-tuning job.
Not sure you need fine-tuning at all? For knowledge-lookup use cases, RAG is usually cheaper (see my production cost breakdown), and the LLM fine-tuning guide covers when training pays off.
OpenAI Is Retiring Self-Serve Fine-Tuning: What It Means
OpenAI announced on May 7, 2026 that its self-serve fine-tuning platform is winding down: organizations that had never fine-tuned lost access immediately, restrictions tightened on July 2, 2026, and no new fine-tuning jobs can be created after January 6, 2027. Existing tuned models keep serving until their base models are deprecated. Practical consequence: open-model LoRA (Llama, Qwen, Mistral) served on your own infrastructure — or via Together/Fireworks — is now the durable path for custom models. That is the stack I use: the answer-sheet reader is a custom-trained open-source vision-language model served with vLLM.
LLM LoRA vs Image-Model LoRA (FLUX/SDXL)
Half the people searching "LoRA training cost" mean image models, not language models. For completeness: a FLUX or SDXL style/character LoRA typically costs $2–$5 per training run on hosted services (fal.ai charges ~$2/run) or minutes on a rented consumer GPU. I train FLUX LoRAs for my own app art; the economics are trivial next to the curation work of building a good 20–80 image dataset.
What Is LoRA Fine-Tuning?
LoRA (Low-Rank Adaptation) is a parameter-efficient fine-tuning technique that allows you to customize large language models for your specific use case while dramatically reducing training costs.
Traditional fine-tuning updates all model parameters (billions of weights), which requires massive compute resources. LoRA updates only a small subset of parameters (millions), achieving similar results at a fraction of the cost.
Traditional Fine-Tuning vs. LoRA
| Metric | Traditional Fine-Tuning | LoRA |
|---|---|---|
| Parameters Trained | All ~7 billion (100%) | Usually under 1% (millions to tens of millions) |
| Training Time | 24-72 hours | 2-8 hours on one GPU |
| GPU Requirements | 8x A100 (80GB each) | 1x A100, or one RTX 4090 with QLoRA |
| GPU cost per run (July 2026 rental rates) | About $230-$800 | $3-$10 |
Typical LoRA Project Budgets
These are budget ranges for a complete fine-tune, not invoices. The GPU lines assume on-demand instances from AWS or GCP; on the rented GPUs in the table above, the same runs cost a few dollars. Engineering time is the part that moves the total.
Small-Scale (1,000-10,000 Training Examples)
- Training time: 1-2 hours
- GPU cost: $50-$100 (AWS/GCP rates)
- Engineering time: 8-16 hours
- Total cost: $1,200-$2,400
Medium-Scale (10,000-100,000 Training Examples)
- Training time: 3-6 hours
- GPU cost: $150-$300
- Engineering time: 16-24 hours
- Total cost: $2,800-$4,200
Large-Scale (100,000-1,000,000 Training Examples)
- Training time: 8-12 hours
- GPU cost: $400-$800
- Engineering time: 24-40 hours
- Total cost: $4,500-$8,000
Costs Around the Training Run
The training run is the cheap part. These are the line items that decide the budget:
1. Data Preparation (Often 50% of Total Cost)
- Data cleaning: $1,000-$3,000
- Labeling/annotation: $2-$10 per sample (for supervised learning)
- Format conversion: $500-$1,500
2. Infrastructure Setup
- Cloud GPU setup: $500-$1,000 (one-time)
- Storage costs: $50-$200/month
- Monitoring tools: $100-$300/month
3. Evaluation & Testing
- Benchmark testing: $800-$1,500
- Human evaluation: $500-$2,000
- A/B testing: $1,000-$2,500
4. Deployment
- Model optimization: $1,000-$2,000
- API setup: $800-$1,500
- Load testing: $500-$1,000
Total Cost of Ownership: First Year
An illustrative first-year budget for a support chatbot built on a fine-tuned model. The figures are assumptions for a mid-size B2B SaaS, not a client invoice:
Illustrative scenario: customer service chatbot for B2B SaaS
Initial Development:
- LoRA fine-tuning: $3,200
- Data preparation: $2,400
- Infrastructure setup: $1,000
- Testing & evaluation: $2,800
- Deployment: $2,200
- Total Initial: $11,600
Ongoing Costs (Monthly):
- Inference costs: $200-$500
- Monitoring: $150
- Re-training (quarterly): $800/month average
- Support: $400
- Annual Ongoing: $19,800
Year 1 total: $31,400
How to Reduce LoRA Fine-Tuning Costs
Four levers, roughly in order of impact. The savings are rules of thumb; test them against your own evaluation set.
1. Use Smaller Base Models
- Choose a 7B parameter model instead of 70B
- Cost savings: 60-70%
- Quality loss: 5-10% (often acceptable for B2B use cases)
2. Start with Pre-Trained Adapters
- Use community-created LoRA adapters as starting points
- Cost savings: $1,000-$3,000
- Time savings: 2-4 weeks
3. Optimize Your Training Data
- Quality over quantity: 1,000 perfect examples > 10,000 average ones
- Cost savings: $2,000-$5,000 in data prep
- Benefit: Better model performance
4. Use Quantization After Training
- Reduce model size by 75% for inference
- Monthly savings: $150-$400 in inference costs
- Quality loss: Minimal (2-3%)
ROI Calculation: When Does LoRA Pay for Itself?
A worked example with assumed numbers, using the scenario above. Swap in your own ticket volume and costs.
Illustrative example: e-commerce customer support
Manual Cost (Baseline):
- 3 support agents @ $45,000/year = $135,000
- Handle 12,000 tickets/year
- Cost per ticket: $11.25
LoRA Chatbot Cost:
- Development: $11,600 (Year 1 only)
- Ongoing: $19,800/year
- Handles 9,600 tickets/year (80% of total)
- Cost per ticket: $3.27
Savings:
- Year 1: $58,600 net ($90,000 for two agents, minus the $31,400 first-year cost)
- Year 2+: $70,200/year ($90,000 minus $19,800 running costs)
- Payback period: about 2 months
Two Production Fine-Tunes
Two models I trained for Erkan Ulu Schools in Istanbul, both in use at the school today:
- The answer-sheet reader. A custom-trained open-source vision-language model, served with vLLM. A YOLO detector finds each answer row first, and reads the model is unsure about go to a teacher instead of being guessed. (case study)
- Otocropper. Not a LoRA job: an RT-DETRv2 detector fine-tuned on 7 page-region classes from a five-book labeled corpus. On a 238-page book it never saw in training it reached 97.1% recall and 96.9% precision at IoU ≥ 0.9, and 222 of the 238 pages needed no edits. Getting there took a labeling pipeline (draft labels, a verifier pass, a box editor) and a review of every remaining error by eye. (case study)
If you budget for a fine-tune, budget for the dataset and the evaluation set first. The training run is the smallest line in the budget.
Model fine-tuning projects at Stratagem start the same way: label real examples and set a test set aside before any training run.
Get a LoRA Cost Estimate
Send me what the model should do, how many examples you have and where it has to run. I'll reply with a GPU estimate and a fixed price for the data and evaluation work. If prompting or RAG would do the job for less, I'll say so.
Frequently Asked Questions
How much does LoRA fine-tuning cost?
At July 2026 rental prices, the GPU time for a LoRA or QLoRA run on a 7–8B model is about $3–$10 on an A100, and $15–$30 for a 70B QLoRA run on an H100. A complete project, including data preparation, evaluation and deployment, usually costs $5,000–$15,000.
Is LoRA cheaper than full fine-tuning?
Yes. LoRA trains a small set of adapter weights, usually under 1% of the model, so a 7–8B model fits on one GPU. A full fine-tune of a 70B model on 8× H100 costs roughly $380–$1,000 or more in GPU time at July 2026 rates, against $15–$30 for a 70B QLoRA run.
