AWS, Google Cloud, and Azure: The Landscape

Build the mental model

AWS, Google Cloud, and Azure use different product names, but the set of categories they all offer is nearly identical.

Compute — need a server
Object storage — need to store files/images
Managed database — need a managed relational database
Function service — need serverless execution
CDN — need to deliver content fast worldwide

This category-mapping mental model dramatically reduces how much you need to memorize. The useful question is simply 'what category does this fall into?'

This also makes switching between providers, or reading an unfamiliar provider's documentation for the first time, much easier — you're just mapping a category you already know onto a new label. Product names change and get relaunched; the underlying categories stay far more stable.

See AWS Fundamentals for depth

For hands-on, product-specific depth on AWS — EC2, S3, RDS, Lambda, IAM, and more — see the AWS Fundamentals course on this platform.

text

NEED -> CATEGORY MENTAL MODEL
-----------------------------
NEED -> CATEGORY MENTAL MODEL
--------------------------------

  NEED                          CATEGORY
  ----                          --------
  "need a server"        --->   Compute
  "need to store files"  --->   Object Storage
  "need a relational db" --->   Managed Database
  "need serverless"      --->   Function Service
  "need fast delivery"   --->   CDN
  "need to watch health" --->   Monitoring

  All three major clouds offer every category above,
  just under different product names.

Connect it to a real scenario

Let's practice the category-mapping skill directly: write a small function that reads a plain-text description of a need and identifies the correct service category.

'run a web server' → Compute
'store uploaded images' → Object Storage
'need a managed relational database' → Managed Database
'run code without managing a server' → Function Service
'deliver static assets fast worldwide' → CDN

Checking order matters

Even though the description contains the word 'server,' the serverless pattern must be checked before the general compute pattern to classify it correctly.

All three providers offer roughly the same set of categories
Think at the category level instead of memorizing product names
AWS hands-on depth lives in the AWS Fundamentals course

Try the working example

javascript

function mapNeedToCategory(need) {
  const n = need.toLowerCase();
  if (/without managing a server|run code on demand|serverless/.test(n)) {
    return "Function Service (serverless compute)";
  }
  if (/cdn|deliver.*fast|static assets|edge/.test(n)) {
    return "CDN";
  }
  if (/managed relational database|relational database|sql database/.test(n)) {
    return "Managed Database";
  }
  if (/store uploaded|object storage|store files|store images/.test(n)) {
    return "Object Storage";
  }
  if (/run a (web )?server|host.*app|virtual machine/.test(n)) {
    return "Compute";
  }
  return "Unclear - needs more detail";
}

const needs = [
  "run a web server",
  "store uploaded images",
  "need a managed relational database",
  "run code without managing a server",
  "deliver static assets fast to users worldwide"
];

needs.forEach((need) => {
  console.log(`"${need}" -> ${mapNeedToCategory(need)}`);
});

You should see

"run a web server" -> Compute
"store uploaded images" -> Object Storage
"need a managed relational database" -> Managed Database
"run code without managing a server" -> Function Service (serverless compute)
"deliver static assets fast to users worldwide" -> CDN

5-minute try-it

Add a new description like 'watch application health and errors' and extend the function with a new pattern so it correctly returns a Monitoring category.

One important caution

Confusing a product name (EC2, Lambda) with the underlying category (Compute, Function Service)

Assuming one provider's terminology is universal across all providers

Wikipedia: Cloud computing — Cloud Providers & Platforms