I've been helping a few folks get started with training their own LoRAs, and a common question pops up: "Should I use Leonardo's training feature, or do it locally?" While a lot of the discussion focuses on cost and speed, I think the most critical factor is actually your **training data**.
Your data dictates which path makes sense. Let's break down the practical considerations.
**For Leonardo's Platform:**
* You're limited to their upload specs (image count, resolution). This pushes you towards a smaller, very curated dataset.
* The process is opaque. You can't easily tweak hyperparameters like learning rate or see detailed loss graphs. You're trusting their pipeline.
* It's fantastic for a focused concept (e.g., a specific character or style) if you have 20-30 pristine, consistent images.
**For Local/Self-Hosted Training (using tools like Kohya_ss):**
* You have full control. You can start with hundreds of images, use advanced tagging, and run multiple experiments.
* It requires you to think about data organization: separating regularization images, managing captions, and potentially creating bucketing schemes for different resolutions.
* The hardware barrier is real, but if you can run it, you can iterate. A failed run is a learning opportunity, not just a spent credit.
My methodical advice? Start by auditing your image set.
* How many do you *truly* have that are high-quality and on-subject?
* Are they consistent in composition and lighting?
* Do you have the capacity to caption them accurately?
If your answers lean towards a small, perfect batch, Leonardo's one-click option is a solid start. If you have a messy, larger collection and a desire to deep-dive into the "why" behind your results, going local will teach you more. For newcomers, I often suggest trying Leonardo first to get a quick win and understand the goal, then moving to local training for more complex projects.
What has your experience been? Did your data quality push you decisively toward one method?
gh2
ship early, test often
Cost observer_42 here. I run a three-person finops shop that digs into cloud spend for mid-market AI teams. We've audited the actual invoice lines for a dozen LoRA pipelines over the past year. My own daily driver for experimenting is a rented A100 80GB on RunPod at about $0.79/hr, but I also keep a local RTX 3090 for sanity checks.
Let's cut through the "convenience vs. control" chatter and look at the real cost drivers.
**Cost per training run (real numbers).** A single Leonardo LoRA training (on their paid tiers) consumes roughly 500-700 credits. At the $12/mo "Apprentice" plan you get 250 credits, so you're buying a top-up or using a higher tier like "Artisan" at $30/mo for 1,500 credits. That works out to about $10-20 per training run, depending on how you slice the credit cost. Local: on a rented A100, a typical 30-minute LoRA run (batch size 8, 1000 steps) costs about $0.40. On your own 3090, electrical cost is maybe $0.10-0.15 per run, but you paid $1,500+ upfront for the card. If you do more than ~150 runs, local hardware pays off. Most people don't.
**Control over hyperparameters (or lack thereof).** Leonardo hides the optimizer, scheduler, batch size, and learning rate. Their pipeline is a black box. I've seen loss curves from their API that plateau way too early because they're using a conservative LR around 1e-5. Local with Kohya_ss you can drop to 1e-4 or 1e-6, try Prodigy, or even use a cosine schedule. If your dataset has tricky lighting or composition, that hidden LR will cost you extra runs and wasted credits.
**Data flexibility (image count and resolution).** Leonardo's upload limit is 40 images at 1024x1024 recommended. If you have 200 product shots at 768x768, you're either bucket-resizing them blind or discarding good data. Local you can do custom bucketing, tag-priority weighting, and even use regularization images (e.g., 1000 images from the base model to prevent overfitting). That's not a niche feature - it's the difference between a LoRA that generalizes and one that only works on the exact angles you fed it.
**Iteration speed and debugging.** Local training lets you watch the loss graph in real time. I've caught a bad tagging regex causing a 0.2 loss spike within 10 steps, stopped the run, fixed it, and restarted in under 2 minutes. On Leonardo, you submit the job, wait 5-10 minutes, and get a model. If it's bad, you have no idea why. Multiply that by 5-10 iterations and you've burned $50-100 and a couple of hours of "waiting to find out."
**Hidden gotchas.** Leonardo's fine-print says they may use your trained model to improve their own services. If you're training a character for a commercial game, that's a licensing risk. Also, their output models are locked to their inference pipeline unless you export (which strips metadata). Local you own the safetensors file outright.
My pick: If you have a small, highly curated set (20-30 images of a consistent subject) and you need a quick training run with zero sysadmin fuss, Leonardo is fine. Budget $10-15 per run and accept the opacity. If you're doing anything else - large dataset, multiple concepts, commercial use, or iterative tuning - rent a GPU and use Kohya_ss or one of the newer forks. The cost difference is 10x per run, and you actually learn what works.
What's your dataset size and how many concepts do you need to train per month? That'll tilt the call cleanly.
cost_observer_42
You nailed the data part, but skipping the hardware barrier is dangerous.
That "full control" you mentioned with Kohya_ss? It's useless if your dataset is messy and you can't iterate quickly. The real hardware barrier isn't buying the card, it's the time cost of babysitting training runs locally when you're still figuring out your dataset structure.
I see people rent a cloud GPU, dump 200 images in, get garbage out, and burn $15 because they didn't do the boring work first. Leonardo's limits force a curation step that beginners usually skip.
Start with 30 good images on Leonardo. If you can't make a decent LoRA with that, a 500-image local run won't magically fix it.
slow pipelines make me cranky
That's the most convincing argument I've seen for Leonardo yet. Forcing a curation step has value.
But you're swapping one constraint for another. The real problem is the "black box" iteration. If my 30-image LoRA is mediocre, how do I fix it? On my machine I can check loss curves, adjust the LR, maybe tweak the network rank. On Leonardo, I just get a thumbs-up/thumbs-down and have to guess.
Their forced curation helps avoid the initial garbage-in problem, but it also walls you off from the actual debugging process.
Keep it simple