AWS Free Tier: What You Can Build for Practice

The fear that stops people practising on AWS is the story everyone has heard: a student leaves something running and receives a large bill. The fear is reasonable, and the Free Tier now addresses it more directly than it used to. It has also changed shape, so advice written a few years ago, including "everything is free for twelve months", no longer describes it.

This guide is based on AWS's billing documentation at the time of writing. Read the current terms before you sign up; they are short.

How the Free Tier works now

When you create an account you choose a plan (AWS docs: Free Tier):

The Free plan is the safe choice for learning. AWS states that you will not incur charges during it until you upgrade.

What happens at the end matters. A Free plan ends after six months or when credits are fully used, whichever comes first. The account then closes automatically and you lose access to your resources and data. AWS retains the content for 90 days, during which you can upgrade to a Paid plan to keep it (AWS docs: choosing a plan). Anything worth keeping, code, notes, screenshots, belongs in your own repository, not only in the account.

Always-free offers are separate from credits: monthly allowances on over 30 services that do not expire. Examples relevant to data work include one million Lambda requests and 400,000 GB-seconds a month, and the first million objects in the Glue Data Catalog.

What to build with it

The credits go a long way if you choose serverless, pay-per-use services and small data. A data engineering practice path that fits comfortably:

Use small data. A pipeline that is correct on a 50 MB file is the same pipeline on 50 GB; the practice is in the design, and the public datasets used across this site, such as one month of New York taxi trips, are large enough to be realistic and small enough to cost almost nothing to process. AWS data engineering projects suggests what to build, and building a serverless analytics stack shows how the pieces join.

What consumes credits quickly

Credits disappear through resources that bill by the hour whether or not you use them:

• A Glue job left on defaults. A Spark job is allocated 10 DPUs unless you set the worker count. Always set it to the minimum for practice.
• Clusters: EMR, a provisioned Redshift cluster, a provisioned Kafka cluster. Hours of idle time.
• NAT gateways, created by many "VPC with private subnets" templates and billed continuously.
• Large or forgotten EC2 instances, and the EBS volumes and Elastic IP addresses that remain after they stop.
• Development endpoints, notebooks and data preview sessions left open.
• Databases left running between study sessions.

The Free plan protects you from a bill in these cases, but not from wasting the credits, and when they are gone the plan ends. On a Paid plan the same mistakes cost real money.

Guard rails

Start on the Free plan unless you need a service it excludes.

Watch the credit balance. The Billing and Cost Management console shows remaining credits and Free plan status.

Set a budget with alerts. AWS Budgets tracks cost against a target and alerts on actual and forecasted spend. It is the first thing to create in any account, and essential on a Paid plan. The script below defines one with boto3; it runs against moto, a local emulator, so nothing is created in a real account.

import os
import boto3
from moto import mock_aws

os.environ.update(AWS_ACCESS_KEY_ID="testing", AWS_SECRET_ACCESS_KEY="testing",
                  AWS_DEFAULT_REGION="us-east-1")
ACCOUNT, EMAIL = "123456789012", "you@example.com"


@mock_aws
def main():
    budgets = boto3.client("budgets")
    alerts = [("FORECASTED", 100), ("ACTUAL", 50), ("ACTUAL", 80), ("ACTUAL", 100)]
    budgets.create_budget(
        AccountId=ACCOUNT,
        Budget={"BudgetName": "practice-monthly", "BudgetType": "COST", "TimeUnit": "MONTHLY",
                "BudgetLimit": {"Amount": "10", "Unit": "USD"}},
        NotificationsWithSubscribers=[
            {"Notification": {"NotificationType": kind, "ComparisonOperator": "GREATER_THAN",
                              "Threshold": float(percent), "ThresholdType": "PERCENTAGE"},
             "Subscribers": [{"SubscriptionType": "EMAIL", "Address": EMAIL}]}
            for kind, percent in alerts])

    budget = budgets.describe_budgets(AccountId=ACCOUNT)["Budgets"][0]
    print(f"budget {budget['BudgetName']}: {budget['BudgetLimit']['Amount']} {budget['BudgetLimit']['Unit']} per month")
    for n in budgets.describe_notifications_for_budget(AccountId=ACCOUNT, BudgetName="practice-monthly")["Notifications"]:
        print(f"  alert when {n['NotificationType'].lower():10} cost exceeds {n['Threshold']:.0f}% of the budget")


main()

budget practice-monthly: 10 USD per month
  alert when forecasted cost exceeds 100% of the budget
  alert when actual     cost exceeds 50% of the budget
  alert when actual     cost exceeds 80% of the budget
  alert when actual     cost exceeds 100% of the budget

A forecast alert warns you while there is still time to act; the actual-cost alerts at 50, 80 and 100 percent tell you how fast you are moving. Ten dollars is an illustration. Pick an amount that would make you stop and look.

Protect the account. Turn on multi-factor authentication for the root user, create a separate identity for daily work, and never put access keys in code or a public repository. Leaked keys are how accounts end up running someone else's workloads.

Work in one Region, so that everything you create is visible in one place.

Tag what you create with a project name, to find it later.

A cleanup routine

At the end of every session, before closing the browser:

1. Stop or delete clusters, notebooks, endpoints and preview sessions.
2. Terminate EC2 instances; delete unattached volumes and release Elastic IPs.
3. Delete NAT gateways.
4. Check that no Glue job or state machine is still running.
5. Empty test buckets you no longer need.
6. Look at the billing console's cost by service for the day.

Better still, create resources from a template, CloudFormation, the CDK or Terraform, so that one command removes everything. Deleting by hand is where things are forgotten.

Practising without an account

A good deal of AWS-shaped practice needs no account at all. The service APIs can be exercised against local emulators such as moto, which is how the code examples in this site's AWS articles are run and labelled. SQL for Athena can be practised with DuckDB on local Parquet files, and Spark transformations with PySpark on a laptop.

Emulators have limits. They accept requests the real service would reject, they do not reproduce performance or permissions faithfully, and nothing replaces seeing a real job fail for a real reason. Use them to learn the shape of the APIs and to test your own logic cheaply, then confirm on the real service with small data.

Getting the most from six months

• Plan projects before creating the account, so the clock starts when you are ready.
• Do one end-to-end project instead of touching twenty services.
• Keep everything in Git: scripts, templates, notes on what failed.
• Finish before the plan ends, and export anything you need.
• Decide deliberately whether to upgrade. An idle Paid account with good guard rails costs very little, but only if the cleanup was thorough.

For the fundamentals the Cloud Practitioner exam expects, including billing concepts, see the Cloud Practitioner guide; for what drives cost once a project grows, AWS cost optimisation for data workloads.

Projects including an end-to-end ETL pipeline and a cloud data warehouse are part of the Data Engineering course, which covers AWS data services.

Sources

• Explore AWS services with AWS Free Tier (AWS Billing and Cost Management User Guide) — AWS Documentation
• Choosing a plan (AWS Billing and Cost Management User Guide) — AWS Documentation
• AWS Free Tier (Amazon Web Services) — Amazon Web Services
• AWS Lambda pricing (Amazon Web Services) — Amazon Web Services
• AWS Glue pricing (Amazon Web Services) — Amazon Web Services
• Managing your costs with AWS Budgets (AWS Billing and Cost Management User Guide) — AWS Documentation