PocketBase

Operator's take

Most no-code builders hit the same wall: they need a real backend — user accounts, a database they can query, somewhere to store uploads — but the options are either a managed BaaS that adds another monthly line item per seat, or a full server setup that requires a developer. PocketBase is the unusual third path: a single file you download, run with one command, and connect to a REST API. That's it. No server config, no managed dependencies, no cloud account needed before you can write your first record. For a solo builder or small team proving out an idea, this is the fastest you'll ever stand up a functional backend.

What makes it different from Supabase or Firebase isn't features — those platforms have more. It's the operational model. PocketBase runs entirely in your environment: a cheap VPS, a local machine, a Railway container. The database is a SQLite file, which means the whole thing backs up with a file copy and migrates with a scp. That simplicity is a genuine asset for small projects that will probably never need Postgres clusters, but the same property is also the ceiling: SQLite doesn't scale horizontally, and once you're running multiple instances or have serious write concurrency, you've outgrown it. The escape hatch is extending PocketBase in Go — it's built to be embedded as a library — but that step requires a developer and changes the operational model entirely.

The sweet spot is the project that needs a real backend but doesn't yet justify managed-cloud costs or devops overhead: MVPs, internal tools, freelance client builds where you want separate clean instances per client, or course platforms where you control the data. Operators running teams of ten or chasing enterprise contracts should look elsewhere; PocketBase doesn't have the multi-tenancy controls, audit logging, or managed uptime guarantees those use cases require.

What it's good at

• Zero-dependency deployment — a single executable runs on Windows, macOS, and Linux; no Docker required, no runtime to install.
• Batteries-included backend — realtime database with automatic REST API and WebSocket subscriptions, built-in email/password and OAuth2 auth (Google, GitHub, Facebook), file storage with optional S3 hand-off, and an admin UI — all from one binary.
• Genuinely free and open source — MIT licensed, self-hosted, no seats and no per-request billing; your only cost is the server you run it on.
• Fast to clone across projects — spinning up a second clean instance for a new client is a file copy and a port number; no cloud console to duplicate.
• Embeddable in Go — can be used as a Go framework for teams that want to add custom server-side logic without abandoning the PocketBase foundation.
• Lightweight operational footprint — the entire state is one SQLite file; backup, restore, and migrate by moving that file.

What it's not

• Not yet at v1.0 — backward compatibility not guaranteed — as of mid-2026 PocketBase is at v0.39.x and the project itself warns it's not recommended for production-critical applications until v1.0; upgrades occasionally require manual migration steps.
• Not horizontally scalable — SQLite means single-node; high write concurrency or multi-instance deployments aren't the design target, and you'll hit the ceiling before a managed BaaS would.
• Not managed — you own hosting, uptime, SSL, backups, and upgrades; PocketHost offers managed PocketBase hosting but that's a third-party service, not the core product.
• Not right for enterprise or compliance-heavy work — no built-in audit logs, role-based access controls beyond the basics, SLAs, or SSO out of the box.
• Not a no-code tool — connecting PocketBase to a frontend still requires writing API calls or using the JS SDK; it's a backend for people comfortable reading documentation, not a visual builder.