PocketBase vs Supabase
PocketBase and Supabase compared for app backends: one SQLite binary vs managed PostgreSQL, auth, realtime, server logic, free-tier limits, Pro pricing and self-hosting as of October 2026.
Quick Answer
PocketBase is an MIT-licensed backend in one executable: embedded SQLite, auth, files, realtime and an admin UI, self-hosted only, scaling on one server, still pre-1.0 and run as a personal volunteer project. Supabase is a company-backed platform built on a dedicated PostgreSQL database per project, with managed hosting (Free, then Pro from $25/month), Edge Functions and a heavier Docker Compose stack if you self-host. Pick PocketBase for small apps on one VPS with zero ops; pick Supabase when you need Postgres, managed backups or room to grow.
Last updated October 29, 2026. Covers PocketBase v0.41.1 (current on pocketbase.io; repository moved off GitHub) and Supabase's current Free, Pro and Team pricing, compute sizes and self-hosting docs (self-hosted/v0.8.3), as of 29 Oct 2026.
| Feature | PocketBase | Supabase |
|---|---|---|
| Licence | MIT | Apache-2.0 |
| Managed Hosting | None (self-hosted only) | Supabase Cloud: Free, Pro, Team, Enterprise |
| Free Tier | Free software; you pay only for your server | 2 active projects, 500 MB DB, 50k MAU; pauses after 1 week idle |
| Entry Paid Plan | None | Pro from $25/month (includes $10 compute credit) |
| Database | Embedded SQLite (WAL mode) only | Dedicated PostgreSQL per project |
| Scaling Model | Vertical only, single server | Compute add-ons up to 64 vCPUs / 256 GB RAM |
| Realtime | Record subscriptions via the SDKs | Postgres Changes; 200 / 500 peak connections (Free / Pro) |
| Auth Methods | Password, email OTP, MFA, 15+ OAuth2 providers | Email, social OAuth, anonymous, MFA; SAML SSO on Pro+ |
| Custom Server Logic | Go framework or JS hooks (embedded ES5 engine) | Edge Functions (500k / 2M invocations Free / Pro) |
| File Storage | Local disk or S3-compatible; ~5 MB default per file field | 1 GB / 100 GB included (Free / Pro); 50 MB / 500 GB max upload |
| Self-Hosting | One executable, no external dependencies | Docker Compose stack; min 4 GB RAM, 2 cores, 40 GB SSD |
| Maturity / Backing | Pre-1.0 (v0.41.1); personal volunteer project | Company-backed; ~114k GitHub stars |
Pricing at a glance
Entry prices and free tiers as listed on TechLogHub for Supabase; the other tool is not listed in the directory yet.
| Tool | Free tier | Starts at | Billing | Plans listed |
|---|---|---|---|---|
| Supabase pricing | Yes | — | — | Free · Pro · Enterprise |
Prices as written by the maker on their listing; medians and context on each tool's pricing page. See the 2026 pricing report for the directory-wide picture.
PocketBase
Open-source Go backend shipped as a single executable, with embedded SQLite, realtime subscriptions, auth, file storage and an admin dashboard.
Pros
- The whole backend is one file: database, auth, file storage, realtime and an admin dashboard, deployed by copying the executable to a server
- Automatic Let's Encrypt TLS when you start it with your domain (pocketbase serve yourdomain.com)
- Light on hardware; the author reports 10,000+ persistent realtime connections on a $4 Hetzner CAX11 (2 vCPU, 4 GB RAM)
- Extend it as a Go framework or with JavaScript hooks in pb_hooks, and still deploy a single portable binary
- Built-in backups that snapshot pb_data to a ZIP, stored locally or in S3-compatible storage
- MIT licensed, with no plans, quotas or project pausing
Cons
- SQLite only on a single server: no horizontal scaling, and replication needs a companion tool such as Litestream
- Pre-1.0: the README warns that full backward compatibility is not guaranteed before v1.0.0
- A personal project developed on a volunteer basis, with no company, paid support or hosted offering
- No cloud-functions model and no prebuilt login screens; you build auth UI yourself with the SDKs
- Only two official SDKs (JavaScript and Dart), no official Docker image, and file fields default to about 5 MB per file
Best For
Solo developers and small teams shipping side projects, internal tools, MVPs or small SaaS apps on one VPS, who want near-zero ops and are happy to build their own auth UI.
Supabase
Open-source backend platform built around a dedicated PostgreSQL database per project, with auth, storage, realtime and Edge Functions, offered as a managed cloud or self-hosted with Docker.
Supabaseon TechLogHub: reviews, pricing & alternativesPros
- A real, dedicated PostgreSQL database per project, so standard SQL and Postgres tooling apply
- Managed hosting with a usable free plan: unlimited API requests, 50,000 MAU and 500,000 Edge Function invocations
- Room to grow: compute add-ons scale to 64 vCPUs and 256 GB RAM, with disks up to 64 TB
- Broad auth on every plan, including social OAuth, anonymous sign-ins, an OAuth 2.1 server, basic MFA and custom SMTP
- Apache-2.0 licensed with an official Docker Compose self-hosting path
- Large community (~114k GitHub stars) and a company behind it
Cons
- Free projects pause after one week of inactivity, and you get two active free projects
- Costs stack up: $25 Pro base, extra projects from $10/month, compute beyond the Micro credit, and PITR at $100/month per 7 days of retention
- Self-hosting is a multi-service stack needing 4 GB RAM minimum (8 GB+ recommended), and it lacks branching, managed backups/PITR, ETL and the Management API
- Self-hosted Studio handles one project only, and self-hosted support is community-only
- SAML SSO for your app's users is not on Free; on Pro it is 50 MAU included, then $0.015 per MAU
Best For
Apps that need PostgreSQL, managed hosting with backups, team access or a clear path past one server.
Architecture: one binary vs a Postgres platform
PocketBase describes itself as an open-source backend in one file. The executable bundles an embedded SQLite database in WAL mode with realtime subscriptions, user and file management, an admin dashboard and a REST-ish API. You download it, run pocketbase serve, and you have a backend; give it a domain and it fetches a Let's Encrypt certificate itself. Custom logic is written either by importing PocketBase as a Go library and compiling your own binary, or with JavaScript files in a pb_hooks folder run by an embedded ES5 engine. The FAQ is explicit that it does not do cloud functions and that it will not support databases other than SQLite. Supabase is a set of services around a dedicated PostgreSQL database for each project: auth, storage with a CDN, realtime (including Postgres Changes), Edge Functions and the Studio dashboard. Because the core is Postgres, your data model is ordinary SQL and any Postgres client or migration tool works against it. That difference decides most of the comparison. PocketBase optimises for having nothing to operate; Supabase optimises for giving you a full Postgres-based platform, which brings more power and more moving parts.
What it costs
PocketBase has no pricing at all. It is MIT-licensed, self-hosted only, and the project does not offer hosting or accept donations; your cost is the server. The FAQ points to free cloud tiers or small VPS providers such as Hetzner, Vultr, UpCloud and Linode. Supabase's Free plan gives unlimited API requests, 50,000 monthly active users, a 500 MB database, shared CPU with 500 MB RAM, 5 GB egress, 1 GB file storage, 500,000 Edge Function invocations and 200 concurrent realtime connections. Free projects pause after a week of inactivity, with a limit of two active projects. Pro starts at $25 a month and includes 100,000 MAU (then $0.00325 each), 8 GB disk per project (then $0.125 per GB), 250 GB egress (then $0.09 per GB), 100 GB storage, 2 million function invocations, 500 realtime connections, daily backups kept 7 days and $10 of compute credit, enough for one Micro instance. Additional projects start at $10 a month; compute runs from Micro at $10 (1 GB) to 16XL at $3,730. Point-in-time recovery is $100 a month per 7 days of retention, and Team is $599 a month. A spend cap is on by default on Pro, so overages need opting into.
Scaling limits and where each breaks
PocketBase's FAQ answers 'does it scale?' with 'only on a single server, aka vertical'. Its author argues most apps do not need a fleet and reports that, without tuning, PocketBase can hold 10,000+ persistent realtime connections on a $4 Hetzner CAX11 with 2 vCPUs and 4 GB RAM; treat that as the project's own figure. The practical ceilings are elsewhere: one SQLite file means one writer process and one machine, and replication or disaster recovery needs a separate tool such as Litestream. Backups are a ZIP snapshot of pb_data, and the docs suggest a different strategy once that directory grows past about 5 GB. File fields default to roughly 5 MB per file, adjustable but with a warning about performance. Supabase scales the way Postgres does on managed infrastructure: you move a project up compute sizes, from shared Micro instances to dedicated machines with up to 64 vCPUs and 256 GB RAM, with connection limits rising from 60 direct and 200 pooled to 500 direct and 12,000 pooled. Disks go to 64 TB on general-purpose storage. Paid plans also add branching, ETL pipelines and a Smart CDN. If your growth plan includes multiple regions, heavy concurrent writes or large analytical queries, Supabase has headroom PocketBase deliberately does not.
Self-hosting: one file vs a Compose stack
Self-hosting is where PocketBase is strongest. The going-to-production guide is a handful of steps: rsync the executable plus your pb_migrations and pb_hooks folders to a server, run it with your domain for automatic TLS, and optionally add a systemd unit. It works behind NGINX or Caddy if you host several apps, and there is no official Docker image, only a minimal example Dockerfile. Upgrades are a binary swap, though the pre-1.0 warning about backward compatibility means you should read release notes first. Supabase's official self-hosting path is Docker Compose. Its docs ask for at least 4 GB RAM, 2 CPU cores and a 40 GB SSD, and recommend 8 GB, 4 cores and 80 GB for comfort; you can trim services such as Realtime, Storage, imgproxy or Edge Runtime to save resources. Logs and analytics are off by default. A self-hosted install is a single project, Studio cannot manage multiple organisations or projects, and branching, advanced metrics, managed backups and PITR, analytics and vector buckets, ETL and the Management API are not available. You are responsible for hardening, Postgres maintenance, backups and high availability, and support is community-based. Kubernetes options exist but are community-maintained. If you chose self-hosting to avoid ops work, PocketBase delivers that; Supabase self-hosted is a real platform to run.
Project risk and maturity
The softer factor is who stands behind each project. PocketBase's FAQ is unusually candid: it is 'neither a startup, nor a business', there is no paid team, it is developed on a volunteer basis with intentionally limited scope, and there are no promises of maintenance beyond what exists. The README still warns that backward compatibility is not guaranteed before v1.0.0, and the repository notice says the code has moved off GitHub to the author's own forge. At the same time it is popular (around 61.6k stars on the GitHub repo) and releases regularly, with the site currently showing v0.41.1, and its MIT licence and single-binary design mean you can keep running a version indefinitely. Supabase is a company with paid plans, SOC 2 and ISO 27001 on Team, HIPAA as an add-on and enterprise support, and the main repository has around 114k GitHub stars under Apache-2.0. The risk there is cost and lock-in to platform-only features rather than abandonment; plain Postgres data is portable, but branching, ETL and managed backups exist only on the cloud. For a weekend project the PocketBase trade-off is easy. For a product with paying customers, factor in whether you are comfortable depending on a volunteer-run pre-1.0 core.
Verdict
Choose PocketBase when the whole app comfortably fits on one server: prototypes, internal tools, mobile backends and small SaaS products where a single binary and SQLite on a small VPS beat running a platform, and where you accept a pre-1.0 project maintained as a personal volunteer effort. Choose Supabase when you need PostgreSQL itself, managed hosting with backups, team access, or a clear path beyond one machine; its Free plan suits experiments, but production realistically means Pro at $25 a month plus any compute above the Micro credit. If self-hosting is the point, PocketBase is far simpler to run, while self-hosted Supabase needs at least 4 GB RAM and gives up branching, managed backups and PITR.