www.awsgood.com
AWS bills EC2 per second with a 60-second minimum, but the “per month” number you see in your invoice is the sum of several independent meters:
| Meter | How it’s charged | Stops when you stop the instance? |
|---|---|---|
| Instance hours | Per second, 60s minimum | Yes (unless it’s a Savings Plan commitment) |
| EBS root + data volumes | Per GB-month, provisioned size | No — still billed |
| EBS snapshots | Per GB-month of stored data | No |
| Elastic IP (public IPv4) | Per hour, attached or not | No |
| Data transfer out | Per GB past the free tier | No |
| NAT Gateway | Per hour + per GB processed | No |
| Detailed monitoring / EBS-optimized extras | Per metric or per hour | No |
The mental model: compute is the only thing that switches off. Everything bolted to the instance keeps billing at 3am on a Sunday.
Run this to see where the money actually goes, grouped by the raw usage type AWS reports:
aws ce get-cost-and-usage
--time-period Start=2025-05-01,End=2025-06-01
--granularity MONTHLY
--metrics UnblendedCost
--group-by Type=DIMENSION,Key=USAGE_TYPE
--query 'ResultsByTime[0].Groups[].[Keys[0],Metrics.UnblendedCost.Amount]'
--output table | sort -k2 -r | head -20
If `EBS:VolumeUsage.gp2`, `EBS:SnapshotUsage` or `DataTransfer-Regional-Bytes` sit near the top, you have a storage or topology problem, not a compute pricing problem.
## The four drivers that actually move the bill
1. **Instance family and size.** Graviton (`t4g`, `m7g`, `c7g`) is consistently cheaper than comparable x86 for the same workload — often 15–20% lower list price, plus better price/performance. If your stack is Docker/Node/Python/Postgres, it almost certainly runs on arm64.
2. **Purchase model.** On-Demand → Savings Plan (1 or 3 year) → Reserved Instance → Spot. Each step down adds commitment or interruption risk.
3. **Storage class and size.** `gp2` is legacy; `gp3` is cheaper per GB and gives you 3,000 IOPS / 125 MB/s baseline regardless of volume size, so you stop over-provisioning capacity just to get IOPS.
4. **Network topology.** Traffic between Availability Zones is billed (~$0.01/GB each direction in most regions). A chatty app tier spread across three AZs can quietly cost more than the instances themselves.
## What a typical SMB setup costs per month
Indicative on-demand figures for a common US-region Linux setup — treat these as ballpark shapes, not quotes, and confirm in the AWS Pricing Calculator for your region:
| Scenario | Components | Rough monthly cost |
|---|---|---|
| Hobby box | 1× t3.micro, 8 GB gp3, no snapshots | ~$8–12 |
| Small business site | 1× t4g.small, 20 GB gp3, 1 Elastic IP, 50 GB egress | ~$20–30 |
| Small business site + backup | Above + nightly snapshots (60 GB stored) | ~$25–40 |
| Two-tier app (HA) | 2× m7g.large, ALB, NAT Gateway, 200 GB EBS, 100 GB egress | ~$140–220 |
| Same app + 1-yr Compute Savings Plan (no upfront) | Above, compute covered | ~$110–180 |
The jump from one instance to two isn't 2×. The ALB (~$16–25/mo base) and NAT Gateway (~$32/mo + per-GB processing) become fixed costs that dwarf the second instance. For an SMB site that doesn't need private-subnet egress, skipping the NAT Gateway and using public subnets with tight security groups is a legitimate, frequently overlooked saving.
## Cutting the monthly bill: the moves that actually work
**Right-size with data, not vibes.** Compute Optimizer reads CloudWatch history and tells you what's genuinely oversized:
```bash
aws compute-optimizer get-ec2-instance-recommendations
--region us-east-1
--query 'instanceRecommendations[].[instanceArn,currentInstanceType,recommendationOptions[0].instanceType,recommendationOptions[0].projectedUtilizationMetrics[0].value]'
--output table
Look for instances averaging under 10% CPU for 14 days. A t3.large idling at 3% is a t3.small waiting to happen.
**Convert gp2 to gp3 in place.** No downtime, no snapshot restore:
```bash
aws ec2 modify-volume
--volume-id vol-0abc123def456
--volume-type gp3 --iops 3000 --throughput 125
**Schedule non-prod to stop.** Staging and dev boxes running 24/7 for a 40-hour week is 76% waste. A simple EventBridge cron calling `stop-instances`/`start-instances` handles most cases; use AWS Instance Scheduler if you need per-tag rules.
**Commit only what's stable.** Before buying a Savings Plan, pull a recommendation and compare it against your actual baseline:
```bash
aws ce get-savings-plans-purchase-recommendation
--savings-plans-type COMPUTE_SP
--term-in-years ONE_YEAR
--payment-option NO_UPFRONT
--lookback-period-in-days SIXTY_DAYS
Cover your 24/7 baseline, leave spiky/bursty workloads on-demand, and put fault-tolerant batch jobs on Spot at up to ~70–90% off.
**Prune snapshots.** Snapshots are incremental but they never expire on their own. A Data Lifecycle Manager policy (`create-snapshot` + `retain 7 days`) costs nothing and typically trims 30–50% of snapshot spend on accounts that have never set one.
## Billing traps that show up a month later
**The hard-won lesson: T3/T2 Unlimited CPU credits.** I had a small batch-processing instance on `t3.small` that was fine for weeks, then the monthly bill jumped by a few tens of dollars with no new resources in the account. The instance looked idle in CloudWatch. The cause was burst behaviour: the workload occasionally pinned both vCPUs for 20–30 minutes, drained the CPU credit balance, and — because the instance was in **Unlimited** mode — kept bursting on surplus credits billed at a per-vCPU-hour rate.
How I verified it, rather than guessing:
1. Cost Explorer showed a distinct usage type containing `CPUCredits` for that account — a line item that doesn't exist if credits are never exceeded.
2. The `CPUCreditBalance` CloudWatch metric for the instance dropped to `0` and stayed there for hours during the batch window.
3. `aws ec2 describe-instance-credit-specifications --instance-ids i-0abc...` confirmed `CpuCredits: unlimited`.
The fix was two-part: pin the batch job to a smaller concurrency (so it stays inside credits), and where burst was genuinely needed, move that workload to a fixed-performance family like `m7g` where the price is predictable rather than metered. The takeaway: on T-family instances, "cheap" is conditional on your workload being genuinely bursty-and-idle. Sustained CPU on a T instance is the most expensive way to buy compute.
**Other traps worth pre-empting:**
- **Stopped ≠ free.** Stopping an instance keeps the EBS volumes and any Elastic IP attached and billed. Terminate instead of stop if you're done.
- **Detached volumes.** `aws ec2 describe-volumes --filters Name=status,Values=available` finds orphaned EBS you're paying for monthly.
- **Public IPv4 charges.** Every public IPv4 address now carries an hourly charge, including ones on load balancers and NAT Gateways. Consolidate where you can.
- **Cross-AZ chatter.** Keep the app tier and database in the same AZ when you can tolerate it; use read replicas or retries rather than chatty cross-AZ calls.
If you'd rather not babysit this monthly, this is exactly the kind of ongoing cost and rightsizing review we run for clients at awsgood.com — the goal is a predictable bill, not a smaller one for its own sake.