AWS Free Tier: How to Use It for 12+ Months

AWS Free Tier Is More Generous Than You Think

Most developers sign up for AWS, spin up an EC2 instance, forget about it, and get a $50 bill the next month. That's not an AWS problem -- it's a strategy problem. I've been running production workloads on AWS since 2014, and I've helped dozens of startups stretch the free tier well beyond the initial 12 months. The trick isn't gaming the system. It's understanding which services are free forever, which are free for 12 months, and which have usage-based free allocations that reset monthly.

AWS's free tier actually consists of three distinct categories, and conflating them is where most people go wrong. This guide breaks down exactly what you get, how to avoid surprise charges, and how to architect applications that stay within free limits for as long as possible.

What Is the AWS Free Tier?

Definition: The AWS Free Tier is a collection of free usage allowances across 100+ AWS services. It includes three categories: (1) Always Free services with permanent monthly quotas, (2) 12-Month Free services available for the first year after account creation, and (3) Short-Term Trial services with one-time allowances that expire after a set period regardless of usage.

The distinction matters because Always Free services like Lambda (1 million requests/month) and DynamoDB (25 GB storage) never expire. You can use them in year five the same way you use them in month one. The 12-month services -- EC2, RDS, S3, CloudFront -- are the ones that catch people off guard when they start incurring charges on month 13.

Complete Free Tier Breakdown (2026)

This table covers the services that matter most for running real applications. I've excluded niche services with trivial free allocations.

Service	Free Tier Type	Monthly Allowance	Expiration
EC2 (t2.micro / t3.micro)	12-Month	750 hours (1 instance 24/7)	12 months
RDS (db.t2.micro / db.t3.micro)	12-Month	750 hours + 20 GB storage	12 months
S3	12-Month	5 GB storage, 20K GET, 2K PUT	12 months
CloudFront	Always Free	1 TB data transfer, 10M requests	Never
Lambda	Always Free	1M requests, 400K GB-seconds	Never
DynamoDB	Always Free	25 GB storage, 25 RCU/WCU	Never
API Gateway	12-Month	1M REST API calls	12 months
SNS	Always Free	1M publishes, 100K HTTP deliveries	Never
SQS	Always Free	1M requests	Never
CloudWatch	Always Free	10 custom metrics, 10 alarms, 5 GB logs	Never
Secrets Manager	30-Day Trial	30 days free	30 days
CodeBuild	Always Free	100 build minutes (general1.small)	Never

Warning: The 750-hour EC2 free tier applies per account, not per instance. Running two t2.micro instances simultaneously burns 1,500 hours/month -- 750 hours over the free limit. That overage costs roughly $4.20 at the us-east-1 on-demand rate of $0.0116/hour. It's a small amount, but it surprises people who thought "micro instances are free."

Strategy 1: Architect Around Always Free Services

The smartest approach is building on services that never expire. Here's a serverless stack that stays free indefinitely for low-to-moderate traffic:

1. Frontend: Host static assets on S3 (after the 12-month period, use CloudFront's Always Free 1 TB transfer instead -- or better, use Amplify Hosting's free tier or serve from a Lambda@Edge function).
2. API: Lambda functions behind API Gateway (or Function URLs, which are free). 1 million Lambda invocations/month handles roughly 33,000 requests/day.
3. Database: DynamoDB with 25 GB and 25 read/write capacity units. That's enough for a blog, small SaaS, or side project with a few hundred daily users.
4. Queuing: SQS for async processing -- 1 million free requests/month.
5. Monitoring: CloudWatch with 10 alarms and 5 GB log ingestion.

This stack costs exactly $0/month in year one, year two, and year five. The catch is DynamoDB's provisioned throughput -- 25 RCU/WCU handles about 25 reads and 25 writes per second. For bursty traffic, switch to on-demand mode, but be aware that on-demand pricing isn't covered by the free tier.

Strategy 2: Maximize the 12-Month Window

If you need EC2 or RDS, plan your usage around the 12-month clock. Here's how to extract maximum value:

Step 1: Create a Fresh AWS Account

The 12-month free tier starts when you create the account, not when you first use a service. Don't create an account "just to explore" -- create it when you're ready to build. Every idle month is wasted free tier.

Step 2: Use the Right Instance Types

Only t2.micro or t3.micro (depending on region) qualify. In most regions as of 2026, t3.micro is the free-tier eligible type. Don't accidentally launch a t3.small -- it's not covered and costs $0.0208/hour ($15/month).

Step 3: Run One Instance at a Time

750 hours covers exactly one instance running 24/7 for a 31-day month. If you need to test something on a second instance, stop the first one. Use AWS Systems Manager Session Manager instead of SSH to avoid paying for an Elastic IP or NAT gateway.

Step 4: Set Up Billing Alerts Immediately

# Create a billing alarm using AWS CLI
aws cloudwatch put-metric-alarm \
  --alarm-name "FreeTierBillingAlarm" \
  --alarm-description "Alert when charges exceed $1" \
  --metric-name EstimatedCharges \
  --namespace AWS/Billing \
  --statistic Maximum \
  --period 21600 \
  --threshold 1.00 \
  --comparison-operator GreaterThanThreshold \
  --evaluation-periods 1 \
  --alarm-actions arn:aws:sns:us-east-1:ACCOUNT_ID:BillingAlerts \
  --dimensions Name=Currency,Value=USD

Pro tip: Enable AWS Budgets (free for the first two budgets) and set a $0.01 budget with email alerts. You'll get notified the moment anything costs money. This is the single most effective way to avoid surprise bills.

Step 5: Migrate to Always Free Before Month 12

Around month 10, start migrating workloads off EC2 and RDS. Move your API to Lambda. Replace RDS PostgreSQL with DynamoDB if your data model allows it. Move static assets to CloudFront. The goal is to have zero dependency on 12-month services before they expire.

Hosting a Next.js App on AWS Free Tier

Let me walk through a real example. Here's how I'd deploy a Next.js 15 application on AWS without spending a dime:

// serverless-nextjs architecture
// Lambda@Edge for SSR, S3 for static assets, CloudFront for CDN

// lambda-handler.ts
import { APIGatewayProxyHandler } from 'aws-lambda';

export const handler: APIGatewayProxyHandler = async (event) => {
  // Lambda Function URL -- no API Gateway needed (free)
  const { default: app } = await import('./server');
  const response = await app(event);
  return {
    statusCode: 200,
    headers: { 'Content-Type': 'text/html' },
    body: response,
  };
};

The architecture breakdown:

• SSR pages: Lambda with Function URLs (free, no API Gateway cost). 1M requests/month free.
• Static assets: S3 bucket with CloudFront distribution. CloudFront's 1 TB/month free transfer handles significant traffic.
• API routes: Separate Lambda functions, also behind Function URLs.
• Database: DynamoDB for session data and dynamic content. 25 GB free.

Total monthly cost: $0. This architecture handles roughly 30,000 daily page views within free tier limits. For comparison, a t3.micro EC2 instance running the same Next.js app handles about 5,000 daily page views before CPU throttling kicks in -- and that free tier expires after 12 months.

Cost Breakdown: What Happens After 12 Months

Here's the real cost comparison between staying on EC2/RDS vs. migrating to serverless before month 13:

Component	EC2/RDS (Post-Free-Tier)	Serverless (Always Free)
Compute	$8.47/mo (t3.micro on-demand)	$0 (Lambda free tier)
Database	$12.41/mo (db.t3.micro RDS)	$0 (DynamoDB free tier)
Storage	$2.30/mo (20 GB EBS)	$0 (S3 via CloudFront)
Data Transfer	~$5/mo (50 GB egress)	$0 (CloudFront free tier)
Total	$28.18/mo ($338/yr)	$0/mo ($0/yr)

That's $338/year in savings for a small application. For a startup running three environments (dev, staging, prod), multiply that by three: over $1,000/year. The serverless migration takes a weekend of work. It's the highest-ROI infrastructure change you can make.

Common Pitfalls That Trigger Surprise Bills

I've audited dozens of AWS accounts with unexpected charges. These are the top offenders:

1. Elastic IPs not attached to running instances -- AWS charges $0.005/hour ($3.60/month) for unattached Elastic IPs. Stop an instance but forget to release the EIP, and you'll get billed.
2. EBS volumes from terminated instances -- Terminating an EC2 instance doesn't automatically delete its EBS volume unless you checked "Delete on Termination." Orphaned volumes cost $0.10/GB/month.
3. NAT Gateway left running -- NAT Gateways cost $0.045/hour ($32/month) plus $0.045/GB data processed. This is the single biggest surprise bill I see. Never create a NAT Gateway on a free tier account unless you absolutely need it.
4. RDS Multi-AZ enabled -- Multi-AZ doubles your RDS cost and isn't covered by the free tier. The RDS creation wizard sometimes defaults to Multi-AZ.
5. CloudWatch Logs retention -- Logs are stored forever by default. Set retention to 7 or 30 days. At $0.50/GB/month for storage, verbose Lambda logging adds up fast.
6. Data transfer between regions -- Moving data between AWS regions costs $0.02/GB. If your Lambda is in us-east-1 and your DynamoDB is in us-west-2, every request incurs transfer fees.

Warning: The AWS free tier usage tracker in the Billing Console has a 24-48 hour delay. Don't rely on it to catch overages in real time. Use CloudWatch billing alarms and AWS Budgets instead -- they alert within 6 hours.

Extending Free Usage Beyond 12 Months

There are legitimate ways to extend your effective free tier beyond the initial year:

• AWS Activate for startups -- If you have a startup, apply for AWS Activate. The Founders tier gives $1,000 in credits valid for 2 years. The Portfolio tier (through an accelerator or VC) gives up to $100,000 in credits valid for 2 years.
• AWS Educate -- Students and educators get additional credits and extended free tier access on select services.
• New account for new projects -- AWS allows multiple accounts under an Organization. Each account gets its own 12-month free tier. Use this legitimately for separate projects or environments, not to game the system for the same workload.
• Reserved Instance savings -- After the free tier ends, a 1-year Reserved Instance for t3.micro costs about $4.25/month -- a 50% discount over on-demand. If you must stay on EC2, commit for the year.

# Check your free tier usage from the CLI
aws ce get-cost-and-usage \
  --time-period Start=2026-04-01,End=2026-04-12 \
  --granularity DAILY \
  --metrics "UnblendedCost" \
  --filter '{"Dimensions": {"Key": "SERVICE", "Values": ["Amazon Elastic Compute Cloud - Compute"]}}'

Frequently Asked Questions

Does the AWS free tier apply to all regions?

Yes, the free tier applies globally across all AWS regions. However, the 750 hours are shared across all regions. Running a t3.micro in us-east-1 and another in eu-west-1 simultaneously uses 1,500 hours/month. Also, the eligible instance type varies by region -- some older regions still use t2.micro while most now offer t3.micro. Check the AWS Free Tier page for your specific region.

Can I run a production application on the free tier?

For low-traffic applications, absolutely. A serverless stack (Lambda + DynamoDB + CloudFront) comfortably handles 30,000+ daily requests within Always Free limits. For higher traffic, you'll exceed free tier quickly. The cutoff is roughly 1 million API calls/month on Lambda and 25 read/write capacity units on DynamoDB. Beyond that, costs scale linearly but are still cheap -- Lambda costs $0.20 per million requests after the free allocation.

What happens if I accidentally exceed the free tier?

AWS charges your credit card at on-demand rates for any usage above free tier limits. There's no automatic shutoff. A single NAT Gateway left running for a month costs $32 even if you're on the free tier. This is why billing alarms are critical. AWS Support will sometimes issue a one-time courtesy credit for accidental overages if you ask nicely -- but don't count on it. Prevention is better than asking for forgiveness.

Is the free tier available on AWS GovCloud or China regions?

No. The AWS Free Tier is only available on standard commercial AWS accounts. GovCloud and the China regions (operated by Sinnet and NWCD) have separate pricing structures and do not include free tier eligibility. If you're working with government workloads, factor in the full on-demand cost from day one.

How does the free tier work with AWS Organizations?

When you create an AWS Organization, the free tier applies to the management (payer) account only. Member accounts created within the Organization do NOT get their own separate free tier -- they share the management account's free tier. However, if an existing account with its own free tier joins an Organization, it keeps its remaining free tier eligibility until the original 12 months expire.

Can I use the free tier for machine learning workloads?

AWS offers limited free ML services. SageMaker Studio Lab is free with no AWS account required. SageMaker proper includes 250 hours/month of ml.t3.medium notebooks for the first 2 months. Amazon Comprehend offers 50K units of text analysis free for 12 months. For serious ML work, the free tier is insufficient -- you'll need at least a g4dn.xlarge ($0.526/hour) for GPU workloads. Consider Google Colab or Kaggle notebooks for free GPU access instead.

What's the difference between AWS Free Tier and AWS credits?

Free tier is a permanent usage allowance that resets monthly -- you don't "spend" it. Credits are a dollar amount applied to your bill that depletes as you use services. Credits from programs like AWS Activate ($1,000-$100,000) expire after 1-2 years and cover any AWS service, not just free-tier-eligible ones. Credits are applied after free tier deductions, so you get both benefits simultaneously. Always use free tier services first to preserve your credits for services that aren't free-tier eligible.

Build Smart, Pay Nothing

The AWS free tier isn't a gimmick or a limited demo -- it's a genuine platform for running small applications indefinitely. The key is architecture. If you build on EC2 and RDS, you're on a 12-month clock. If you build on Lambda, DynamoDB, CloudFront, SQS, and SNS, you're on no clock at all. I've personally run three side projects on a single AWS account for over four years without paying a cent. The serverless stack handles everything I need: server-rendered pages, REST APIs, scheduled jobs, and background processing. Set up billing alarms on day one, architect around Always Free services, and you'll never open an AWS bill with dread again.