Originally published on

Model Routing Cost Checklist: Hosted APIs, Open Models, Or Self-Hosted Inference?

The model question founders ask is usually too broad: "Should we use hosted APIs or self-host?"

The better question is narrower: "Which workload deserves which model path?"

A support summarizer, a code-review assistant, a legal document extractor, and an internal analytics agent do not need the same latency, privacy posture, context window, or reasoning depth. If you route them all to the same premium model, you are buying simplicity at the exact point where usage starts compounding.

This is the checklist we use before a team commits to one AI vendor or one self-hosting plan.

Start With Workload Classes

Split requests into classes before comparing prices:

This one table prevents the common mistake: using a premium interactive model for every background job.

Cost Is More Than Token Price

Token price matters, but it is not the full bill. Add:

• Retry rate from malformed outputs


• Prompt bloat from untrimmed context


• Vector search and storage cost


• Human review time


• Latency impact on conversion


• Engineering time to run open models


• GPU idle time if self-hosted


• Incident cost if the route leaks sensitive data

For one client, the cheapest model on paper became expensive because it failed JSON formatting often enough that the app retried the same request twice. A slightly better model cut retries and won on total cost.

Use A Routing Ledger

Every production AI workload should have a small ledger:

workload: support_ticket_summary

data_class: customer_pii

latency_target_ms: 2500

monthly_requests: 180000

avg_input_tokens: 1800

avg_output_tokens: 220

review_required: false

default_route: hosted_mid_tier

fallback_route: hosted_premium

blocked_route: public_free_tier

owner: support-platform

This forces a decision. It also gives finance and engineering the same vocabulary.

When Hosted APIs Win

Hosted APIs usually win when:

• Usage is volatile


• Quality requirements change weekly


• You need frontier reasoning


• You cannot staff GPU operations


• Latency is acceptable over the network


• Vendor data controls satisfy your customer contracts

For seed and Series A teams, this is often the right starting point. The trap is never revisiting the route after usage grows.

When Open Models Win

Open models can win when:

• The task is repetitive and bounded


• Data locality matters


• You can batch work


• You have stable throughput


• A smaller model is good enough


• The team can own evaluation and deployment

The key phrase is "good enough." Do not self-host because it feels independent. Self-host because the workload is stable enough for the operating burden to pay back.

When Hybrid Routing Wins

Most serious teams end up hybrid. Cheap route first. Premium route on low confidence. Private route for sensitive classes. Batch route for nightly jobs.

A simple policy:

if data_class in ["finance", "customer_pii"]:

    route = "private_controlled"

elif confidence_required > 0.95:

    route = "premium_hosted"

elif batch_job:

    route = "low_cost_batch"

else:

    route = "mid_tier_hosted"

The routing policy should live in code, not in a spreadsheet. The spreadsheet is for review; the application needs deterministic behavior.

The Practical Takeaway

Do not make AI infrastructure a binary hosted-versus-self-hosted argument. Treat it like traffic routing.

Classify the workload. Price the full path. Define allowed and blocked routes. Review the ledger monthly. Then move only the stable, high-volume, privacy-sensitive workloads to a more controlled path.

TechSaaS helps startups build model-routing ledgers, cost reviews, and production AI infrastructure without turning it into a research project: techsaas.cloud/contact