Back to blog

    Ertas Builder Plan ($20/mo): Who It's For, What You Get, Honest Review

    An honest breakdown of the Ertas Builder plan. What's included, who it's right for, when to upgrade, and how the pricing compares to the API costs it replaces.

    A pale astronomical impression in graphite and copper, with a soft amber penumbra on warm paper.A flowing heliospheric ribbon in copper and ivory with a soft vermilion flare.

    The Ertas Builder plan is $20 per month. This is a detailed breakdown of what that gets you, who it is right for, when it is not enough, and how the math works against the API costs it typically replaces.

    No spin. If Builder is not the right plan for your situation, this review says so.

    What's Included in Builder

    2,000 credits per month. US$1 buys 100 credits on every plan, so Builder's $20 comes back as $20 of credits each month. Credits pay for training runs and for API usage. Training on Builder runs on A10G GPUs at about 4 credits a minute. A typical fine-tuning run on a 7B model with 500-1,000 training examples costs about 240-450 credits. With 2,000 credits, you can realistically run 4-8 training jobs per month, enough for regular experimentation, iterative improvement, or maintaining 2-3 active projects with monthly retraining. Unused credits last 12 months from when you get them.

    Full model export. Turn on "Export full model" in Training Config and the run hands back a merged 16-bit safetensors checkpoint, not just the LoRA adapter. This is the single biggest jump from Free, where you get the adapter and have to merge it against the base model yourself before it is usable anywhere. The full checkpoint drops straight into a serving stack, and it leaves quantisation decisions to you rather than baking Q4_K_M in.

    Continue training from your own models. The full checkpoint is also what you train again. Pick a model you already trained as the base for the next run via "Continue from your models" instead of starting from the base model every time. When a run gets the tone right but the model still rambles, you build on that run rather than throwing it away and paying for a from-scratch retrain.

    Models up to 14B parameters on A10G GPUs. Free trains models under 5B on T4 GPUs. Builder unlocks 14B models (Qwen 2.5 14B, Llama 3.1 14B, etc.). For most narrow-task applications, 7B is sufficient. 14B becomes relevant when you need better reasoning or multilingual capability while still running locally on a mid-range VPS.

    50 GB model storage, 2 GB dataset storage. Covers your exported GGUF files and the datasets you upload. A fine-tuned 7B GGUF (Q4 quantized) is approximately 4-5 GB. 50 GB comfortably stores 8-10 exported models, and 2 GB holds the datasets that produced them.

    Data Craft and Prompt Studio. Prompt Studio builds a generation prompt from your own context, which you run in the AI tool you already pay for and import back as JSONL. Useful when you have limited real-world data.

    Three inference samples on every run. When a run finishes, Studio puts a small fixed set of prompts through the fresh model so you can see it produces coherent, on-format text before downloading anything. Grading it properly means running your own probe set against the exported model, which the Verifying exports guide covers. A built-in evaluation suite is on the roadmap.

    Deploying your trained models on the Ertas API is coming soon on paid plans, Builder included. Exporting and running the model yourself works today.

    The Credit System In Practice

    Model SizeDataset SizeApprox Credits Per Run
    7B model200-500 examples150-240 credits
    7B model500-1,500 examples240-360 credits
    7B model1,500-3,000 examples360-540 credits
    14B model200-500 examples240-450 credits
    14B model500-1,500 examples450-750 credits

    At about 4 credits a minute on A10G, 150 credits is roughly 40 minutes of training and 750 credits roughly three hours. The Training Confirm dialog shows the estimate for your run before you press play.

    At 2,000 credits per month, you can run roughly 3-13 training jobs on a 7B model (2,000 ÷ 540 ≈ 3.7, 2,000 ÷ 150 ≈ 13), or 2-8 on a 14B model (2,000 ÷ 750 ≈ 2.7, 2,000 ÷ 240 ≈ 8). For a typical indie developer running one fine-tuned model with monthly retraining, that is substantial headroom. A heavy month can be topped up at US$1 per 100 credits.

    Who Builder Is Right For

    Indie developer replacing an OpenAI API bill. You have a SaaS app currently spending $80-400/month on API calls. You want to fine-tune a model on your domain, export GGUF, run locally. Builder + a $26/month VPS replaces that bill at $46/month total, and the savings grow with usage since your inference cost is now zero.

    Solo builder with 1-3 active projects. You are experimenting with fine-tuning for different use cases, running training experiments every 1-2 weeks, maintaining 2-3 active models. Builder's 2,000 credits per month fits this pattern.

    Non-technical founder adding AI features. You do not have ML engineers. Ertas's visual interface lets you fine-tune without code. Builder unlocks the credit budget and the model sizes you need to do this seriously, not just once.

    Someone validating a fine-tuning use case. You are not sure yet if fine-tuning is right for your application. Builder lets you run multiple experiments, compare results, and evaluate quality before committing to infrastructure investment.

    Use Case: Indie Developer Replacing OpenAI API

    Here is the math for a concrete scenario.

    The situation: You built a writing assistant app using the OpenAI API. At 800 users, you are spending $130/month on API costs (roughly 2M tokens/month). You expect to reach 3,000 users in 6 months, at which point the API bill will be $480/month.

    The migration:

    • Month 1: Export 600 input/output pairs from your OpenAI API logs as JSONL. Upload to Ertas, fine-tune Qwen 2.5 7B. About 240 credits used.
    • Month 2: Test the fine-tuned model against your test set. Quality matches GPT-3.5, close to GPT-4 for your specific task. Deploy on a VPS budgeted at $26/month.
    • Month 3: Switch API endpoint in your app from OpenAI to local Ollama. Cancel (or reduce) OpenAI subscription.

    The economics:

    Before (OpenAI API)After (Builder + VPS)
    AI costs at 800 users$130/month$46/month ($20 + $26)
    AI costs at 3,000 users$480/month$46/month
    AI costs at 10,000 users$1,600/month$61.50/month ($20 + a $41.50 larger VPS)
    Break-even-~1.5 months

    The monthly savings at 3,000 users: $480 - $46 = $434. At 10,000 users: $1,600 - $61.50 = $1,538.50. Builder pays for itself in the first month.

    When Builder Is Not Enough

    You are retraining several client models every month. If you are doing agency work and managing models for multiple clients simultaneously, you need the Pro plan ($100/month, 10,000 credits, A100 GPUs, 100 GB of model storage).

    You need models larger than 14B. 14B covers most production fine-tuning use cases. If you are working with larger models, Pro and Business train on A100 GPUs, and Enterprise is priced to your volumes and infrastructure.

    You are deleting models to make room. Builder gives you 50 GB of model artifact storage and 2 GB for datasets. If you are removing exports you still want in order to free space for the next run, Pro takes those to 100 GB and 5 GB.

    You have more than 2,000 credits of monthly training needs. If you are running many experiments or maintaining many models that need frequent retraining, Builder's credits may run short. Pay-as-you-go credits at US$1 per 100 cover the occasional heavy month. Track your usage in the first month to assess.

    You are waiting on the GPU queue. Builder and Pro share the standard queue. If queue time is costing you delivery time, Business ($200/month) adds priority in the GPU queue.

    Free vs Builder: Is the Upgrade Worth It?

    FeatureFreeBuilder ($20/mo)
    Credits150 once, after card verification2,000 a month
    Max model sizeUnder 5BUp to 14B
    GPU tierT4A10G
    Model storage5 GB50 GB
    Dataset storage250 MB2 GB
    Full model exportNoYes
    Pay-as-you-go top-upsUS$1 per 100 creditsUS$1 per 100 credits

    Free is genuinely useful for learning fine-tuning and testing the workflow. Verify a card (a hold of up to US$1, which is released) and you get 150 credits once. On a T4 at about 1.5 credits a minute, that is roughly 100 minutes of training, or two or three small runs, and the same credits can go on the API instead.

    The wall most people hit on Free is the hardware rather than the balance, because you can top up Free at US$1 per 100 credits. Free trains models under 5B on T4 GPUs, so a 14B model is out of reach however many credits you buy.

    Builder adds 2,000 credits every month and A10G GPUs. That combination is what makes 14B models and longer training runs possible at all, rather than just faster. It is the right tier once you are training often enough that a monthly allowance beats topping up, or you want the larger 50 GB model and 2 GB dataset allowances to keep several models around at once.

    Predictable Monthly Pricing

    Builder is $20/month for 2,000 credits.

    • Credits from your plan and from top-ups last 12 months from when you get them, and the oldest are used first.
    • Unused credits carry forward inside that 12 months, so a quiet month leaves budget for a busy one.
    • If you cancel, the credits you hold stay usable until they expire, and your account moves to Free.

    You pay monthly and can cancel anytime.

    How to Know You Are Ready for Builder

    You are ready for Builder if:

    • You have a specific use case in mind (not "I want to try fine-tuning")
    • You have or can generate 300+ training examples in JSONL format
    • You are currently spending more than $40/month on API calls for a narrow task
    • You have a VPS or are willing to spin one up for local inference

    If you are not yet at this stage, use the Free tier until you are, and top it up at US$1 per 100 credits if you only need a few more small runs. Builder is for when you have a real problem to solve and you are solving it often.


    Further Reading