After the Free Tier Ends: Mapping the Month-by-Month Cost Curve of AWS, GCP, Oracle

Every cloud provider advertises a free tier. Almost none of them advertise what happens on day 366. The arithmetic is simple to do once you know which meters start running, but the meters differ in ways that make a naive price comparison wrong by a factor of two or more. This article walks through the actual billing units of AWS, Google Cloud, Oracle Cloud and Azure free offerings, then shows how to build a month-by-month cost curve on your own VPS so you can see the crossover point instead of guessing.

Treat this as a measurement exercise. You will collect billing exports, normalise them to the same units, and plot cumulative spend. If you would rather own the hardware outright and skip the curve entirely, compare VPS plans first, then use the method below to sanity-check your assumptions.

What the four free tiers actually give you

AWS Free Tier is time-boxed: 750 hours per month of a t2.micro or t3.micro for the first 12 months, plus 30 GB of EBS and 100 GB of monthly egress. After month 12 the same instance in us-east-1 bills at roughly USD 0.0116/hour on-demand, about USD 8.47/month, and 100 GB egress is about USD 9.00. That is a jump from near-zero to roughly USD 18/month with no change to your workload.

Google Cloud’s always-free e2-micro (1 vCPU, 1 GB) runs in us-central1, us-west1 and us-east1 only, with 30 GB standard disk and 1 GB egress to most destinations. The trap is egress: GCP charges around USD 0.12/GB for internet egress from North America beyond the free allowance, so a 200 GB/month workload costs about USD 23.90 before any compute.

Oracle Cloud’s Always Free tier is genuinely permanent: two AMD VM.Standard.E2.1.Micro instances plus up to 4 OCPU / 24 GB of Ampere A1 capacity. The costs appear later as idle-reclamation, capacity unavailability in popular regions, and the upgrade path when you need a shape that is not in the free catalogue. Azure’s 12-month free tier mirrors AWS closely: B1s for 750 hours, 64 GB of managed disk, 100 GB egress, then pay-as-you-go.

Normalise everything to a monthly unit price

Before you can compare, convert every meter into USD/month at a fixed reference load: 1 vCPU, 2 GB RAM, 50 GB SSD, 1 TB egress. Write it into a small CSV and keep it in version control. Here is a shell snippet that pulls a GCP billing export and pivots it with awk, which is enough for a few thousand rows:

gcloud billing accounts list --format='value(name)'
bq query --use_legacy_sql=false --format=csv \
 'SELECT service.description AS svc, sku.description AS sku,
         SUM(cost) AS cost, SUM(usage.amount) AS qty
  FROM `proj.billing.gcp_billing_export_v1_XXXX`
  WHERE invoice.month = "202611"
  GROUP BY svc, sku ORDER BY cost DESC' > gcp_nov.csv
awk -F, 'NR>1{split($1,a,"/"); k=a[1]; s[k]+=$3} END{for(i in s) printf "%-40s %8.2f\n", i, s[i]}' gcp_nov.csv

For AWS, the Cost Explorer CLI gives the same shape with one call per service. Pull it on the first of each month and append a row to a history file — retroactive analysis is much harder than forward collection.

aws ce get-cost-and-usage \
  --time-period Start=2026-11-01,End=2026-12-01 \
  --granularity MONTHLY --metrics UnblendedCost \
  --group-by Type=DIMENSION,Key=SERVICE \
  --output json | jq -r '.ResultsByTime[0].Groups[]
  | [.Keys[0], .Metrics.UnblendedCost.Amount] | @tsv'

Build the month-by-month curve from real counters

The curve has three components: fixed compute, storage growth, and egress. Fixed compute is flat and predictable. Storage grows roughly linearly with logs, snapshots and container images. Egress is the wildcard, and on a VPS you can measure it precisely from /proc/net/dev rather than trusting the provider console.

# Sample per-interface byte counters every 5 minutes
while true; do
  awk '/eth0:/ {printf "%s %s\n", strftime("%F %T"), $10}' /proc/net/dev \
    >> /var/log/egress.log
  sleep 300
done
# Monthly total, converting the counter wrap-safe delta to GB
awk 'NR==1{p=$2; next}{d=$2-p; if(d<0)d=0; t+=d; p=$2}
     END{printf "egress %.2f GB\n", t/1073741824}' /var/log/egress.log

Compare that figure to the billed bytes. A 3–5% gap is normal (retransmits, protocol overhead). A 40% gap means you are being billed for something you are not generating, such as NAT gateway processing or inter-AZ traffic, and that changes your curve more than any instance-size decision.

Where the crossover actually lands

Run the numbers for a typical small web workload — 2 vCPU, 4 GB, 80 GB SSD, 1.5 TB egress per month. On AWS after the free year, that lands around USD 45–60 depending on region and whether you use savings plans. On GCP, roughly USD 40–55 plus egress. On Azure, similar. A fixed-price VPS at the same specification from a provider that includes generous transfer typically sits at USD 15–30 flat with no month-13 surprise.

So the crossover is not at month 13 for everyone. It depends on your egress profile. A build server that pushes container images to a registry will blow through free egress in week two of every month. A private dashboard behind a VPN will never pay egress at all. The same provider can be the cheapest and the most expensive choice depending on which of these two shapes your workload has.

Add liquidity and exit costs to the model

Price per month is only part of the curve. Add a column for exit cost: snapshot export fees, DNS migration effort, data transfer out of the region when you leave. On hyperscalers, pulling a 500 GB disk image out via the internet costs real money (around USD 0.09/GB on AWS) and can turn a “free” migration into a USD 45 charge. On a VPS where you control the disk, dd or rsync over the network is billed as normal egress and you were paying it anyway.

Model this explicitly: add a 10% probability of exit in any given month and multiply exit cost by that factor. It is a crude adjustment, but it correctly penalises platforms that are cheap to enter and expensive to leave. For more on how to interpret where those hours go, our VPS performance guides cover benchmarking and monitoring in detail.

A repeatable script for your own curve

Store three files: meters.csv (month, provider, compute, storage, egress), prices.csv (sku, unit, usd, region) and curve.py (join, project, plot). Recompute on the first of each month with fresh billing exports and overwrite the projection for months 13–24. A 30-line pandas script is enough; the value is in the discipline of updating it, not the sophistication of the model.

The practical outcome: decide at month 8, not month 13. If the projected month-13 cost exceeds your fixed-price alternative by more than 30%, migrate early while you still have budget and momentum. If it does not, stay — but record the decision and the assumptions so you can revisit it in six months when your traffic profile changes.

Finally, re-run the model whenever a provider changes its free tier terms. All four have adjusted allowances at least once in the last three years, usually with about 30 days’ notice, and each time the curve shifts. A spreadsheet you update quarterly is worth more than a blog post you read once.

Leave a Reply