Performance & scalability

Latency & throughput

Real Cloudflare (§2.2). All latencies in milliseconds.

Geography — routed-call p50 (ms), by client region × object region

What it means: a call to a co-located object costs 3–35 ms; the same call to an object on the far side of the world costs 450–692 ms. Where you put the object is the largest single effect in this entire benchmark — bigger than the durable-write cost (+28 ms), the saturation knee, and fan-out combined. Because every workspace, log and doc is its own object, that placement is a per-tenant decision, and Cloudflare makes it wherever the object is first touched — so it is worth being deliberate about. Halve these figures for one-way distance: a routed call crosses to the object and back twice.

Measured by running the shipped client from a probe pinned to each region against an object placed in each region — all 9×9 combinations (6 shown; the full matrix and the two regions that collapsed onto one datacentre are in the report). Placement is not assumed: it is validated by requiring the diagonal to be the minimum of its column, which held for every distinct location. Both ends are inside Cloudflare, so this is region-to-region cost, not an end-user's last mile.

Horizontal scale — the same load against N independent objects at once

What it means: per-object throughput stays nearly flat as objects are added, so 32 objects do ~25× the work of one. This is the sharding claim measured rather than argued — it was previously printed as "∞" with no data behind it. It is not perfectly linear: about 21% of per-object efficiency is lost by 32 objects. A client-side event-loop-lag control ran throughout (~2 ms), confirming the benchmark client was never the limit.

Cost of an operation — above the network, measured by pairing

What it means: routing a call through the mesh into a peer costs ~3 ms of server work; a durable commit costs ~28 ms. The "negative pairs" column is the honesty check — a DO-backed call cannot really be faster than a Worker-only one, so that fraction bounds the jitter still inside each pair. Zero of them for the durable write means that figure is cleanly resolved.

RPC round-trip — a call routed into a peer client (no durable write)

What it means: a routed call is ≈ one network round-trip plus ~3 ms of server work. The wide ranges are this host's uplink, not the platform — which is exactly why the paired table above is the figure to design against.

Concurrency — where one socket saturates

What it means: throughput climbs steeply to about 64 in flight, then flattens while latency keeps rising roughly linearly. Past the knee you are buying queue depth, not throughput — add sockets or objects instead.

Log — one Log DO; append = a durable SQLite commit

What it means: ~488 durable appends/s per log carries a busy chat or event stream, and sharding across logs multiplies it (see the scale table). Subscribe-replay re-sends a recent window in ~20 ms so a reconnecting client catches up gap-free.

Replay depth & the cold tier — what a client that was away a long time pays

What it means: every depth replayed completely — a client away for 50,000 entries still loses nothing, and now you know it takes ~17 s, so you can show progress instead of appearing to hang. Entries older than the hot threshold live in R2 cold segments, and reading across that boundary was no slower than reading the hot tail (104 vs 125 ms/page) — the tier split is not a latency cliff.

Doc — one Doc DO; durable conditional + atomic writes

What it means: the single-writer DO never loses an update; a server-side atomic incr commits a counter/ledger in one round-trip with no retry storm — so cheap, exact counters and balances whose cost scales with useful commits, not with contention.

Connections, presence & cold start

What it means: one object holds 1,022 live connections and still serves traffic, with connect latency flat the whole way up — and the wall it hits is DEFAULT_MAX_CONNS_PER_WORKSPACE, a deliberate DoS control you can raise, not resource exhaustion. The previous "≥200, ceiling not reached" was the harness's own configured target, not a limit.

Presence fan-out — propagation vs number of subscribers

What it means: presence reaches a handful of subscribers in about one round-trip, but fan-out is not free at width — 200 subscribers takes ~2.7× as long as 10. An earlier edition of this page said there was no fan-out cost; that was generalised from a 3-subscriber sample, a width at which the cost cannot show up.

Payload limits — how big a routed call can be

What it means: cost is flat to ~16 KB then tracks bytes; 512 KB is the largest usable payload. At 1 MiB the server rejects the frame before parsing it (close 1009) — a deliberate control, since an unbounded frame is cheap memory amplification against a single-threaded shard. Bulk bytes belong on the artifact plane below.

Artifacts — bulk bytes to R2

What it means: large files upload direct edge↔R2 (bytes never touch billable DO time) and round-trip byte-for-byte; small/medium blobs stream simply through the Worker.