Snap Cut Caching Costs 60% With Valkey: What the Number Really Means When You Self-Host It

Snap took its caching bill from $2.1 million a year to $840,000 a year by moving 70% of its Redis clusters to Valkey on ElastiCache. That is a 60% cut on 5 billion daily requests — a real production number, not a benchmark slide.

The bill didn't fall for one reason. It fell for three at once: AWS charges 20% less per node for Valkey than for Redis OSS, Valkey's reworked hashtable uses roughly 20-28% less memory for the same dataset so Snap could run smaller instances, and bursty workloads moved to ElastiCache Serverless where Valkey is 33% cheaper per operation. Each discount stacks on the last.

That number settles the "should we switch from Redis OSS to Valkey on ElastiCache" question. It doesn't settle the next one: what does the same caching workload actually cost if you skip ElastiCache entirely and run Valkey yourself on owned hardware. The managed-service bill still contains a per-gigabyte markup that has nothing to do with the engine — it's the price of someone else operating it. The self-hosted bill replaces that markup with your own operational cost. The two floors are not the same number.

This post puts both floors on the same page, line by line.

The answer up front: three prices for the same cache​

We priced the same reference workload three ways: a mid-size caching tier holding roughly 13 GB of hot data, serving tens of millions of operations per day, with replication for high availability. Every number below is drawn from live 2026 AWS pricing and Hetzner post-June-2026 rates. The Hetzner line is an owned box managed under Cluster API — the RAM is yours, the bandwidth is bundled, and the operational cost is explicit rather than hidden inside a per-GB meter.

Snap's $2.1M → $840K is the ElastiCache Redis OSS → ElastiCache Valkey column at Snap's scale. The self-hosted column is the next comparison the $840K invites: at this mid-tier size, the hardware itself is roughly 90% cheaper than even the discounted managed rate. Whether that arithmetic wins depends entirely on what you budget for the ops row.

Why Snap's 60% is three discounts stacked, not one​

It is tempting to read "60% cheaper" as "Valkey is 60% cheaper than Redis." It isn't. The headline number decomposes into three separable savings, and each has a different implication for a team deciding between ElastiCache Valkey and self-hosted Valkey.

Discount 1: The engine price cut (20% node-based, 33% Serverless)​

AWS made Valkey the default engine for new ElastiCache clusters in late 2024 and priced it permanently lower than Redis OSS. The numbers have not moved since:

• Node-based (self-designed) clusters: Valkey is 20% cheaper per node-hour than Redis OSS for the same instance class. A cache.t4g.medium lands at $0.052/hr on Valkey versus $0.065/hr on Redis OSS — about $114 per node per year for a small instance, scaling linearly.
• ElastiCache Serverless: Valkey is 33% cheaper — $0.016 per million ECPUs versus the Redis OSS Serverless rate, and $0.0672 per GB-hour for stored data versus the Redis OSS equivalent. The minimum stayed at 100 MB for Valkey (versus 1 GB for Redis OSS Serverless), so small caches start at roughly $6/month.

This is the simplest line to verify: open the ElastiCache pricing page, pick any instance class, toggle the engine. The Valkey column is exactly 20% lower. It has been since 2024 and AWS markets it as permanent, not promotional.

Discount 2: Memory efficiency (~20-28% less RAM for the same keys)​

Valkey 8.1 rewrote its hashtable on top of data structures inspired by Google's Swiss Tables and reworked its defragmentation engine. The production effect is straightforward: the same dataset needs fewer bytes.

• AWS's own migration writeups cite up to 40% memory savings in specific workloads.
• An independent 2026 hashtable benchmark: 50 million key-value pairs consume 3.77 GB on Valkey 8.1 versus 4.83 GB on Redis — a 28% improvement.
• Snap's fleet saw roughly 20% memory efficiency gains, enough to drop one instance size class across large parts of its tier.

This matters because it compounds with Discount 1. You are not just paying 20% less per node — you may need fewer nodes or a smaller node type to hold the same data. In Snap's case that right-sizing is a meaningful share of the $1.26M annual savings, not just the per-node price cut.

For a self-hosted fleet the same efficiency still applies but lands differently: there is no per-GB meter to save against. Fewer gigabytes means you can fit more cache on the same Hetzner box before needing a larger one — a step function, not a linear bill reduction.

Discount 3: Serverless for bursty shards (up to 75% on spiky workloads)​

Teams that moved bursty or unpredictable shards to ElastiCache Serverless for Valkey reported the steepest drops — one production migration documented roughly 75% lower cache infrastructure cost versus its previous provisioned deployment, and AWS customers with spiky traffic patterns routinely cite Serverless as the largest single contributor to their savings.

The mechanism is simple: provisioned nodes charge for capacity you reserved whether you use it or not. Serverless charges per ECPUs consumed and GB-hours actually stored. For a workload that idles 70% of the day and spikes 5x at peak, the reserved-capacity waste dominates the bill. Serverless eliminates it — and Valkey Serverless does so at a 33% discount to Redis OSS Serverless.

Self-hosted Valkey has no Serverless tier. An always-on box charges the same flat rate whether it is idle or saturated. For bursty workloads, that flat rate can be either a bargain (you already sunk the hardware cost for peak anyway) or waste (you bought peak capacity for an average load) depending on how spiky the workload actually is.

What ElastiCache Valkey still charges after the 60% cut​

The $840K number is dramatically cheaper than $2.1M. It is not free of line items that a self-hosted bill replaces with different costs.

Per-GB storage metering. ElastiCache Serverless bills $0.0672 per GB-hour for data stored. ElastiCache node-based doesn't meter per GB directly but prices nodes by memory size — a larger dataset forces a larger (pricier) instance class. Either way, more data means a larger bill, linearly. On a Hetzner box, 8 GB of RAM costs the same whether you use 2 GB or 7 GB of it for cache — the cost is flat until you outgrow the box.

Inter-AZ data transfer. This is the line item teams discover late. ElastiCache replication, client reads across availability zones, and backup traffic all generate inter-AZ transfer charges. One widely cited Valkey migration (Redis Cluster + Lettuce → ElastiCache Valkey + GLIDE with AZ-aware routing) cut inter-AZ transfer costs by 94% — which tells you how large that line was before the optimization. Self-hosted Valkey on a single-region Hetzner fleet has no inter-AZ transfer concept; a multi-region self-hosted setup has inter-region traffic, but it rides the flat 20 TB included bandwidth rather than a per-GB transfer meter.

The minimum footprint. ElastiCache Serverless for Valkey has a 100 MB minimum billable storage — small, but not zero. Node-based has a per-node minimum (one node is the floor). Hetzner's floor is one server, typically €4-15/month depending on class — also not zero, but flat rather than metered.

Version upgrades and engine coupling. Staying on ElastiCache means staying on AWS's supported Valkey versions and upgrade cadence. Valkey's rapid 8.x releases (8.0, 8.1 with the hashtable rewrite) land on ElastiCache on AWS's schedule, not yours. Self-hosted Valkey upgrades when you decide to — which is flexibility but also operational responsibility.

Self-hosted Valkey on owned hardware: the other bill​

Running Valkey yourself on a Hetzner box — the model a Bex.co / Cluster API fleet uses — replaces every per-GB and per-request meter with a flat hardware fee and an operational cost you budget explicitly.

The hardware line is flat and small. A representative node for the 13 GB tier above:

• Hetzner CPX31: 4 vCPU (shared, AMD), 8 GB RAM, 160 GB SSD, 20 TB traffic — €14.75/month before the June 2026 repricing adjustment, roughly €16-19/month after depending on line.
• Hetzner CX32/CCX13 (dedicated vCPU): 4 dedicated vCPU, 8 GB RAM — €22-30/month post-hike for dedicated cores.
• Netcup RS 1000 G12 (comparison point): 4 dedicated AMD EPYC 9645 cores, 8 GB DDR5 ECC, 256 GB NVMe, 2.5 Gbps — €8.74/month, though without a mature Cluster API provider today.

Three replicated nodes on CPX31-class hardware: roughly $45-60/month total for the caching tier itself. Even on dedicated-vCPU instances the tier stays under $100/month. Compare that to $400-680/month for the same tier on ElastiCache.

What you get for free on the flat fee:

• Bandwidth: 20 TB per server included. Replication traffic, client reads, and snapshot offload all ride the same flat allocation. No per-GB egress or inter-AZ meter.
• Storage for persistence: 160 GB SSD per CPX31, local NVMe. AOF and RDB snapshots stay on-box; offload to S3-compatible storage (Hetzner Object Storage or any S3 endpoint) costs roughly $0.015/GB-month only for what you actually offload.
• No engine markup: Valkey is BSD-licensed. No per-node license line regardless of scale.

What you pay in operations instead:

The honest total cost is hardware plus the amortized labor of that right column. For a solo developer or two-person team, that labor can outweigh the hardware savings — ElastiCache's markup is effectively a fractional DBA salary you don't have to hire. For a team already operating a Kubernetes fleet on Hetzner, the incremental ops for one more stateful workload is small because the cluster, monitoring, and backup plumbing already exist.

Where each model actually wins: a sensitivity check​

No single "winner" holds across all scales. Here is how the arithmetic shifts when the workload — not the marketing — changes.

Small cache, low traffic (1-2 GB, thousands of ops/min). ElastiCache Serverless for Valkey starts at roughly $6/month and scales with usage. A Hetzner box starts at €4-15/month even if you use 10% of it. At this size the managed-service minimum is competitive and you avoid all ops. Self-hosting only wins if you already have a box running other workloads and the cache is a sidecar on spare capacity.

Mid-size, steady traffic (10-30 GB, millions of ops/day). This is where self-hosted pulls ahead decisively. The ElastiCache bill scales linearly with data size and request rate; the Hetzner bill stays flat until you outgrow the box. A 20 GB tier that costs $300-500/month on ElastiCache Valkey fits on a single Hetzner CCX-class server for under $30/month. Even budgeting a generous ops allowance, the managed markup is 10x the hardware.

Large, bursty, or multi-tenant (100+ GB, spiky, many logical caches). ElastiCache Serverless shines on burstiness — you pay for what you use, not what you provisioned for peak. If your workload idles most of the day and spikes 5-10x, the provisioned-node waste can make Serverless cheaper than a flat box sized for peak. But if the workload is large and steady — Snap's 5B requests/day is steady at scale — the flat box wins on amortization because you saturate what you provisioned.

The rule of thumb: if your cache tier already justifies a dedicated node and you operate your own fleet, self-hosted Valkey's flat hardware cost will undercut even the discounted ElastiCache Valkey rate by 80-90% on the hardware line. The question is never "is the hardware cheaper" — it always is — but "does the ops cost you already carry cover one more stateful service."

What this means for a platform team​

Snap's migration is a clean proof that Valkey is not a protest fork anymore — it is the engine the managed services themselves are discounting. AWS, Google Cloud, and Oracle all ship Valkey at 20-33% below their Redis OSS price, Valkey 8.1 is measurably faster and leaner than Redis 7.x, and the Linux Foundation governance removes the relicensing risk that triggered the fork in the first place.

But the deeper lesson of the $2.1M → $840K story is not "switch the engine." It is that the engine price was only one of three savings — and the managed-service markup underneath even the discounted engine is still the largest line item for any team that can carry the ops.

A self-hosted PaaS like Bex.co takes that observation to its natural conclusion: if your fleet already runs on owned Hetzner hardware under Cluster API, Valkey is just another workload on a box you already pay for flat. No per-GB meter, no inter-AZ transfer line, no Serverless ECPUs. The 20% memory efficiency still helps — it just means you fit more cache on the same server before needing a bigger one. The operational responsibilities are real but incremental when the cluster, monitoring, and backup plumbing already exist for every other service on the fleet.

You don't have to pick one or the other on day one. Many teams land in the middle: start on ElastiCache Valkey for the zero-ops ramp, then reclaim the caching tier to self-hosted Valkey once the fleet and the operational muscle are there. Snap moved 70% of its clusters — not 100% — and the remaining 30% is a reminder that migration is a dial, not a switch.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Valkey, Postgres, and any other backing service run on the same Cluster API-managed Hetzner fleet, with no per-GB cache markup. Star the repo on GitHub or deploy your first app today.