AWS Services — the problem each one solves
AWS has 200+ services, but you build most systems from a few dozen. This is an architect's field guide to 40 core services: for each, the problem it solves, its real limitations & quotas, and when to choose it.
How to read each entry. Every service has three labeled lines —
Solves the problem it exists for,
Limits the constraints, quotas and gotchas that bite in production, and
Choose when it's the right tool. Quotas noted are defaults; many are soft limits you can raise via a support request.
4 services1 · Foundation & Identity
Who you are and who can do what: IAM, Organizations, KMS, Secrets Manager.
7 services2 · Compute
Where code runs: EC2, Lambda, ECS, EKS, Fargate, Beanstalk, Auto Scaling.
4 services3 · Storage
Where bytes live: S3, EBS, EFS, S3 Glacier.
5 services4 · Databases
Structured state: RDS, Aurora, DynamoDB, ElastiCache, Redshift.
5 services5 · Networking & Delivery
Connectivity & reach: VPC, Route 53, CloudFront, API Gateway, ELB.
5 services6 · Integration & Messaging
Decoupling: SQS, SNS, EventBridge, Step Functions, Kinesis.
3 services7 · Observability & IaC
See & provision: CloudWatch, CloudTrail, CloudFormation.
4 services8 · Analytics & AI/ML
Insight & intelligence: Athena, Glue, SageMaker, Bedrock.
3 services9 · Security & Edge
Protect the perimeter: Cognito, WAF, GuardDuty.
Category 1 Foundation & Identity
Before anything runs, AWS must know who is acting and what they're allowed to do. These services are the substrate every other service depends on.
IAM Identity & Access Management
Solves Centralized control of who (users, roles, services) can perform which actions on which resources — the authorization layer for all of AWS. Roles let workloads assume short-lived credentials instead of hard-coding keys.
Limits Policy changes are eventually consistent (propagation lag). Policy evaluation (allow/deny/boundaries/SCPs) gets complex fast. Quotas: e.g. 10 managed policies per role, ~6 KB inline policy size. IAM authenticates AWS principals, not your app's end users — that's Cognito.
Choose Always. Design least-privilege roles per workload from day one; prefer roles over long-lived access keys.
Organizations multi-account governance
Solves Managing many AWS accounts as one: consolidated billing, and guardrails via Service Control Policies (SCPs) that cap what any account can do. Account-per-team/env is the recommended isolation boundary.
Limits SCPs only restrict — they never grant permissions (you still need IAM). The management account is a high-value target and can't be constrained by SCPs. New accounts take time to provision; some quotas are per-account.
Choose The moment you have more than one account — for isolation, blast-radius control, and central billing.
KMS Key Management Service
Solves Creating, storing and controlling encryption keys, with envelope encryption and audited key usage — so "encrypt everything at rest" becomes a checkbox integrated into S3, EBS, RDS, etc.
Limits Direct Encrypt is capped at 4 KB (use data keys / envelope encryption for larger payloads). Keys are regional (except multi-Region keys). Cryptographic requests share a per-region rate quota; cost accrues per key per month plus per request.
Choose Any time you need managed, auditable encryption keys — especially for compliance (customer-managed keys, key rotation, grants).
Secrets Manager secret storage & rotation
Solves Storing database credentials, API keys and tokens securely, with built-in automatic rotation and fine-grained IAM access — no more secrets in env files or code.
Limits Priced per secret per month plus API calls. Rotation requires a Lambda function. Max secret size 64 KB. For plain config or cheaper storage without auto-rotation, SSM Parameter Store is often the better fit.
Choose Credentials that must rotate (RDS/Redshift integration is turnkey) or secrets needing tight audit and access control.
Category 2 Compute
The spectrum runs from "I manage the whole machine" to "I just hand AWS a function." Higher up the ladder means less operational burden but less control — pick the least you can get away with.
EC2 Elastic Compute Cloud
Solves On-demand, resizable virtual servers with full OS-level control — the general-purpose "rent a computer" primitive. Hundreds of instance types (CPU, memory, GPU, ARM Graviton).
Limits You own patching, scaling, and multi-AZ resilience. Regional vCPU service quotas cap how much you can launch; specific instance types can hit capacity shortages. Idle instances still cost money.
Choose Lift-and-shift, long-running stateful workloads, GPU/ML, or anything needing full control over the OS and kernel.
Lambda serverless functions
Solves Running code with zero server management, triggered by events, billed per millisecond — scales from zero to thousands of concurrent executions automatically.
Limits 15-minute max execution, 10 GB memory ceiling, 250 MB unzipped package (or 10 GB container image), 6 MB synchronous payload. Cold starts add latency; functions are stateless; default 1,000 concurrent executions per region (soft).
Choose Event-driven glue, spiky/unpredictable traffic, short tasks, and APIs behind API Gateway. Avoid for long-running or ultra-low-latency-sensitive paths.
ECS Elastic Container Service
Solves Running and orchestrating Docker containers with a simple, AWS-native control plane — deep IAM/VPC/ALB integration and far less complexity than Kubernetes.
Limits AWS-proprietary — not portable to other clouds like Kubernetes is. Smaller ecosystem of third-party tooling. Service/task quotas apply; networking (awsvpc mode, ENIs per instance) needs planning.
Choose You want containers on AWS without the operational weight of Kubernetes and don't need multi-cloud portability.
EKS Elastic Kubernetes Service
Solves A managed Kubernetes control plane so you get the portable, standard k8s API and ecosystem without running etcd/masters yourself.
Limits All of Kubernetes' complexity remains yours (YAML, upgrades, add-ons, RBAC). The control plane costs a flat hourly fee per cluster. Version upgrades are frequent and mandatory; steeper learning curve than ECS.
Choose You've standardized on Kubernetes, need its ecosystem (Helm, operators), or want workload portability across clouds/on-prem.
Fargate serverless containers
Solves Running ECS/EKS containers without provisioning or patching EC2 nodes — you specify CPU/memory per task and AWS runs it. No cluster capacity to manage.
Limits Higher per-unit cost than well-utilized EC2. Fixed CPU/memory combinations; limited host customization (no GPUs on ECS-Fargate, no privileged/daemonset patterns). Task startup is slower than a warm EC2 host.
Choose Bursty or low-ops container workloads where you'd rather pay a premium than manage node fleets and bin-packing.
Elastic Beanstalk PaaS for web apps
Solves Deploying a standard web app (upload code, pick a platform) while AWS provisions the EC2, load balancer, auto-scaling and health checks for you — a fast on-ramp for teams new to AWS.
Limits The abstraction leaks — debugging the generated infra can be confusing. Less control, and it lags behind the newest AWS features. Many teams outgrow it and move to ECS/EKS or raw CloudFormation/CDK.
Choose Quick deployment of a conventional web/API app when you don't yet want to hand-wire the underlying infrastructure.
Auto Scaling EC2 Auto Scaling / Application Auto Scaling
Solves Automatically adding/removing capacity to match demand — maintain availability during spikes and cut cost during troughs, driven by metrics or schedules.
Limits Scaling is reactive — there's a lag between load rising and capacity arriving (mitigate with warm pools, predictive scaling, headroom). Requires stateless, horizontally-scalable design and good CloudWatch signals.
Choose Any variable-load fleet (EC2, ECS tasks, DynamoDB, etc.) where you want elasticity instead of static over-provisioning.
Category 3 Storage
Three shapes of storage — object, block, and file — plus an archive tier. Matching the access pattern to the storage type is one of the highest-leverage architecture decisions.
S3 Simple Storage Service
Solves Virtually unlimited, extremely durable (11 nines) object storage over HTTPS — the default home for files, backups, data lakes, static sites and logs. Now strongly read-after-write consistent.
Limits It's object storage, not a filesystem: no in-place edits or appends (rewrite the whole object). Max object size 5 TB (5 GB per single PUT). Higher latency than block storage; very high request rates need key-prefix planning.
Choose Almost any bulk, static, or write-once-read-many data. The backbone of data lakes and content delivery (behind CloudFront).
EBS Elastic Block Store
Solves Persistent, low-latency block storage that attaches to an EC2 instance like a physical disk — the boot volume and database disk for EC2.
Limits Locked to a single Availability Zone; normally attaches to one instance at a time (io1/io2 Multi-Attach is the exception). To move across AZs you snapshot to S3 and restore. IOPS/throughput are provisioned (and priced) per volume type.
Choose A disk for one EC2 instance — databases, boot volumes, anything needing consistent low-latency block I/O.
EFS Elastic File System
Solves A shared, elastic NFS filesystem that many instances (or Lambda/containers) mount at once and that grows/shrinks automatically — the answer to "multiple compute nodes need the same files."
Limits Higher latency and cost than EBS. Throughput depends on mode (Bursting/Elastic/Provisioned). Linux/NFS only — for Windows/SMB or high-performance HPC use Amazon FSx. Overkill (and pricey) for a single instance.
Choose Shared file access across many compute nodes — web content, CMS uploads, shared home directories, ML training data.
S3 Glacier archival storage
Solves Long-term archival at a fraction of standard S3 cost — for compliance data, backups and cold data you rarely read (Glacier Instant / Flexible / Deep Archive tiers).
Limits Retrieval carries latency (minutes to 12+ hours for Deep Archive) and per-GB retrieval fees. Minimum storage-duration charges (90 days Flexible, 180 days Deep Archive) — deleting early still bills. Not for anything accessed frequently.
Choose Regulatory retention, backup archives, and cold data — usually applied automatically via S3 Lifecycle rules.
Category 4 Databases
Relational for consistency and joins, NoSQL for scale and flexible schemas, in-memory for speed, columnar for analytics. The data model, not the brand, drives the choice.
RDS Relational Database Service
Solves A managed relational database (PostgreSQL, MySQL, MariaDB, Oracle, SQL Server) — AWS handles provisioning, patching, backups, and Multi-AZ failover so you keep SQL without the DBA toil.
Limits Scales vertically (bigger instance) far more easily than horizontally; write throughput is bounded by one primary. Superuser and some engine features are restricted. Maintenance windows, storage and max-connection caps apply.
Choose Traditional transactional apps needing ACID, joins and a familiar SQL engine at small-to-medium scale.
Aurora cloud-native relational
Solves MySQL/PostgreSQL-compatible databases re-architected for the cloud: auto-scaling storage, up to 15 low-latency read replicas, faster failover, and Serverless v2 that scales capacity to load.
Limits AWS-only (no portability). More expensive than plain RDS at small scale. Still a single writer node (writes don't scale horizontally by default). Engine versions can lag upstream community releases.
Choose Relational workloads that have outgrown RDS on read scaling, availability, or need serverless elasticity — while staying MySQL/PostgreSQL-compatible.
DynamoDB managed NoSQL
Solves A fully-managed, serverless key-value/document database with single-digit-millisecond latency at effectively any scale — no servers, automatic partitioning, on-demand capacity.
Limits You must design the table around your access patterns up front — no ad-hoc queries or SQL joins, and re-modeling later is painful. 400 KB max item size; queries need partition keys or GSIs; hot partitions throttle; reads are eventually consistent unless you ask for strong.
Choose High-scale, well-understood access patterns — user sessions, carts, IoT, event stores, anything needing predictable latency at massive throughput.
ElastiCache Redis / Memcached / Valkey
Solves A managed in-memory cache/data store that puts microsecond reads in front of a slower database — offloading hot queries, sessions, rate limits and leaderboards.
Limits Memory is expensive, so datasets are size-bound. It's volatile — treat it as a cache, not the source of truth (data can be evicted or lost on failure unless persistence/replication is configured). Scaling clusters is an operational task.
Choose Read-heavy hot paths, session stores, real-time leaderboards, and anywhere sub-millisecond latency matters.
Redshift data warehouse
Solves Petabyte-scale columnar analytics (OLAP) — run complex aggregate SQL across huge datasets far faster than a row-store transactional DB could.
Limits Built for analytics, not high-concurrency transactional writes (not OLTP). Loading is batch-oriented (ETL pipelines needed); concurrency has limits (mitigated by concurrency scaling / Serverless). Right-sizing clusters takes tuning.
Choose BI dashboards, reporting, and large-scale aggregations over structured data — often fed from S3 via Glue.
Category 5 Networking & Delivery
These services define the private network your resources live in, resolve names to them, and get content to users quickly and safely.
VPC Virtual Private Cloud
Solves A logically isolated virtual network you fully control — subnets, route tables, security groups, NACLs, gateways — so resources talk privately and are exposed only where intended.
Limits Real networking complexity (public/private subnets, NAT, peering, endpoints). CIDR ranges are painful to change after the fact — plan address space early. Regional; quotas on VPCs, subnets and route entries. NAT Gateways bill per hour and per GB.
Choose Every non-trivial deployment — it's the network foundation almost all other services run inside.
Route 53 DNS & domain routing
Solves Highly-available DNS with health checks and traffic policies (latency, geolocation, weighted, failover) — plus domain registration. It's how users' requests find your infrastructure.
Limits DNS changes are bound by TTL/propagation, so failover isn't instant. Priced per hosted zone and per query. It routes to endpoints — it is not a CDN or a load balancer itself.
Choose Any public domain, plus advanced routing (multi-region failover, latency-based routing, blue/green DNS switches).
CloudFront content delivery network
Solves A global CDN that caches content at edge locations near users — cutting latency, offloading origins, and terminating TLS plus absorbing DDoS at the edge (with Shield/WAF).
Limits Cache invalidations cost money and take time to propagate — versioned asset names are preferred. Highly dynamic, per-user, uncacheable content sees less benefit. TTL and cache-key tuning has a learning curve.
Choose Serving static assets, media, and websites globally; fronting S3 or an API/ALB for edge caching and security.
API Gateway managed API front door
Solves A fully-managed front door for REST/HTTP/WebSocket APIs — routing, throttling, auth (IAM/Cognito/JWT), request validation, caching and versioning — most often fronting Lambda.
Limits 29-second integration timeout; 10 MB payload limit. Per-request pricing (REST APIs cost more than the lighter HTTP APIs). Adds latency versus a direct call; feature-rich REST configuration can get intricate.
Choose Exposing serverless or microservice APIs with built-in throttling, auth and metering — especially in front of Lambda.
Elastic Load Balancing ALB / NLB / GWLB
Solves Distributing incoming traffic across healthy targets for availability and scale — ALB for HTTP(S)/L7 routing, NLB for ultra-low-latency L4/TCP, Gateway LB for inline appliances.
Limits Regional, not global (combine with Route 53 or Global Accelerator for multi-region). Huge instantaneous spikes may need pre-warming. Priced per hour plus per LCU/capacity unit; ALB is HTTP(S)-only.
Choose Fronting any fleet of EC2/ECS/Lambda targets — ALB for web apps and path/host routing, NLB for extreme throughput or static IPs.
Category 6 Integration & Messaging
These services let components communicate without being directly coupled — the backbone of resilient, event-driven, microservice architectures. Their differences are subtle, so a cheat sheet follows below.
SQS Simple Queue Service
Solves A durable, fully-managed message queue that decouples producers from consumers — buffering work so a slow or failed downstream doesn't drop requests or take the system down.
Limits Standard queues are at-least-once (expect occasional duplicates) and best-effort ordered; FIFO guarantees order/exactly-once but with throughput caps. 256 KB message max, 14-day max retention. It's poll-based (not push) and does no content-based routing.
Choose Point-to-point work queues, load leveling, and absorbing spikes between services (e.g. web tier → worker tier).
SNS Simple Notification Service
Solves Pub/sub fan-out — one published message pushed to many subscribers at once (SQS queues, Lambda, HTTP endpoints, email, SMS). The classic "notify N systems of an event" primitive.
Limits No message storage or replay — if a subscriber is down it can miss the message (the SNS→SQS fan-out pattern fixes this). 256 KB payload; limited delivery retries. It's a broadcaster, not a queue or a rich router.
Choose Fan-out notifications and simple event broadcasting, especially SNS→multiple SQS queues for durable parallel processing.
EventBridge serverless event bus
Solves A serverless event bus that routes events from AWS services, SaaS apps and your own apps to targets, with rich content-based filtering, a schema registry and scheduling — the connective tissue of event-driven architectures.
Limits Delivery is asynchronous and at-least-once (design idempotent consumers). 256 KB event size; quotas on rules/targets per bus. Slightly higher latency than a direct call, and debugging routing rules takes care.
Choose Decoupled, many-to-many event routing with filtering — especially integrating AWS service events or third-party SaaS into your app.
Step Functions workflow orchestration
Solves Coordinating multi-step workflows as visual state machines — sequencing, branching, parallelism, retries with back-off, error handling and human-approval steps — without writing brittle orchestration glue.
Limits Standard workflows run up to 1 year but bill per state transition (chatty workflows add up); Express workflows are cheap but cap at 5 minutes. State/payload passed between steps is limited (256 KB). Learning Amazon States Language takes time.
Choose Long-running or multi-step business processes (order fulfillment, ETL, approvals) that need reliable retries, visibility and error handling.
Kinesis real-time streaming
Solves Ingesting and processing high-volume real-time streams — clickstreams, logs, IoT telemetry — with ordered, replayable records (Data Streams) or managed delivery to S3/Redshift (Firehose).
Limits Data Streams throughput is shard-based (1 MB/s or 1,000 records/s write per shard) — you manage/monitor shard counts (on-demand mode eases this). Ordering is only guaranteed within a shard. Retention 24 h (up to 365 days, priced). Firehose adds buffering latency.
Choose Real-time analytics and stream processing where ordering, replay and multiple independent consumers matter (vs. SQS's simple queueing).
Category 7 Observability & Infrastructure-as-Code
You can't operate what you can't see, and you can't scale what you build by hand. These cover monitoring, auditing, and repeatable provisioning.
CloudWatch metrics, logs & alarms
Solves The central telemetry service — collects metrics, logs, and events from AWS and your apps, then drives dashboards, alarms and automated responses. The default "is it healthy?" console.
Limits Costs climb with high-cardinality custom metrics and large log volumes (ingestion + Logs Insights queries + retention). Standard metric granularity is 1 minute (high-resolution 1s costs more). It's monitoring, not full distributed tracing — pair with X-Ray.
Choose Baseline monitoring, alerting and log aggregation for essentially every workload.
CloudTrail API activity audit log
Solves An immutable audit trail of who did what, when across the AWS API — indispensable for security investigation, compliance and change tracking.
Limits Management events are recorded by default, but high-volume data events (S3 object-level, Lambda invokes) cost extra. Delivery has minutes of latency, so it's forensic, not real-time alerting on its own. Long-term storage in S3 adds cost.
Choose Always on for governance — every account should log to a secure, centralized trail for audit and incident response.
CloudFormation infrastructure as code
Solves Declaratively defining your infrastructure in templates so entire stacks are provisioned, updated and torn down repeatably and reviewably — no click-ops drift between environments.
Limits Templates get verbose (YAML/JSON); failed updates can trigger slow rollbacks; manual console changes cause drift. New AWS features sometimes lag in coverage. ~500 resources per stack (use nested stacks). Prefer the CDK (generates CloudFormation) or Terraform for a nicer authoring experience.
Choose Any environment you need to reproduce reliably — which is all of them. Start IaC early; retrofitting is painful.
Category 8 Analytics & AI/ML
Turning raw data in S3 into queryable insight, and adding machine learning — from custom models to ready-to-use foundation models.
Athena serverless SQL over S3
Solves Running standard SQL directly against data sitting in S3 — no servers, no loading, no ETL. Point it at your data lake and query in seconds (Presto/Trino under the hood).
Limits Billed per terabyte scanned — costs explode without partitioning and columnar formats (Parquet/ORC). Latency grows with scan size; it's read-only analytics, not a low-latency application database. Complex queries inherit Trino quirks.
Choose Ad-hoc exploration, log analysis and occasional queries over a data lake where standing up a warehouse would be overkill.
Glue serverless ETL & Data Catalog
Solves Discovering, cataloging and transforming data at scale without managing Spark clusters — crawlers infer schemas into the Data Catalog (shared by Athena/Redshift/EMR), and serverless jobs run the ETL.
Limits Spark jobs have cold-start time and DPU-based cost; debugging distributed jobs has a learning curve. Crawlers have their own cost and quirks. Primarily batch (streaming ETL exists but is less mature).
Choose Building the ingestion/transformation layer of a data lake and maintaining a central schema catalog for analytics services.
SageMaker end-to-end machine learning
Solves The full custom-ML lifecycle in one managed platform — label, build, train, tune, deploy and monitor models — removing the heavy infrastructure lifting of doing ML from scratch.
Limits Broad and complex surface area with a real learning curve. Costs add up (training jobs plus always-on inference endpoints). GPU instance quotas can block training. Overkill if you only need to call a pre-trained model API.
Choose Teams training and serving custom models at scale who want managed training, tuning and deployment infrastructure.
Bedrock managed foundation models
Solves Accessing top foundation models (Anthropic Claude, and others) through a single API — no infrastructure to run — with built-in support for RAG (Knowledge Bases), agents and guardrails.
Limits Per-token pricing; model and feature availability varies by region. On-demand throughput has quotas (reserve capacity via Provisioned Throughput for scale). Less control than self-hosting, and each model has its own context-window and prompt limits.
Choose Adding generative-AI features (chat, summarization, RAG, agents) without managing GPUs or model serving — the fast path to LLMs on AWS.
Category 9 Security & Edge
Beyond IAM's authorization, these protect your application's users and its perimeter — a reminder that security is layered, not a single service.
Cognito application user identity
Solves Authentication and authorization for your app's end users — sign-up/sign-in, User Pools, hosted UI, OAuth2/OIDC, and federation with Google/Apple/SAML — so you don't build an auth system yourself.
Limits Customization and UX flexibility are limited (the hosted UI is basic); advanced flows can be fiddly. Quotas on users/requests; migrating an existing user base in has friction. It is not for authorizing AWS API calls — that's IAM.
Choose Web/mobile apps needing managed user sign-in, social/enterprise federation, and token issuance without running your own identity provider.
WAF Web Application Firewall
Solves Filtering malicious HTTP(S) traffic — SQL injection, XSS, bad bots — with rate-based rules and managed rule groups, attached to CloudFront, ALB, API Gateway or AppSync.
Limits Rules need tuning to avoid false positives/negatives; managed rules still require review for your app. Priced per web ACL, per rule and per million requests. It's Layer-7 filtering — it is not by itself volumetric DDoS protection (that's Shield).
Choose Public web apps/APIs needing protection against common exploits, bot mitigation and per-IP rate limiting at the edge.
GuardDuty threat detection
Solves Continuous, intelligent threat detection — it analyzes CloudTrail, VPC Flow Logs and DNS logs with ML and threat intel to flag compromised credentials, crypto-mining, recon and anomalies. No agents to deploy.
Limits It detects, it doesn't prevent — findings still need triage and a response workflow (wire to EventBridge/Security Hub). Priced on analyzed data volume; must be enabled per region; can produce noise needing tuning.
Choose Baseline continuous security monitoring for any account handling sensitive workloads — low-effort, high-value detection.
Look-alikes cheat sheet
The services architects most often confuse — and the one question that separates them.
| When you're torn between… | Reach for… | The deciding question |
| SQS vs SNS vs EventBridge | SQS / SNS / EventBridge | One consumer pulls work? SQS. Broadcast to many now? SNS. Route/filter events to varied targets? EventBridge. |
| SQS vs Kinesis | SQS / Kinesis | Just decouple & process-then-delete? SQS. Need ordering, replay, or multiple independent readers? Kinesis. |
| EC2 vs ECS vs Lambda | EC2 / ECS/Fargate / Lambda | Full OS control? EC2. Containers? ECS/Fargate. Short event-driven functions? Lambda. |
| ECS vs EKS | ECS / EKS | Want simplest AWS-native orchestration? ECS. Need the Kubernetes ecosystem / portability? EKS. |
| S3 vs EBS vs EFS | S3 / EBS / EFS | Objects over HTTP? S3. One instance's disk? EBS. Shared filesystem for many? EFS. |
| RDS vs DynamoDB | RDS/Aurora / DynamoDB | Need joins, ad-hoc queries, ACID relations? RDS/Aurora. Known access patterns at massive scale? DynamoDB. |
| RDS vs Redshift | RDS / Redshift | Transactional reads/writes (OLTP)? RDS. Big analytical aggregations (OLAP)? Redshift. |
| IAM vs Cognito | IAM / Cognito | Authorizing AWS principals/services? IAM. Authenticating your app's end users? Cognito. |
| WAF vs Shield vs GuardDuty | WAF / Shield / GuardDuty | Filter bad requests (L7)? WAF. Absorb DDoS? Shield. Detect account/threat anomalies? GuardDuty. |
| SageMaker vs Bedrock | SageMaker / Bedrock | Train/host your own models? SageMaker. Call ready-made foundation models via API? Bedrock. |
The recurring theme: AWS gives you a ladder of managed-ness for every need — more management means less control and (often) higher per-unit cost, in exchange for less operational burden. Good architecture is choosing the lowest rung that meets the requirement.
Knowledge check
Six questions on matching problems to services. Pick an answer for each, then check your score.
Next steps
📘 AWS Well-Architected
The five pillars — the framework for evaluating these choices against cost, reliability, security, performance and operations.
☸️ Cloud Native
The architecture — containers, microservices & Kubernetes: how ECS/EKS/Lambda fit a cloud-native design.
🌩️ GCP & IaC
The other cloud — Google Cloud's services mapped to AWS, plus Infrastructure as Code with Terraform.
🤖 LLM apps tutorial
The companion guide — building LLM applications with LangChain, LangGraph and vector databases (pairs with Bedrock).