How do Savings Plans and Reserved Instances actually work?
Both instruments are billing constructs. Neither reserves a specific server. AWS matches your commitment against eligible usage every hour, and the discount lands wherever that usage happens to be.
A Savings Plan commits you to a fixed dollar amount of compute spend per hour, such as $10/hour, for the term. Eligible usage up to that amount is billed at the discounted rate, and anything above it is billed on demand. A Reserved Instance commits you to an instance configuration (family, size, platform and region or Availability Zone), and matching usage gets the reserved rate.
| Instrument | Applies to | Flexibility after purchase | Relative discount |
|---|---|---|---|
| Compute Savings Plan | EC2 in any family, size, region, OS or tenancy, plus Fargate and Lambda | Automatic across all of these; cannot be cancelled, exchanged or resold | Lower |
| EC2 Instance Savings Plan | One instance family in one region, with any size, OS or tenancy | Automatic within that family; cannot be cancelled, exchanged or resold | Higher |
| Standard RI | A specific configuration; regional Linux RIs float across sizes | Can be sold on the RI Marketplace, subject to restrictions | Higher |
| Convertible RI | A specific configuration | Can be exchanged for another configuration of equal or greater value | Lower |
The flexible instruments trade discount depth for coverage that survives migrations, such as moving to Graviton or shifting services to Fargate.
Why commitment size matters more than the instrument
The discount gap between instruments is a few percentage points. Unused commitment loses 100% of its value, because you pay for every committed hour whether or not usage shows up to absorb it. Use this to compare the two:
waste = unused committed $/hour × hours remaining in term
An oversized commitment usually costs more than picking the less optimal instrument.
When should a backend fleet use Reserved Instances instead of a Savings Plan?
That cost of idle commitment is also why plan type matters. Savings Plans are the default for EC2, but Reserved Instances still win in three situations.
You need guaranteed capacity. A Savings Plan is a billing discount and holds no capacity. A zonal RI reserves capacity for a specific instance type in one Availability Zone, which matters if you must scale during an AZ failover or a regional capacity crunch. The more flexible alternative is an On-Demand Capacity Reservation (ODCR), which you can pair with a Savings Plan or regional RI for the discount. Either way, you pay for a reservation whether or not instances run in it, so reserve only for workloads that cannot tolerate a launch failure.
Your stack includes managed data services. Compute Savings Plans cover EC2, Fargate and Lambda. They do not cover RDS, ElastiCache or OpenSearch, which use their own reserved instances or reserved nodes. A typical backend therefore needs a Savings Plan for the app tier and RIs for the databases and caches. Check the current commitment options for each service you run.
Your fleet is stable and homogeneous. If you have run one instance family in one region for years, Compute Savings Plan flexibility goes unused. EC2 Instance Savings Plans and Standard RIs give a deeper discount in exchange for that flexibility.
| Need | Best fit |
|---|---|
| Capacity guarantee in one AZ | Zonal RI, or ODCR plus a Savings Plan |
| RDS / ElastiCache / OpenSearch | Service-specific RIs |
| Fixed family and region | EC2 Instance Savings Plan or Standard RI |
| Changing families, Fargate, Lambda | Compute Savings Plan |
Illustrative estimate (assumed numbers, not a benchmark): forgone savings = covered On-Demand $/hour × hours per year × (deeper discount − flexible discount). Assume $10/hour of covered usage and a 6-point discount gap: 10 × 8,760 × 0.06 = $5,256 per year paid for flexibility you don't use.
How do you size a compute savings plan commitment from usage data?
Size from hourly data, not monthly totals. A monthly sum hides the overnight and weekend troughs, and those troughs set the safe commitment level. Export hourly line items from your billing data for the usage a Compute Savings Plan can cover: EC2, Fargate and Lambda. Express each hour as On-Demand-equivalent cost so that hours already covered by existing commitments still count as demand. Exclude Spot entirely. It is already discounted and will never consume a commitment.
Commit at or below a low percentile, such as p5 or p10, not the mean. The mean includes peaks. If you commit at the mean, the commitment sits partly unused through every trough, and you pay for those unused hours anyway.
Before computing the floor, remove demand you plan to eliminate:
- Rightsizing.
- Graviton migrations, which lower the hourly cost of the same work.
- Containerization that bin-packs workloads onto fewer instances.
- Retired services.
The lookback window has a failure mode in both directions:
- Too short (a few weeks): it misses month-end dips, holiday lulls and seasonal lows.
- Too long: it includes workloads you have since removed.
Use a window long enough to capture a full business cycle. Then delete the series for decommissioned workloads instead of shortening the window.
Commitments are stated at Savings Plan rates, so convert the result:
commitment ($/h) = floor_OD × (1 − planned reduction) × (1 − SP discount)
Illustrative estimate (assumed numbers, not a benchmark): p10 floor of $40/h, 15% planned reduction, 25% discount gives 40 × 0.85 × 0.75 = $25.50/h.
The example script below loads an hourly cost CSV, filters out Spot and ineligible services, sums the remaining cost per hour, and returns the chosen quantile.
# Usage: python size_sp.py hourly_costs.csv --quantile 0.10 --reduction 0.15 --discount 0.25 --drop legacy-batch
# Expected CSV columns (rename to match your billing export):
# usage_start, service, purchase_option, workload, od_equivalent_cost
import argparse
import pandas as pd
# Compute Savings Plan-eligible services, labelled as they appear in your export.
ELIGIBLE = {"EC2", "Fargate", "Lambda"}
ap = argparse.ArgumentParser()
ap.add_argument("csv")
ap.add_argument("--quantile", type=float, default=0.10) # low percentile, not the mean
ap.add_argument("--reduction", type=float, default=0.15) # planned rightsizing/Graviton/etc.
ap.add_argument("--discount", type=float, default=0.25) # assumed SP discount vs On-Demand
ap.add_argument("--drop", nargs="*", default=[]) # decommissioned workloads
args = ap.parse_args()
df = pd.read_csv(args.csv)
df["hour"] = pd.to_datetime(df["usage_start"], utc=True).dt.floor("h")
# Keep eligible usage only. Spot never consumes a commitment, and removed
# workloads are dropped here instead of shortening the lookback window.
mask = (
df["service"].isin(ELIGIBLE)
& (df["purchase_option"] != "Spot")
& ~df["workload"].isin(args.drop)
)
hourly = df[mask].groupby("hour")["od_equivalent_cost"].sum()
# Hours with no eligible usage are real troughs. Fill them with 0 so the
# percentile sees them.
full = pd.date_range(df["hour"].min(), df["hour"].max(), freq=pd.Timedelta(hours=1))
hourly = hourly.reindex(full, fill_value=0.0)
floor_od = hourly.quantile(args.quantile)
commit = floor_od * (1 - args.reduction) * (1 - args.discount)
print(f"hours={len(hourly)} mean_od={hourly.mean():.2f}/h "
f"p{args.quantile * 100:.0f}_od={floor_od:.2f}/h commitment={commit:.2f}/h")
A pandas script that filters an hourly cost export to Savings Plan-eligible, non-Spot usage, fills empty hours with zero, takes a low-percentile On-Demand-equivalent floor, and converts that floor into an hourly commitment at Savings Plan rates.
Coverage vs utilization: why 100% coverage is the wrong goal
Two metrics describe a commitment, and they pull in opposite directions. Coverage is the share of eligible spend billed at the discounted rate. Utilization is the share of the commitment you actually consume. You pay for the commitment every hour whether or not workloads use it. Spend above the commitment is billed at on-demand rates, so the money you lose is in the hours when usage falls below the commitment.
Illustrative estimate
The inputs below are assumed, not measured. A day has 2 hours at $60, 10 at $85, 8 at $110 and 4 at $140 of on-demand-equivalent spend, for a total of $2,410. The discount is 30%. To keep the arithmetic simple, each commitment is expressed as the on-demand spend it covers, so a $80 commitment costs $56 per hour.
| Commitment (on-demand equiv./h) | Coverage | Utilization | Unused commitment paid/day | Net savings/day |
|---|---|---|---|---|
| $50 | 50% | 100% | $0 | $360 |
| $80 | 78% | 98% | $28 | $536 |
| $110 | 95% | 87% | $245 | $442 |
Moving from $50 to $80 adds $176 a day, because the extra commitment is idle for only two hours. Moving from $80 to $110 raises coverage by 17 points but loses $94 a day. The added commitment sits unused through twelve low hours, and it only earns its discount during the twelve peak hours. Those peaks are cheaper to run on demand or on Spot.
Handling the dashboard
Finance often tracks coverage because a high number looks like good discipline. Report net savings and utilization alongside it, and show the table above built from your own data. Once the table shows that a 95% coverage target loses money compared with 78%, the discussion shifts from raising the coverage number to raising savings.
How should you layer and ladder commitments over time?
Buying the whole commitment in one purchase locks in today's baseline and gives you one renewal date that will probably fall at a bad time. Split it into tranches instead, for example one purchase per quarter, each sized to the floor you have measured since the last one. Each tranche then reflects current usage, and the expirations spread across the calendar. When a tranche expires, you decide whether to renew it based on the fleet you are running at that point, not the one you had at the original purchase.
Stagger terms around planned architecture changes. If a migration to a different instance family or to containers is expected in about a year, keep the family-specific commitments short enough to expire before it. Put the longer-lived commitments into Compute Savings Plans, which carry over to the new family.
The layers stack in the same order AWS applies discounts each hour. Reserved Instances and EC2 Instance Savings Plans are applied first. Compute Savings Plans cover the eligible usage that remains. On-demand and Spot absorb the peaks.
$/hr
| /\ /\ <- On-demand / Spot (peaks)
| /\ / \ /\ / \
|-----/--\---/----\-/--\--/----\---- <- Compute SP (flexible middle)
| / \_/ V \/ \
|==================================== <- RIs / EC2 Instance SP (steady floor)
|####################################
+------------------------------------> hour of day
Keep the bottom layer below the lowest point of the usage curve, so the family-specific commitment is fully used every hour. The Compute Savings Plan layer can sit in the range where usage moves day to day, because it still applies if workloads change instance family or move to Fargate or Lambda.
+--------------------------------------+
| Hourly usage: EC2, Fargate, Lambda |
+--------------------------------------+
|
v
+--------------------------------------+
| 1. RIs + EC2 Instance Savings Plans |
| steady floor, family-specific |
+--------------------------------------+
| remaining usage
v
+--------------------------------------+
| 2. Compute Savings Plans |
| any family, Fargate, Lambda |
+--------------------------------------+
| remaining usage
v
+--------------------------------------+
| 3. On-demand and Spot for peaks |
+--------------------------------------+
Laddered tranches (one purchase per quarter, sized to measured floor)
time ---------------------------------------------------------------->
Q1 [EC2 Instance SP, 1 yr]
Q2 [Compute SP, 3 yr ---------------------------------->]
Q3 [EC2 Instance SP, 1 yr]
Q4 [Compute SP, 3 yr ---------------------------->]
^
planned migration: family-specific tranches end first
Each hour, usage is matched against RIs and EC2 Instance Savings Plans first, then Compute Savings Plans, then billed as on-demand or Spot, while quarterly tranches with staggered terms let family-specific commitments expire before a planned migration.
Should you choose a one-year or three-year term, and how much should you pay upfront?
The term and payment choices are separate decisions, and they should be made for different reasons.
Upfront payment is a cost-of-capital question
All three payment options buy the same commitment. Paying more upfront earns a somewhat larger discount, and that discount works like a return on cash handed to AWS early. Compare the extra discount against what the money would earn or save elsewhere, such as your internal hurdle rate, the interest on debt, or runway at a startup. If the gap is small, no-upfront keeps cash flexible and costs little. All-upfront also moves spend into a single period, which can complicate budgeting and amortization. Check how finance wants it recorded before you choose it.
A three-year term is a bet on architecture
A one-year term only requires you to predict next year's baseline. A three-year term requires you to predict that the same workloads, in roughly the same shape, will still be running at the end. Ask whether that held for your fleet over the past three years.
| Option | Discount depth | What you're betting on |
|---|---|---|
| 1-year, no upfront | Lowest | Baseline holds for 12 months |
| 3-year Compute SP | Higher | Total compute spend holds |
| 3-year all-upfront EC2 Instance SP / Standard RI | Highest | Family, region and cash tied up for 3 years |
The deepest discounts carry the tightest constraints. They fix the instance family and region for three years, which is the period in which you are most likely to move to a newer generation or to ARM for better price-performance. A migration that saves money can leave the old commitment stranded. Keep three-year family-specific commitments for workloads whose instance choice you are confident will not change.
When should you avoid committing, and how do you operate commitments without wasting engineering time?
Cases where committing is a bad idea
Fleets mid-migration. If a service is changing regions, instance families, or compute platforms within the next few quarters, you cannot size a commitment for a fleet whose end state is unknown. Wait until the new footprint has a stable baseline.
Workloads already on Spot. Savings Plans and Reserved Instances do not discount Spot usage. A commitment sized against total compute that includes Spot capacity will go unused.
Teams with planned efficiency work. A commitment is a fixed hourly spend. Once rightsizing pushes usage below that line, further reductions stop saving money until the term ends.
Illustrative estimate (assumed numbers, not a benchmark): Assume eligible usage of $100/hour (at the discounted rate), a commitment of $90/hour, and rightsizing that cuts usage to $70/hour.
Realized saving = usage_before − max(usage_after, commitment) = 100 − max(70, 90) = $10/hour, not $30/hour.
Operating commitments
- Set alerts on both metrics. Alert when utilization falls below your threshold, which signals waste. Alert when coverage drops, which signals new on-demand spend. Review both monthly.
- Treat purchase recommendations as one input. They are computed from a lookback window. They cannot see a planned migration or decommission.
- Plan for discount sharing. Shared discounts apply to eligible usage across linked accounts. A team's bill can therefore shift because of another team's usage. Before you publish chargeback or showback numbers, agree on one allocation rule, such as amortizing commitment cost by each account's eligible usage.
- Use one repeatable process. Use the same data, the same sizing rule, and the same purchase tranche each month. Ad hoc purchases force someone to re-run the analysis from scratch each time and make the decisions hard to audit.
How OneEnv can help
Disclosure: OneEnv is the product behind this blog.
OneEnv (oneenv.io) is a workspace-based governance platform for the things services share — environment variables, database structure, API routes and validation rules. A change to a shared value is staged on a branch, reviewed once, and then every affected service explicitly approves or rejects it before it goes live, so you can see who a change touches before it ships instead of finding out in production.
Applied to savings plans vs reserved instances, this is where it helps:
Saves time
- Every service that inherits a shared value is listed in one place, so nobody searches repos and chats to find out who is affected.
- One review per branch replaces coordinating each team separately; each service still keeps its own approve/reject.
- Changing a shared variable is one edit and one review instead of editing every service's
.envby hand.
Saves cost
- Fewer production incidents and rollbacks caused by a shared value, route or column changing under a consumer unannounced.
- Less duplicated configuration to maintain: one shared definition inherited by many services.
- A wrong or stale value is caught at review time by the services it affects, not by a failed deploy.
- OneEnv has a free plan (1 workspace, unlimited services and members, full governance), so trying it costs nothing.
These are qualitative benefits, not measured results — how much you save depends on how many services share the value.
Want to try it? Start at oneenv.io.