AWS Builder Center
AWS for Azure People: A Service Map Built From Real Mistakes

AWS for Azure People: A Service Map Built From Real Mistakes

A practical Azure-to-AWS service map for IT students who already know Azure — built from actual incidents, not a generic side-by-side comparison table.

Tech Enthusiast

Who this is for

You've used Azure — maybe in a class, an internship, or a job — and now you need to learn AWS. Most comparison articles give you a naming dictionary (this Azure thing = this AWS thing) and stop there. That's useful for a five-minute skim, but it quietly hides the fact that a lot of these "equivalent" services don't actually behave the same way underneath, even when the marketing pitch is identical.
This article does both: a quick-reference map for the breadth you need, and a few deeper sections — clearly marked — on services where "the AWS version works differently than you'd expect" turned out to be true in practice, not just in theory.
A scope note: this doesn't cover GCP or other major clouds — Azure and AWS are the two I've actually worked with, so that's what I can speak to with any real authority. If you've worked with GCP, Oracle Cloud, or anything else, drop a comment on what's genuinely similar or different versus AWS from your experience — the more cloud backgrounds represented in the comments, the more useful this becomes for anyone reading who's coming from somewhere other than Azure.

The map (start here)

Category
Azure
AWS
Worth knowing
Virtual machines
Azure VMs
EC2
Instance family names and sizing conventions don't map 1:1 — don't assume a "similar spec" guess is close
Serverless functions
Azure Functions
Lambda
Similar concept, different pricing and cold-start behavior in the details
Managed Kubernetes
AKS
EKS
AWS also has ECS — a simpler, non-Kubernetes container option with no real Azure equivalent
Object storage
Blob Storage
S3
See the deep dive below — the "obvious" S3 setup path is outdated
Relational database
Azure SQL Database
RDS

NoSQL database
Cosmos DB
DynamoDB
Cosmos DB's multi-API model (SQL, Mongo, Cassandra APIs) has no direct DynamoDB parallel
CDN
Azure CDN / Front Door
CloudFront
See the deep dive below
Virtual network
VNet
VPC

Workflow / integration automation
Logic Apps
Step Functions
Step Functions orchestrates AWS-native services well, but Logic Apps' library of 1,400+ prebuilt connectors (SharePoint, Salesforce, Dynamics, etc.) has no real AWS equivalent — expect to pair Step Functions with Lambda for custom integration code
Private connectivity to a managed service
Private Endpoint
PrivateLink (Interface VPC Endpoint)
Same underlying idea: your traffic to the service reaches it over a private IP inside your network, never touching the public internet
Network firewall
Azure Firewall
AWS Network Firewall
Both are managed, stateful, centralized filtering with FQDN-based rules — see the perimeter-security note below for how the surrounding architecture differs
Web application firewall
Azure WAF
AWS WAF
Azure typically bundles WAF as a mode inside Application Gateway or Front Door; AWS WAF is its own resource (a Web ACL) that you separately attach to ALB, CloudFront, or API Gateway
Layer-7 load balancer
Application Gateway
Application Load Balancer (ALB)
Application Gateway bundles WAF as an integrated option on the same resource; on AWS, ALB and WAF stay as two resources you wire together yourself
API management
API Management
API Gateway
Azure's APIM is a heavier, more "enterprise" product by default than API Gateway
Isolation + billing boundary
Subscription
Account
See the deep dive below — this is a bigger structural difference than the name suggests
Grouping many subscriptions/accounts for policy
Management Group
Organizational Unit (via AWS Organizations)
See the deep dive below
Grouping resources for coordinated deployment
Resource Group
CloudFormation Stack (closest functional equivalent)
See the deep dive below — AWS has no direct 1:1 for this one
Billing scope
Per subscription
Per account, consolidated via AWS Organizations
See the deep dive below
Human identity
Entra ID
IAM Identity Center

App-to-app identity
Entra ID app registration
IAM roles / SigV4
See the deep dive below — this is the one that actually surprised me
Customer identity (CIAM)
Entra External ID
Cognito
Pricing models diverge in a way that matters — see below
Sending email
Azure Communication Services Email
SES
See the deep dive below
Monitoring & logs
Azure Monitor / Log Analytics
CloudWatch

AI model hosting
Azure AI Foundry / Azure OpenAI
Bedrock
Auth model difference again — see below
One general warning before you use any table like this: don't assume a 1:1 row always means 1:1 behavior. Some AWS services split a job that's one Azure service into two AWS pieces (or vice versa). The table gets you oriented; it doesn't replace actually reading how the specific service works before you build on it.
A pattern specific to networking and perimeter security: Azure tends to bundle these into fewer, more full-featured resources — Azure Firewall for network-layer filtering, Application Gateway with an integrated WAF mode for the web layer. AWS tends to decompose the same job into more single-purpose resources you compose yourself: Network Firewall, ALB, and a separately-managed WAF Web ACL, wired together rather than bundled. Neither approach is strictly better — Azure's bundling is faster to stand up, AWS's decomposition gives you more granular control over which piece sits where — but if you're used to Azure's "one resource does most of it" model, expect AWS's version to involve more distinct pieces that each need their own configuration and IAM permissions.

Deep dive: subscriptions and resource groups don't have a single AWS equivalent

This is one of the most common points of confusion moving from Azure to AWS, because Azure's hierarchy is one nested structure — tenant → management group → subscription → resource group → resource — and AWS's isn't one structure. It's several different mechanisms, each doing a different piece of that job.
The isolation and billing boundary. In Azure, a subscription is both a hard boundary — its own resources, its own RBAC scope — and a native billing scope, which is exactly why "one subscription per team or project" is such a common pattern: it gives each team a clean, separate bill with no extra setup. AWS's equivalent boundary isn't a resource living inside something bigger — it's the account itself. An AWS account is its own hard isolation boundary and its own native billing scope, the same role a subscription plays. "One AWS account per team or project" is the direct equivalent pattern — not something you build with a container inside a single shared account.
Grouping many of those together. Azure's management groups sit above subscriptions, letting you apply Azure Policy and RBAC inheritance across several subscriptions at once. AWS's Organizations, specifically its organizational units (OUs), do the same job for accounts: apply a service control policy (SCP) once at the OU level, and every account underneath inherits it — the same way management group policy flows down to the subscriptions beneath it.
Grouping resources for coordinated deployment. This is the part that actually catches people out, because it's the one place AWS genuinely doesn't have a matching container. Azure's resource group lives inside a subscription — a place to put related resources so you can manage, and critically delete, them together as a unit. AWS has no equivalent standing container inside an account. The closest functional match is a CloudFormation stack — a set of resources you define and deploy together, and can tear down as one unit — but a stack is fundamentally a deployment construct, not a persistent organizational container the way a resource group is. (AWS does have a service literally named "Resource Groups" — don't let the name fool you. It's a tag-based view over resources you already have, for convenience and automation, not something you deploy into or that scopes access control the way an Azure resource group does.)
Billing, concretely. Azure's per-subscription billing makes splitting cost reporting by team or project close to automatic once you've split them into separate subscriptions. AWS's answer is AWS Organizations' consolidated billing: a central payer account receives one rolled-up invoice covering every linked account in the organization, while Cost Explorer and Cost and Usage Reports still break spend down per individual account — one bill to actually pay, full per-team visibility underneath it, which is the same outcome Azure reaches via subscriptions under an Enterprise Agreement. The practical takeaway: if the goal is "give each team its own clean billing," the AWS equivalent is a separate account per team under an Organization — not a resource group equivalent inside one shared account, because that container doesn't exist on AWS.

Deep dive: identity for apps, not people

Azure default: an app registration authenticates with a client secret — a static value — presented as a bearer token. Simple to use, and it's why so many tutorials show a raw  curl  command with an  Authorization: Bearer  header.
AWS default: the opposite. IAM has always required SigV4 — every request gets cryptographically signed using your credentials, not just tagged with a static token. You genuinely cannot copy-paste an AWS access key into a  curl  header and have it work, the way you can with an Azure token.
Why this actually matters: AWS later added "API keys" for Bedrock (and similar services) specifically to give people the Azure-style bearer-token experience. If you don't know the SigV4-first history, it's easy to assume API keys are the "normal" AWS way to authenticate and reach for them by default — when the more secure, more idiomatic path ( aws sso login , or an IAM role if you're inside AWS already) was sitting there the whole time, quietly requiring no extra configuration to lock down.

Deep dive: customer identity pricing isn't as similar as it looks

Cognito and Entra External ID both do the same job — identity for your app's external users — and both charge per monthly active user past a free tier. Where they genuinely diverge is machine-to-machine authentication: one app calling another, no human involved.
Entra ID's client credentials flow (app-to-app, via an app registration) is bundled into your existing license — no per-call charge in any normal scenario. Cognito's equivalent charges per token request, with no free tier at all, meaning a service that requests a fresh token on every API call instead of caching it can rack up a real, unexpected bill. Same job, same OAuth flow, very different cost model — and it's not something either service's landing page makes obvious.

Deep dive: hosting a static site is not what most tutorials show

S3 has a "static website hosting" feature that most tutorials still default to — it requires making your bucket public. That's the outdated pattern. The current recommended approach keeps the bucket private and uses CloudFront with Origin Access Control (OAC) so only CloudFront can read from it — closer in spirit to how you'd never directly expose a Blob Storage container to the internet without a CDN or SAS token in front of it on Azure.
The gotcha worth knowing: the private-bucket setup doesn't automatically handle folder-style URLs ( /projects/  serving  /projects/index.html ) the way the old public-website feature did. You need a small CloudFront Function to rewrite those URIs yourself — a detail almost every basic tutorial skips.

Deep dive: "no incident on our end" doesn't mean it's not DNS

This one isn't AWS-specific, but it's the one real incident underneath this whole series: an SES domain kept failing DKIM verification intermittently, and AWS Support correctly found no issue on their side. The actual cause was that our domain's DKIM subzone had only ever been delegated to two of four public nameservers — a gap that had existed for a long time, just never queried consistently enough to notice. The fix had nothing to do with AWS and everything to do with checking every nameserver in our own delegation individually, not just whatever one a normal DNS lookup happened to answer from.
The lesson generalizes past SES: when a cloud provider tells you there's no incident on their end, that's a strong signal to check the consistency of your own infrastructure — not proof that everything on your side is fine.

If you're a student, here's a suggested order

  1. Start with identity (IAM vs Entra ID) before anything else — every other service's security model builds on it, and it's the piece where Azure habits are most likely to mislead you.
  1. Pick one small, real project — a portfolio site is a good one — and build it with S3 + CloudFront rather than reading about it. The pretty-URL gotcha above is the kind of thing you only really learn by hitting it.
  1. Read AWS's own pricing pages for whatever you're using before you assume a service is "basically free" because the Azure equivalent was. The Cognito M2M story above is exactly this mistake.
  1. When something breaks and AWS Support says it's not them — believe them, and go look at your own configuration's consistency, not just whether it "looks right" at a glance.
None of this requires memorizing a naming dictionary. It requires building the instinct that "same job" doesn't mean "same defaults," and checking that assumption every time it actually matters.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article