What AWS actually is
AWS is a global utility-computing platform — on-demand compute, storage, networking, and managed services billed per use. This lesson maps the service categories and core vocabulary the rest of the track assumes.
A two-person startup gets a feature on the front page of a news aggregator. Traffic goes from 40 requests a minute to 8,000 in under a minute. They never bought a server. There is no rack, no colocation contract, no “let’s order more capacity, it’ll arrive in three weeks.” A line in an autoscaling config noticed the CPU climb and started more instances; a managed load balancer spread the flood across them; a managed database absorbed the read spike from a replica it had been quietly keeping warm. The bill at the end of the month is a few hundred dollars more than usual. That elasticity — capacity that appears in seconds and is billed by the second — is what AWS sells. It is also what makes the bill, and the architecture, easy to get wrong.
By the end of this lesson you’ll know the six service categories, how to read the managed-vs-self-managed tradeoff, and why that same elasticity that saved the startup can silently run up a five-figure bill if you’re not paying attention.
AWS is a utility, not a product
The clearest way to understand AWS is by analogy to the electrical grid. You do not run a generator in your basement; you draw power from a shared utility, pay for what you consume, and the utility handles generation, distribution, and reliability. AWS — Amazon Web Services, launched in 2006 — is that utility for computing. Instead of buying servers, racking them in a data center, wiring networking, and replacing failed disks at 3 a.m., you rent those capabilities over an API and pay only for what you use.
That phrase “over an API” is the whole shift. Every resource in AWS — a virtual server, a terabyte of storage, a database, a DNS record, a firewall rule — is created, changed, and destroyed by a programmatic call. The web console you click through is just a front end over the same API the SDKs and Terraform use. This is why infrastructure becomes code, why a script can stand up an entire environment in minutes, and why the same elasticity that saved the startup in the hook can, run carelessly, spin up a thousand instances and a five-figure bill just as fast.
AWS today is not one service but over 200 of them, available on-demand with pay-as-you-go pricing, running in 190+ countries. Nobody learns all 200. The skill is not memorizing services — it is knowing the categories, so that when you have a problem you know which shelf to look on.
The mental model: service categories
Treat AWS as a hardware store organized by aisle. You do not need to know every product; you need to know what each aisle is for. Six categories cover the vast majority of what a working application uses:
| Category | What it gives you | Flagship services (a map, not a syllabus) |
|---|---|---|
| Compute | Somewhere to run code | EC2 (virtual machines), Lambda (functions, no server to manage), ECS/EKS (containers) |
| Storage | Somewhere to put bytes | S3 (object storage for files/backups/static sites), EBS (disks for EC2) |
| Database | Somewhere to put structured data | RDS (managed Postgres/MySQL), DynamoDB (managed NoSQL) |
| Networking | How traffic reaches and moves between things | VPC (private network), ELB (load balancing), Route 53 (DNS), CloudFront (CDN) |
| Security & identity | Who can do what | IAM (permissions), KMS (encryption keys), Secrets Manager |
| Observability | What is happening, and what happened | CloudWatch (metrics/logs/alarms), CloudTrail (audit log of every API call) |
A typical web app touches one service from most of these aisles: code on EC2 or Lambda, files in S3, data in RDS, traffic via a VPC behind an ELB with Route 53 out front, access governed by IAM, and the whole thing watched by CloudWatch. Learn the aisles first; the specific product names attach themselves naturally once you know what problem they solve.
Managed vs self-managed: the axis that defines AWS
The single most important distinction in the whole platform is how much of the operational work AWS does for you. The same capability — say, a Postgres database — is available at several points along a spectrum, and the choice is a real tradeoff, not a default.
At the self-managed end, you run EC2 (a raw virtual machine), install Postgres yourself, and own everything above the hypervisor: OS patches, Postgres upgrades, backups, replication, failover, monitoring. You get total control and the lowest per-hour price, and you inherit all the 3 a.m. pages. At the managed end, you use RDS: AWS runs the database engine, applies patches, takes automated backups, and can fail over to a standby in another Availability Zone automatically. You pay more per hour and give up some knobs, but you stop owning the operational toil. Further still are serverless services like Lambda and DynamoDB, where there is no instance to size at all — you are billed per request and per millisecond, and capacity is the provider’s problem entirely.
This managed-vs-self-managed axis is the lens for almost every AWS decision. “Should we use RDS or run Postgres on EC2?” is really “is the operational work worth the premium for this workload?” For most teams, most of the time, the answer is to buy the managed version and spend the saved hours on the product — but it is a decision, and senior engineers make it deliberately.
▸Why this works
“Managed” does not mean “no responsibility.” AWS operates under a shared responsibility model: AWS secures the cloud infrastructure — physical data centers, hypervisor, the managed service’s internals — while you remain responsible for security in the cloud — your IAM policies, your data, your network rules, your application code. A managed database is patched for you, but an S3 bucket left public, or an IAM role with * permissions, is entirely your failure, not Amazon’s. Most real-world AWS breaches are misconfigurations on the customer’s side of that line.
A team needs a Postgres database and wants to minimize the operational work of patching, backups, and failover. Which AWS choice fits, and why?
Global infrastructure, in one paragraph
AWS runs in physical locations called Regions (39+ of them worldwide, e.g. us-east-1, eu-west-1), each an independent geographic area. Inside every Region are multiple Availability Zones (AZs) — 120+ in total — which are physically separated groups of data centers with independent power and cooling but joined by low-latency links, so spreading your app across AZs survives a single data center failure. Out at the edge are hundreds of edge locations (CloudFront points of presence) that cache content close to users for low latency. You will deepen all of this in the next lesson; for now, hold the hierarchy Region → Availability Zone → edge, and the rule that high availability on AWS means running across at least two AZs.
Why teams choose AWS — and what it costs
Teams pick AWS for two reasons above all. Breadth: 200+ services mean you can almost always assemble what you need without inventing it, from a queue to a managed Kubernetes cluster to a machine-learning endpoint. Elasticity: you scale up in seconds for a traffic spike and scale down when it passes, paying only for what you used — exactly the property that saved the startup in the hook. Add the maturity of the platform and a deep hiring pool, and AWS is the safe institutional default.
The downsides are equally real and worth naming as a senior engineer would. Cost complexity: pay-per-use is a double-edged sword — pricing spans compute hours, storage GB-months, request counts, and data transfer out (egress), which surprises teams more than anything else; an idle-but-forgotten resource or a chatty cross-region call can quietly bleed money. Lock-in: the more you lean on proprietary managed services (DynamoDB, Lambda, SQS), the harder and costlier it is to leave — the convenience and the lock-in are the same feature. Operational surface: AWS hands you enormous power and an enormous number of ways to misconfigure it; IAM alone is a deep discipline, and a single over-permissive policy or public bucket is a breach. None of these are reasons not to use AWS; they are the things you manage deliberately because you chose to use it.
A new web service needs a relational database. The team is small and wants to ship features, not operate infrastructure. Which option fits best?
- 01What does it actually mean to say AWS is a 'utility-computing platform', and why is 'over an API' the key phrase?
- 02Explain the managed-vs-self-managed axis using a database, and tie it to the shared responsibility model.
AWS is a global utility-computing platform: launched in 2006, it offers 200+ on-demand services — compute, storage, networking, and managed higher-level services — billed per use and provisioned in seconds over an API, across 190+ countries. The way to hold it in your head is by category — compute (EC2, Lambda), storage (S3), database (RDS, DynamoDB), networking (VPC, ELB, Route 53, CloudFront), security and identity (IAM, KMS), observability (CloudWatch, CloudTrail) — and by the managed-vs-self-managed axis that runs through every category: the same capability is available raw (you operate it), managed (AWS operates the engine), or serverless (no instance at all), and choosing among them is a real tradeoff of control versus operational toil. The global infrastructure stacks as Region → Availability Zone → edge, with high availability meaning at least two AZs. Teams choose AWS for breadth and elasticity and accept its costs: pay-per-use pricing that is easy to overrun (especially data egress), lock-in that grows with every proprietary managed service, a large misconfiguration surface, and a shared responsibility model where securing your data, IAM, and config is always your job. Now when you’re evaluating whether to use a managed service or run it yourself, you have the axis and the cost model to make that call deliberately — not by reflex.
Practice
Start at the top. Tasks go easiest → hardest: recall a fact, apply it to a case, then a senior-level stretch. Open one, attempt it, then reveal.
Something unclear?
Ask a question about this lesson. Questions are anonymous and go straight to the author to make the lesson better.