Supabase Got Expensive and My Boss Said Find Something Cheaper

Supabase isn't terrible, but it's got problems that'll bite you in production. I learned this during a product demo that crashed spectacularly when our real-time connections started dropping around 240-250 concurrent users.

The Real Problems Nobody Talks About

Connection limits are fucking brutal. That 200 connection limit on the free tier? Yeah, turns out it counts every goddamn API call, real-time subscription, and background job. We hit it during what should've been a minor traffic spike and started getting FATAL: remaining connection slots are reserved errors. The Pro tier bumps you to 500 connections for $25/month, but their pgBouncer setup is a nightmare to configure properly.

Edge Functions cold starts will ruin your day. Despite claims of "sub-100ms" improvements, I'm still seeing 300-500ms cold starts on Edge Functions that haven't run in 10 minutes. This killed our payment webhook processing because Stripe expects responses under 200ms.

Storage costs get insane fast. That innocent 1GB file storage on the free tier? We burned through it in 2 weeks with user avatars. The overage charges hit almost $50 before I noticed. Storage pricing scales at $0.021/GB/month, which sounds reasonable until you're at 50GB wondering why your bill doubled.

Real-time doesn't scale like they claim. Our chat feature worked perfectly with 20 users. At 200 concurrent users, messages started arriving 2-3 seconds late. The broadcast feature that's supposed to handle thousands of connections? It choked hard and started dropping WebSocket connections randomly.

Why I Started Looking Elsewhere

The breaking point was during our Series A pitch. Right in the middle of our demo, the real-time updates just died. Error logs showed WebSocket connection to 'wss://realtime.supabase.co' failed. Our investor asked if our "infrastructure was production-ready." I wanted to crawl under the table.

Then their recent pricing changes moved row-level security from free to Pro tier. Not the end of the world, but it bumped our monthly cost from something like $25 to around $75 across multiple projects. When you're bootstrapping, that extra few hundred a year hurts.

The Search for Something That Doesn't Suck

I spent 3 weeks testing PocketBase, Nhost, Firebase, AWS Amplify, Appwrite, Convex, and a few others. Most have their own bullshit, but some actually work better for specific use cases.

PocketBase runs everything in a single 15MB binary. Sounds too good to be true, and mostly it is, but for smaller apps it's surprisingly solid.

Nhost gives you Hasura GraphQL out of the box, which is either awesome or overwhelming depending on your team.

Firebase is still Google's overpriced nightmare, but the real-time database actually works at scale.

AWS Amplify will make you question your career choices, but if you're already in the AWS ecosystem, it's not terrible.

The truth? There's no perfect backend service. But depending on what broke in Supabase for you, there's probably something that sucks less for your specific use case. Here's what I learned the hard way.

Want specifics? Check real user experiences on Reddit where developers share actual migration stories and costs.

PocketBase: The One That Actually Doesn't Suck

I was skeptical. How can a 15MB binary replace an entire backend? Turns out, for smaller apps, it fucking works.

My test setup: E-commerce site with 1,200 products, user auth, file uploads. Threw it on a $5/month DigitalOcean droplet. The whole migration from Supabase took 6 hours - I couldn't believe it either.

What actually works: Real-time updates stay solid up to about 500 concurrent connections. The admin UI shits all over Supabase's dashboard. File uploads just work without you having to sacrifice a goat. Authentication doesn't randomly explode like Firebase.

Where it breaks: SQLite starts choking around 50k users with heavy concurrent writes. No connection pooling means you'll hit limits faster than PostgreSQL. Complex queries get slow without proper indexing.

Real cost: $5/month for hosting + $10/month for backups = $15/month total. Way better than that $300+ Supabase bill.

AWS Amplify: The Soul-Crushing Experience

Don't do this to yourself unless you're already deep in AWS hell and hate weekends.

My nightmare: Spent 2 weeks setting up what should've been a simple CRUD app. Their CLI tool generated way too many CloudFormation files - I stopped counting after like 30. Each deployment takes 8-12 minutes of watching progress bars. Rolling back a broken deployment? Hours of pain.

The DynamoDB clusterfuck: Their default database is DynamoDB, which means throwing out everything you know about SQL and learning their weird NoSQL shit. My nice relational e-commerce data turned into a nightmare of nested JSON objects that made zero sense.

Cost explosion: That "pay-per-use" pricing? My test app with 50 users cost $89/month because DynamoDB read units are expensive and every page load triggers 12 separate API calls.

When it might not suck: If you're already using Cognito, S3, and Lambda, and you have a dedicated DevOps person who enjoys pain.

Appwrite: Docker Hell But Worth It

Appwrite is what Supabase should've been - if you can handle the Docker complexity.

My setup pain: Runs about a dozen containers for the database, cache, monitoring, and a bunch of other stuff. Took me 2 days to get monitoring and backups working properly. The Docker Compose file is like 300 lines of pure terror.

What's actually good: The web console is actually pretty nice - way better than Supabase's dashboard. Multiple database support means I could keep my PostgreSQL data structure. The 30+ SDKs are well-maintained.

Resource reality: Needs 4GB RAM minimum for production. My 8GB server runs comfortably with 500 concurrent users. Self-hosted means your 3am outages are your problem, not theirs.

Migration timeline: 3 weeks total. 1 week for Docker setup and DevOps. 2 weeks migrating data and rewriting API calls. Would've been faster if their migration docs weren't garbage.

Nhost: GraphQL If You're Into That Sort of Thing

Nhost pairs PostgreSQL with Hasura, which is either amazing or overwhelming depending on your team.

GraphQL learning curve: If your team knows SQL but not GraphQL, budget 2-3 weeks for the learning curve. The Hasura console is powerful but complex as fuck.

Real performance: Handles 2,000 concurrent GraphQL subscriptions without breaking a sweat. Their real-time is actually faster than Supabase's. But the query complexity limit will bite you - learned this when our product catalog query hit the depth limit.

Cost reality: $25/month minimum becomes $75/month with backup and staging environments. Still cheaper than our Supabase bill, but not by much.

Convex: TypeScript Paradise or Vendor Lock-in Hell?

Convex has the smoothest development experience I've ever used. Also the most terrifying vendor lock-in.

The good: TypeScript database queries that feel like magic. Reactive updates that actually work. No API layer needed - your functions run on their servers.

The terrifying: Proprietary query language. Proprietary runtime. Proprietary everything. If they go out of business or jack up prices, you're rebuilding from scratch.

Performance: Handled 1,000 concurrent users flawlessly during my stress test. But I've never seen it tested beyond that scale.

My verdict: Amazing for prototypes and MVPs. Too risky for anything you plan to scale or maintain long-term.

What Actually Matters

PocketBase for small apps where you control the hosting and don't need massive scale.

Appwrite if you have DevOps skills and want full control without the Supabase pricing bullshit.

Nhost if your team already knows GraphQL and needs real-time performance.

Everything else has too many gotchas or costs too much to recommend unless you have specific needs.

Skip Firebase (overpriced), skip AWS Amplify (soul-crushing), and definitely skip anything that requires learning a proprietary query language.

My Migration Timelines (Real Numbers)

PocketBase: 6 hours total.

Simple e-commerce app with user auth and product catalog. Exported JSON from Supabase, imported to PocketBase, changed API URLs. Easiest migration ever.

Appwrite: 3 weeks.

Same app, but self-hosted. 1 week learning Docker, 1 week fighting with their 14-container setup, 1 week migrating data and testing. Docker knowledge required or you're fucked.

Nhost: 2 weeks.

PostgreSQL migration was smooth, but GraphQL learning curve killed time. Team spent 40 hours rewriting REST calls to GraphQL queries.

Firebase: 6 weeks of hell.

Complete data model redesign from SQL to NoSQL. Relationships became nested objects. Query logic completely rewritten. I don't recommend this unless you're desperate.

The Hidden Costs Nobody Tells You

Self-hosting isn't free.

PocketBase on a $5/month VPS needs automated backups (another $10/month), monitoring (maybe $20/month for something decent), and SSL certificates (free with Let's Encrypt, but setup takes time). Total: around $35/month plus however much time you spend babysitting it.

My Appwrite server costs:

Around $40/month for an 8GB DigitalOcean droplet plus backups and stuff. Add in a few hours of monthly maintenance and the opportunity cost gets expensive fast. Cheaper than Supabase if your time is free, which it never is.

AWS killed my budget.

Test app with like 50 users hit almost $90/month on Amplify because DynamoDB read units are expensive. Each page load triggered a bunch of API calls. Math is brutal.

Nhost's real cost:

$25/month starter + staging and backups brings it to around $75/month. Plus a couple weeks learning GraphQL fundamentals which ain't cheap if you factor in developer time. Sometimes that Supabase bill starts looking reasonable.

Performance Reality (Actually Tested)

Hasura vs Supabase:

Tested identical queries on both. Hasura was noticeably faster - maybe 25-30ms vs Supabase's 40-50ms. Better, but nowhere near the "sub-5ms" bullshit you read in their marketing. Those microsecond claims? Pure marketing fantasy.

PocketBase stress test:

Started choking on WebSocket connections around 500 concurrent users on a 2GB VPS. Supabase crapped out around 240-250 users during our demo. PocketBase wins, but both are pretty shit for real-time chat.

Appwrite on dedicated hardware:

8GB RAM server handled 800 concurrent users smoothly. Database queries averaged 12ms. Faster than Supabase's shared infrastructure, but required babysitting the server.

Firebase real-time:

Handles 5,000+ concurrent users reliably. Expensive as hell ($180/month for our use case), but the real-time database actually works at scale.

What Breaks During Migration

Authentication is always a nightmare.

Password hashes don't transfer between systems. Forced password resets piss off users. OAuth needs reconfiguration. Budget 1 week minimum for auth migration.

File uploads require rewriting.

Supabase Storage URLs turn into broken links. You've got to migrate all files to the new service and update every reference. I completely forgot about this during my first PocketBase migration - users couldn't see their avatars for like 2 days and the support tickets were brutal.

Real-time features break.

WebSocket connection code needs complete rewrite for most alternatives. PocketBase, Appwrite, and Nhost all use different syntax. No drop-in replacements.

Database relationships get messy.

PostgreSQL foreign keys work in Nhost, break in PocketBase (SQLite), and become nightmare NoSQL queries in Firebase. Test your most complex queries first.

Lessons From 3 Migrations

Start small.

Migrate a simple feature first, not your entire app. I moved user profiles before touching the e-commerce logic.

Run in parallel.

Both systems during testing. Redirect 5% of traffic to new backend. Caught authentication bugs before full cutover.

Plan for rollback.

Keep Supabase running for 2-4 weeks after migration. Users will find edge cases you missed in testing.

Communication is crucial.

Warned users about password resets 1 week before migration. Still got angry support tickets, but fewer than expected. Use email templates and status pages for better user communication.

When NOT to Migrate

If Supabase works and you're profitable,

optimize your usage instead. Better connection pooling, query optimization, and caching often solve performance issues cheaper than migration.

If your team is small,

migration burns 1-2 months of development time. Sometimes that $347/month is cheaper than opportunity cost of lost features.

If you're close to raising funding,

investors care about growth metrics, not backend costs. Optimize revenue first, infrastructure second.

If you have complex real-time features,

Firebase is still the most reliable option. Expensive but battle-tested at massive scale.

The truth? Most migrations happen because of cost, not technical limitations. Do the math on developer time costs vs. monthly savings before starting. Check migration case studies from other developers who've been through this.