VERCEL VS HARPER

On live data, Harper runs 4 to 14x faster than the Vercel stack.

We built one identical app twice. Once inside Harper, once on Vercel with Neon, Upstash, and Ably. Same UI, same code contract, same data. The only variable was the architecture.
474
TEST RUNS
843,240
REQUESTS
99.9999%
SUCCESS
2
U.S. COASTS
100%
RAW DATA PUBLIC
THE WHOLE STORY, IN ONE READ

It comes down to one network hop that isn’t there.

A personalized read cannot be cached at the edge, so something has to go fetch it. On the Vercel stack, the function leaves and crosses the network to Upstash to get the data. On Harper, the app runs inside the database, so the same read is a function call in the same memory. No hop. Here is one personalized read, measured on both.
≈ 8.5x Faster
0.35
MS READ
same process · no hop
User
Harper
The data lives inside the app, so the read happens in memory. Basically instant. Time to First Byte was as low as 11 ms.
2.98
MS READ
User
Vercel fn
Upstash
The data lives in a separate service, so the read has to leave the app and wait on the network. Time to First Byte was as low as 34 ms.
This is one live, personalized read at the median, about 8.5x faster on Harper. That 0.35 vs 2.98 ms gap drives every live-data result below.
THE HONEST SCORECARD

Each platform wins the half of the web it was built for.

We tuned both stacks to their best case, then measured them separately. Here is the full split.

Harper Wins

Live, Personalized Data
In-process reads
A personalized read is a call in the same memory, not a network round trip to Upstash.
~8x
Read fan-out at normal load
A personalized read is a call in the same memory, not a network round trip to Upstash.
~4x to 14x
Server-side streaming
First byte in about 12 ms on both coasts, against 37 to 97 ms on the Vercel read depending on location.
Both Coasts
Write-to-read freshness
Data changes, then a reader sees it fresh. 128 ms on Harper against 387 ms on Vercel revalidation.
~3x
Cost to run the whole suite
The entire benchmark fit on Harper’s free tier, multi-region out of the box, with zero configuration.
$0
Start Free with Harper
White arrow pointing right

Vercel's Last Stand

Static and Cached
Cacheable static pages
A page that is identical for everyone is exactly what a CDN is for, and Vercel’s is excellent: about 4 ms faster at p50, compared to Harper. That is the entire margin. Harper takes the p95 tail back, 13 to 15 ms against Vercel’s 22 to 27 ms.
CDN
Broadcast-only realtime
Client-direct delivery to Ably’s edge measured 17 to 24 ms, faster on the median and the tail. Harper delivers 100 percent too, but also persists every event, so it does more work.
Ably
Autoscaling
Serverless holds latency flat by spawning instances, roughly 50 to 120 ms, while Harper’s single 1 vCPU, 1 GB free node, the smallest compute in the test, hits its ceiling. Vercel does not remove that wall though, it moves it from latency to cost: the flat latency is bought with a linearly rising bill.
Serverless
Harper beat the Vercel stack on one free node: 1 CPU core, 1 GB of RAM, less memory than Vercel’s serverless function alone. With Neon’s autoscaling Postgres, the whole stack can scale to 3x the CPU and 10x the RAM. Harper results are the floor, not the ceiling.
BUILT TO BE ARGUED WITH

Every number is public. Run it yourself.

Open-model load from two U.S. coasts, one platform per run, both stacks tuned to their best case, and the AI generator stubbed out so you measure platform overhead instead of model speed. The full method, all 474 runs, the raw data, and the saturation sweep live in the repo.
GitHub Logo
View Benchmark on GitHub
Green Arrow
474
TEST RUNS
843,240
REQUESTS
99.9999%
SUCCESS
100%
REPRODUCIBLE

The benchmark ran on Harper's free tier. So can your app.

Harper Fabric gives you a runtime where data, cache, application logic, and messaging live in one process. Your cluster is multi-region automatically, with no replication or routing to configure.
Illustration of Harper unified runtime with layered, modular stack: GraphQL, API, REST, WebSocket, and MQTT interfaces above cache and in-memory services, built on blob, database, NoSQL, and vector storage. Floating code and agent cubes represent programmable intelligence, all integrated into a cohesive, high-performance platform.