Supabase vs Firebase vs Appwrite vs PocketBase - Which Backend Won't Fuck You Over

Supabase: PostgreSQL with Batteries Included

The Good News

Supabase is basically PostgreSQL with a REST API and real-time subscriptions. If you know SQL, you'll feel at home. If you're coming from NoSQL hell, prepare to remember why relational databases exist.

Performance Reality

I've pushed Supabase to around 18K concurrent users (maybe 22K during Black Friday) before getting connection pool exhausted errors. The problem wasn't Supabase - it was my dumbass JOIN query across 5 tables that looked fine in development but murdered the connection pool in production. PostgreSQL lets you write actual joins, but just because you CAN doesn't mean you should without proper indexing.

Production War Stories

We migrated from Firebase to Supabase and it took 3 months, not the "few weeks" everyone promises. Firestore's document model doesn't map cleanly to SQL relationships. Budget way more time than you think.

The migration took forever, but once we finished, our reporting queries went from 15-second nightmares to 2-second wins. Actually worth the pain.

Cost Reality Check

Pro plan is $25/month, which is reasonable until you factor in storage costs of $0.125/GB after your 8GB limit. Adds up fast if you're storing images or files. But honestly, it's still cheaper than Firebase if you're doing any real work.

Firebase: The Roach Motel (Easy to Get In, Hell to Get Out)

For Mobile? No Contest

Firebase is bulletproof for mobile apps. The SDKs are rock solid and offline sync just works. If you're building iOS/Android first, this is your answer.

Firestore's Weird Query Hell

Firebase real-time is black magic - it just works. But Firestore's query limitations will drive you insane. Want to query on multiple fields? Nope, create a composite index. Want to do a simple NOT IN query? Good fucking luck. You'll end up writing horrible client-side filtering code.

Pricing Surprise Party

Firebase billing will fuck you sideways. That pricing calculator? Might as well use a magic 8-ball. We got hit with an $847 bill at 3am on Saturday because our real-time listener got stuck in a loop - kept reading the same 50 documents over and over again. 2.3 million document reads in 6 hours. The worst part? Firebase doesn't have circuit breakers to stop runaway queries. You just get fucked and billed for it.

Vendor Lock-in Reality

Firebase gets you hooked with convenience, then the bills destroy your budget. Every database read costs money, and your app reads way more than you think. Migrating off Firebase? Hope you like rewriting everything. It's designed to be a roach motel.

Appwrite: The Underdog with Potential

What They're Trying to Do

Appwrite wants to be everything to everyone - web, mobile, server. It's like Firebase but with more database options and better self-hosting. They bumped pricing from $15 to $25/month as of September 2025, which tells you they're burning cash trying to catch up.

The Good Parts

Credit where it's due - unlike Firebase's Firestore weirdness, Appwrite lets you choose your database. Want MongoDB? Sure. MySQL? Fine. The SDKs are decent and the admin panel doesn't suck. Self-hosting is actually well documented, unlike some platforms.

The Reality Check

Appwrite is fighting an uphill battle. Firebase has mobile locked down, Supabase has the PostgreSQL crowd, and PocketBase has the indie developers. Appwrite's trying to be in the middle of everything, which means they're not the best at anything specific.

When to Use It

If you need multi-database support or want to hedge your bets with self-hosting options, Appwrite makes sense. The documentation has gaps, but the community on Discord actually helps instead of telling you to read the docs.

PocketBase: The Single Binary That Actually Works

Holy Shit, It's One File

PocketBase is the entire backend in one fucking file - a 10MB Go binary. Download it, run it, you're done. Database, auth, file uploads, real-time - it's all there. No Docker, no Kubernetes, no bullshit.

SQLite Performance Reality

PocketBase handles reads like a beast - seriously fast. But SQLite chokes when multiple users write simultaneously. I learned this the hard way during a product launch - hit around 400 concurrent users trying to sign up and started getting database is locked errors. SQLite queues all writes behind each other. Fine for blogs, disaster for anything with real user interaction.

Development Experience

Local development IS production. The admin UI is surprisingly decent for a Go app. Schema migrations are just SQL files. No complicated deployment pipelines, no environment variable hell.

Honestly? It's refreshing in a world of overcomplicated infrastructure. Sometimes simple just works.

The Indie Developer's Best Friend

A $5/month VPS can run multiple PocketBase instances. No monthly subscription fees eating into your indie SaaS profits. But when you need to scale beyond one server, you're on your own. No managed scaling, no support team to call at 3am.

Just Tell Me What to Use

Use Supabase If

You know SQL and want PostgreSQL with an API. Building a SaaS with complex reporting needs. Want to self-host later. Don't mind paying for actual database features.

Use Firebase If

Building mobile apps. Need bulletproof real-time features. Want Google's ecosystem. Don't mind vendor lock-in and weird billing surprises.

Use Appwrite If

You need multi-database support or want to hedge your bets with self-hosting. Building across multiple platforms simultaneously. The Discord community seems helpful.

Use PocketBase If

You're an indie dev who wants to keep things simple. Building content sites or low-write apps. $5/month VPS sounds better than $25/month SaaS. You can handle scaling yourself when the time comes.

Escaping Firebase Hell (And Other Migration Nightmares)

Firebase to Anything Else: Migrating from Firebase is like getting out of a subscription to the gym - they make it as painful as possible. Spent 4 months (not 3) rewriting everything because Firestore's nested document bullshit doesn't translate to normal database tables. Here's what they don't tell you:

• Your "users/{userId}/posts/{postId}" becomes a foreign key nightmare in SQL
• Those clever Firestore security rules? Rewrite them as RLS policies (fun!)
• Real-time listeners that "just worked" now need WebSocket debugging at 3am
• "Zero downtime migration" is a lie - budget for weekend maintenance windows

The Chatbase migration story mentions "3-4 weeks" but that's probably just the database part. Factor in testing, auth migration, and fixing all the edge cases you forgot about.

SQL Platform Hopping: Moving between Supabase, Appwrite, and PocketBase is less painful because they all speak SQL. But you'll still hit these gotchas:

• API endpoints change (REST vs GraphQL vs whatever PocketBase calls theirs)
• Auth providers need reconfiguration (your OAuth apps need new redirect URLs)
• File uploads go to different buckets/paths
• Cloud functions become edge functions become... PocketBase hooks?

PocketBase Is the Exit Strategy: PocketBase is just SQLite and a binary. Want to migrate away? Copy the .db file and you're done. Want to migrate TO PocketBase? Hope your write concurrency isn't too crazy because SQLite only handles one writer at a time.

Community Support Reality Check

Stack Overflow Tells the Story: Firebase has 89K+ questions on Stack Overflow. Supabase has 3,200+. PocketBase has like 200. Look, I'm not saying popularity equals quality, but when you're debugging at 3am with production down, guess which platform has answers to your exact fucking problem?

Integration Ecosystem: Firebase wins because it's been around forever. Every framework has Firebase tutorials, every service has Firebase webhooks, every developer has copy-pastable Firebase code. Supabase is catching up fast, but you'll still hit "no examples found" more often.

Documentation Quality: Firebase docs are comprehensive but sometimes outdated. Supabase docs are newer and cleaner but have gaps. Appwrite docs are improving but still patchy. PocketBase docs are minimal but at least they're accurate - probably because there's less to document.

Performance: What Actually Matters

Database Speed: PostgreSQL on Supabase absolutely destroys Firestore for anything with JOINs. Our user dashboard query went from 12 seconds (Firestore client-side filtering hell) to 1.8 seconds in Postgres. But grabbing a single document by ID? Firestore wins - 50ms vs 120ms. PocketBase is stupid fast for reads (SQLite is optimized for that) but the moment two users try to POST simultaneously, you get database is locked errors.

Real-Time Performance: Firebase real-time is black magic - it just works everywhere. Supabase real-time works but you'll spend time debugging WebSocket connections. PocketBase real-time is fine for simple stuff but don't expect Firebase-level magic.

Function Performance: Firebase Cloud Functions have cold start issues (300ms+ on a bad day). Supabase Edge Functions are faster (Deno runtime starts quick) but the ecosystem is smaller. PocketBase "functions" are just Go hooks, so they're instant but less flexible.

Security: The Boring Stuff That Matters

Auth Implementation: Firebase auth just works - social logins, MFA, password resets, all handled. Supabase auth is solid but you'll debug magic link deliverability issues. Appwrite auth is decent with good OAuth support. PocketBase auth is basic but functional.

Compliance Nightmares: Need HIPAA? Firebase has you covered (if you pay). Supabase got SOC 2 in 2024. Appwrite offers compliance on higher tiers. PocketBase? You're on your own - good luck explaining SQLite files to your compliance auditor.

Security by Default: Firebase and Supabase encrypt everything automatically. Appwrite does too in the cloud. PocketBase requires you to set up SSL yourself, and if you forget, your API is sitting naked on the internet.

Will These Platforms Still Exist in 5 Years?

Who's Got Money: Firebase is backed by Google's infinite cash pile - it's not going anywhere. Supabase raised $80M in 2022 and is growing fast. Appwrite got $27M but is fighting an uphill battle.

Now here's the twist - PocketBase is one guy's project but it's so simple it'll probably outlive us all. Sometimes the scrappy underdog wins just by not trying to do everything.

Development Speed: Firebase ships features constantly but half of them get deprecated later. Supabase moves fast and breaks things (in a good way). Appwrite is trying to keep up but resources are limited. PocketBase barely changes because it doesn't need to.

Lock-in Risk Assessment:

• Firebase: You're trapped. Good luck getting out.
• Supabase: It's open source PostgreSQL, you can always leave
• Appwrite: Open source core, but some cloud features are proprietary
• PocketBase: It's just SQLite and Go, ultimate freedom

The Real Decision Framework

Just Starting Out? Firebase for mobile, PocketBase for simple web apps. Don't overthink it.

Building Something Serious? Supabase if you want PostgreSQL power, Firebase if you need Google's ecosystem, Appwrite if you have specific multi-platform needs.

Worried About Costs? PocketBase on a VPS beats everything, but you'll handle scaling yourself.

Need Enterprise Features? Firebase or Supabase. Appwrite is getting there but isn't ready for the big leagues yet.