
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.
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
- 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.
- 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.
- 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.
- 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.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article