How to Deploy PocketBase on a Budget VPS — Free Firebase Alternative (2026)

One-sentence verdict: PocketBase gives you a full backend — database, auth, file storage, and real-time subscriptions — in a single 30 MB binary that runs happily on the cheapest VPS you can find.

Who This Guide Is For

• Indie developers shipping MVPs who want a backend without Firebase lock-in.
• Side-project builders who need auth + database + file uploads for under $5/month.
• Small teams replacing Supabase or Firebase for apps with fewer than 10,000 daily active users.
• Developers who want full data ownership and portable SQLite-based storage.

If you need horizontal scaling across multiple servers, managed Postgres, or enterprise-grade high availability out of the box, PocketBase is not the right fit. Look at managed Supabase or PlanetScale instead.

Why PocketBase on a VPS Makes Sense

PocketBase is a Go binary. No runtime dependencies. No Docker required (though it works fine in Docker). No database server to configure. It embeds SQLite, serves an admin dashboard, handles JWT auth, and exposes a REST + real-time API.

This means:

• 512 MB RAM is enough for most small apps.
• No cold starts — it’s always running, unlike serverless functions.
• Backups are trivial — one SQLite file to copy.
• Zero vendor lock-in — move the binary and database file to any server.

The trade-off: SQLite means single-writer. For read-heavy apps (blogs, dashboards, internal tools), this is fine. For write-heavy apps with thousands of concurrent writes per second, you’ll hit limits.

Minimum Server Requirements

PocketBase itself uses about 20–50 MB of RAM at idle. The rest goes to your OS, reverse proxy, and request handling under load.

Provider Comparison

Our pick for PocketBase: Hetzner CX22 or Contabo VPS S. Both give you more than enough resources at the lowest price, and PocketBase benefits from fast disk I/O for SQLite operations.

Step-by-Step Installation

1. Provision Your VPS

Spin up a fresh Ubuntu 22.04 or 24.04 instance. SSH in:

ssh root@your-server-ip

Update the system:

apt update && apt upgrade -y

2. Download PocketBase

Check the latest release and download:

mkdir -p /opt/pocketbase
cd /opt/pocketbase
wget https://github.com/pocketbase/pocketbase/releases/download/v0.25.0/pocketbase_0.25.0_linux_amd64.zip
unzip pocketbase_0.25.0_linux_amd64.zip
rm pocketbase_0.25.0_linux_amd64.zip
chmod +x pocketbase

Test it runs:

./pocketbase serve --http="0.0.0.0:8090"

Visit http://your-server-ip:8090/_/ to see the admin setup screen. Stop it with Ctrl+C — we’ll set up a proper service next.

3. Create a Systemd Service

Create a dedicated user:

useradd -r -s /bin/false pocketbase
chown -R pocketbase:pocketbase /opt/pocketbase

Create the service file:

cat > /etc/systemd/system/pocketbase.service << 'EOF'
[Unit]
Description=PocketBase Backend
After=network.target

[Service]
Type=simple
User=pocketbase
Group=pocketbase
WorkingDirectory=/opt/pocketbase
ExecStart=/opt/pocketbase/pocketbase serve --http="127.0.0.1:8090"
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

Enable and start:

systemctl daemon-reload
systemctl enable pocketbase
systemctl start pocketbase
systemctl status pocketbase

4. Set Up Caddy as Reverse Proxy (with automatic HTTPS)

Caddy handles TLS certificates automatically via Let’s Encrypt. Install it:

apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list
apt update && apt install caddy -y

Create your Caddyfile:

cat > /etc/caddy/Caddyfile << 'EOF'
api.yourdomain.com {
    reverse_proxy 127.0.0.1:8090
}
EOF

Restart Caddy:

systemctl restart caddy

Point your domain’s DNS A record to your VPS IP. Caddy will automatically provision an HTTPS certificate.

5. Configure the Firewall

ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw deny 8090/tcp
ufw enable

This ensures PocketBase is only accessible through Caddy’s HTTPS, not directly on port 8090.

Backup Strategy

PocketBase stores everything in a single pb_data directory. Daily backups are simple:

cat > /opt/pocketbase/backup.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/opt/pocketbase/backups"
mkdir -p "$BACKUP_DIR"
# Use SQLite's backup command for consistency
sqlite3 /opt/pocketbase/pb_data/data.db ".backup '$BACKUP_DIR/data_$(date +%Y%m%d_%H%M%S).db'"
# Keep only last 7 days
find "$BACKUP_DIR" -name "*.db" -mtime +7 -delete
EOF
chmod +x /opt/pocketbase/backup.sh

Add a cron job:

echo "0 3 * * * root /opt/pocketbase/backup.sh" >> /etc/crontab

For off-site backups, add rclone sync to S3-compatible storage (Backblaze B2 at $0.005/GB is ideal).

Performance Expectations

We benchmarked PocketBase on a Hetzner CX22 (2 GB RAM, 2 vCPU) with realistic API operations:

For context: 900 writes/sec handles roughly 5,000–8,000 active users making typical CRUD operations. Most indie apps never reach this.

Risks and Limitations

• Single-writer constraint — SQLite allows one write at a time. Under extreme concurrent write load, you’ll see “database is locked” errors. Solution: batch writes or switch to a Postgres-backed alternative like Supabase.
• No built-in horizontal scaling — You can’t run multiple PocketBase instances against the same database. One server = one instance.
• Backup window — While SQLite’s .backup is safe, very large databases (10+ GB) take several seconds during which writes queue.
• Community-maintained — PocketBase is a one-person project. Updates depend on one maintainer. Mitigation: the codebase is small and forkable.

When to Upgrade

Comparison: PocketBase vs Alternatives

Final Checklist Before Going Live

• Admin account created with a strong password
• PocketBase running as a systemd service (auto-restarts on crash)
• Caddy reverse proxy with HTTPS enabled
• Firewall blocks direct access to port 8090
• Daily automated backups configured
• DNS pointing to your VPS with low TTL initially
• Collection rules set (never leave collections publicly writable)
• Rate limiting enabled in Caddy for auth endpoints
• Monitoring set up (UptimeRobot free tier or similar)

Conclusion

PocketBase is the fastest path from “I need a backend” to “it’s live in production” for indie developers and small teams. A $3–$5/month VPS gives you everything Firebase offers — minus the lock-in, minus the surprise bills, and with full data ownership.

Start with the cheapest VPS you can find. When you outgrow it, scaling up is as simple as copying one directory to a bigger server.