Benchmarks

Managed pgvector benchmarks.
QPS with recall. Not marketing.

Measured pgvector throughput, latency, and recall by node and workload. Reproduce the results with the open source pgvector-bench CLI.

Honest numbers · HNSW · dedicated NVMe · reproducible with pgvector-bench

pgvector-bench --tier solo

bench> Solo · 1 vCPU / 2 GB · 250k × 1536

~983QPS · 4 clients · ef_search=80 · recall@10 0.93

3.8 ms

p50

6.6 ms

p95

8.3 ms

p99

A measured operating point, including dataset, recall, concurrency, and latency.

Key numbers

A representative result per tier, with recall, concurrency, and p50, p95, and p99 latency.

Solo · 1 vCPU / 2 GB

$29/mo · 250k × 1536

recall 0.93

~983

QPS · 4 clients · ef_search=80

3.8 ms

p50

6.6 ms

p95

8.3 ms

p99

Growth · 4 vCPU / 8 GB

$85/node · 250k × 1536

recall 0.94

~2,949

QPS · 16 clients · ef_search=80

5.1 ms

p50

8.7 ms

p95

11.4 ms

p99

Scale · 8 vCPU / 16 GB

$159/node · 250k × 1536

recall 0.95

~4,465

QPS · 16 clients · ef_search=80

3.4 ms

p50

5.3 ms

p95

6.6 ms

p99

Full results table

All measured (tier, dataset, ef_search, recall@10, concurrency) combinations listed below. The full ef_search sweep, including Solo at ef_search=200 (recall@10 0.974, p50 13.4 ms at 1 client), is in the measured tables.

tiervectorsef_searchrecall@10clientsQPSp50p95p99
Solo250k × 1536100.7441,446 2.7 ms4.0 ms5.6 ms
Solo250k × 1536800.931712 lowest latency1.3 ms2.0 ms2.7 ms
Solo250k × 1536800.934983 3.8 ms6.6 ms8.3 ms
Solo250k × 15361200.964832 4.4 ms7.8 ms9.7 ms
Starter250k × 1536100.75162,088 peak throughput7.1 ms13.0 ms17.3 ms
Starter250k × 1536800.9341,185 3.2 ms4.8 ms6.0 ms
Starter250k × 1536800.93161,599 9.3 ms17.1 ms22.3 ms
Growth250k × 1536100.82163,961 peak throughput3.7 ms6.7 ms8.7 ms
Growth250k × 1536800.9441,989 1.9 ms2.7 ms3.2 ms
Growth250k × 1536800.94162,949 5.1 ms8.7 ms11.4 ms
Scale250k × 1536100.80165,815 peak throughput2.6 ms4.1 ms5.1 ms
Scale250k × 1536800.9583,323 2.3 ms3.1 ms3.8 ms
Scale250k × 1536800.95164,465 3.4 ms5.3 ms6.6 ms
Scale1M × 1536800.74163,600 1M index hot in RAM4.2 ms6.9 ms8.9 ms
Scale1M × 15362000.85162,410 1M, higher recall6.2 ms10.7 ms14.0 ms
HNSW m=16 · ef_construction=64 · cosine distance · same-region client via TLS · Hetzner EU Falkenstein · PostgreSQL 17.10 · pgvector 0.8.2 · synthetic clustered 1536-dim vectors (Gaussian mixture, cosine-normalized) · recall@10 vs brute-force KNN ground truth

Build ceiling

Size for index build memory first. An index that cannot fit may take hours to build or fail. Size the node by index build memory first, QPS second.

tier (RAM)builds finebuilds, but slow / unusablewill not build
Solo (2 GB)250k (~15 min)500k (RAM-limited)1M (OOM)
Starter (4 GB)250k (~5 min)500k (tight)1M (OOM)
Growth (8 GB)250k (~2 min)~500-750k1M (untested)
Scale (16 GB)250k (~80 s), 1M (~9 min)——
HNSW m=16 · ef_construction=64 · 1536-dim vectors · a 1M × 1536 index requires approximately 6 GB of build memory

Measured tables

The real numbers, row by row

Every figure below was measured with our open pgvector-bench harness on real Rivestack-class nodes, over the production client path (TLS, a same-datacenter client), on 20 July 2026. Nothing here is modeled or rounded up. Each QPS number carries its recall@10 and its client count, because on approximate nearest-neighbour search those never travel alone: peak throughput and minimum latency are opposite ends of the same curve.

Two things we won't hide

1. cpx is shared vCPU, not dedicated. Every region now runs the AMD cpx line, fast per core and reliably in stock, but the vCPUs are shared (AMD EPYC), not isolated. Only Hetzner's ccx line is dedicated, and we don't use it. The win over the older Intel cx line is faster cores plus availability, not CPU isolation. (US and Asia run the same cpx family at slightly different sizes.)

2. The client was never the bottleneck. Every load generator has ≥ the DB's core count, and throughput scaled with concurrency on every tier (Scale at ef_search=10, recall@10 0.803, went from 2,098 QPS at 4 clients to 4,031 QPS at 8 clients on its 8 cores). If the client were saturating, QPS would plateau. It didn't.

Solo

1 vCPU / 2 GB · cpx12 (AMD · shared vCPU) · $29/mo

250,000 × 1536-dim vectors · HNSW m=16 ef_construction=64 cosine · index build 889s · load generator cpx32 (4 vCPU)

ef_searchrecall@101 client
QPS · p50
4 clients
QPS · p50
8 clients
QPS · p50
16 clients
QPS · p50
100.738972 · 1ms1446 · 2.7ms1347 · 5.5ms1172 · 12.5ms
200.788847 · 1.1ms1261 · 3ms1263 · 5.8ms1285 · 11.5ms
400.838825 · 1.1ms1166 · 3.3ms1250 · 5.9ms1458 · 9.7ms
800.925712 · 1.3ms983 · 3.8ms886 · 8.2ms917 · 15.8ms
1200.964636 · 1.4ms832 · 4.4ms781 · 9.7ms689 · 20.9ms
2000.97453 · 13.4ms163 · 18ms222 · 27.1ms345 · 35ms

Highlighted row ≈ recall@10 0.90 to 0.95, the usual production operating band.

Starter

2 vCPU / 4 GB · cpx22 (AMD · shared vCPU) · $49/node

250,000 × 1536-dim vectors · HNSW m=16 ef_construction=64 cosine · index build 293s · load generator cpx32 (4 vCPU)

ef_searchrecall@101 client
QPS · p50
4 clients
QPS · p50
8 clients
QPS · p50
16 clients
QPS · p50
100.753392 · 2.4ms1463 · 2.6ms1932 · 4ms2088 · 7.1ms
200.813398 · 2.3ms1397 · 2.7ms1882 · 4.1ms1996 · 7.6ms
400.881342 · 2.9ms1291 · 3ms1638 · 4.7ms1770 · 8.4ms
800.930369 · 2.5ms1185 · 3.2ms1497 · 5ms1599 · 9.3ms
1200.968356 · 2.6ms1115 · 3.4ms1356 · 5.6ms1360 · 10.7ms
2000.988214 · 4.5ms717 · 5.4ms838 · 9ms936 · 15.6ms

Highlighted row ≈ recall@10 0.90 to 0.95, the usual production operating band.

Growth

4 vCPU / 8 GB · cpx32 (AMD · shared vCPU) · $85/node

250,000 × 1536-dim vectors · HNSW m=16 ef_construction=64 cosine · index build 122s · load generator cpx62 (16 vCPU)

ef_searchrecall@101 client
QPS · p50
4 clients
QPS · p50
8 clients
QPS · p50
16 clients
QPS · p50
100.818604 · 1.6ms2278 · 1.7ms3326 · 2.3ms3961 · 3.7ms
200.854602 · 1.6ms2291 · 1.7ms3101 · 2.4ms3712 · 4ms
400.903530 · 1.8ms2126 · 1.8ms2907 · 2.6ms3370 · 4.4ms
800.939505 · 1.9ms1989 · 1.9ms2675 · 2.8ms2949 · 5.1ms
1200.949479 · 2ms1812 · 2.1ms2340 · 3.2ms2574 · 5.8ms
2000.968316 · 3ms1238 · 3.1ms1468 · 5.2ms1497 · 9.8ms

Highlighted row ≈ recall@10 0.90 to 0.95, the usual production operating band.

Scale

8 vCPU / 16 GB · cpx42 (AMD · shared vCPU) · $159/node

250,000 × 1536-dim vectors · HNSW m=16 ef_construction=64 cosine · index build 76s · load generator cpx62 (16 vCPU)

ef_searchrecall@101 client
QPS · p50
4 clients
QPS · p50
8 clients
QPS · p50
16 clients
QPS · p50
100.803522 · 1.8ms2098 · 1.9ms4031 · 1.9ms5815 · 2.6ms
200.838510 · 1.9ms1985 · 1.9ms3928 · 2ms5539 · 2.7ms
400.898461 · 2.1ms1847 · 2ms3600 · 2.1ms5091 · 3ms
800.953455 · 2.1ms1724 · 2.2ms3323 · 2.3ms4465 · 3.4ms
1200.973398 · 2.4ms1534 · 2.4ms3058 · 2.5ms3883 · 3.9ms
2000.983266 · 3.6ms1076 · 3.6ms2068 · 3.7ms2418 · 6.3ms

Highlighted row ≈ recall@10 0.90 to 0.95, the usual production operating band.

Scale: 1,000,000 × 1536 (large index)

cpx42 · 8 vCPU / 16 GB · ~6 GB HNSW index built in 544s (9 min) and held hot in RAM. At bigger N the same ef_search gives lower recall (more true neighbours to find), so read recall per row.

ef_searchrecall@101 client4 clients8 clients16 clients
100.561479 · 2ms1920 · 2ms3765 · 2ms5446 · 2.8ms
200.623403 · 2.4ms1866 · 2.1ms3554 · 2.1ms4921 · 3.1ms
400.674431 · 2.2ms1682 · 2.3ms3321 · 2.3ms4294 · 3.5ms
800.738386 · 2.4ms1493 · 2.5ms2936 · 2.5ms3600 · 4.2ms
1200.778354 · 2.6ms1397 · 2.6ms2664 · 2.7ms3176 · 4.7ms
2000.845273 · 3.4ms1087 · 3.4ms2095 · 3.5ms2410 · 6.2ms

# re-validated 10 August 2026

In August we changed the fleet's connection and memory defaults: every dedicated node now runs PgBouncer with 20 to 40 transaction slots per database (500 to 10,000 pooled client connections by tier) and a tighter work_mem of 8 to 32 MB. Because those settings could plausibly move the numbers above, we re-provisioned all four tiers from scratch and re-measured with the same harness. Like-for-like operating points came back within shared-vCPU run variance, so the July tables stand. Two additional findings, both measured:

  • - work_mem A/B, zero difference. Filtered vector queries with hnsw.iterative_scan = relaxed_order at 10% and 1% selectivity, measured order-interleaved after warmup at both the new and the old work_mem on every tier: recall@10 exactly equal, p50 and p95 within noise. The scan-memory bound is never reached at these dataset sizes.
  • - Past the pool, queries queue instead of failing. We ran double each tier's transaction slots (80 clients on Scale's 40). Zero connection errors; backends pin at the cap and the extra clients wait, trading p50 for admission.

New measurements the July run didn't cover (pgvector 0.8.6):

tierdatasetef_searchrecall@10clientsQPS · p50
Solo100k × 1536400.9591489 · 2ms
Solo100k × 1536200.849201,417 · 13.7ms
Starter250k × 1536800.927251,468 · 16.8ms
Growth500k × 1536800.834302,493 · 11.5ms
Growth500k × 15362000.934301,768 · 16.3ms
Scale1M × 1536800.714403,455 · 11.1ms
Scale1M × 15362000.829402,125 · 17.8ms
Scale1M × 1536100.558804,629 · 16.7ms2× the pool: every client past 40 slots queues; nothing errors

A 500k × 1536 index (~3 GB) builds and serves hot on Growth (8 GB); Scale's 1M row above is the same large-index claim as July, now also measured at 40 and 80 clients. Read recall per row, as always: the 4,629 QPS row is a low-recall operating point shown for the queueing behavior, not a headline.

# methodology

  • - Data: Gaussian-mixture clusters (structure dominates, not uniform random noise). Queries are small perturbations of real points, giving a well-defined recall@10 against exact brute-force KNN.
  • - Index: pgvector 0.8.5 HNSW, m=16, ef_construction=64, cosine. PostgreSQL 17.10.
  • - Tuning: each node uses Rivestack's per-size defaults: shared_buffers 25% RAM, effective_cache_size 75%, parallel workers = vCPU, random_page_cost 1.1. The July tables ran work_mem = RAM/64; since August the default is 8 to 32 MB by tier, and the re-validation above measured no difference between the two.
  • - ef_search is set with SET LOCAL inside each query's transaction (a plain session SET is silently dropped by PgBouncer transaction pooling).
  • - Client path: a separate same-datacenter VM (≥ the DB's core count) over TLS. Measured network floor 0.34 to 0.51 ms per round-trip. Throughput uses one process per client (no GIL).
  • - What we don't claim: peak QPS and minimum p50 at the same time; competitor numbers we didn't run; a single number for all regions.

# reproduce it

On a same-region VM with Python, numpy and psycopg2:

# harness: https://github.com/Rivestack/pgvector-bench
export DSN='postgres://USER:PASS@YOUR-DB.eu.db.rivestack.io:6432/db?sslmode=verify-full'
export N=250000 EFS='10,20,40,80,120,200' CONCS='1,4,8,16' DUR=12
python3 bench.py
# prints: ef | recall@10 | per-concurrency QPS/p50/p95/p99

Point it at your own database and dataset, and the numbers you get are the numbers you get. That's the whole idea.

Measured & signed by Yasser, Rivestack, 20 July 2026. Re-validated under the current fleet configuration on 10 August 2026.

Runs on the AMD cpx line, which every region now uses (cpx is shared vCPU, not dedicated, see above). Re-run anytime with the harness; if your numbers differ, tell us and we'll publish the correction.

Run it yourself

pgvector-bench

The numbers on this page were measured with the open-source pgvector-bench CLI. Point it at any PostgreSQL database that has pgvector installed.

curl -fsSL https://rivestack.io/install.sh | sh

Or install from source with go install github.com/Rivestack/pgvector-bench/cmd/pgvector-bench@latest. Releases and the MIT source are on GitHub.

Methodology

Exactly what was measured and how, for anyone who wants to understand or reproduce it.

Client and network path

The March 2026 benchmark client ran on a separate VM in the same Hetzner region, connecting over the public endpoint with TLS (sslmode=require at benchmark time; use verify-full for production). Solo connected directly to PgBouncer, while Growth and Scale used the load balancer path. Every tier was transaction-pooled. The measured bare SELECT 1 floor was about 0.4 ms on Solo and 0.9 ms on Growth/Scale. The current HA path also includes a private PROXY-aware HAProxy hop for client-IP filtering, so remeasure your own end-to-end latency rather than treating that historical floor as a guarantee.

Dataset and index

Vectors are synthetic but clustered: a 1536-dimensional Gaussian mixture, normalized for cosine distance. A clustered mixture is used rather than uniform random noise so that recall is representative of real embedding structure, and real embeddings may recall slightly higher. The index is HNSW with m=16 and ef_construction=64 (the pgvector defaults for 1536-dim). Recall@10 is measured against exact brute-force KNN ground truth computed with index scans disabled.

Why recall and concurrency are non-negotiable

Approximate nearest-neighbor search trades recall for speed. The hnsw.ef_search parameter controls the tradeoff. A QPS number without a recall number and a concurrency count is an advertisement, not a measurement. Every result on this page is a (tier, dataset, ef_search, recall@10, concurrency, QPS, latency) tuple. A single headline number without those qualifiers tells you nothing about what the system actually delivers for your workload.

Reproducibility

All numbers were produced with the open-source pgvector-bench CLI, released under the MIT license and available at github.com/Rivestack/pgvector-bench. A single Go binary with an interactive wizard and a self-contained HTML report. Run it against any PostgreSQL instance to measure your own p50/p95/p99, QPS curve, and recall@k against brute-force ground truth on your actual data.

Related: NVMe vs cloud SSD benchmarks (full blog post) walks through the same measured runs. The tables on this page are the record of every number here. Run the benchmarks yourself with the pgvector-bench CLI. Try managed pgvector on a 7-day Solo trial (new customers, card required) to measure your own index.

Frequently asked questions

Your next idea

Make room for your next idea.

Send us your current setup and we'll tell you in 48 hours whether Rivestack is cheaper, faster, and a good production fit. New customers can also test their own data on Solo free for 7 days.

For new customers. Card required; cancel before the trial ends and you pay nothing.