DEV Community: chnby

How I Cut My LLM API Bill by 80% With a Simple Router

chnby — Mon, 22 Jun 2026 15:41:21 +0000

No fancy infrastructure. Just a 50-line Python function that picks the right model for the right query.

Last month my LLM API bill hit $340. This month: $67.

Same traffic. Same product. The only change was adding a simple router that stops sending every request to Claude Sonnet when GPT-4o mini can handle it just as well.

Here's exactly how it works.

The Problem
When you prototype, you pick one model and hardcode it everywhere. Usually something capable like GPT-4o or Claude Sonnet, because you want good results fast.

Then you ship, traffic grows, and you get a bill that makes you question your life choices.

The thing is — not all queries need a flagship model. In a typical RAG app:

"What is the return policy?" → GPT-4o mini handles this fine
"Summarize these 5 conflicting documents and identify the key disagreement" → needs Sonnet
You're paying Sonnet prices for return policy questions. That's the bug.

The Fix: A Complexity Router

import anthropic
from openai import OpenAI

openai_client = OpenAI()
anthropic_client = anthropic.Anthropic()

def classify_complexity(query: str) -> str:
"""Returns 'simple' or 'complex'."""
simple_indicators = [
len(query.split()) < 15,
query.endswith("?") and query.count("?") == 1,
not any(w in query.lower() for w in [
"compare", "analyze", "summarize", "explain why",
"difference between", "pros and cons", "evaluate"
])
]
return "simple" if sum(simple_indicators) >= 2 else "complex"

def route(query: str, context: str = "") -> str:
complexity = classify_complexity(query)

if complexity == "simple":
    # $0.15/M input — GPT-4o mini
    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": context},
            {"role": "user", "content": query}
        ]
    )
    return response.choices[0].message.content
else:
    # $3.00/M input — Claude Sonnet (only when needed)
    response = anthropic_client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=context,
        messages=[{"role": "user", "content": query}]
    )
    return response.content[0].text

Adding a Cache Layer
The router alone saved me ~50%. The cache pushed it to 80%.

import hashlib
import json
from functools import lru_cache

In production: use Redis. For prototyping: this works fine.

_cache: dict = {}

def get_cache_key(query: str, context: str) -> str:
payload = json.dumps({"q": query, "c": context}, sort_keys=True)
return hashlib.sha256(payload.encode()).hexdigest()

def route_cached(query: str, context: str = "") -> str:
key = get_cache_key(query, context)

if key in _cache:
    return _cache[key]  # free

result = route(query, context)
_cache[key] = result
return result

Turns out ~30% of queries in my app were near-identical. "What are your hours?" gets asked constantly. Paying for the same LLM call 200 times/day is just burning money.

Logging Costs in Real Time
You can't optimize what you don't measure. I added cost tracking so I know exactly what each call costs:

COST_PER_1K_TOKENS = {
"gpt-4o-mini": {"input": 0.000150, "output": 0.000600},
"claude-sonnet-4-6": {"input": 0.003000, "output": 0.015000},
}

def calculate_cost(model: str, input_tokens: int, output_tokens: int) -> float:
rates = COST_PER_1K_TOKENS.get(model, {"input": 0, "output": 0})
return (input_tokens * rates["input"] + output_tokens * rates["output"]) / 1000

def route_with_logging(query: str, context: str = "") -> dict:
complexity = classify_complexity(query)
model = "gpt-4o-mini" if complexity == "simple" else "claude-sonnet-4-6"

if complexity == "simple":
    response = openai_client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": context},
            {"role": "user", "content": query}
        ]
    )
    content = response.choices[0].message.content
    usage = response.usage
else:
    response = anthropic_client.messages.create(
        model=model,
        max_tokens=1024,
        system=context,
        messages=[{"role": "user", "content": query}]
    )
    content = response.content[0].text
    usage = response.usage

cost = calculate_cost(model, usage.input_tokens, usage.output_tokens)

print(f"[{model}] {complexity} | ${cost:.5f} | {query[:50]}...")

return {"content": content, "cost": cost, "model": model}

Sample output:

[gpt-4o-mini] simple | $0.00008 | What are your business hours?...
[claude-sonnet-4-6] complex | $0.00340 | Compare the refund policies across...
[gpt-4o-mini] simple | $0.00006 | How do I reset my password?...
Results After 30 Days
Metric Before After
Avg cost per query $0.0034 $0.0007
% queries → mini model 0% 73%
Cache hit rate 0% 31%
Monthly bill $340 $67
Answer quality complaints 2 3
The quality delta was negligible. Three users in a month said an answer felt shallow — all three were simple factual queries that I probably should have cached anyway.

When This Doesn't Work
Be honest about the limits:

Creative writing / long-form content — mini models struggle here, don't route these down
Multi-document synthesis — always route to the capable model
Anything with high stakes (medical, legal, financial) — don't optimize cost here, use the best model
The classify_complexity function above is naive on purpose. You know your query patterns better than I do. Tune the keywords list to your domain.

Next Step
Before you do any of this, model your current costs to know where the money is actually going. I used APICalculators LLM cost calculator — free, no signup, shows cost per model at your actual token volumes. Knowing the delta between models makes it obvious which optimization to prioritize.

Questions or a different routing approach that worked for you? Drop it in the comments.

How I Got a $340 AWS Bill from a Side Project (And What I Built to Prevent It)

chnby — Fri, 19 Jun 2026 15:37:59 +0000

The invoice arrived on a Tuesday morning.

$340. For a side project I'd built in a weekend. A small LLM-powered summarization tool — users paste text, model returns a summary. I'd done the math before launching: roughly $0.002 per request, ~500 requests/day, around $30/month. Totally fine.

What I hadn't accounted for:

system_prompt_tokens = 800
requests_per_day = 2000 # not 500 — it went viral in a group chat
input_price_per_1M = 2.50 # GPT-4o

daily_cost = (800 * 2000 / 1_000_000) * 2.50

= $4.00/day → $120/month just from system prompts

Plus the actual user input tokens. Plus output tokens. $340 later, I had learned my lesson.

The Real Problem: API Pricing Is Designed to Be Hard to Compare
Every provider uses different units:

OpenAI → per million tokens (input vs output, different rates)
Pinecone → read units + write units + storage GB/month
Stripe → % of transaction + fixed fee + monthly platform fee
AWS Lambda → per GB-second + per request + data transfer
None of it is comparable at a glance. You end up either building a spreadsheet from scratch every time or just guessing — and guessing gets expensive.

What I Built
After the invoice incident I started keeping a cost estimation spreadsheet. It grew. Eventually I turned it into APICalculators.com — 16 free, browser-based calculators covering the infrastructure decisions most AI/SaaS developers face:

LLM APIs

GPT-4o, Claude Sonnet, Gemini Flash, Llama — cost by model, context length, daily volume
Side-by-side comparison at your exact usage
Vector Databases

Pinecone vs Qdrant vs Supabase vs Weaviate
Enter index size + queries/day → monthly cost
Serverless

AWS Lambda vs Cloudflare Workers vs Vercel Functions
Cost at your invocation volume and memory config
Auth Providers

Clerk vs Auth0 vs Supabase Auth vs Cognito
Monthly cost by MAU tier
Payment Processors

Stripe vs Paddle vs Lemon Squeezy
Real fee comparison on your transaction volume
The System Prompt Problem, Solved in 30 Seconds
Here's what the LLM cost calculator would have shown me before I shipped:

Model: GPT-4o
System prompt: 800 tokens
Avg user input: 200 tokens

Avg output: 150 tokens
Requests/day: 2,000

→ Input cost: (800+200) × 2,000 / 1M × $2.50 = $5.00/day
→ Output cost: 150 × 2,000 / 1M × $10.00 = $3.00/day
→ Monthly: $240

vs my estimate of $30. 8x off.
The fix was obvious once I saw it: cache the system prompt, shorten it, switch to a cheaper model for summarization. Cut the cost by 70%.

Everything Runs in Your Browser
No signup. No data sent anywhere. All calculations happen client-side — your usage numbers never leave your machine.

If you're building anything that touches LLM APIs, vector databases, or cloud infrastructure, check your numbers before you ship.

Surprise invoices are optional.

What's the most unexpected cloud bill you've received? Drop it in the comments.

I Calculated the Exact Cost of Running an AI SaaS at 1K, 10K, and 100K Users

chnby — Wed, 17 Jun 2026 15:17:33 +0000

Everyone asks "how much does it cost to build an AI SaaS?" and gets vague answers like "it depends." So I built calculators for every layer of the stack and actually ran the numbers at three scales.
Here's the full breakdown for a typical AI SaaS — think a document Q&A tool, a customer support copilot, or an AI writing assistant.
The Stack
Every AI SaaS has roughly the same infrastructure layers:

LLM API — the brain (GPT-5.4, Claude Sonnet, Gemini Flash)
Vector Database — long-term memory (Pinecone, Qdrant, pgvector)
Hosting — where it runs (Hetzner, AWS, Vercel)
Auth — who can log in (Supabase Auth, Clerk, Auth0)
Payments — how you get paid (Stripe, Paddle, Lemon Squeezy)
Serverless — background jobs, webhooks, cron (Lambda, Cloudflare Workers)

Most cost guides only talk about the LLM layer. But I've seen startups where auth costs more than their AI budget, and others where the vector database quietly became their biggest line item.
Scale 1: Startup — 1,000 Users
Your first paying customers. Maybe $5K-10K MRR. You're optimizing for speed, not cost.
LayerCheap OptionCostPremium OptionCostLLM APIGPT-5.4 nano$15/moClaude Sonnet 4.6$180/moVector DBQdrant self-hosted$7/moPinecone Serverless$22/moHostingHetzner CAX21$6/moAWS t3.small$30/moAuthSupabase Auth$0/moClerk$0/mo (free tier)PaymentsStripe2.9%Paddle5%ServerlessCloudflare Workers$0/moAWS Lambda$0/mo
Cheapest viable stack: ~$28/month
Premium stack: ~$232/month
At 1K users, most services are within free tiers. The LLM API is your only real variable cost. If your users make 50 queries/day average with GPT-5.4 nano, that's ~$15/month. With Sonnet, it's ~$180.
The 12x difference between nano and Sonnet sounds scary, but here's the thing: for most tasks (classification, extraction, simple Q&A), nano is good enough. Save Sonnet for the complex reasoning chains.
Scale 2: Growth — 10,000 Users
Things get interesting here. Free tiers end, costs become real, and bad architecture decisions start hurting.
LayerCheap OptionCostPremium OptionCostLLM APIGPT-5.4 nano$150/moClaude Sonnet 4.6$1,800/moVector DBQdrant self-hosted$36/moPinecone$210/moHostingHetzner$17/moAWS$120/moAuthSupabase Auth$25/moClerk$275/moPaymentsStripe~$290/moPaddle~$500/moServerlessCF Workers$5/moLambda$45/mo
Cheapest viable: ~$523/month
Premium: ~$2,950/month
This is where auth pricing becomes a trap. Clerk at 10K users is $275/month. At 1K it was free. That's the steepest curve in the entire stack. If you started on Clerk's free tier thinking "I'll worry about cost later," later just arrived.
The LLM cost at this scale depends entirely on your caching strategy. If you're re-computing embeddings or re-running the same prompts, you're burning money. A Redis cache in front of your LLM calls can cut costs 30-50%.
Scale 3: Scaling — 100,000 Users
This is where architecture choices made at 1K users either pay off or blow up.
LayerCheap OptionCostPremium OptionCostLLM APIGPT-5.4 nano$1,500/moClaude Sonnet 4.6$18,000/moVector DBQdrant self-hosted$480/moPinecone$1,900/moHostingHetzner cluster$120/moAWS$800/moAuthSupabase Auth$25/moClerk$1,825/moPaymentsStripe~$2,900/moPaddle~$5,000/moServerlessCF Workers$25/moLambda$300/mo
Cheapest viable: ~$5,050/month
Premium: ~$27,825/month
The difference between cheap and premium is now $22,775/month — that's $273K/year. At this scale, every architecture decision has a five or six figure annual impact.
The wildest number: auth. Supabase Auth at 100K MAU is $25/month. Clerk is $1,825. Auth0 would be $5,000+. That's a 73x difference for the same core feature: letting people log in.
What I Learned Building These Calculators

LLM costs are overestimated. Everyone worries about the AI bill, but at startup scale it's usually the smallest line item. A well-architected app with caching and nano-class models runs for $15-50/month at 1K users.
Auth costs are underestimated. Clerk and Auth0 have aggressive pricing curves that feel invisible at small scale and devastating at medium scale. Check the pricing page before you npm install.
Self-hosting saves 70-80% on vector databases. Qdrant on a Hetzner box vs Pinecone managed: the performance is identical, the cost is 5-10x less. The trade-off is operational overhead, which is real but manageable if you know Docker.
Payment processor choice is permanent. Migrating from Stripe to Paddle means re-integrating billing for every customer. Choose once, choose carefully. The Stripe vs Paddle decision isn't about 2.9% vs 5% — it's about whether you want to handle global tax compliance yourself.
Serverless is effectively free at startup scale. Cloudflare Workers gives you 10M requests/month free. Lambda gives you 1M. Don't spin up dedicated servers for background jobs until you actually need to. Run Your Own Numbers Every SaaS has different usage patterns. I built free calculators for each layer:

LLM API Cost Calculator
Vector Database Cost Calculator
Cloud VPS Comparison
Auth Provider Cost Calculator
Payment Processor Fees
Serverless Cost Calculator

No signup, runs in your browser, open source pricing data updated monthly.

What does your AI SaaS stack look like, and what's your biggest cost surprise been? I'm especially curious about anyone running at 50K+ users — does the math hold up?

I Moved Everything to a $4.50 Hetzner Box. Here's What Broke and What Didn't.

chnby — Tue, 16 Jun 2026 15:55:03 +0000

Last year my side project was running on AWS. A t3.small EC2 instance, an RDS PostgreSQL db.t3.micro, an S3 bucket, and a CloudFront distribution. Total bill: $47/month for an app with 200 daily users.
Then someone on Reddit told me to look at Hetzner. I now run the same stack on a single CAX21 (4 vCPU ARM, 8GB RAM, 80GB SSD) for €5.49/month.
Here's exactly what happened.
The Migration
What I was running on AWS:

Node.js API (Express)
PostgreSQL database
Redis for sessions
Nginx reverse proxy
Static files on S3 + CloudFront

What I moved to Hetzner:

Same Node.js API
PostgreSQL installed directly on the server
Redis installed directly on the server
Nginx + Certbot for SSL
Static files served by Nginx

Total migration time: one Saturday afternoon. The hardest part was setting up automated backups (solved with a cron job + Hetzner's snapshot API).
What Broke
Nothing critical, but:

No managed database failover. On RDS, if the database crashes, AWS restarts it automatically. On Hetzner, if PostgreSQL crashes at 3 AM, I'm the one fixing it. In 8 months, this has happened zero times. But it could.
No CDN by default. My static assets now serve from a single Hetzner datacenter in Germany. For my EU-heavy userbase, this is actually faster than CloudFront. For US users, it's about 50ms slower. I added Cloudflare (free tier) in front and the problem disappeared.
Deployment changed. No more eb deploy or push-to-deploy. I wrote a 12-line bash script that SSHs in, pulls from git, runs migrations, and restarts PM2. Takes 8 seconds. Honestly prefer it — I know exactly what's happening.

The Cost Comparison at Every Scale
This is what surprised me most. The gap isn't just at my small scale — it gets wider as you grow:
SpecAWSDigitalOceanVultrHetzner2 vCPU, 4GB$30/mo$24/mo$24/mo€4.50/mo4 vCPU, 8GB$61/mo$48/mo$48/mo€8.50/mo8 vCPU, 16GB$122/mo$96/mo$96/mo€16/mo
Hetzner is roughly 5-7x cheaper than AWS at every tier. DigitalOcean and Vultr sit in the middle.
👉 Calculate your exact costs
When NOT to Use Hetzner
I want to be fair. Hetzner is not the right choice for everyone:
Stay on AWS/GCP if:

You need 20+ managed services talking to each other (Lambda, SQS, DynamoDB, Step Functions). The ecosystem lock-in is real but so is the productivity.
Your company requires SOC2/HIPAA compliance with vendor support. Hetzner doesn't offer compliance certifications.
You need presence in Asia-Pacific or South America. Hetzner only has EU and US-East datacenters.
Your traffic is extremely spiky (0 to 100K requests in seconds). Auto-scaling on Hetzner means you built it yourself.

Use Hetzner if:

Your workload is predictable
You're comfortable with basic Linux administration
You're a solo founder or small team where $40/month saved = $480/year
You want raw performance per dollar (Hetzner's ARM boxes are incredibly fast)

The "But What About Reliability" Question
In 8 months on Hetzner: zero unplanned downtime. Their status page history is cleaner than most hyperscalers. The Nuremberg and Helsinki datacenters are enterprise-grade.
That said, I added simple safeguards:

Daily automated snapshots (€0.01/GB/month)
Health check with UptimeRobot (free)
Database backup to Backblaze B2 ($0.005/GB)

Total backup cost: ~$1.50/month. Peace of mind: priceless (or at least very cheap).
My Annual Savings
Before (AWS)After (Hetzner)Compute$30/mo€5.49/moDatabase$15/mo$0 (self-hosted)Storage/CDN$2/mo$0 (Cloudflare free)Total$47/mo ($564/yr)~$8/mo ($96/yr)
Annual savings: $468. For a side project, that's meaningful. Multiply it across 3-4 projects and you're saving $1,500-2,000 a year.

What's your hosting setup and monthly bill? I'm curious how other developers balance cost vs convenience. Built a comparison tool if you want to run your own numbers: Cloud VPS Cost Calculator

I Pay $200/mo for AI Coding Tools. Here's What Actually Saves Me Time vs What's a Waste.

chnby — Mon, 15 Jun 2026 15:37:12 +0000

I've been using AI coding tools daily for over a year now. At one point I was paying for Copilot, Cursor, and Claude Code simultaneously. My monthly bill hit $200 before I realized I was using one of them for 90% of my work.
Here's my honest breakdown after 12 months.
What I Actually Use
Claude Code ($20/mo with Pro, or API usage) — This became my daily driver. I run it from the terminal and it handles the tasks I used to waste hours on: refactoring across multiple files, writing tests, debugging deployment configs, reading codebases I didn't write. The key difference is it works with your actual file system, not just the file you have open.
Cursor ($20/mo) — Great for in-editor work. Autocomplete is fast, tab-complete feels natural. I use it when I'm writing new code from scratch and want the IDE experience. But for anything touching more than 2-3 files, I switch to Claude Code.
GitHub Copilot ($19/mo) — I cancelled this. Not because it's bad, but because Cursor does everything Copilot does plus more. The inline chat, the multi-file context, the ability to reference docs — Cursor just does it better for the same price.
The Real Cost Breakdown
Here's where it gets interesting. The subscription price isn't the full picture:
ToolMonthly CostWhat You GetHidden CostsGitHub Copilot$19/moAutocomplete + chat in VS CodeNone — flat rateCursor Pro$20/mo500 fast requests, unlimited slowAPI costs if you exceed fast requestsClaude Code$20/mo (Pro)Terminal agent, multi-file editsHeavy usage burns through limits fastWindsurf$15/moSimilar to Cursor, cheaperFewer model optionsCody (Sourcegraph)FreeGood for large codebasesLimited model selection
But the real cost is API usage if you're a power user. I hit Cursor's 500 fast request limit by day 12 last month. After that, you're either on slow mode (painful) or paying API rates.
Claude Code on the API is where costs can spike. My heaviest month was $340 in API costs because I was letting it run complex multi-file refactors on a large codebase. Each "subagent" it spawns runs its own API calls.
What Actually Saves Time (and What Doesn't)
Worth every penny:

Generating tests. Writing unit tests for existing code used to take me 2-3 hours per module. Now it's 15 minutes. This alone justifies the subscription.
Debugging error messages. Paste the stack trace, get the fix. Saves 20-30 minutes per bug.
Boilerplate code. API endpoints, database schemas, config files — anything repetitive.
Code review. "Review this PR for security issues" catches things I'd miss.

Not worth the hype:

Writing complex business logic from scratch. The AI gets the structure right but the edge cases wrong. You spend more time fixing than you saved.
"Vibe coding" entire features. Fun for prototypes, terrible for production code. You end up with code you don't understand.
Architecture decisions. AI will confidently suggest patterns that don't fit your constraints.

My Current Setup (Optimized for Cost)
I settled on Cursor Pro ($20/mo) + Claude Code on API (variable):

Cursor for daily in-editor coding, autocomplete, quick questions
Claude Code for heavy lifting: multi-file refactors, codebase analysis, deployment tasks
Total: ~$60-80/mo on average

I use a cheaper model (Sonnet) for Claude Code subagents instead of Opus. Same quality for simple tasks, 5x cheaper. That one config change cut my API bill by 40%.
The Pricing Trap Nobody Talks About
Every AI coding tool advertises the subscription price. None of them advertise the effective cost per productive hour.
Here's my rough calculation:

I code ~160 hours/month
AI tools save me ~30% of that time = 48 hours saved
Total cost: ~$70/month
Effective cost: $1.46/hour saved

That's insane ROI. A junior developer costs $30-50/hour. Even if AI tools only replace 10% of that work, the math is overwhelmingly in favor.
But — and this is the trap — you need to be deliberate about which tool you use for what. Using Opus for a task that Sonnet handles fine is like taking a taxi when the bus goes to the same place.
Calculate Your Own Costs
I built a calculator that compares all major AI coding tools at different usage levels:
👉 AI Coding Tool Cost Calculator
And if you're specifically comparing Cursor vs Copilot:
👉 Cursor vs Copilot Comparison
Bottom Line
The best AI coding tool is the one that fits your workflow, not the one with the best benchmarks. I know developers who are more productive with just Copilot than I am with my $70/month stack. The tool matters less than how deliberately you use it.
If you're only going to pay for one tool: Cursor if you want IDE integration, Claude Code if you work in the terminal and do a lot of multi-file work.

What's your AI coding setup? Curious about real-world costs from other developers — especially anyone who's tracked their actual API spending over months.

Clerk Charges $1,825/mo at 100K Users. Supabase Auth Charges $25. Same Features.

chnby — Sun, 14 Jun 2026 15:52:30 +0000

I was migrating my SaaS from Firebase to a dedicated auth provider and almost made a $21,000/year mistake.
Here's what happened: I had 85,000 MAU and growing. Clerk's landing page looked great — beautiful pre-built components, easy integration, good docs. I was about to commit when I decided to actually calculate the cost at scale.
The Math That Changed My Mind
I built a calculator to compare every major auth provider at different scales. Here's what the numbers look like at 100K monthly active users:
ProviderFree TierCost at 100K MAUSupabase Auth50,000 MAU$25/moWorkOS1,000,000 MAU$0/moFirebase Auth50,000 MAU$275/moClerk10,000 MAU$1,825/moAuth07,500 MAU$5,000+/mo
That's a 73x price difference between Clerk and Supabase for the same core features: email/password login, social OAuth, session management, JWTs.
But Wait — Cheapest Isn't Always Best
Before you rush to Supabase, here's the nuance the pricing table doesn't show:
Clerk gives you production-ready UI components out of the box. Sign-in forms, user profile pages, organization management — all themed and responsive. If your team is small and shipping fast, the $1,825/mo might actually save you engineering time worth more than that.
Supabase Auth has no pre-built UI. You're writing every login form, every password reset flow, every MFA setup screen yourself. For a solo founder, that's 2-3 weeks of work.
WorkOS has the most generous free tier (1M MAU!) but it's designed for enterprise features — SSO, SAML, directory sync. If you just need email + Google login, it's overkill in complexity.
Auth0 is the most expensive option at scale, but it has the deepest enterprise compliance certifications. If your customers require SOC2 Type II and you need to check a box, Auth0's price includes that peace of mind.
The Decision Framework
Here's how I think about it now:

< 10K MAU: Doesn't matter, everything is free. Pick whatever has the best DX for your stack.
10K–50K MAU: This is where Clerk starts charging and the gap opens. If you're on Supabase for your database already, Auth is essentially free.
50K+ MAU: You need to do the math. $1,825/mo is $21,900/year. That's a senior developer's time for 2 months. Enough to build auth UI from scratch on Supabase.

Calculate Your Exact Number
I built a free calculator that lets you plug in your MAU and see exact costs across all providers:
👉 Auth Provider Cost Calculator
No signup, runs in your browser, data doesn't leave your machine.
What I Ended Up Choosing
I went with Supabase Auth. It took me 4 days to build the auth UI (login, signup, password reset, MFA toggle, profile page). At my current 95K MAU, I'm paying $25/mo instead of $1,825/mo. That's $21,600/year saved.
Was it the right call for everyone? No. If I had a team of 5 shipping features daily and couldn't afford 4 days on auth UI, Clerk would have been worth it. But as a solo founder, $21K buys a lot of runway.

What auth provider does your team use, and at what scale? I'm curious if these numbers match your experience.

I Run 5M Vectors on a $6/mo Server. Pinecone Would Charge Me $210.

chnby — Sun, 14 Jun 2026 15:51:30 +0000

Six months ago I moved my RAG pipeline from Pinecone to self-hosted Qdrant. My vector search bill went from $210/month to $6.50/month. Same latency. Same recall. Here's exactly how.
The Setup
My app does document Q&A for legal contracts. The numbers:

5.2 million vectors (1536-dim, OpenAI embeddings)
~800K queries/month
P99 latency requirement: < 50ms

On Pinecone Serverless, this cost me roughly $210/month — storage plus read units plus write units for daily ingestion of new documents.
What I Moved To
A single Hetzner CX32 server:

4 vCPU, 8 GB RAM, 80 GB SSD
€8.50/month (about $9.20)
Qdrant running in Docker
Automated daily backups to S3-compatible storage ($0.50/month)

Total: ~$10/month. That's a 95% cost reduction.
The Migration Was Easier Than Expected
bash# Export from Pinecone (I used their scroll API)
python export_pinecone.py --index legal-docs --output vectors.jsonl

Start Qdrant

docker run -d -p 6333:6333 -v ./storage:/qdrant/storage qdrant/qdrant

Import

python import_qdrant.py --input vectors.jsonl --collection legal-docs
The whole migration took an afternoon. The Qdrant Python client is straightforward, and the API is surprisingly similar to Pinecone's.
Performance Comparison
I ran the same 10,000 test queries against both setups:
MetricPinecone ServerlessQdrant Self-HostedP50 latency23ms4msP99 latency89ms12msRecall@100.970.97Monthly cost$210$10
The self-hosted Qdrant is actually faster because the data sits in memory on the same machine. Pinecone Serverless loads data from object storage on demand, which adds cold-start latency.
When Self-Hosting Is a Bad Idea
I want to be honest about the trade-offs:
Don't self-host if:

You have zero DevOps experience and no one on the team does
You need 99.99% uptime SLA for enterprise customers
Your vector count is growing unpredictably (10M one month, 100M the next)
You're a team of 1-2 and every hour on infra is an hour not building product

Do self-host if:

Your scale is predictable (you know roughly how many vectors you'll have)
You're comfortable with Docker and basic server management
Cost matters — the difference between $10 and $210 is $2,400/year
You want full control over your data and indexing parameters

The Cost at Every Scale
I built a calculator to compare all four major vector DBs at different scales:
ScalePineconeQdrant CloudQdrant Self-HostedSupabase pgvector1M vectors~$22/mo~$14/mo~$7/mo~$27/mo10M vectors~$210/mo~$120/mo~$72/mo~$95/mo100M vectors~$1,900/mo~$950/mo~$480/moN/A
👉 Calculate your exact cost
One Thing I Miss About Pinecone
The dashboard. Pinecone's web console lets you browse vectors, run test queries, and see index stats visually. With self-hosted Qdrant, I'm using curl and Python scripts. There's a Qdrant Web UI but it's basic.
Would I go back? At $200/month savings, absolutely not. But if I were building a quick prototype and didn't want to think about infrastructure, Pinecone's free tier (100K vectors) is genuinely good for getting started.

Running self-hosted vector search? I'd love to hear your setup and costs. Also built comparison pages for specific matchups: Pinecone vs Qdrant, Supabase vs Pinecone.

The Stripe vs Paddle Break-Even Point Most SaaS Founders Get Wrong

chnby — Sun, 14 Jun 2026 15:50:02 +0000

"Stripe is 2.9%. Paddle is 5%. Stripe is cheaper. End of discussion."
I hear this all the time. And it's wrong — or at least, it's incomplete. The break-even point where Paddle actually becomes cheaper than Stripe is lower than most founders think.
The Hidden Costs of Stripe
Stripe's 2.9% + $0.30 is only the processing fee. Here's what you're actually paying when you sell globally:
CostStripePaddleProcessing fee2.9% + $0.305% + $0.50International cards+1.5%IncludedCurrency conversion+1%IncludedStripe Tax (VAT)+$0.50/transactionIncludedChargeback fee$15 eachIncludedVAT filingYour accountantIncluded
A European customer paying with a non-USD card on Stripe actually costs you: 2.9% + 1.5% + 1% + $0.30 + $0.50 = 5.4% + $0.80 per transaction.
That's already more expensive than Paddle's 5% + $0.50.
The Real Break-Even Math
I modeled this across different MRR levels with realistic assumptions (40% international customers, 2% chargeback rate, monthly VAT filing cost of $200 if you handle it yourself):
At $5K MRR:

Stripe total effective cost: ~$340/mo (6.8%)
Paddle: ~$300/mo (6.0%)
Winner: Paddle by $40/mo

At $25K MRR:

Stripe total: ~$1,450/mo (5.8%)
Paddle: ~$1,375/mo (5.5%)
Winner: Paddle by $75/mo

At $100K MRR:

Stripe total: ~$5,200/mo (5.2%)
Paddle: ~$5,050/mo (5.05%)
Winner: Paddle by $150/mo — but it's close

The surprise: Paddle is cheaper than "real" Stripe (with tax handling) at almost every scale for global SaaS.
So Why Does Anyone Use Stripe?
Because cost isn't everything. Here's the honest trade-off:
Choose Stripe if:

Your customers are mostly US/domestic (no international card surcharge)
You want full control over your checkout experience
You need Stripe Connect for marketplace payments
You're B2B and invoicing, not card payments
You already have a tax solution (Avalara, TaxJar)

Choose Paddle if:

You sell to consumers or small businesses globally
You don't want to deal with VAT registration in 30+ countries
You're a solo founder and "merchant of record" sounds like a nightmare
You want to launch in the EU without an EU entity

Choose Lemon Squeezy if:

Same reasons as Paddle, but you prefer their UI/UX
You're selling digital products, courses, or subscriptions
Pricing is identical to Paddle (5% + $0.50)

The Merchant of Record Advantage
This is the part most comparisons skip. Paddle and Lemon Squeezy are "Merchants of Record" — they're legally the seller. This means:

They handle VAT/sales tax in 100+ countries. You don't register, you don't file, you don't worry about EU VAT thresholds.
Chargebacks are their problem. You never see the $15 fee.
Refunds are cleaner. They handle the tax reversal.
You don't need an EU entity to sell in Europe without triggering VAT obligations.

For a solo founder selling a $29/mo SaaS globally, this saves 5-10 hours/month in tax compliance. What's your hourly rate?
Calculate Your Exact Fees
I built a calculator where you plug in your MRR and transaction count to see exact fees across Stripe, Paddle, Lemon Squeezy, and PayPal:
👉 Payment Processor Fee Calculator
It shows raw fees only — but now you know to add the international/tax costs for Stripe mentally.
What I Use
I started with Stripe (because everyone says "just use Stripe"), hit my first EU VAT registration requirement at $10K MRR, panicked, and switched to Lemon Squeezy in a weekend. My effective fee went from ~6.2% to 5.5%, and I stopped spending 3 hours/month on tax spreadsheets.
No regrets. The 2.1% headline difference between Stripe and Paddle is a mirage once you factor in the real costs of global payments.

I Compared GPT-4o vs Claude vs Mistral API Costs for My SaaS — The Numbers Shocked Me

chnby — Wed, 10 Jun 2026 15:28:16 +0000

I was building a document Q&A feature for my SaaS.
Estimated 100,000 LLM requests per month.
Picked GPT-4o without thinking.
Then I actually ran the numbers.

Here's what I found.

The Setup

Typical request profile for a document Q&A backend:

Input tokens per request: 1,500 (system prompt + retrieved context)
Output tokens per request: 500 (answer)
Volume: 100,000 requests/month

Simple calculation. Turns out not so simple on the wallet.

The Cost Table

Model	Input $/1M	Output $/1M	Monthly Cost
GPT-4o	$2.50	$10.00	$875
Claude 3.5 Sonnet	$3.00	$15.00	$1,200
Mistral Large	$2.00	$6.00	$600
Llama 3.1 70B (Together AI)	$0.88	$0.88	$220
GPT-4o mini	$0.15	$0.60	$52
Claude 3.5 Haiku	$0.80	$4.00	$320
Gemini 1.5 Flash	$0.075	$0.30	$26

$875/month vs $26/month for the same 100K requests.
That's a 33× price gap between GPT-4o and Gemini Flash.

What I Actually Did

I didn't just blindly switch to the cheapest model.
I ran a tiered approach:

Routing layer (GPT-4o mini) → classifies the query complexity → $52/month

Simple queries (Gemini Flash) → factual lookups, short answers → $26/month

Complex queries (GPT-4o) → reasoning, synthesis, long-form → $175/month

Total: ~$253/month instead of $875.
Same quality. 71% cheaper.

The Hidden Cost: Context Bloat

Most tutorials show you per-token pricing.
Nobody talks about context window bloat.

As your conversation history grows, your input tokens explode:

Turn 1: 1,500 tokens input
Turn 5: 6,000+ tokens input (full history)
Turn 10: 12,000+ tokens input

At GPT-4o pricing, a 10-turn conversation costs 8× more than a single request.
Solutions: summarize history after turn 3, use semantic compression, or cache repeated context.

Batch API: The 50% Discount Nobody Uses

OpenAI's Batch API gives you 50% off for non-realtime workloads.
Same models. Same quality. Just async (results in ~24h).

Use cases that work perfectly with batch:

Document indexing pipelines
Nightly report generation
Bulk content classification
Offline data enrichment

If your use case tolerates async, you're leaving half your budget on the table.

Prompt Caching: 75–90% Off Repeated Context

Anthropic's prompt caching lets you cache your system prompt + static context.
Cache hit cost: ~10% of normal input price.

For document Q&A with a fixed system prompt (say 2,000 tokens),
caching saves you 90% on that chunk every request.
At 100K requests/month, that's meaningful.

The Calculator I Used

I was doing all this math in spreadsheets until I found
APICalculators.com —
a free browser-based LLM cost calculator.

You plug in your token averages and monthly volume,
it shows you the breakdown across all major providers instantly.
No signup, runs locally.

Useful for sanity-checking before you commit to a model in production.

The Decision Framework

Under $50/month budget:

Gemini Flash or GPT-4o mini. Full stop.

$50–$200/month, quality matters:

Claude 3.5 Haiku or Mistral Small.
Good reasoning, fraction of flagship cost.

$200–$500/month, complex reasoning needed:

GPT-4o mini for routing + GPT-4o for hard queries only.
Model routing cuts cost 60–70%.

Over $500/month:

Audit your prompts first.
Most overspend comes from bloated system prompts, not model choice.

TL;DR

GPT-4o is 33× more expensive than Gemini Flash at the same volume
Model routing (cheap router + expensive worker) cuts costs 60–70%
Batch API = 50% discount for async workloads
Prompt caching = 75–90% off repeated context
Use a cost calculator before picking a model in prod

What's your current LLM spend? Have you tried model routing?