StitchDB vs PocketBase: Managed Postgres or One Go Binary?

PocketBase and StitchDB solve the same problem (a backend with auth, data, files and realtime) from opposite ends. PocketBase is one MIT-licensed Go binary with embedded SQLite that you run on your own server; it is free, tiny and fast, and you operate it. StitchDB is a managed platform with a dedicated Postgres database per project and backups, branching, functions and app services handled for you; it costs a monthly plan after the free tier and you can't self-host it. For a small app on one server, PocketBase is hard to beat. For a team that wants Postgres and no server to look after, StitchDB is the better fit.

#Quick comparison

#Who does the operations?

This is the real difference. With PocketBase, the binary is simple, but you still own everything around it:

If you enjoy running a VPS and your app is small, the left column is not much work. PocketBase's FAQ says even an inexpensive VPS can hold 10,000+ persistent realtime connections. If nobody on the team wants to be paged at night, the right column is what you are paying for.

#Access rules: API rules vs RLS

PocketBase guards each collection with API rules, filter expressions such as owner = @request.auth.id. StitchDB uses Postgres policies, which work the same way in principle and run inside the database:

alter table public.posts enable row level security;

-- list/view rule
create policy "owners read" on public.posts
  for select to authenticated using (owner_id = auth.uid());

-- create rule
create policy "owners create" on public.posts
  for insert to authenticated with check (owner_id = auth.uid());

A policy also applies to Realtime subscriptions, GraphQL and files in buckets. One thing to remember on StitchDB: tables created with SQL start with RLS off and are readable with the anon key until you enable it; tables made in the Studio table editor have it on by default. See row level security.

#Extending: hooks vs functions

PocketBase can be used as a Go framework, or extended with JavaScript hooks. That is very flexible: your logic ships with the backend in one deploy.

On StitchDB, logic goes in one of three places:

• In the database: triggers, SQL functions callable with rpc(), cron with pg_cron, and queues with pgmq.
• In Edge Functions: TypeScript on Deno for webhooks, payments, e-mail and AI calls.
• In webhooks: database changes sent to your own endpoint, signed and retried.

A PocketBase "on record create, send an e-mail" hook becomes a database webhook to an Edge Function, or pg_net from a trigger (with the service role key kept in Vault):

create function public.notify_new_order() returns trigger
language plpgsql security definer as $$
begin
  perform net.http_post(
    url := 'https://<project-ref>.p.stitchdb.com/functions/v1/order-email',
    headers := jsonb_build_object(
      'Authorization', 'Bearer ' || (select decrypted_secret from vault.decrypted_secrets where name = 'service_role_key'),
      'Content-Type', 'application/json'),
    body := jsonb_build_object('order_id', new.id)
  );
  return new;
end $$;

create trigger on_order_created after insert on public.orders
  for each row execute function public.notify_new_order();

#Local development

PocketBase's local story is great: run the binary. StitchDB's is close: stitchdb start runs Postgres 17, Auth, REST, Realtime, Storage, Edge Functions, a local Studio and a mail catcher as plain processes on your machine, with no Docker. The first start downloads about 40 MB; later starts take about a second. See local development.

#Data and portability

Both are portable. PocketBase data is a folder you can copy. A StitchDB project exports as one archive on every plan with a pg_dump, auth users with bcrypt hashes, files and function source, restorable into any Postgres 15+ (see export). Postgres also means any BI tool, ORM or psql can connect directly over TLS.

#Cost

PocketBase costs whatever your server costs. StitchDB's Free plan is $0 with 2 projects, a 500 MB database per project, 1 GB of files, 25 GB egress and 50,000 monthly active users; Free projects are not paused while you use your account, though their Auth and REST services sleep after 60 minutes idle and wake in a few seconds. Pro is $15.99/month with a 10 GB database, 100 GB files, 1 TB egress and 100,000 MAU, and Scale is $49/month (as of November 2026). Paid plans start with a spend cap on. See pricing.

So in raw hosting cost, PocketBase wins. The comparison that matters is your time on operations against a plan price.

#Realtime, auth and files side by side

PocketBase covers the core of what most apps need with very little setup. StitchDB's list is longer mostly because it targets teams that would otherwise add separate vendors for SSO, push or image processing.

#Where each one wins

PocketBase wins when:

• The app is small or internal, and one server is enough.
• You want to self-host, or data must stay on hardware you control outside the EU.
• You like writing backend logic in Go inside the same binary.
• You want the cheapest possible monthly bill.

StitchDB wins when:

• You want Postgres: joins, constraints, extensions like pgvector and PostGIS, and direct SQL access.
• You need point-in-time recovery, read replicas, branching or a team workflow.
• You want app services built in: push notifications, in-app purchase checks, feature flags, crash reporting, analytics.
• Nobody on the team wants to run servers.

Thinking of moving? PocketBase alternatives includes a step-by-step move from SQLite to Postgres.

#FAQ

#Is PocketBase faster than StitchDB?

For a single-server app, an embedded SQLite database in the same process has very low latency. A managed Postgres adds a network hop. For most apps both are fast enough; the bigger factor is distance to your users.

#Can PocketBase use Postgres?

No. Its FAQ says it uses embedded SQLite and there are no plans to support other databases.

#Can I self-host StitchDB?

No. It is managed only, with regions in Germany and Finland. You can run it locally for development.

#Is PocketBase production-ready?

Many apps run it in production. Its README says full backward compatibility is not guaranteed before v1.0, so pin versions and test upgrades.

Want PocketBase-style simplicity without running a server? Create a free StitchDB project.