Skip to main content
emnode
Cost

Purchase MemoryDB Reserved Nodes

MemoryDB is a durable in-memory database, not a cache: Reserved Nodes are its only commitment lever, but they cover node hours and leave the data-written and snapshot-storage charges at full price.

14 min·10 sections·AWS

Last reviewed

MemoryDB Reserved Nodes: the basics

Why a durable in-memory database needs its own commitment decision

Amazon MemoryDB is a durable, in-memory database that speaks the Redis OSS and Valkey protocols. The word that matters is durable, unlike ElastiCache, which is a cache you can lose without data loss, MemoryDB persists every write to a Multi-AZ transactional log before acknowledging it. That makes it a primary datastore, not a disposable accelerator, and it means MemoryDB bills you for more than just compute: you pay for node hours, for the volume of data you write (data written, charged per GB), and for snapshot storage (per GB-month). Reserved Nodes only touch the first of those three.

A MemoryDB Reserved Node is a billing commitment, not a resource you launch. You promise AWS you'll run a particular node type in a particular region for one or three years, and in exchange AWS discounts the node-hour rate by up to roughly 55% versus On-Demand. The discount applies automatically against any matching node you happen to be running, nothing about the cluster changes. The commitment is scoped by node type, engine family, and region; there's no Multi-AZ toggle the way RDS reservations have, because MemoryDB is always Multi-AZ durable by design. Engine matters too: a Redis OSS reserved node can even cover running Valkey nodes (Valkey is priced about 30% below Redis OSS, so the same reservation stretches further), but the offering you buy is keyed on node type and region.

MemoryDB sits entirely outside Savings Plans: Compute and EC2 Savings Plans cover EC2, Fargate, and Lambda, and reach none of the managed in-memory services. So for MemoryDB the Reserved Node is the only structured discount lever you have. It's also a newer service than ElastiCache or RDS, with a smaller offerings catalogue and availability in fewer regions, so before you build a commitment plan, confirm the node type you run is actually offered as a reservation in your region.

In this lesson you'll learn why MemoryDB is a durable database rather than a cache, why that durability splits the bill across node hours, data written, and snapshot storage, and why Reserved Nodes only touch the first of those. You'll see how reservations are scoped (the offering you buy is keyed on node type and region; engine flexibility lets a Redis OSS reservation cover Valkey nodes), why the smaller offerings catalogue and limited regional availability matter before you plan, and the sequence that protects you: right-size shards and replicas first, then commit to the stable baseline. You'll see the AWS CLI calls that surface reserved-node offerings, make the irreversible purchase, and list what you already own.

Fun fact

The cache that wasn't a cache

Teams routinely mistake MemoryDB for ElastiCache because both speak Redis OSS and Valkey, and the cost mistake follows the conceptual one. A platform team migrated a Redis workload from ElastiCache to MemoryDB for the durability guarantee, then bought Reserved Nodes expecting the same near-total bill coverage they were used to on the cache. They were surprised when the MemoryDB invoice only dropped about a third: the data-written charge (billed per GB on everything written through the durable transactional log) and the snapshot-storage charge, which barely exist on a pure cache, made up a large share of the MemoryDB total, and no reservation touches them. The node hours were 55% cheaper exactly as advertised; the bill simply had two other meters running underneath that the cache never had.

Buying MemoryDB reservations in action

Lena runs the platform team at a real-time analytics company. The FinOps dashboard shows about $22k of monthly MemoryDB spend on a Valkey-compatible cluster that's been steady for a year, almost entirely On-Demand. The Compute Savings Plan the company bought covers their EKS fleet, and does nothing for MemoryDB.

Before committing a dollar, Lena does the unglamorous work first. She reviews the cluster shape: it's over-provisioned with two replicas per shard where one would meet the availability SLA, and a couple of shards are running a node size larger than the working set needs. She right-sizes the replica count down and drops the oversized shards a tier, confirming the remaining cluster is genuinely steady-state. Then she splits the bill: about $15k is node hours, the rest is data written and snapshot storage, and she notes only the node-hours portion is reservable.

She lists the available reserved-node offerings for her node type and region, confirms it's actually offered (MemoryDB's catalogue is smaller than ElastiCache's), and prices a three-year Partial Upfront commitment at roughly 54% off the node-hour rate. She buys to cover ~85% of the steady node baseline, leaving the top of the curve On-Demand so a future right-size doesn't strand a reservation, and sets a calendar reminder for month 30 to plan renewal.

First, list the reserved-node offerings available for your node type and region. MemoryDB's catalogue is smaller than ElastiCache's, so confirm the shape you run is actually offered before planning around it.

$ aws memorydb describe-reserved-nodes-offerings --node-type db.r6g.xlarge --query 'ReservedNodesOfferings[?Duration==`94608000`].{Id:ReservedNodesOfferingId,Node:NodeType,Term:Duration,Offer:OfferingType,Fixed:FixedPrice,Recurring:RecurringCharges}' --output table
------------------------------------------------------------------------------------------
| DescribeReservedNodesOfferings |
+--------------------------------------+----------------+----------+------------------+
| Id | Node | Offer | Fixed |
+--------------------------------------+----------------+----------+------------------+
| 438a9b21-0c4d-4e1f-aa22-7c9d3e5f0011 | db.r6g.xlarge | Partial | 2810.00 |
| 7f2c11d4-9e88-4a3b-b6e2-1d4f8a90c233 | db.r6g.xlarge | All | 5640.00 |
| c01e44a7-2b13-4d9c-8f51-6a2e7b30d845 | db.r6g.xlarge | No | 0.00 |
+--------------------------------------+----------------+----------+------------------+
# Three payment shapes for ONE node type in ONE region — that pair is the whole commitment scope.

The offering you buy is scoped to node type and region, no Multi-AZ dimension. That pair is exactly what you lock in, though engine flexibility lets a Redis OSS reservation cover Valkey nodes.

Once you've right-sized and chosen the offering, purchase against its ID. This is the irreversible step; there are no convertible MemoryDB reservations.

$ aws memorydb purchase-reserved-nodes-offering --reserved-nodes-offering-id 438a9b21-0c4d-4e1f-aa22-7c9d3e5f0011 --node-count 8 --reservation-id memdb-ri-r6g-xl-2026 --tags Key=Owner,Value=platform Key=Workload,Value=session-store
{
"ReservedNode": {
"ReservationId": "memdb-ri-r6g-xl-2026",
"NodeType": "db.r6g.xlarge",
"NodeCount": 8,
"Duration": 94608000,
"OfferingType": "Partial Upfront",
"FixedPrice": 2810.00,
"State": "payment-pending",
"StartTime": "2026-05-26T09:31:07.000Z"
}
}
# Covers node HOURS only — data written (per GB) and snapshot storage (per GB-month) keep billing at full rate.

The purchase is irreversible and covers node hours alone: the data-written and snapshot-storage meters underneath it are untouched by the reservation.

MemoryDB reservations under the hooddeep dive

MemoryDB's pricing model has three distinct meters, which is the single most important thing to internalise before committing. First, node hours: you pay an hourly rate per node (for example a db.r6g.xlarge runs roughly $0.432/hour On-Demand in us-east-1, about $315/month). Second, data written: MemoryDB charges $0.20/GB for the volume of data you write to the cluster (a per-GB charge on what you write, not a per-GB-month storage charge), with a generous monthly free allowance on Valkey: a meter that simply doesn't exist on a non-durable cache. Third, snapshot storage: MemoryDB charges per GB-month for snapshot data kept beyond the free allowance. A Reserved Node discounts the first meter and nothing else.

A MemoryDB Reserved Node offering is matched against running nodes by node type (db.r6g.xlarge) and AWS region; there is no Single-AZ vs Multi-AZ choice, because MemoryDB is always Multi-AZ durable. Engine does play a role in how the benefit applies: each node type and engine has a normalisation factor, and because Valkey is priced about 30% below Redis OSS, a Redis OSS reserved node can cover more Valkey units than Redis OSS ones, so a Redis OSS reservation can stretch across an upgrade to Valkey. Every reservation is a standard commitment; there are no convertible MemoryDB reservations, so once bought you cannot exchange the node type or move it to a different region. Your main flexibility is the engine coverage above and buying against the shape you actually run, which is why right-sizing has to come first. The catalogue is also narrower than ElastiCache's, and MemoryDB is available in fewer regions, so always confirm an offering exists for your node type and region before building a plan around it.

This is exactly why right-sizing shards and replicas precedes the commitment. MemoryDB scales by sharding (more shards = more total memory and throughput) and by replicas per shard (more replicas = higher availability and read capacity, at a node cost each). An over-provisioned cluster (too many replicas for the SLA, or shards a size larger than the working set needs) inflates the node count you'd reserve. Commit before trimming and you lock in the oversized footprint for the full term against a cluster you're about to shrink, paying for reserved nodes nothing consumes. Sequence the shard/replica decisions first; buy the reservation against the node count and type you'll still be running in three years.

# Confirm an offering exists for your node type and region, and inspect both prices
# (the fixed upfront and the recurring hourly) before buying.
aws memorydb describe-reserved-nodes-offerings \
  --node-type db.r6g.xlarge \
  --query 'ReservedNodesOfferings[?Duration==`94608000` && OfferingType==`Partial Upfront`].{Id:ReservedNodesOfferingId,Fixed:FixedPrice,Recurring:RecurringCharges[0].RecurringChargeAmount}'

# List what you already own so you don't double-buy, and see what's expiring.
aws memorydb describe-reserved-nodes \
  --query 'ReservedNodes[].{Id:ReservationId,Node:NodeType,Count:NodeCount,Offer:OfferingType,State:State,Start:StartTime}' \
  --output table

What is the impact of leaving MemoryDB uncommitted?

The direct impact is paying full On-Demand node rates on a stable, always-on database. A db.r6g.xlarge node runs roughly $315/month On-Demand in us-east-1; a three-year Partial Upfront reservation drops the effective node-hour rate by around 50 to 55%, to roughly $145/month. Across an eight-node baseline that's about $1,400 a month (over $16k a year) of node-hour discount that AWS offers and that simply isn't being claimed because no one owns the MemoryDB commitment decision.

The most important impact is the one teams get wrong: a Reserved Node covers node hours only. MemoryDB's data written (per GB) and snapshot storage (per GB-month) are separate meters that no reservation touches, and on a durable database they can be a meaningful fraction of the total. So the realistic bill reduction is the node discount applied to only the node-hour slice, not the headline 55% across the whole MemoryDB line. A team that assumes the reservation will cut the MemoryDB invoice by half will be disappointed when data written and snapshots keep billing at full rate; the discount is real but its reach is narrower than on a pure cache.

Then there's the asymmetry with Savings Plans. Teams that have invested in Compute Savings Plans often believe their commitment coverage is healthy because the EC2 number looks great, but MemoryDB, like RDS and ElastiCache, sits entirely outside that program and is invisible on the Savings Plan dashboard. The result is a blind spot: a committable, stable database running at sticker price while everyone congratulates themselves on compute coverage. MemoryDB node coverage has to be tracked on its own meter or it disappears.

Finally there's the stranding risk, which runs the opposite direction. Because MemoryDB reservations are standard-only and non-convertible, a premature or over-eager commitment is expensive. Commit before right-sizing the shard and replica count and you lock in the oversized footprint. Buy against a node type you later migrate away from (say a move to a newer Graviton generation) and the reservation bills against nothing while the new nodes pay On-Demand, until it expires. The discount and the trap are two sides of the same rigidity, and MemoryDB's smaller catalogue means a re-tiering plan can leave you with no matching offering at all.

How do you commit to MemoryDB reservations safely?

Buying MemoryDB Reserved Nodes is a four-step sequence, and the order is the whole point: right-size the cluster, split the bill so you know what's reservable, commit only to the stable node baseline, and review coverage and utilisation every month.

1. Right-size shards and replicas BEFORE you commit

Reservations lock in a node type and count, so fix the cluster shape first. Trim replicas to what the availability SLA actually needs, drop oversized shards a tier where the working set is smaller than provisioned, and resolve any planned node-type migration (for example a move to a newer Graviton generation) before purchasing. A reservation bought against a footprint you're about to shrink is stranded waste for the full term, and there's no convertible escape hatch for MemoryDB, plus the narrower catalogue may not even offer the shape you migrate to.

2. Split the bill so you know what a reservation can actually reach

Before modelling any saving, break the MemoryDB line into its three meters: node hours, data written (per GB), and snapshot storage (per GB-month). Only the node-hours slice is reservable. On a write-heavy or snapshot-heavy cluster, data written and snapshots can be a substantial fraction of the total, which caps how much any reservation can save. Model the discount against the node-hour slice alone, and report the data-written-and-snapshot share so no one mistakes a 55% node discount for a 55% bill reduction.

3. Commit to the stable node baseline, not the peak

Look at the trailing 60 to 90 days and find the floor: the node count that is always running. Commit to roughly 80 to 90% of that steady baseline and leave the variable top of the curve On-Demand. This deliberately under-covers so a future right-size or node-type migration doesn't strand a reservation. Choose the payment option (No/Partial/All Upfront) and term (1 vs 3 years) as a cash-versus-discount decision with an explicit payback number, it's finance's call, not a console default.

4. Review coverage and utilisation on every FinOps cadence

Track two numbers monthly: node coverage (share of MemoryDB node hours covered by a reservation; target 80 to 95% on stable clusters) and utilisation (share of reserved nodes actually consumed; must stay near 100%). Watch expirations 60 to 90 days out so renewals are deliberate, not silent lapses back to full price. If utilisation drops, a right-size or migration has stranded a reservation, investigate before buying anything new.

# Confirm an offering exists for your node type, then compare payment options before buying.
for opt in "No Upfront" "Partial Upfront" "All Upfront"; do
  echo "== $opt =="
  aws memorydb describe-reserved-nodes-offerings \
    --node-type db.r6g.xlarge \
    --query "ReservedNodesOfferings[?Duration==\`94608000\` && OfferingType==\`$opt\`].{Id:ReservedNodesOfferingId,Fixed:FixedPrice,Recurring:RecurringCharges[0].RecurringChargeAmount}"
done

# List what you already own so you don't double-buy, and surface anything expiring soon.
aws memorydb describe-reserved-nodes \
  --query 'ReservedNodes[?State==`active`].{Id:ReservationId,Node:NodeType,Count:NodeCount,Term:Duration,Start:StartTime}' \
  --output table

Quick quiz

Question 1 of 5

You have a stable MemoryDB cluster on db.r6g.xlarge nodes, fully On-Demand, and the team is planning to migrate to a newer Graviton node generation next quarter. The bill is roughly 60% node hours and 40% data written plus snapshot storage. What's the right move on Reserved Nodes?

Keep learning

Dig deeper into MemoryDB reservation mechanics, its durable pricing model, and how in-memory databases fit the broader commitment strategy.

You've completed Purchase MemoryDB Reserved Nodes. You now know why MemoryDB is a durable database rather than a cache, why that durability splits the bill across node hours, data written, and snapshot storage, and why a Reserved Node discounts only the node hours. You know the offering you buy is scoped by node type and region with no Multi-AZ dimension (and that engine flexibility lets a Redis OSS reservation cover Valkey nodes), that the catalogue is narrower and the regions fewer than ElastiCache or RDS, and the sequence that protects you: right-size shards and replicas first, then commit to the stable node baseline. The next time the bill shows an uncommitted MemoryDB cluster, you'll have a defensible path from On-Demand to a sound commitment without stranding a node or overstating the prize.

Back to the library