Is PocketBase production-ready or will it break my shit?

It's pre-1.0 software, so expect things to break between versions. I've had to migrate schemas twice this year. That said, I'm running 3 production apps on it without major issues. Just don't use it for anything mission-critical until v1.0.

How many users can it actually handle?

Stress tested with about 80-90 concurrent users on one project, hit some write bottlenecks around there but nothing crashed. Beyond 100 users things get sketchy. If you need more than 10k active users, just use PostgreSQL instead. Don't try to force SQLite to be something it isn't.

How do I backup without fucking it up?

Stop the server first, then copy the entire `pb_data` folder. Don't just copy files while it's running - you'll corrupt the database and lose everything. I learned this lesson at 3AM when a backup script I wrote corrupted our production database. Now I have a proper backup script that stops the service, copies files, then restarts it.

Can I connect it to my existing PostgreSQL database?

No. PocketBase is SQLite only. If you need PostgreSQL integration, you're looking at the wrong tool. Use Supabase or build a custom API.

What happens when I outgrow SQLite?

Export everything via the REST API and migrate to something else. It's not fun, but the data isn't locked in. Plan for this from the start if you expect to scale beyond 50k records.

Is it secure enough for real apps?

The auth system is solid, but you're responsible for server security, SSL, updates, and monitoring. If you're not comfortable being your own sysadmin, use a hosted solution instead.

Does real-time actually work?

Yeah, the SSE (Server-Sent Events) implementation is solid. I use it for live chat features and it handles 50+ concurrent connections fine. Way better than the time I tried to roll my own WebSocket server and spent a week debugging connection drops and memory leaks.

Can I extend it or am I stuck with what's included?

You can write custom Go code or JavaScript hooks. The Go approach is powerful but you're essentially forking the project. JavaScript hooks are easier for simple stuff like validation or webhooks.

What's the deal with file uploads?

Default 5MB limit that you'll need to increase. Local storage is fine for prototypes, but you'll want S3 for production. Set MIME type validation or users will upload random garbage.

How do database migrations work?

JavaScript files in `pb_migrations` folder. Version control these or you're fucked when deploying. The migration system is simple but works well enough.

Any limits on how many collections I can create?

SQLite can handle thousands of tables, so you're more likely to hit design limits than technical ones. Keep it simple - don't create 100 collections for something that could be 10.

Can I run multiple instances for high availability?

You can run multiple independent instances, but they don't sync with each other. It's not true HA - more like multiple separate databases. For real HA, use something designed for it.

Currently viewing the AI version

Switch to human version

PocketBase: AI-Optimized Technical Reference

Core Technology Overview

What It Is: Single Go binary (15MB) bundling SQLite + authentication + file storage + admin UI

Current Version: v0.29.3 (late 2024)
Status: Pre-1.0 software - expect breaking changes between versions
Architecture: SQLite with WAL mode for concurrent reads

Critical Scaling Limits

User Capacity Thresholds

0-1,000 users: No performance issues
1,000-10,000 users: Monitor write bottlenecks, expect some slowdown
10,000+ users: SQLite becomes limiting factor, migrate to PostgreSQL

Technical Bottlenecks

Concurrent users: 50-100 before write bottlenecks
File uploads: Degrades with 100+ concurrent uploads
Query performance: Complex joins slow at 50k+ records
Backup operations: 30-second database locks during backup

Configuration That Actually Works

Production Settings

# Port configuration to avoid conflicts
./pocketbase serve --http=127.0.0.1:8091

File Upload Limits

Default: 5MB (will cause user complaints)
Action Required: Increase limit in settings
Production: Configure S3 storage early - local storage fills up fast
Critical Failure: Server ran out of space at 2AM, 6-hour outage for profile uploads

CORS Configuration

Common Issue: 30 minutes debugging localhost CORS failures
Solution: Add domain to allowed origins in settings before development

Installation Failure Modes

Permission Issues

Linux/Mac: Requires chmod +x pocketbase
Windows: Antivirus may quarantine as malware
First Run: Opens browser for admin setup (use --dev flag for headless servers)

Directory Structure

pb_data: SQLite database + uploaded files (CRITICAL TO BACKUP)
pb_migrations: Schema change scripts (commit to version control)

Migration and Schema Pain Points

Breaking Changes

March 2024: Collection validation system changed
August 2024: Auth system updated
Action Required: Read changelog before any upgrade

Schema Design Gotchas

Many-to-many relations: UI becomes confusing beyond 3 levels
File fields: Set MIME type validation or users upload random files
Access rules: JavaScript-like syntax difficult to debug

Resource Requirements

Time Investment

Initial setup: 10 minutes (vs 2 hours Firebase, 4 hours Supabase)
First-time OAuth setup: 2 hours reading Google's OAuth documentation
Schema migration debugging: Plan for substantial time investment

Expertise Requirements

Self-hosting reality: You become the DBA - 3AM outages are your problem
Monitoring: Essential from day one (servers go down for hours without monitoring)
Backup strategy: Must stop server before copying files to avoid corruption

Cost Structure

Development: Free (single binary)
Self-hosting: $10 DigitalOcean droplet + monitoring + backup costs
Hidden costs: Human time for maintenance, security updates, troubleshooting

Critical Warnings

Data Integrity Risks

Backup corruption: Never copy pb_data while server is running
Migration failures: Schema changes can break between versions
Single point of failure: No built-in high availability

Production Readiness Issues

Pre-1.0 software: Not recommended for mission-critical applications
Limited scaling: SQLite write bottleneck is fundamental limitation
No true HA: Multiple instances don't sync with each other

Decision Criteria

Use PocketBase When

Prototype or side project development
Client work under 10k users
Full data control required
Rapid MVP development (10 minutes to deployment)
Simple to moderate complexity requirements

Don't Use PocketBase When

Need to scale beyond SQLite limits
Mission-critical applications required
Complex analytics workloads
High availability requirements
Team lacks sysadmin expertise

SDK and Integration Reality

JavaScript SDK

Quality: Solid with good TypeScript support
Common Issue: CORS configuration required for localhost development

Alternative SDKs

Dart SDK: Functional but thin documentation
Python SDK: Community-maintained, decent quality
Risk: Community SDKs often abandoned

Competitive Comparison

Criteria	PocketBase	Firebase	Supabase
Setup Time	10 minutes	2 hours	4 hours
Scale Limit	~10k users	Millions	Hundreds of thousands
Cost Reality	Server costs only	Expensive at scale	Reasonable until scale
Complexity	Single binary	SDK complexity	Docker/Kubernetes required
Vendor Lock-in	Zero	Complete	Possible to escape
Operational Burden	Full self-management	Google managed	Partial management

Operational Intelligence

Common Failure Scenarios

Port conflicts on first run - Use custom port configuration
CORS blocking localhost development - Configure allowed origins
File storage filling server disk - Migrate to S3 before production
Database corruption during backup - Stop server before file copying
Performance degradation at user thresholds - Monitor write patterns

Success Patterns

Monitoring from day one - Prevents hours-long outages
S3 configuration early - Avoids storage emergencies
Read changelog religiously - Prevents breaking change surprises
Test access rules in incognito - Catches permission issues

Real-World Performance

3 production deployments: Booking app, small CRM, prototype-turned-production
Stress testing: 80-90 concurrent users before write bottlenecks
File upload degradation: Noticeable at 100+ concurrent uploads
Complex query slowdown: Begins around 50k records

This reference provides actionable implementation guidance while preserving critical operational context for AI decision-making systems.

Useful Links for Further Investigation

Actually Useful Links (Unlike Most PocketBase Content)

Link	Description
Official Docs	The official documentation for PocketBase, surprisingly well-written for an open-source project. This is the essential starting point for new users.
API Reference	This comprehensive API reference will become a frequently bookmarked page, offering practical examples that are proven to work.
GitHub Releases	Download binaries here. Don't compile from source unless you enjoy pain.
Changelog	It is crucial to read this changelog before attempting any upgrades to avoid potential breaking changes or issues.
JavaScript SDK	The official JavaScript SDK for PocketBase, known for its solid performance and excellent TypeScript support.
Dart SDK	Works but docs are thin. You'll be reading source code.
Python SDK	A community-made Python SDK offering decent quality, providing a much better alternative than rolling your own implementation.
Discord	Most responsive place for help. Devs actually answer questions.
GitHub Issues	Use this platform for reporting bugs and submitting feature requests. Always search existing issues before creating a new one.
Reddit r/pocketbase community	Good for "how did you solve X" type questions. Search for "pocketbase" on Reddit.
Stack Overflow	While answers can be hit or miss, Stack Overflow does contain some quality solutions for specific PocketBase questions.
PocketHost	Managed hosting, works fine for prototypes. Costs $5 per month.
Fly.io	Good self-host option. Provides community discussions on best practices for hosting PocketBase.
Railway	Offers one-click deployment for PocketBase. Easy to use but comes with a cost for the convenience.
Go Framework Guide	Provides guidance for when you need custom functionality. Be warned, you're essentially forking the project.
TypeScript Types	Offers auto-generated TypeScript types. Install this package if you are using TypeScript in your project.
Backup Solutions	Essential information on backup and restore solutions. Avoid learning about backups the hard way.
LogRocket Article	A solid walkthrough on using PocketBase to build a full-stack application, providing practical insights.

PocketBase: AI-Optimized Technical Reference

Core Technology Overview

Critical Scaling Limits

User Capacity Thresholds

Technical Bottlenecks

Configuration That Actually Works

Production Settings

File Upload Limits

CORS Configuration

Installation Failure Modes

Permission Issues

Directory Structure

Migration and Schema Pain Points

Breaking Changes

Schema Design Gotchas

Resource Requirements

Time Investment

Expertise Requirements

Cost Structure

Critical Warnings

Data Integrity Risks

Production Readiness Issues

Decision Criteria

Use PocketBase When

Don't Use PocketBase When

SDK and Integration Reality

JavaScript SDK

Alternative SDKs

Competitive Comparison

Operational Intelligence

Common Failure Scenarios

Success Patterns

Real-World Performance

Useful Links for Further Investigation

Actually Useful Links (Unlike Most PocketBase Content)

Related Tools & Recommendations

Supabase + Next.js + Stripe: How to Actually Make This Work

GitOps Integration Hell: Docker + Kubernetes + ArgoCD + Prometheus

Firebase Alternatives That Don't Suck - Real Options for 2025

Firebase Alternatives That Don't Suck (September 2025)

Firebase - Google's Backend Service for When You Don't Want to Deal with Servers

Supabase - PostgreSQL with Bells and Whistles

Supabase Auth: PostgreSQL-Based Authentication

Should You Use TypeScript? Here's What It Actually Costs

Python vs JavaScript vs Go vs Rust - Production Reality Check

JavaScript Gets Built-In Iterator Operators in ECMAScript 2025

Appwrite - Open-Source Backend for Developers Who Hate Reinventing Auth

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

Fast React Alternatives That Don't Suck

Stripe Terminal React Native Production Integration Guide

Converting Angular to React: What Actually Happens When You Migrate

SvelteKit Authentication Troubleshooting - Fix Session Persistence, Race Conditions, and Production Failures

Svelte - The Framework That Compiles Away

SvelteKit + TypeScript + Tailwind: What I Learned Building 3 Production Apps

Stop Stripe from Destroying Your Serverless Performance

Claude API + Next.js App Router: What Actually Works in Production