Module 00 · Lesson 1
Course Overview
What this course builds, who it's for, and why we're using AWS for something that could be hosted for free elsewhere.
- Describe what this course builds and roughly what shape the finished result takes.
- Explain, in your own words, why this course chose AWS over a free static host.
- Know who this course is written for, and what it assumes you already know.
What you're building
You start with a small, polished static website: HTML, CSS and a little vanilla JavaScript. No framework, no build step. You host that same site four times, and each time it gets a little more professional. Each of these is a stage:
- S3. Put the site in a public S3 bucket by hand, and upload it with one command.
- Terraform. Describe that same bucket as code, and create it with
terraform apply. - CloudFront. Make the bucket private and serve the site through CloudFront over HTTPS. Then add your own domain, with a certificate from AWS Certificate Manager and a Route 53 record.
- CI/CD. Let GitHub Actions apply the Terraform and deploy the site on every push, signing in to AWS without ever storing a long-lived credential.
That's the destination. This course is the thirteen-module path to get there, and back down again. The last module tears the whole thing apart and rebuilds it, which is how you prove the setup is reproducible rather than just lucky.
Why AWS, when free hosting exists?
It's a fair question, so here is the answer up front. The static site you'll clone in the next module could be live in about sixty seconds on GitHub Pages, Cloudflare Pages, Netlify or Vercel. All four are free, all four are good, and none of them need a single lesson in this course to use.
Look at the address bar. The course website you're reading right now is itself hosted on Cloudflare Pages, deployed straight from a Git branch with no infrastructure behind it. That isn't an oversight. It's this lesson's argument, made concrete.
So why not host the application the same way? Because then we'd miss the entire reason this course exists. A static site is the excuse; the platform underneath it is the subject. Building it on AWS, deliberately, forces you to work with the pieces that show up in almost every real infrastructure job:
| You'll build | Because in real work you need |
|---|---|
| A public S3 bucket, then a private one | Object storage, bucket policies, and why "public bucket" is a headline waiting to happen |
| A CloudFront distribution | CDNs, edge caching, cache invalidation, TLS termination |
| An ACM certificate and a Route 53 record | Certificate issuance, DNS validation and renewal, plus a regional gotcha that catches almost everyone once |
| Terraform configuration | Infrastructure as code: state, drift, plan vs. apply, teardown |
| A GitHub Actions workflow | CI vs. CD, pipeline design, manual runs, deployment gates |
| An IAM role with OIDC trust | Short-lived credentials instead of long-lived access keys |
Every one of those transfers directly to running containers, APIs and data pipelines later. A static site is just the cheapest, lowest-stakes place to learn them. It's small enough to hold in your head all at once, and forgiving enough that a mistake costs you cents rather than an outage.
Who this course is for
Developers moving toward DevOps, junior DevOps engineers, cloud and platform engineers, and
technical teams learning CI/CD. You need to be comfortable in a terminal: cd,
git, running a command. You do not need to know AWS or Terraform. Infrastructure
concepts are explained as they come up, without assuming prior cloud experience and without
re-explaining things a working developer already knows.
This course doesn't give fake time estimates ("2 hours", "45 minutes"). Everyone reads, types and debugs at a different pace, and a fabricated number is either wrong or demoralising. Instead, each module states its conceptual weight, meaning how many new ideas it introduces, so you can set your own pace.
How the course is structured
Thirteen modules, each leaving the project in a working state before handing you something concrete for the next one. Roughly:
- Getting ready: meet the site and learn the AWS basics you need, then Stage 1, where you put the site in S3 by hand so you understand every piece before automating any of it.
- Stages 2 and 3: rebuild it as Terraform, then put CloudFront in front, with your own domain and certificate, and pick up the workflow habits that make infrastructure code reviewable.
- Stage 4: automate deployment with GitHub Actions, and study the ideas that separate a working pipeline from an operable one.
- Finally: see where the architecture grows next, then tear it all down.
A free host can serve this site in sixty seconds. So what is the AWS build actually buying you?
A managed host is faster to reach and cheaper at this scale. What it doesn't give you is contact with the layers underneath, and those layers are the transferable part.
Module 12 destroys the infrastructure you spent the whole course building. What is that meant to prove?
Stopping the bill is a nice side effect. The real test is whether apply rebuilds what destroy removed. Infrastructure you can't recreate is a liability, however well it currently runs.
This course builds a real AWS platform underneath a static site, on purpose, to teach infrastructure skills a free host would never require. It's written for people who are comfortable in a terminal but new to AWS and Terraform. Next you'll tour the architecture of each stage and see what the start and end branches are for.