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. By the end of this course, that same site is running in your own AWS account behind a private Amazon S3 bucket, delivered globally by Amazon CloudFront over HTTPS, with the certificate managed by AWS Certificate Manager.
None of that infrastructure is created by clicking around forever. It's declared in Terraform, and every deployment after the first one happens automatically through a GitHub Actions pipeline that authenticates to AWS without ever storing a long-lived credential.
That's the destination. This course is the thirteen-module path to get there, and — just as importantly — back down again, since Module 12 tears the whole thing apart and puts it back together to prove it's reproducible.
Why AWS, when free hosting exists?
Let's address this immediately, because it's a fair question. A static site — exactly what 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. This course website — the one you're reading right now — is
itself hosted on GitHub Pages, published straight from this repository's
learning-platform branch. That isn't an oversight; it's the whole point of
this lesson, made concrete instead of hypothetical.
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 private S3 bucket | 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 | Certificate issuance, validation and renewal — and a genuinely common regional gotcha |
| Terraform configuration | Infrastructure as code: state, drift, plan vs. apply, teardown |
| GitHub Actions workflows | CI vs. CD, pipeline design, 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 simply the cheapest, lowest-stakes place to learn them — small enough to hold the whole architecture in your head, and forgiving enough that a mistake costs you cents, not an outage.
Who this course is for
Developers moving toward DevOps, junior DevOps engineers, cloud and platform engineers, and
technical teams learning CI/CD. The assumption is that you can use a terminal — you know
your way around cd, git and running a command — but you don't
necessarily know AWS or Terraform yet. Unfamiliar infrastructure concepts are explained as
they come up, without assuming prior cloud experience and without over-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 tells you its conceptual weight — how many new ideas it introduces — so you can judge 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:
- Modules 1–4 — build the architecture entirely by hand, in the AWS Console, so you understand every piece before automating any of it.
- Modules 5–7 — rebuild it as Terraform, and pick up the engineering-workflow habits that make infrastructure code reviewable.
- Modules 8–10 — automate deployment with GitHub Actions, and study the platform-engineering ideas that separate a working pipeline from an operable one.
- Modules 11–12 — see where the architecture grows next, then tear everything down.
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 comfortable with a terminal who haven't necessarily touched AWS or Terraform. The next lesson tours the finished architecture and explains what each of the three Git branches in this repository is for.