Render's New Memory-Optimized Plans Repriced: A Steady Web Service Bill vs a Fixed Hetzner Node

On August 26, 2026, Render quietly redrew its price list. Not with a headline rate cut or a new billing model, but with fifteen-plus new compute plans: memory-optimized tiers at every 2+ CPU step, a brand-new 12-CPU tier reaching 96 GB of RAM, and spec-based plan IDs (2c-8g) replacing the old Starter-to-Pro-Ultra names. Every legacy price point stayed exactly where it was — $7, $25, $85, $175, $225, $450 — so if your bill didn't move, that is expected. The change is not what the old plans cost. It is what RAM costs once you stop being forced to buy CPUs you don't need to get it.

Here is the repriced answer up front, for one steady, always-on production stack (web service, background worker, managed Postgres, Pro workspace): ≈$79/month on Render, unchanged by the August overhaul — and about $10/month on a fixed Hetzner node running the same footprint. But if your workload is memory-hungry, August genuinely cut your bill: an 8 GB web service drops from $175 to $135 a month, saving $480 a year for changing one plan ID. The rest of this post works both bills line by line, shows where the new $/GB curve bends, and separates the workloads that genuinely benefit from usage-shaped pricing from the steady ones whose cost is easier to own and forecast.

What actually changed on August 26​

Three things shipped together, per Render's changelog entry and the follow-up blog post:

1. Memory-optimized plans at every 2+ CPU tier. At 2 CPU you can now pick 4, 8, or 16 GB of RAM; at 4 CPU, 8, 16, or 32 GB; at 8 CPU, 16, 32, or 64 GB. Previously each CPU tier had exactly one RAM size, so memory scaled only by buying more cores.
2. A new 12-CPU tier for web services, private services, and background workers, with 24, 48, or 96 GB of RAM — explicitly aimed at agent platforms and other heavy vertical workloads.
3. Spec-based plan IDs. 4c-32g means 4 CPU and 32 GB RAM. Legacy IDs (standard, pro plus, pro ultra) keep working in Blueprints, the API, CLI, and SDK, and "compute plan" replaces "instance type" across the dashboard and docs. No migration action is required.

The pricing consequence is best read as dollars per gigabyte of RAM, because that is the resource the overhaul reprices:

Two things stand out. First, the cheapest RAM on Render is now the new 4c-32g at $10.94/GB — undercutting every legacy tier, including the old cheapest (Standard at $12.50/GB). Second, the new tiers consistently beat the old way of reaching the same memory: 8 GB used to require 4c-8g at $175 ($21.88/GB); now 2c-8g delivers it at $135 ($16.88/GB). Render's stated motivation is agent harnesses holding session state and retrieval pipelines keeping embeddings in memory — workloads with far higher RAM-to-CPU ratios than request/response services — and the price curve now reflects that shape instead of punishing it.

Postgres pricing, for reference, runs $6 (256 MB) → $19 (1 GB) → $40 (2 GB) → $55 (4 GB) → $75–$100–$160 (4/8/16 GB) and up, plus $0.30/GB-month for storage beyond the included 1 GB. Key Value (Redis-compatible) starts at $10 for 256 MB. Those catalogs were not the focus of the August change; compute was.

The repriced steady bill: $79 a month​

Take the deliberately boring reference stack: a small production SaaS running 24/7. One web service (1 vCPU, 2 GB RAM), one background worker (0.5 vCPU, 512 MB), managed Postgres at 1 GB RAM with about 10 GB of storage, on a Pro workspace. Egress under 25 GB a month, a handful of custom domains, build minutes within the included 1,000. This is the median footprint, not a stress test.

Call it $76 before storage growth, $79 with it — Render's own write-up lands in the same place, putting a Starter web service plus Basic-256MB Postgres at "about $13/month before bandwidth and storage growth" (exactly $7 + $6). The August overhaul moves none of these lines: every plan in this stack kept its legacy price, and a 2 GB web service has no cheaper new tier to drop into. If your services fit the small fixed sizes, August 26 was a non-event for your invoice, and the new IDs are the only thing you'll notice in the dashboard.

That stability is the point worth naming. Render's pricing story in 2026 has been two separate acts: the April 23 workspace restructure (flat $25 Pro with unlimited seats, forced migration August 1) changed who pays the subscription; the August 26 compute expansion changed what memory costs at the middle and top of the catalog. A steady small stack sits below both fault lines.

The workloads that genuinely got cheaper​

Now the interesting half. Before August 26, RAM came bundled with CPU on a fixed ladder. A service needing 8 GB of memory — a Rails monolith with a fat cache, a Node API holding large in-memory indexes, a self-hosted agent harness with concurrent sessions — had exactly one option: Pro Plus (4 CPU / 8 GB) at $175/month, paying for four cores to reach the memory. Today that workload maps to 2c-8g at $135/month:

The 32 GB row is the sharpest: $100/month saved by halving the CPU attached to the same RAM. And the bottom two rows are new capabilities, not discounts — the old catalog topped out at 8 CPU / 32 GB, so anything needing more memory per instance simply couldn't run on Render before. The 12-CPU tier at the same $450 entry price as the old top-end 8c-32g is also a deliberate signal: CPU-heavy vertical scale-ups no longer force a proportional RAM (and dollar) increase.

A full memory-hungry stack shows the combined effect. Web 2c-8g ($135) + worker 1c-2g ($25) + Postgres 2c-8g ($100) + Pro workspace ($25) = $285/month today, versus $325 before August ($175 web, same everything else). The $40 delta is modest against the total — Postgres and the workspace fee don't move — but it recurs every month for a one-line Blueprint change, and legacy plan IDs keep working, so there is no migration risk in capturing it.

The fixed-node counterfactual: about $10 a month​

The same reference stack from section two fits comfortably on a single Hetzner Cloud CX32: 4 vCPU, 8 GB RAM, 80 GB disk, 20 TB of included traffic, at €6.80/month net — roughly $8 including VAT, plus about $2 for automatic backups. App, worker, Postgres, and Redis-equivalent all share the box; nothing in the footprint needs more. Total: ≈$10/month, all-in, against Render's ≈$79.

That 8x gap decomposes cleanly, and each piece is worth pricing honestly rather than waving away:

• Managed Postgres (~$19 of the $79). On Render this buys automated backups, point-in-time recovery, connection pooling guidance, and version upgrades without maintenance windows you schedule yourself. On the Hetzner box it is a container you back up, and the backup story is the part most self-hosters under-invest in until the first incident.
• The workspace subscription ($25 of the $79). This is the line item with no hardware counterpart at all — dashboard, deploys, preview environments, audit logs, autoscaling primitives. It is also the flattest part of the bill: it doesn't shrink when your services do, which is why Render's smallest possible production stack (Hobby + Starter + 256MB Postgres ≈ $13) still costs more than a CX22 (≈$5) with headroom to spare.
• Operations labor (the $0 line that isn't). Patching the host OS, rotating Postgres, watching disk fill, responding to the 3 a.m. page — Render's margin is largely an on-call retainer. A team with existing platform capacity prices this near zero; a team of five product engineers with no ops practice should price it as the most expensive line on the page.

Scale the comparison to the memory-hungry stack and the ratio compresses but doesn't flip: a CX42 (8 vCPU, 16 GB, ≈$19 with backups ~$23) absorbs the 8 GB web service plus Postgres with room left over, against Render's $285. The fixed node wins on dollars at every size here; it loses on every line item above that involves someone else being awake.

Sensitivity: where usage pricing wins, and where steady wins​

A single worked bill answers one workload. Three variables decide whether the answer generalizes, and each has a crossover worth computing.

Egress. Pro includes 25 GB/month; overage is $0.15/GB. At 100 GB of egress the Render bill gains $11.25; at 500 GB, $71.25; at 1 TB, $146.25 — nearly doubling the reference stack. Hetzner includes 20 TB, so egress is $0 all the way up. Any steady workload serving large downloads, images, or API payloads at volume hits this wall fast; it is the single biggest sensitivity in the comparison, bigger than the August compute changes. (Scale's $499 fee buys 1 TB included — the crossover where Scale beats Pro-plus-overage sits around 3.2 TB of egress, firmly in "you already know you need it" territory.)

Idleness. This is the variable that runs the other way. Render bills compute per second, and services that sleep or scale to zero stop accruing — a staging environment used eight hours a day costs roughly a third of its sticker price, and Hobby workspaces add no subscription at all. The Hetzner node bills $8 whether it serves a million requests or zero. Bursty, spiky, nights-and-weekends-idle workloads genuinely benefit from usage-shaped pricing; the fixed node only wins when utilization is high and flat, which is exactly what "steady" means.

People. The April restructure already settled the seat question — unlimited members on Pro ($25 flat) — so team size no longer moves the Render side. It still moves the self-hosted side: the $10 Hetzner figure assumes someone on the team already knows how to run Postgres in production. For a solo founder who does, the 8x gap is real money. For a team that would learn it on a production database, the tuition exceeds the savings.

The decision rule that falls out is simple: steady, high-utilization, high-egress workloads have costs that are easier to own and forecast on fixed hardware, and August's new tiers don't change that. Spiky, idle-heavy workloads with modest egress are where Render's per-second metering earns its premium — and memory-hungry steady workloads just got $25–$100/month cheaper to keep there, which narrows (without closing) the gap for exactly the agent-era workloads Render is courting.

What to do Monday morning​

If you run on Render, the August change asks one question of you: is any service sitting on a bigger CPU tier than its load needs, just to reach its RAM? Any web service or worker on 4c-8g, 4c-16g, or 8c-32g whose CPU graphs are flat while memory is tight is a candidate for 2c-8g, 2c-16g, or 4c-32g respectively — same memory, fewer cores, $25–$100/month back. Check the mapping in the dashboard (old names are shown alongside the new IDs), update the Blueprint pin at your leisure, and note that legacy IDs remain valid, so nothing breaks if you don't.

If you're choosing between Render and a fixed node for a new steady service, price all three sensitivities, not just compute: model your egress against $0.15/GB past 25 GB, be honest about your utilization curve, and put a number — any number — on the ops labor line before comparing $79 to $10. The platforms have spent 2026 converging on hybrid pricing (flat subscription plus usage metering) precisely because neither extreme wins every workload; the bill that fits your shape is the cheapest one, not the cheapest sticker.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.