Single-file Go backend with SQLite
PocketBase is a single-file Go backend with SQLite built in. It is fast to prototype with and easy to self-host. nself uses PostgreSQL, Hasura GraphQL, and a plugin ecosystem. The trade-off is simplicity versus scale and extensibility.
See the [full comparison table](/compare) for a side-by-side view across nself, Supabase, Nhost, Firebase, and Appwrite.
Single binary, zero dependencies. PocketBase ships as one Go binary. Drop it on a server, run it, done. No Docker, no Compose, no Postgres to manage. For a personal project or hobby app, this is hard to beat. Source: [PocketBase docs](https://pocketbase.io/docs/).
Extremely fast cold start. A PocketBase instance starts in under a second. nself starts a full stack (Postgres, Hasura, Auth, Nginx) which takes 20-30 seconds on first boot. Source: [PocketBase quickstart](https://pocketbase.io/docs/going-to-production/).
SQLite for low-traffic apps. SQLite avoids the memory overhead of a separate Postgres process. For apps with under 1K daily active users and modest data sizes, SQLite is often faster and simpler. Source: [PocketBase architecture](https://pocketbase.io/docs/).
Built-in admin UI. PocketBase ships a real-time admin dashboard at `/_/`. No separate install step, no Docker image, no localhost port to remember. Source: [PocketBase admin UI](https://pocketbase.io/docs/manage-app/).
PostgreSQL at scale. SQLite has known limits: single writer, no native JSON aggregation operators, limited concurrent reads under high load. nself uses Postgres with full JSONB support, pgvector for AI embeddings, and ltree for hierarchical data. Source: [PostgreSQL feature list](https://www.postgresql.org/about/).
Plugin ecosystem. nself has 87 plugins for AI assistants, media processing, real-time chat, billing, monitoring, and email. PocketBase has community plugins but no installable marketplace. Source: [nself plugins](https://docs.nself.org/plugins).
Multi-tenancy. nself supports multiple tenants per deploy via table prefixes and Hasura role isolation with custom domains. PocketBase has no built-in multi-tenancy. Source: [nself multi-tenancy](https://docs.nself.org/guides/multi-tenancy).
GraphQL API. nself uses Hasura for a full GraphQL API with subscriptions, computed fields, and remote schemas. PocketBase provides a REST API with limited filtering; no native GraphQL. Source: [Hasura GraphQL](https://hasura.io/docs/latest/queries/postgres/index/).
Managed admin GUI for teams. nself Admin runs at `localhost:3021` with plugin management, service health, and environment switching. PocketBase's admin is built in but limited to its own collections. Source: [nself admin](https://docs.nself.org/admin).
*Prices from public sources, verified April 2026.*
| Scale | nself | PocketBase |
|-------|-------|------------|
| **Personal project** | $5/mo VPS | Free (open-source) |
| **Small team (10K MAU)** | $5/mo VPS | Free + $5-10/mo VPS |
| **Growth (100K MAU)** | $10-20/mo VPS | SQLite limits may require migration |
Both are open-source and self-hosted. PocketBase has no hosting cost beyond your VPS. nself is the same. The real difference is database capability and ecosystem breadth.
1. You need PostgreSQL features: JSONB, pgvector, ltree, full-text search, concurrent writes
2. You want a plugin ecosystem for AI, media processing, or real-time chat
3. You need multi-tenancy or white-label deployment
4. You need GraphQL subscriptions, computed fields, or remote schema stitching
5. Your app will exceed 1K concurrent writers
1. You want the fastest possible prototyping path with a single binary
2. Your data fits comfortably in SQLite and load is low
3. You want zero infrastructure overhead for a personal project
4. You prefer a REST API over GraphQL
5. You do not need plugins or a multi-tenant architecture
Moving from PocketBase to nself. PocketBase stores data in SQLite; nself uses PostgreSQL.
### Step 1: Export PocketBase data
# Use PocketBase admin API to export collections
curl -s http://localhost:8090/api/collections \
-H "Authorization: Bearer YOUR_ADMIN_TOKEN" \
> pb_collections.json
# Export all records per collection
curl -s "http://localhost:8090/api/collections/YOUR_COLLECTION/records?perPage=500" \
-H "Authorization: Bearer YOUR_ADMIN_TOKEN" \
> pb_records.json### Step 2: Install nself
curl -fsSL https://install.nself.org | sh
nself init my-project
cd my-project
nself start### Step 3: Create Postgres schema from PocketBase collections
# Open Hasura console to create tables matching your PocketBase schema
nself hasura console
# Manually create tables matching your PocketBase collection fields
# PocketBase types map: text->text, number->numeric, bool->boolean, date->timestamptz### Step 4: Import records via SQL
# Write a migration script to INSERT pb_records.json into Postgres
# Then verify the import
nself db psql -c "SELECT COUNT(*) FROM your_table;"**Can I use PocketBase alongside nself during migration?**
Yes. Run both on different ports. Migrate collection by collection and test your app against nself before shutting down PocketBase.
**Does nself have a REST API like PocketBase?**
nself uses Hasura GraphQL as the primary API. You can add REST endpoints via Hasura REST endpoints or expose custom REST routes through the Functions plugin.
**Is nself harder to run than PocketBase?**
Yes. nself manages multiple services (Postgres, Hasura, Auth, Nginx). PocketBase is one process. The trade-off is that nself gives you a production-grade stack; PocketBase gives you a development shortcut.
**Can nself replace PocketBase for small personal projects?**
It can, but it is overkill for a single hobby project. If you outgrow SQLite or need AI/chat/media plugins, nself is the natural next step.
[Install nself](https://install.nself.org) | [View pricing](/pricing) | [See all comparisons](/compare)
MIT-licensed CLI. Full backend stack in 5 minutes.