Compared to

voidbase compared to PocketBase

This is the odd one out, because voidbase is PocketBase's API. The admin panel is PocketBase's, unmodified. The SDK is PocketBase's, unmodified. The question is not which API you want. It is whether you want a machine.

	voidbase	PocketBase
API, panel, SDK	PocketBase's.	PocketBase's.
You operate	Nothing.	The machine: TLS, restarts, backups, disk, upgrades.
Where it runs	Every Cloudflare region, wherever the request lands.	One machine in one place. Everyone else pays the round trip.
Scaling	Per request, automatically.	A bigger machine, and a restart.
Realtime	A durable object holds the sockets and pushes changes. One hop more, and it is not bounded by one machine.	Pushed straight from memory in the same process. Nothing is faster than that.
Transactions	None today. Writes validate, then run as one atomic batch. A durable object per instance makes them real.	Real and interactive.
Database limits	100 bound parameters per statement, 100 columns per table. The same move drops both.	SQLite's own, which you will not reach.
Maturity	A reimplementation of the wire protocol. A reimplementation is where bugs live.	The original, maintained for years.
Trying it	A local process, or one command to deploy.	Download one file and run it.
Cost when idle	Nothing.	The machine bills whether or not anyone visits.

in your favour not yet, and on the roadmap against you depends what you are building

What PocketBase does better

It has no platform limits, because there is no platform. Interactive transactions work. A statement binds as many parameters as SQLite allows rather than 100. A table has 2000 columns rather than 100. A request takes as long as it takes, so resizing a very large image is not a question of CPU budget. All of it is written down on the differences page, and if one of those lines is a problem for your data, PocketBase is the better answer.

It is also one binary written by people who have maintained it for years, and voidbase is a reimplementation of its wire protocol. We test against the real thing to keep that honest, and the original still has fewer moving parts.

And if you already have a server, PocketBase costs nothing extra to run on it.

What voidbase does better

There is no machine. No certificate to renew, no restart after a kernel update, no backup script you wrote once and never tested, and no pager at 3am because a disk filled up.

Distance. PocketBase is in one region by construction and everyone else pays the round trip. voidbase runs wherever the request lands.

Load. One PocketBase handles a lot, until it does not, and then the answer is a bigger box. Workers add capacity per request without being asked.

Moving between them

Both directions work, because both speak the same API. Export the collections as JSON and import them on the other side, and your hooks and migrations come across as files. What does not transfer is a backup archive, since the two store them differently. Migrate with export and import, not by copying a backup.

Pick PocketBase if

You need transactions, or you have a server you are happy operating, or you would rather run the original than a reimplementation of it.

Pick voidbase if

You like PocketBase and do not want the machine that comes with it.

What it costs

Move the sliders to your own traffic. Both columns are computed from published list prices, and every assumption behind them is in the panel at the bottom of this section.

Reads / month20MWrites / month1MStored files50 GBPeak realtime connections1kMonthly active users100k

voidbase, on your own Cloudflare account

$9.79/month

Workers Paid, D1, R2, Durable Objects

Workers Paid basethe account minimum: $5.00
Requests21.0M, 10M included: $3.30
CPU time3ms a request: $0.66
Database rows80M read, 3.0M written: $0.00
Database storage1.5 GB, 5 GB included: $0.00
File storage50 GB in R2, egress free: $0.75
Realtime fanout1.5M durable object requests: $0.08

No per-user charge: signing in is an ordinary request, so monthly active users do not appear at all. Durable object compute is left out, because a hibernating connection bills none.

The same app on PocketBase

$13.00/month

on a server you rent

1.3× the voidbase bill

The servera 2 GB VPS: $12.00
Backups off the box50 GB of object storage: $1.00

Realtime costs nothing either, but the sockets are held by that one machine, which is what sizes it. PocketBase costs nothing; the machine does. This assumes a VPS sized to the data and object storage for backups, and it is the honest cheap answer at small scale. It leaves out the thing that actually costs: somebody patching, restarting and restoring it, and the request that arrives while the one box is down.

Model assumptions and sources

An estimate whose assumptions are hidden is an advertisement. This one assumes each API read or write is one Worker request; a read touches about 4 SQLite rows with a relation expanded and a write about 3; a request costs about 3ms of CPU, measured on this site's own instance; each realtime connection receives about 50 pushed updates a day; and a response is about 8KB where a plan bills bandwidth. A WebSocket connection is billed as one request and the messages over it are not, and a hibernating connection bills no compute. Monthly active users are an authentication headcount: voidbase has no per-user charge at all, because signing in is an ordinary request.

Rates as of 8 September 2026, from Workers, D1, R2, Durable Objects and no vendor pricing: it is a binary. Both columns are estimates. Measure before you commit either way, and tell us if a number here is wrong.

And what about speed?

Everything below this line is guesswork. We have not benchmarked these systems against each other, and we are not qualified to do it well. Doing it properly means controlled hardware, representative workloads, warm and cold paths measured separately, percentiles rather than averages, and somebody who has done it before checking the method. None of that happened here.

What follows is arithmetic over round numbers we believe are roughly right. It is here to give a rough shape of the trade to someone who wants one, and to annoy someone who knows better into correcting us. The numbers being multiplied are listed underneath so you can argue with a specific one. Do not choose a backend on this section.

How far the user is from PocketBaseAcross an oceanDatabase round trips a request makes2Requests a second, at the busy moment100Clients subscribed at once1kAfter a quiet period, coldno

voidbase on Cloudflare~69 ms

Reaching the edge: ~15 ms
Database: ~50 ms
The handler: ~4 ms

The code runs near the user, so distance barely enters. The database is the slow part, because a Worker reaches D1 over the network rather than a socket on the same box.

A change reaches every subscriber in: ~8 ms
As the load grows: Flat. Capacity is added per request, so the number above does not change between ten requests a second and ten thousand.
What gives way first: Nothing here scales by being bigger. Requests spread across every location, and each instance's sockets are held by one durable object, so the first real limit is that object's own throughput rather than a machine size.

PocketBase~126 ms

Reaching the machine: ~120 ms
Database: ~2 ms
The handler: ~4 ms

The fastest backend in the world once the request arrives, and nothing to warm up. Getting there is the whole cost, and it is the same cost for every request.

A change reaches every subscriber in: ~2 ms
As the load grows: Flat while there is headroom, then the same queue, and with no second machine to spill into it is also the failure mode.
What gives way first: One process, one disk, one network card. Past about 800 requests a second or 20k open sockets the only move is a bigger machine, and while you are making it there is nowhere else for the traffic to go.

What we think the trade is

	voidbase	PocketBase
Where the code runs	Every Cloudflare location, so near the user by construction	The one machine, wherever you put it
Where the database is	A network hop from the code, which is the slow part above	The same disk. Nothing is faster
A user far away	Pays about the same as one nearby	Pays the full round trip, on every call the page makes
Cold start	Milliseconds: an isolate, not a container	None. It is always running
Ten times the traffic	Same latency, more instances. Nothing to do	A bigger machine, and a restart
A hundred times the traffic	Same again. The limit is your database, not the runtime	Beyond one machine. The architecture changes
Realtime transport	One hibernating socket per client, held by a durable object	Server-sent events from the process itself, pushed straight from memory
Realtime fanout	~8 ms to 1k subscribers	~2 ms to the same
Subscribers before it hurts	Per instance, and the object hibernates when quiet	Bounded by one process, around 20k sockets
Idle	Costs nothing and runs nothing	The machine runs anyway
What gives way first	Database throughput, or one instance's own durable object	The machine, and there is no second one

One machine, wherever you put it, with SQLite on its own disk.

The numbers being multiplied

Correct one of these and the bars move. Reaching a Cloudflare edge location, 15ms. A Worker starting cold, 5ms, because an isolate is not a container. A container waking, 900ms. One D1 query from a Worker, 25ms. One query to a database beside the code, 3ms. One query to SQLite on the same disk, 1ms. The handler itself, 4ms.

The one we are least sure of is the D1 number, and it is the one that decides whether the first bar beats the second. It is also the one most likely to change: putting an instance's data in a durable object beside its own code would replace that network hop with a local read.

Please prove us wrong

If you benchmark backends for a living, we would rather publish your method and your results than our arithmetic. Open an issue on the repository with what you would measure and how, and we will run it, publish whatever it says, and replace this section with it.