Nov 5, 2026 - 7 min read

Yes, you can train your own LLM, and for most teams that means fine-tuning an open model, not building one from scratch. On Nodus, fine-tuning, continued pretraining and scratch pretraining all run on one managed training runtime. By our math they cost about $2, $1,200 and $19,000 in GPU time for an 8B model, but the deciding factor is how much data you have.

What are the three ways to train your own LLM?

There are three paths, and they differ by how much of the model you change. Each one starts from a different place and needs a different amount of text.

Path	Starts from	What it changes	Data you need
Fine-tuning (LoRA or full)	An open model’s weights	Behavior: format, tone, task skill	Thousands of examples, millions of tokens
Continued pretraining	An open model’s weights	Knowledge of a domain or language	Billions of tokens of raw text
Pretraining from scratch	Only an architecture and tokenizer	Everything	Hundreds of billions of tokens or more

Fine-tuning teaches a capable model to behave a certain way on your task. Continued pretraining keeps training the base model on raw domain text, such as legal filings or a low-resource language, before any fine-tuning. Scratch training begins with random weights, so the model learns language itself from your data.

If what you really need is fresh facts at answer time, you may not need training at all. Our post on RAG vs fine-tuning covers that choice.

How much does each path cost for an 8B model?

Fine-tuning costs a few dollars, continued pretraining about a thousand, and scratch training about nineteen thousand. We priced all three for the same 8-billion-parameter model on NVIDIA H100s, listed at $2.60/hr on the Nodus pricing page. The method comes from our post on what it costs to train an LLM. It assumes about 6 operations per parameter per training token and an H100 at 989 teraFLOPS of dense BF16 math. At 30% utilization, one H100-hour delivers about 1.07 × 10^18 useful operations.

Path (8B model)	Training tokens	H100-hours	GPU cost
LoRA fine-tune	20 million	0.9	$2.34
Continued pretraining (full)	10 billion	449	$1,168
Scratch, compute-optimal	160 billion	7,190	$18,695

Prices checked November 5, 2026. These are planning numbers for GPU time only, not quotes.

The 20 million tokens are, for example, 10,000 examples of 2,000 tokens each. The 10 billion tokens are our example size for a domain corpus. The 160 billion tokens follow the rule of about 20 tokens per parameter from DeepMind’s Chinchilla paper. We use 6 operations per token for LoRA too: gradient checkpointing adds back about as much work as frozen weights save, the same assumption as our 70B fine-tuning cost post.

Each step down the ladder costs roughly 16 to 500 times more GPU time than the one before.

How long does each path take?

A LoRA fine-tune of an 8B model takes about an hour on one GPU, while the other two take days. The H100-hours above divide across however many GPUs you run.

Full training needs more memory than one GPU has. Adam in mixed precision keeps about 16 bytes per parameter, per the ZeRO paper, so an 8B model carries about 128 GB of training state before activations. That rules out one 80 GB H100 and points to an 8-GPU machine with the state sharded across it.

On one 8 × H100 machine, continued pretraining on 10 billion tokens takes about 56 hours. Compute-optimal scratch training takes about 899 hours, or 37 days.

Scratch training on a single machine runs for over a month, so it usually means several machines at once.

Nodus multi-node training (Beta) runs one job across 2 to 8 machines. Eight 8 × H100 machines bring the scratch run down to about 112 hours, or 4.7 days, for the same $18,695. Our post on how many GPUs you need shows how to size this for other models.

Is training from scratch ever worth it?

Rarely, because the open models you would compete with saw far more data than a budget scratch run can afford. Meta’s Llama 3.1 model card says the family was pretrained on about 15 trillion tokens. That is about 94 times the 160 billion tokens of our compute-optimal 8B run. The card also lists 1.46 million H100 GPU-hours for the 8B model alone.

So a scratch 8B model for $18,695 will usually be weaker at general language than a free open model you fine-tune for a few dollars. Scratch training still makes sense in a few cases:

• You need a tokenizer or architecture that no open model has, such as a new script or a non-text modality.
• Your domain looks nothing like web text, such as genomic or machine-log sequences.
• You need full control over every token the model saw, for licensing or research.
• The model is small. Our cost post puts a compute-optimal 1B model at about $292.

Which path should you pick?

Pick the cheapest path your data and goal justify, and move down only when the one above has failed on held-out tests. This is the rule we use.

1. Start with an open model, prompting and retrieval. Measure it on 50 to 100 real tasks you keep aside.
2. If it knows enough but behaves wrong (format, tone, tool calls, a narrow task), fine-tune with LoRA. Our LoRA vs QLoRA post covers the memory trade-off.
3. If it lacks the vocabulary and facts of your field, and you have billions of tokens of clean domain text, run continued pretraining, then fine-tune on top.
4. Train from scratch only for one of the reasons in the previous section.

The data test settles most cases. If your corpus is measured in millions of tokens, a fine-tune or a retrieval index fits it, and continued pretraining has too little to learn from.

What does it take to run each path on Nodus?

One training runtime covers all three paths, so moving down the ladder changes a few lines, not your tooling. The managed nodus/sft runtime does supervised fine-tuning (full, LoRA or QLoRA), and with task: Pretrain it does continued or from-scratch pretraining. This example is from the Nodus training guide:

spec:
  runtime: nodus/sft
  task: Pretrain
  model: {uri: hf://Qwen/Qwen3-0.6B@c1899de289a04d12100db370d81485cdf75e47ca}
  data: {volume: corpus, format: JSONL}
  parameters: {steps: 10000, initialization: Scratch, packing: true}
  resources: {gpu: {type: [h100-sxm-80g], count: 8}}

initialization: Scratch keeps only the model’s architecture and tokenizer. Continued, the default, keeps its weights, which turns the same file into continued pretraining. For a fine-tune you drop task: Pretrain and add a lora block, as the guide shows.

Price the run before it starts. nodus apply -f sft.yaml --dry-run -o yaml returns an estimate of cost to completion, built from steps times measured seconds per step. Then set spec.maxCostUSD: when the run reaches the cap it is suspended, not failed, and raising the cap resumes it from its checkpoint. Training runs are checkpointed, and a lost machine resumes from the latest checkpoint, so a long pretraining run does not restart at zero.

FAQ

Can I train my own LLM on a single consumer GPU?

You can fine-tune on one, but not pretrain a useful model. QLoRA stores the base in 4 bits, so an 8B model’s weights take about 4 GB, and the QLoRA paper fine-tuned a 65B model on one 48 GB GPU. Nodus lists the 24 GB RTX 4090 at $0.29/hr on its pricing page.

Does fine-tuning add new knowledge to a model?

Not reliably. In a 2023 comparison of knowledge injection, retrieval beat unsupervised fine-tuning for both facts seen in training and new ones. Use fine-tuning for behavior and retrieval for facts that change.

How do I know if my trained model is actually better?

Compare it with the untouched base model on the same held-out tasks you set aside before training. On Nodus, set data.validationFraction to pick the checkpoint with the lowest validation loss, then judge quality on a separate test set, as the training guide advises.

Is training on Nodus generally available?

TrainingJobs are in Beta, and multi-node training is also in Beta, so fields may still change. Each change is announced in the changelog with a migration note.

Tags:

• gpu
• training
• pretraining
• fine-tuning
• llm

Can OpenAI Codex run GPU jobs, and how do you set it up?

How do you evaluate an LLM for multilingual customer support?