Performance benchmarks

Real numbers,

benchmarked in the open.

We benchmarked Selfhost.dev managed PostgreSQL and Redis on AWS with production settings on and no benchmark-specific tuning. Not a cherry-picked demo: here are the methodology, the numbers, and what we did not test.

pgbench + memtier / AWS / 3 x 60s median / 2026
PostgreSQL Redis
~30k
read TPS at ~1 ms latency
~2,100
mixed OLTP TPS at 16 clients
~2.8x
cheaper than an equivalent RDS instance*
100%
durability on, zero errors across every run

*Same AWS instance class, at our all-in pay-as-you-go price. RDS figures estimated, not measured.

Want these numbers for your own setup? Get a free cost audit →

PostgreSQL results

Throughput and latency,
on real instances.

r6g.large 16 GB / 2 vCPU / ARM Graviton

$66.52/mo
Read-only (pgbench -S)
ClientsTPSLatency
45,4470.73 ms
1618,8110.85 ms
3229,4571.09 ms
5028,6621.74 ms
10021,4954.65 ms
20019,56610.2 ms
Mixed OLTP (TPC-B-like)
ClientsTPSLatency
23515.7 ms
46735.9 ms
81,2626.3 ms
162,1117.4 ms
323,2519.8 ms

Dataset scale 10 vs scale 200 (~3 GB) stayed within 2%: cache absorbs 20x dataset growth. Reads peak near 32 clients, then taper on 2 vCPU. PgBouncer is recommended above ~100 concurrent clients.

t3.micro 1 GB / 2 vCPU burstable / x86

$13.50/mo
Read-only (pgbench -S)
ClientsTPSLatency
44,3210.93 ms
1615,8191.01 ms
3230,2521.06 ms
5031,4851.59 ms
10022,8644.37 ms
Mixed OLTP (TPC-B-like)
ClientsTPSLatency
22687.5 ms
45207.7 ms
89408.5 ms
161,51610.5 ms

Burstable: 60s runs ride accumulated CPU credits, so sustained baseline is lower. A $13.50/mo instance still serves tens of thousands of cached reads per second.

Price-performance vs RDS

Same hardware.
About 2.8x less to run.

The same AWS instance class as RDS, at our all-in pay-as-you-go price, lands around 2.8x cheaper at comparable throughput and the same durability defaults. And where RDS meters IOPS and egress as separate surprise line items, our price-performance above is all-in. Plus tuning, pooling, and an AI control layer RDS does not have.

  • ✓ Auto RAM-aware tuning at provision time (RDS: manual)
  • ✓ Config guardrails that reject unsafe overrides
  • ✓ Built-in PgBouncer (RDS Proxy is an extra charge)
  • ✓ Real-time telemetry and 150+ MCP tools
  • ✓ Always-on instances, no cold-start penalty

Want this price-performance with the data in your own AWS account? BYOC runs the same instance in your own cloud.

r6g.large, read TPS per dollar
Selfhost.dev443 TPS/$
$66.52/mo
AWS RDS (est.)~130 TPS/$
~$230/mo estimated

See the full RDS comparison. RDS pricing estimated, not measured. The chart uses raw list prices; the ~2.8x headline uses our final all-in price, which is the number to plan on.

How we tested PostgreSQL

Durability on.
Nothing tuned for the benchmark.

A benchmark is only worth trusting if it runs your production settings. Ours did: full durability, PostgreSQL defaults plus our automatic tuning, and no benchmark-only knobs.

Durability, verified on every instance
synchronous_commit=on fsync=on full_page_writes=on wal_level=replica
Setup
  • pgbench 18.4, -M prepared, -j 4
  • Dedicated EC2 runner, cross-VPC, same region
  • 3 iterations x 60s, median reported, 15s warmup discarded
  • 20 GB gp3 (3000 IOPS, 125 MB/s), PostgreSQL 18.4
What we did not test (yet)

Honesty is part of the point. These are open gaps, not hidden ones.

  • - Latency percentiles (p95 / p99); we report median and average only
  • - A measured RDS head-to-head; RDS numbers are estimates
  • - IO-bound workloads larger than RAM
  • - HA failover and replication under load
  • - PgBouncer-fronted high-concurrency runs

Managed Redis

Sub-millisecond reads,
up to 230k ops a second.

Managed Redis 7 on a single r7g.large, measured with memtier over a real cross-VPC network path, the way a client actually connects. We report full latency percentiles, P50 through P99.9, not just an average.

~230k
ops/sec peak throughput (pipelined)
0.88 ms
P99 latency on a single connection
~76k
ops/sec at 200 concurrent clients
~2.1x
cheaper to run than ElastiCache*

*Same r7g.large class. ElastiCache cache.r7g.large at AWS on-demand list (~$165/mo) vs our $76.47/mo. Estimated, not measured.

r7g.large 16 GB / 2 vCPU / ARM Graviton3 / Redis 7

$76.47/mo
GET/SET 1:4, 1 KB values, ~8 GB dataset (median of 3, latency in ms)
Pipeline Clients Ops/sec P50 P95 P99 P99.9
11 5,872 0.650.72 0.882.38
1200 75,992 9.4715.10 38.1470.14
641 230,293 1.031.54 1.913.31
64200 225,895 211.97311.30 507.90638.98

Median of 3 x 60s runs. A single non-pipelined connection holds a 0.88 ms P99; batching 64 commands per round-trip lifts throughput to 230k ops/sec. The last row is the deliberate stress corner: 64-deep pipelines across 200 connections queue on 2 vCPU, so latency climbs (P50 around 212 ms) while throughput stays flat. For latency-sensitive traffic, keep pipelines shallow.

Price-performance vs ElastiCache

Same class.
About 2.1x less to run.

Monthly cost, r7g.large (lower is better)
Selfhost.dev$76.47/mo
AWS ElastiCache (est.)~$165/mo

Same r7g.large class and Redis 7, at comparable throughput. ElastiCache cache.r7g.large at AWS on-demand list price, estimated, not measured. Run Redis on Selfhost.dev.

How we tested Redis
memtier_benchmark Redis 7 HDR histograms
  • 1 KB values, 8M keys (~8 GB), 1:4 read:write, Gaussian
  • Pipeline x clients sweep, 3 x 60s, median reported
  • Dataset held in RAM, no maxmemory set
  • Latency measured in-region, cross-VPC, over public IP
What we did not test (yet)
  • - A measured ElastiCache head-to-head; their price is a list estimate
  • - Workloads larger than RAM, or eviction under memory pressure
  • - Cluster-mode (multi-shard) horizontal scale-out
  • - Read-replica fan-out under load

Run the numbers yourself.
Deployed in under 2 minutes.

Deploy a database Managed PostgreSQL Run Redis