Skip to content

Pricing Trap Detector

Hidden costs that hit when you scale. Real stories, real bills.

105
Traps found
36
High severity
68
Services affected
105 traps
Vercel— Bandwidth overage
high
Trigger: Exceeding 100GB/mo on Pro ($20)
A viral blog post cost one dev $3,500 in bandwidth overages in one weekend.
How to avoid: Set spend limits in dashboard. Use Cloudflare as CDN in front.
Vercel— Serverless function invocations
medium
Trigger: High-traffic API routes on free/Pro tier
A cron-heavy app hit 5M invocations. Bill jumped from $20 to $180.
How to avoid: Move heavy APIs to Railway/Fly. Use ISR/SSG instead of SSR.
Firebase— Firestore reads explosion
high
Trigger: Listing queries without pagination, listeners on large collections
Dev left a listener on a 50k-doc collection. 2M reads/day = $150/mo.
How to avoid: Always paginate. Use .limit(). Monitor reads in Firebase console.
AWS— Data egress charges
high
Trigger: Serving files from S3 or transferring between regions
Startup serving 10TB/mo of images from S3 paid $900/mo just in egress.
How to avoid: Put CloudFront in front. Consider Cloudflare R2 (free egress).
Stripe— Dispute fees
medium
Trigger: Chargebacks on digital products
SaaS with poor cancellation UX got 50 disputes in a month. $750 in fees regardless of outcome.
How to avoid: Easy cancellation flow. Radar rules. Clear billing descriptor.
MongoDB Atlas— Storage auto-scaling
medium
Trigger: Data grows past provisioned cluster storage
Cluster auto-scaled from M10 ($57) to M30 ($215) overnight due to log collection.
How to avoid: Set up alerts on storage %. TTL indexes on logs. Archive old data.
Algolia— Record count pricing
high
Trigger: Each record variant counts separately
E-commerce site with 10k products but 150k variants. Expected $29/mo, got $249/mo.
How to avoid: Consolidate variants into fewer records. Consider Typesense/Meilisearch.
Clerk— MAU-based pricing cliff
medium
Trigger: Crossing 10k MAU on Pro plan
App grew from 8k to 15k MAU. Bill went from $25 to $95 with per-MAU charges.
How to avoid: Track MAU trends. Consider self-hosted auth (Keycloak) at scale.
Cloudflare— Workers unbound billing
medium
Trigger: CPU-intensive workers on Workers Unbound
Image processing worker used 500K GB-s. Expected $5, billed $65.
How to avoid: Monitor CPU time per request. Offload heavy work to a proper server.
Supabase— Database size on free tier
low
Trigger: Exceeding 500MB database on free tier
Project paused after DB hit 500MB. Lost 24h figuring out which data to delete.
How to avoid: Monitor DB size. Upgrade to Pro ($25) before hitting limit.
PlanetScale— Row reads pricing
high
Trigger: Unindexed queries scanning full tables
Missing index caused 50B row reads/mo. Bill went from $29 to $380.
How to avoid: Use EXPLAIN on queries. Add indexes. Monitor reads in dashboard.
Netlify— Build minutes
low
Trigger: Monorepo with frequent deploys
Team of 5 pushing 20x/day on a 3-min build. Used 6,000 build min/mo (limit: 300).
How to avoid: Skip builds for non-code changes. Use build cache. Consider self-hosted CI.
Datadog— Custom metrics explosion
high
Trigger: Apps emitting 1000+ custom metrics per host
Expected $15/host for infra monitoring. Got $200/host after metrics+logs+APM enabled.
How to avoid: Audit custom metrics before enabling. Use Prometheus for custom metrics instead.
Auth0— Enterprise tier lock-in
high
Trigger: Needing more than 2 social connections or custom domains on free plan
Free plan covers 1 social connection. Adding Google+GitHub+Apple forced jump to $35/mo immediately.
How to avoid: Start with Auth.js or Lucia for full control. Auth0 free tier is intentionally narrow.
Snowflake— Auto-resume warehouse cost
high
Trigger: BI tools or dashboards auto-resuming suspended warehouses via scheduled queries
Metabase cron queries resumed warehouse every hour around the clock. $2k/mo in idle compute.
How to avoid: Set auto-suspend to 1 minute. Use separate small warehouses per team/tool.
Render— Free tier spin-down
medium
Trigger: Free web services receiving traffic after 15 min of inactivity
Cold starts of 30-60s on free tier killed user experience for a demo app shown to investors.
How to avoid: Use Fly.io or Railway $5 plan for always-on small services.
GitHub Actions— macOS runner cost multiplier
medium
Trigger: iOS or Mac builds consuming included minutes
2000 Linux minutes included but macOS runners apply 10x multiplier — effectively only 200 min free.
How to avoid: Use self-hosted runners on a Mac Mini for iOS CI. Saves $40-200/mo at moderate build volume.
Supabase— Realtime connection limits
medium
Trigger: More than 200 concurrent WebSocket connections on free or 500 on Pro
Chat app hit 500 concurrent connections on Pro plan. Required Team plan upgrade at $599/mo.
How to avoid: Use Ably or Pusher for heavy realtime workloads. Supabase Realtime suits low-concurrency use cases.
OpenAI— Output token cost asymmetry
high
Trigger: Chatbot or writing apps generating long responses with GPT-4o
GPT-4o charges $2.50/M input but $10/M output. App generating 500-word replies paid 4x more than expected.
How to avoid: Set max_tokens limits. Use GPT-4o-mini for drafts and rewrites. Cache repeated outputs.
Heroku— Dyno sleeping
low
Trigger: Free or Eco dynos receiving first request after 30 min of inactivity
First request after idle period takes 10-30s to respond. Demo apps felt broken to new users.
How to avoid: Use always-on Standard dyno ($25/mo) or switch to Railway for comparable pricing without sleep.
Datadog— Bait pricing — credit card required for free trial
high
Trigger: 14-day free trial requires credit card; auto-converts unless cancelled
Team forgot to cancel 14-day trial. Got billed $1,800 for monthly Infrastructure + APM across 5 hosts.
How to avoid: Set calendar reminder day 12. Or use Grafana Cloud free tier for evaluation instead.
Lemon Squeezy— Merchant of record fees
medium
Trigger: Selling digital products via Lemon Squeezy MoR
5% + $0.50 per sale = on $50 product, $3 goes to LS vs ~$1.75 on Stripe — but no tax/VAT compliance work.
How to avoid: Run the math: if VAT/tax compliance work costs you 4hr/mo, MoR is cheap. If you're scaling past $50k MRR, Stripe + Anrok/Sphere is cheaper.
Auth0— Production Free trap — features locked behind tier jump
high
Trigger: Adding SAML, custom domain, or multi-factor enforcement on free tier
Free tier covers 7,500 MAU but SAML SSO requires Enterprise (sales call, $1k+/mo). Custom domain requires $35+ Essentials.
How to avoid: Choose Auth.js, Better Auth, or WorkOS up front if SSO is on the roadmap. Auth0 free is a teaser, not a foundation.
Vercel— Forced annual billing for discounts
medium
Trigger: Pro plan annual = 10-20% off but locks you in
Team committed annual to save $50/mo. Hit bandwidth overage 3 months later — couldn't downgrade or pause.
How to avoid: Stay monthly until usage stabilizes for 6+ months. Annual locks both base + commits you to platform during overages.
Stripe— Stripe Tax + Billing double-counting
medium
Trigger: Enabling both Stripe Billing (0.5%) and Stripe Tax (0.5%) on subscriptions
SaaS at $20k MRR enabled both products. Effective fee jumped from 2.9% to 3.9% — extra $200/mo.
How to avoid: Calculate combined add-on cost. Some products bundle (Billing includes some tax features). Or self-implement tax with Anrok.
Notion— Notion AI per-seat add-on
medium
Trigger: Enabling AI for entire workspace at $10/user/mo on top of base plan
20-person team on Plus ($10) added AI ($10). Bill went from $200 to $400/mo. AI usage was concentrated in 5 users.
How to avoid: Notion AI bills per-seat regardless of usage. Cheaper to give heavy users ChatGPT Plus ($20) than enable AI for all.
Twilio— Phone number price hikes + 10DLC fees
high
Trigger: Operating SMS to US numbers requires 10DLC registration + per-msg carrier fees
App with $0.0079 advertised SMS pays $0.0079 + $0.005 carrier + $4 brand reg + $15/campaign — effective $0.013-0.015/msg.
How to avoid: Budget 2x advertised SMS price for US. Consider WhatsApp Business API (Meta) for international.
Heroku— Free tier removal aftermath
high
Trigger: Legacy projects assuming free dynos still exist
Devs returning to old projects in 2024 find apps offline — free dynos killed Nov 2022, Postgres data deleted after grace period.
How to avoid: Migrate any legacy Heroku project to Railway/Render/Fly.io now. Don't trust free tiers without active commitment.
WorkOS— Per-connection SSO pricing
medium
Trigger: Enterprise customers each requiring own SAML connection
B2B SaaS with 30 enterprise customers = 30 SSO connections × $125 base + $1.25/conn = ~$165/mo. Scales linearly.
How to avoid: Price into enterprise contracts. WorkOS is cheaper than Auth0 SSO at low volume but each customer adds cost.
Linear— Guest seats counted as full users
medium
Trigger: Inviting clients/contractors for project visibility
Agency with 10 staff and 30 client guests pays for 40 seats × $10 = $400/mo. Guests have read-only needs.
How to avoid: Use comments via email or shared docs for clients. Linear has no true guest tier.
Algolia— Opaque Search Unit billing
high
Trigger: After 2025 pricing migration: searches counted as variable Search Units
Same query workload that cost $29/mo on legacy plan now bills $40-60/mo on Search Units — 30-40% effective increase.
How to avoid: Demand pricing calculator before migrating. Or switch to Meilisearch/Typesense with predictable per-record + per-search pricing.
Snowflake— Auto-scaling warehouse with no spend cap
high
Trigger: Multi-cluster auto-scaling enabled on heavy query workloads
Analytics team enabled auto-scaling. A poorly-tuned dashboard query spun up 10 warehouses for 2hrs = $400 in one afternoon.
How to avoid: Set resource monitors with hard limits. Disable auto-scaling on dev/staging warehouses. Single-cluster for analyst queries.
Mailchimp— 'Free forever' with feature lockout creep
medium
Trigger: Free plan kept narrowing: removed scheduling 2022, removed A/B test, capped contacts at 500 in 2023
Free users who built workflows in 2020 lost scheduled-send in 2022 and segmentation in 2024 — forced upgrade to keep existing automations.
How to avoid: Treat 'free forever' as 'free until next strategic review'. Buttondown/Loops have stable freemium boundaries.
Linear— Monthly→annual surprise increase at renewal
medium
Trigger: Renewal prices applied at next billing date even for legacy customers
Linear raised $8 → $10/user Jan 2025. Annual customers locked at $8 only until renewal — bills jumped 25% on renewal date with no discount.
How to avoid: Check renewal date before any plan change. Some vendors honor old pricing for active subscriptions until renewal — others force immediate.
Clerk— MAU counted before churn — billed for inactive users
medium
Trigger: MAU counted as 'unique signed-in user in last 30 days' regardless of subsequent churn
App spiked to 12k MAU after a launch, but 80% never returned. Bill stayed at higher tier for 30+ days even after users churned.
How to avoid: Plan MAU billing around viral spikes. Set spending alerts. Some auth vendors offer rolling 7-day MAU for spikier products.
PostHog— Anonymized analytics still billed as MAU
low
Trigger: Identified vs anonymous users — anonymous still count toward event quotas
Marketing site with 200k anonymous monthly visitors hit 1M events/mo PostHog free cap from page-views alone.
How to avoid: Use a marketing-only analytics tool (Plausible, Fathom) for anonymous traffic. Reserve product analytics for signed-in users.
Vercel— Deprecated plan removal at renewal
high
Trigger: Legacy Pro plan grandfathered features (e.g. unlimited team members) removed at renewal in 2024
Teams on legacy Pro flat $20 found their 5-person team would now cost $100/mo (per-seat) at renewal in 2024.
How to avoid: Read every renewal email. Don't assume grandfathering is permanent. Snapshot your current bill structure annually.
OpenRouter— 'Bring your own LLM key' but markup on base usage
medium
Trigger: Using OpenRouter as gateway adds 5% markup vs direct provider — but BYOK is still possible without markup
Team thought OpenRouter was a free passthrough. Discovered 5% markup on $2k/mo Anthropic spend = $100/mo extra they could have saved with BYOK.
How to avoid: Use OpenRouter for routing/fallback experimentation. For high-volume single-provider workloads, BYOK or go direct.
Cursor— Regional pricing arbitrage gap
low
Trigger: Cursor doesn't offer regional/PPP pricing — $20/mo flat globally
Devs in India/Brazil/Eastern Europe pay same $20 as SF devs — effective cost is 2-5x in local terms. Aider/Continue (free OSS) gain share in non-US markets.
How to avoid: Open-source alternatives (Aider, Continue, Cline) get free Anthropic/OpenAI API spend at local cost rather than fixed USD subscription.
Datadog— Sales-required for compliance features
high
Trigger: HIPAA-eligible logging, FedRAMP, SOC 2 add-ons all require enterprise sales call (no self-serve pricing)
Health-tech startup needed HIPAA logs. Sales call resulted in 50% premium over base + annual prepay required. Took 6 weeks to procure.
How to avoid: Confirm compliance scope BEFORE adopting. Sentry, Honeycomb, Grafana Cloud have self-serve HIPAA tiers.
Heroku— Partial refunds only on cancellation
low
Trigger: Mid-month cancellation pro-rates compute but not add-ons (Postgres, Redis, etc.)
Project shutdown mid-month — got refund on dynos but full month charged for $50/mo Postgres add-on.
How to avoid: Cancel add-ons individually before destroying app. Check each add-on's refund policy — most are non-prorated.
Snowflake— Surprise minimum-spend on enterprise contracts
high
Trigger: Annual contracts include 'minimum commit' that's burned even if usage stays low
Startup signed $50k/yr Snowflake commit thinking it was a credit pool. Actual usage was $30k. Lost $20k unused commitment at year end.
How to avoid: Stay on month-to-month until usage stabilizes for 6+ months. Negotiate rollover credits or downward flexibility before signing annual commits.
Anthropic— Output tokens 5x input price on Claude Sonnet
high
Trigger: Any app generating long-form content, code, or multi-step responses
SaaS app modeled costs on $3/M input tokens. Actual bill 3x higher because Sonnet output is $15/M and responses averaged 800 tokens.
How to avoid: Always model both input and output. Use Claude Haiku for short tasks; Sonnet only for quality-critical generation. Prompt cache long system prompts.
Anthropic— Prompt caching not enabled by default
medium
Trigger: Apps with long static system prompts or repeating document context
RAG app sending 10K-token system prompt on every request paid full input price. Enabling cache-control dropped API cost 60%.
How to avoid: Add cache_control: {type: 'ephemeral'} to stable prompt sections. Caching cuts costs by 90% for cached tokens; read pricing doc.
OpenAI— Assistants API storage fees
medium
Trigger: Using the Assistants API with file uploads or vector store attachments
Team built chatbot on Assistants API. Didn't notice $0.10/GB/day vector store fee. 10GB of docs = $30/mo just for storage, billed silently.
How to avoid: Delete vector stores when not in use. Or build own RAG pipeline with pgvector — avoids the storage fee entirely.
OpenAI— Fine-tuning training costs are per-epoch, not per-job
medium
Trigger: Fine-tuning GPT-4o-mini or GPT-3.5 on large datasets with multiple epochs
50K token dataset × 5 epochs × 3 fine-tuning runs = 750K tokens billed. At $0.008/1K = $6/run — minor. But 1M token datasets get expensive fast.
How to avoid: Start with 1-2 epochs. Evaluate before running full 5-epoch training. Smaller high-quality datasets beat large noisy ones.
Groq— Daily rate limits on free tier — not monthly
high
Trigger: Using Groq free tier for any production traffic
App was under monthly free-tier estimates. Groq's daily token cap reset at midnight UTC — app 429'd from 6pm US time daily.
How to avoid: Treat Groq free tier as dev-only. Add API key to paid account before any real traffic. Implement exponential backoff.
OpenRouter— 5% routing markup is invisible in per-request cost
medium
Trigger: Using OpenRouter for all LLM traffic at volume
Team thought OpenRouter was free routing. At $3,000/mo LLM spend, discovered $150/mo routing markup they could eliminate by going direct.
How to avoid: Use OpenRouter for multi-provider experiments and fallbacks. For >$500/mo single-provider spend, go direct to provider API.
Together AI— Dedicated endpoints billed per-hour regardless of usage
high
Trigger: Provisioning dedicated inference endpoints for low-latency guarantees
Team needed <200ms latency for chatbot. Spun up dedicated 70B endpoint at $1.80/hr. Month 1: $1,296 for endpoint that handled 40% of expected traffic.
How to avoid: Serverless shared inference is fine for most apps. Only use dedicated endpoints if p99 latency SLA is business-critical.
Replicate— Cold starts billed — not just inference time
medium
Trigger: Using private or custom models with infrequent traffic patterns
App called Replicate every 5 min. Each cold start billed as 20–30s compute. Model took 5s to run. Cold start was 4–6x the actual work.
How to avoid: Use Replicate's 'keep alive' feature to warm a replica. Or use a dedicated GPU on Modal/RunPod for frequently-called custom models.
Supabase— Project auto-pause on free tier after 7 days inactivity
medium
Trigger: Free tier projects with no traffic for 7 days (e.g. dev/staging)
Dev left a staging project idle over a 2-week holiday. Returned to find the project paused — needed manual resume before CI could deploy.
How to avoid: Ping the project via a cron health-check every 3 days. Or upgrade staging to Pro ($25/mo) to disable auto-pause.
Neon— Compute auto-suspends after 5 min — cold start adds latency
medium
Trigger: Free or Launch plan with infrequent traffic
Demo app on Neon free tier showed 3–6s first-request latency to investors. Compute was cold. Fixed with min compute size on Launch plan.
How to avoid: Set min compute to 0.25 CU on Launch plan to keep compute warm. Cost: ~$3/mo vs cold starts on every demo.
PlanetScale— No free tier since April 2024 — and the removal was sudden
high
Trigger: Existing hobby apps on free Hobby plan before April 2024
PlanetScale removed free tier overnight in April 2024. Thousands of hobby apps went offline. No grace period for data export was the biggest complaint.
How to avoid: All PlanetScale plans start at $39/mo. Use Neon, Turso, or Supabase for hobby projects. Never assume free tiers are permanent.
Turso— Per-database charges apply even to empty databases
low
Trigger: Multi-tenant apps creating per-user or per-org databases
Multi-tenant SaaS created 2,000 Turso databases (one per customer). Free tier covers 500 — the remaining 1,500 triggered per-database charges.
How to avoid: Free tier: 500 databases. Check tenant count before architecture decision. Consider schema-per-tenant in single DB if >500 tenants.
MongoDB Atlas— Vector Search requires dedicated cluster — no serverless
high
Trigger: Apps building semantic search or RAG on Atlas Vector Search
Dev built RAG on Atlas Serverless. Discovered Vector Search requires M10+ dedicated cluster ($57/mo). Had to migrate mid-project.
How to avoid: Confirm feature requirements before architecture. Atlas Vector Search = M10+ ($57/mo min). pgvector on Supabase/Neon is often a better fit for budget-constrained startups.
CockroachDB— Request Unit pricing spikes with large scans
high
Trigger: Analytical queries or full-table scans on CockroachDB Serverless
Startup ran analytics dashboard on CockroachDB Serverless. Unoptimized count(*) scans consumed 500M RUs in a week — bill jumped from $0 to $40 unexpectedly.
How to avoid: Add indexes for all common query patterns. Use EXPLAIN to check RU estimates before enabling features. Set spend limits in the console.
EdgeDB— Rebranded to Gel — documentation and tooling in transition
low
Trigger: Evaluating EdgeDB Cloud documentation (now Gel Cloud)
Team adopted EdgeDB based on 2023 docs. Discovered product rebranded to Gel in 2024 — old docs partially broken, migration guide incomplete.
How to avoid: Check gel.dev for current docs. The database is solid but the brand transition caused ecosystem fragmentation.
Clerk— SMS verification billed per-send on top of monthly fee
medium
Trigger: Phone auth enabled — every OTP SMS billed $0.05/send
App with 10K users requiring phone verification on every login pays $500/mo in SMS fees alone — not visible in base plan pricing.
How to avoid: Prefer email or TOTP auth. If SMS required, batch usage: only send OTP on new device, not every login.
WorkOS— Each enterprise SAML connection billed at $125 base + $1.25/user
medium
Trigger: B2B SaaS with multiple enterprise customers each needing SSO
25 enterprise customers × $125/conn minimum = $3,125/mo in WorkOS SSO fees, separate from app infrastructure. Viable only if enterprise contracts cover it.
How to avoid: Price SSO explicitly into enterprise tiers — minimum $500/mo plan that offsets WorkOS SSO cost. Many use $125/conn as a template for enterprise add-on pricing.
Stytch— B2B auth suite pricing jumps sharply at 10k MAU
high
Trigger: Growing B2B app crossing 10K MAU on Stytch
Consumer Auth free tier covers 10K MAU. App at 11K MAU moved to Growth tier — bill jumped to $249/mo immediately regardless of usage distribution.
How to avoid: Monitor MAU weekly as you approach 10K. WorkOS or Better Auth self-hosted may be more cost-effective for B2B beyond this point.
Paddle— 5% MoR fee applies to full subscription value, not net revenue
medium
Trigger: Subscription products using Paddle as Merchant of Record
SaaS at $50k MRR pays $2,500/mo to Paddle. Stripe alternative would be $1,450/mo — $1,050/mo more for tax handling that Anrok could cover for $200/mo.
How to avoid: At $50k+ MRR, model Stripe + Anrok/Sphere vs Paddle MoR. MoR wins at low volume; direct Stripe wins at high volume.
Stripe— Stripe Connect platform fees on top of standard processing
medium
Trigger: Marketplaces or platforms using Stripe Connect to route payments to sellers
Marketplace paid 2.9% + $0.30 standard Stripe fee PLUS $2/active account/mo on Stripe Connect Express. 500 active sellers = $1,000/mo platform fee.
How to avoid: Stripe Connect Express: $2/active account/mo. Budget this into unit economics. Inactive accounts (no transfer in month) are not charged.
Lemon Squeezy— 5% + 50¢ per transaction is expensive at low price points
high
Trigger: Selling products under $10 via Lemon Squeezy
A $5 app selling via Lemon Squeezy pays $0.75/transaction (15% effective rate). At that price point, Polar (4% + 40¢) or Stripe ($0.44) is substantially cheaper.
How to avoid: For sub-$10 products, fixed per-transaction fee dominates. Consider Polar or direct Stripe at low price points.
Polar— 30-day payout hold for new accounts affects cash flow
low
Trigger: New Polar account processing first transactions
Indie dev launched product, made $2k in first month — all held for 30 days. Needed other funds to cover expenses while waiting for payout.
How to avoid: Plan for 30-day payout cycle when launching. After account is established, payouts move to 7-day cycle.
Railway— Usage-based billing with no hard cap by default
high
Trigger: Services with memory leaks, infinite loops, or traffic spikes
A background worker had a memory leak. Railway auto-scaled memory, billing $200 in two days before the dev noticed. No default spend cap.
How to avoid: Set memory limits per service in Railway dashboard. Set up Railway spend alerts. Hard-limit RAM on all services.
Fly.io— Volume storage billed even when apps are stopped
medium
Trigger: Created Fly Postgres or volumes for hobby apps then stopped using them
Dev stopped a Fly app but left 3 volumes attached. Each 1GB volume billed $0.15/mo. Small but silently accumulates; $5.40/yr on dead volumes.
How to avoid: Run 'fly volumes list' and destroy unused volumes. Fly does not auto-delete volumes when apps are deleted.
Cloudflare Workers— CPU time billing on Workers Unbound surprises CPU-heavy workloads
medium
Trigger: Image processing, PDF generation, or compute-heavy ops in Workers
PDF-generation Worker used 300ms CPU per request at 100K req/mo = 8.3 CPU-hours. Workers Paid: first 30M req/mo $5, but 8.3 CPU-hr × $12.50/M GB-s = $60+ extra.
How to avoid: Profile CPU time per Worker invocation. For >50ms CPU tasks, offload to a regular server or Durable Object. Use Workers for lightweight edge logic only.
Netlify— Bandwidth overage at $55/100GB is one of the priciest in the industry
high
Trigger: Traffic spike, viral content, or video/large file serving on Netlify
Newsletter linked to a Netlify-hosted video (300MB file). 5,000 downloads = 1.5TB bandwidth. Netlify bill: $20 Pro + $825 overage = $845.
How to avoid: Never serve large files from Netlify. Use Cloudflare R2 (free egress) or Bunny CDN for any large asset. Netlify is for HTML/JS only.
Render— Free services spin down after 15 min — 30-60s cold start kills demos
medium
Trigger: Free Render web services used for demos, investor pitches, or public apps
Startup used Render free tier for demo. First request after 15-min idle took 45s to respond. Investor demoed to 'broken' loading screen.
How to avoid: Upgrade to Render Starter ($7/mo) for always-on. Or use Fly.io's free machines which resume in <1s vs Render's full cold start.
Datadog— Enabling APM tracing on all services multiplies the bill by 3–5x
high
Trigger: Turning on full distributed tracing across a microservices stack
Team enabled APM on 5 services. Each added $31/host/mo. 5 services × 2 hosts each = $310/mo APM cost on top of $150/mo infra — total jumped to $460/mo.
How to avoid: Enable APM only on critical paths. Sample traces at 10–20% for non-critical services. Or use Jaeger/Tempo self-hosted for non-production tracing.
Sentry— Performance monitoring quota depletes separately from error quota
medium
Trigger: Enabling Sentry performance monitoring on high-traffic apps
Team assumed Sentry Team at $26/mo covered everything. Enabled performance tracing on API server — burned through performance quota in week 1, then billed $30/100K extra.
How to avoid: Use sample rates to cap performance event volume. Set 0.1 tracesSampleRate for production unless debugging specific issues.
Axiom— 500GB/mo ingest limit sounds huge but structured app logs are verbose
low
Trigger: Noisy microservices emitting JSON logs with debug level enabled
Team left debug logging enabled in production. 10 services × 50MB/hr = 360GB/day. Hit 500GB/mo free limit in 36 hours.
How to avoid: Log at INFO level in production. Use log sampling for high-throughput services. Axiom free tier is generous — but only if you're not logging every request detail.
Resend— 100 emails/day hard cap on free tier breaks any onboarding campaign
medium
Trigger: Running email welcome sequences or onboarding drip campaigns on free tier
Product launched with 300 signups in day 1. First 100 got welcome emails; rest got nothing. Churn was 40% among users who never received onboarding.
How to avoid: Upgrade to Resend Pro ($20/mo) on launch day. 50K/mo is sufficient for any early-stage app.
SendGrid— IP reputation damage on shared IPs if neighbors send spam
medium
Trigger: Sending transactional email on SendGrid shared IP pool (Essentials plan)
SaaS had 15% Gmail delivery rate. Root cause: shared IP pool neighbor had high spam complaint rate, affecting all senders on that pool.
How to avoid: Use a dedicated IP ($30/mo) at 100K+ emails/mo. Or use Postmark (known for transactional deliverability on shared IPs).
Mailgun— Permanent free tier removed in 2020 — only 30-day trial now
medium
Trigger: Following any tutorial or blog post that describes a Mailgun free tier
Developer followed a 2019 tutorial. Set up Mailgun 'free tier'. Trial expired after 30 days — all emails silently stopped sending.
How to avoid: Mailgun has no free tier. Use Resend (100/day free) or AWS SES ($0.10/1K, near-zero for small volumes).
Algolia— Typo-tolerance and synonyms count as separate search operations
medium
Trigger: Complex queries with multiple typo-tolerance rules + synonym expansion
Search with 5 synonyms groups triggered 6 internal searches per query (original + 5 expansions). Expected 10K queries/mo, billed for 60K SUs.
How to avoid: Disable unnecessary synonym groups. Use Algolia's search unit estimator before enabling advanced query features.
Typesense Cloud— Cluster pricing is RAM-based — need to right-size for dataset
medium
Trigger: Large index that doesn't fit in RAM tier selected — requires upgrade
E-commerce index with 5M records needed 4GB RAM. Cheapest tier (0.5GB) failed ingestion. Forced jump to 4GB cluster at $240/mo.
How to avoid: Estimate index RAM usage before provisioning: rule of thumb is 1–2KB per record. 5M records ≈ 5–10GB RAM needed.
Contentful— 'Free' plan removal left teams on $300/mo Lite with no migration notice
high
Trigger: Contentful users who relied on the old 'Community' free plan (removed 2024)
Agency had 3 client projects on Contentful Community (free). Plan removed — forced to $300/mo Lite covering only 1 space. Cost for 3 projects: $900/mo.
How to avoid: Sanity free plan (3 users, 10k docs) is a real free tier. Strapi self-hosted is free. Never rely on Contentful free — it's been repeatedly narrowed.
Sanity— API CDN overage at $0.50/1k additional requests beyond free quota
low
Trigger: High-traffic headless site fetching Sanity content on every page load without caching
Marketing site fetched Sanity content server-side without ISR. 500k page views/mo × 5 queries = 2.5M CDN requests. Free includes 100K — overage: $1,200/mo.
How to avoid: Always use Sanity's CDN caching headers. With Next.js, use ISR or static generation. Never fetch Sanity on every SSR request without a cache layer.
LaunchDarkly— MAU pricing includes every user who evaluates any flag
high
Trigger: Server-side flag evaluation for all anonymous users
E-commerce site evaluated feature flags on anonymous product page visits. 500K monthly visitors × all anonymous = 500K MAU billed at $0.04/MAU. $20K/mo for feature flags.
How to avoid: Use client-side anonymous evaluation with consistent bucketing. Or move to PostHog feature flags (generous free tier) for apps with lots of anonymous traffic.
Statsig— Warehouse Native integrations (BigQuery, Snowflake) require Enterprise
medium
Trigger: Teams wanting to run experiments on warehouse data directly
Team adopted Statsig specifically for warehouse-native experiments. Discovered warehouse native = Enterprise (custom pricing, ~$2k+/mo). Free tier only covers client-side events.
How to avoid: Clarify warehouse native requirements before choosing. GrowthBook OSS offers warehouse-native experiments for free via self-hosted.
GitHub— Advanced Security (GHAS) at $49/committer/mo for secret scanning + code scanning
high
Trigger: Enterprise requiring code scanning, secret push protection on private repos
40-developer team added GHAS. $49 × 40 = $1,960/mo on top of $4/user GitHub Enterprise. Equivalent to nearly doubling the GitHub bill.
How to avoid: GHAS is baked into GitHub Enterprise Cloud — evaluate if ECS bundle is cheaper than adding GHAS to Teams. CodeQL has free OSS alternative.
Linear— No export in open standard format — vendor lock-in risk
low
Trigger: Considering migration away from Linear after heavy adoption
Team tried to migrate from Linear to Plane (OSS). CSV export exists but loses all cycle history, custom views, and automation configs. 6h manual migration work per project.
How to avoid: Linear is excellent but treat it as a long-term commitment. Run exports quarterly as a backup discipline.
Vercel— Next.js App Router ISR cost multiplier — every page revalidation = serverless invocation
medium
Trigger: App Router with on-demand revalidation or short revalidate periods on Pro
Marketing site set revalidate: 60 on 500 pages. Every minute = 500 revalidation function calls. 720K serverless calls/day blew past Pro included 1M/mo in 36 hours.
How to avoid: Set longer revalidate windows (3600+) for content that doesn't change hourly. Use on-demand revalidation only for content with real-time requirements.
Clerk— Billing for inactive MAU during viral spike doesn't recover on churn
medium
Trigger: Product goes viral — MAU spikes then churns rapidly
App featured on HN — 25K new signups in 48h. Clerk billed for 25K MAU in that month at $0.02/MAU = $500 in auth fees. 80% of those users never returned.
How to avoid: No workaround for post-viral billing. Set usage alerts. Some founders use WorkOS (1M MAU free) for apps expecting viral exposure.
Supabase— Realtime concurrency on Team plan: $599/mo surprises teams needing >500 connections
high
Trigger: Chat apps, collaborative editors, or live dashboards exceeding 500 concurrent connections
Dev tool with 500 simultaneous users all subscribed to realtime updates. Pro plan limit = 500 concurrent. Needed Team ($599/mo) for 1,000. 24x price increase.
How to avoid: Architect around Supabase Realtime only for low-concurrency use cases. For >500 concurrent connections, consider Ably, Liveblocks, or self-hosted Socket.io.
Neon— Branching creates separate compute — all branches billed if they're active
low
Trigger: CI/CD pipelines creating preview branches per PR
Team created Neon branch per PR for isolated testing. 20 open PRs × 0.5 CU compute = 10 CU running simultaneously. Monthly compute bill 3x expected.
How to avoid: Configure branches to auto-delete on PR merge/close. Set compute to minimum size (0.25 CU) on branches and ensure auto-suspend is enabled.
Pinecone— Serverless indexes billed on reads/writes plus storage — high read apps pay per-query
high
Trigger: RAG app with high query volume on Pinecone Serverless
RAG chatbot querying Pinecone 50K times/day × 30 = 1.5M queries/mo. At $0.10/M reads = $0.15 direct read cost, but write batching on ingest + storage pushed bill to $350/mo.
How to avoid: Cache top-k results for repeated queries. Use Pinecone metadata filtering to narrow namespaces before vector search. Consider pgvector for simpler use cases.
Langfuse— Observation volume explodes with streaming + multi-step chains
medium
Trigger: LLM app with streaming responses and multi-step agent chains generating 10K+ observations/day
AI agent with 5-step chains, each step logged. 2K users/day × 5 steps × 3 sub-calls = 30K observations/day. Burned through 50K free monthly limit in 2 days.
How to avoid: Sample observations (log 10-20% in production). Batch non-critical traces. Self-host for unlimited observations.
RunPod— Idle GPU pods billing 24/7
high
Trigger: Forgetting to stop a GPU pod after a training run or experiment
Dev ran fine-tuning on A100 ($3.98/hr), forgot to stop pod over weekend. Monday surprise: $190 bill for 48h of idle GPU.
How to avoid: Set auto-stop timers. Use serverless endpoints for inference (only billed on requests). Never leave interactive pods running overnight.
Modal— GPU timeout misconfiguration burns free credits in minutes
medium
Trigger: Setting high timeout on GPU functions without concurrency limits
Function with 300s timeout on A100 GPU, triggered by 50 concurrent users. $30 free credit gone in 40 minutes. No spend alerts on free tier.
How to avoid: Set container_idle_timeout to minimum. Use keep_warm=0 for dev. Set max concurrent containers explicitly.
Cerebras— Free tier rate limits make production impossible
medium
Trigger: Trying to use Cerebras free tier for a real app beyond prototyping
Prototyped app on Cerebras free tier (amazing speed). Launch day: 30 req/min limit hit instantly, 95% of users got errors.
How to avoid: Free tier is for prototyping only. Budget for paid tier from day one if building on Cerebras. Have a fallback provider (Groq, Together).
Groq— Model availability during peak hours
medium
Trigger: Relying on Groq as sole LLM provider for production app
Free tier app depended on Groq for all LLM calls. During peak hours, 20-30% of requests timed out or returned 503. Users blamed the app, not the provider.
How to avoid: Always implement LLM fallback routing. Use OpenRouter or build a simple failover to Together/Fireworks.
Mintlify— Free→Startup cliff at 5 editors
medium
Trigger: Growing team needs 6th person to edit docs
5-person startup on free Mintlify. Hired 6th engineer — forced to jump to $150/mo Startup plan for 1 extra editor. No $50 intermediate tier.
How to avoid: Use Docusaurus/Starlight (free OSS) if team is growing. Mintlify's value is speed — evaluate if $150/mo speed premium is worth it vs free alternatives.
Orama— Document count limit catches e-commerce sites
medium
Trigger: Product catalog exceeding 10K documents on free tier
E-commerce site with 12K products. Free tier maxed at 10K docs. Had to upgrade to $49/mo Pro or remove 2K products from search.
How to avoid: Count your searchable entities before committing. Meilisearch Cloud or self-hosted Typesense have more generous document limits.
Stack Auth— Open-source but cloud lock-in via hosted components
low
Trigger: Starting on Stack Auth Cloud then wanting to self-host
Team built on Stack Auth Cloud for 6 months. Decided to self-host to save costs — migration required changing auth endpoints, updating all client SDKs, and moving user data.
How to avoid: If self-hosting is on the roadmap, start self-hosted. Cloud→self-hosted migration is doable but not zero-effort.
Better Auth— Plugin ecosystem creates hidden dependency costs
low
Trigger: Building on Better Auth with multiple community plugins
Team used 5 community plugins for Better Auth. Two were abandoned 3 months later. Had to fork and maintain them or rewrite auth flows.
How to avoid: Stick to core Better Auth features. Evaluate plugin maintenance history before depending on community plugins. Core library is solid.
Polar— 5% platform fee + Stripe fees = 8% effective take rate
high
Trigger: Selling digital products or subscriptions through Polar
Indie dev selling $29 course via Polar. 5% Polar + 2.9% Stripe + $0.30 = $2.74 per sale (9.4% effective). At $10K/mo revenue, $940 in fees vs ~$320 on Stripe alone.
How to avoid: Great for open-source sponsorship monetization. For pure product sales at scale, Stripe direct or Lemon Squeezy (5% flat, no stacking) is cheaper.
Dub— 25-link free tier is functionally a demo
medium
Trigger: Any real marketing or product usage beyond personal links
Marketing team created 30 short links for a launch campaign. Hit free tier limit before campaign started. Had to upgrade to $24/mo mid-launch.
How to avoid: Budget for Pro ($24/mo) from day one. Free tier is for evaluation only. Self-host the open-source version for unlimited links at infra cost.
Cal.com— Per-seat pricing makes team adoption expensive
medium
Trigger: Sales or support team of 10+ people needing shared scheduling
20-person sales team adopted Cal.com Team plan. $12/user × 20 = $240/mo for scheduling. Calendly equivalent would be $200/mo but with more integrations.
How to avoid: Self-host Cal.com for free (all features included). Cloud per-seat pricing only makes sense for small teams (< 5 users).
Twenty CRM— Cloud per-seat pricing vs self-hosted total cost of ownership
low
Trigger: Evaluating cloud vs self-hosted for a growing sales team
10-person team on Twenty Cloud: $90/mo. Self-hosted on $15/mo VPS with same features — but 4h/mo maintenance overhead.
How to avoid: Cloud makes sense for < 5 users or no DevOps capacity. Self-hosted ROI kicks in at 10+ users where cloud costs exceed VPS + maintenance time.
PGlite— Browser storage limits silently truncate data
medium
Trigger: Storing > 50-100MB of data in PGlite running in browser (IndexedDB backend)
Local-first app stored 200MB in PGlite/IndexedDB. Safari silently evicted data after 7 days of no use. Users lost their local database.
How to avoid: Use PGlite for caching/offline, not as sole data store. Sync to a server-side Postgres. Warn users about browser storage limits.
Electric SQL— Sync bandwidth scales with active users × data size
medium
Trigger: Local-first app with large datasets syncing to many concurrent users
Collaborative app syncing 50MB dataset to 500 concurrent users. Electric sync generated 25GB/day in transfer. VPS bandwidth bill tripled.
How to avoid: Use shapes to sync only relevant subsets of data. Implement pagination in sync. Monitor bandwidth closely in staging before production launch.
Pirsch— No free tier — even personal blogs pay
low
Trigger: Personal site or blog wanting privacy-friendly analytics
Dev moved from Plausible Cloud ($9/mo) to Pirsch hoping for a free tier. Pirsch starts at $4/mo — no free option. Ended up self-hosting Umami instead.
How to avoid: If you need free: self-host Umami, Plausible CE, or use Cloudflare Web Analytics (free). Pirsch is affordable but has no $0 option.
Hatchet— Cloud free tier event limit exhausted by retries
medium
Trigger: Jobs with retry logic on free tier (1K events/day)
Background job with 3 retries on failure. 500 jobs/day × average 1.5 attempts = 750 events. Add monitoring events and hit 1K limit in first week.
How to avoid: Count retries as events in your capacity planning. Use exponential backoff to reduce retry volume. Self-host for unlimited events.

See also

Free Tiers
Exact free plan limits
Hidden Costs
Real price beyond the landing page
Annual Cost
Yearly spend comparison

Explore other areas

DX Score
Developer experience rated
Outages
Downtime history & post-mortems
Integrations
Service compatibility grid