A Well-Architected review in practice
AWS III introduced the Well-Architected Framework through its reliability pillar. A review is how teams actually use it: a structured conversation, workload by workload, through the framework's questions - with evidence from the account instead of opinions - that ends in a short, prioritised list of risks and an owner for each fix. It is not an audit and nobody fails it; a review with no findings was not looked at closely enough.
Need to know: six pillars, each with design principles and questions:
| Pillar | The question it asks | Typical findings |
|---|---|---|
| Operational excellence | can you run, observe and change it safely? | no alarms, manual deploys, no runbooks, no post-incident reviews |
| Security | who can do what, and how would you know? | wide roles, long-lived keys, public data, no encryption or logging |
| Reliability | does it recover from failures and meet its RPO / RTO? | one AZ, no DLQ, untested backups, no quotas headroom |
| Performance efficiency | does it use the right resources, and keep up as demand changes? | wrong compute type, no caching, oversized or undersized |
| Cost optimization | does it deliver value at the lowest price? | idle resources, no commitments on the baseline, no budget, no tags |
| Sustainability | does it minimise the energy and resources it needs? | always-on dev, x86 where Graviton works, data kept forever |
Each question's answers are best practices; a missing one is a high risk issue (HRI) or a medium risk issue (MRI). The AWS Well-Architected Tool in the console records the workload, the answers, the risks and an improvement plan, saves milestones to compare later, and adds lenses with extra questions for a kind of workload: Serverless, Containers, SaaS, Financial Services, Generative AI (the wellarchitected API is not simulated here).
Collect the evidence
review.sh gathers read-only evidence for the try- workload - a queue, two functions, an assets bucket - grouped by pillar. Read it first: every line is a CLI call you already know.
$ cd ~/oncall-lab/labs/aws/try6
$ sed -n '1,25p' review.sh
#!/usr/bin/env bash
# review.sh - read-only evidence for a Well-Architected review of one workload
# usage: bash review.sh [PREFIX] (PREFIX = the workload's name prefix, default try-)
set -uo pipefail
P=${1:-try-}
echo "== Reliability"
for q in $(aws sqs list-queues --queue-name-prefix "$P" --query 'QueueUrls[]' --output text); do
name=${q##*/}
case $name in *-dlq) continue ;; esac
if aws sqs get-queue-attributes --queue-url "$q" --attribute-names RedrivePolicy --output text | grep -q deadLetterTargetArn; then
echo " ok queue $name has a DLQ"
else
echo " HIGH queue $name has no DLQ: a poison message is retried until it expires"
fi
done
for f in $(aws lambda list-functions --query "Functions[?starts_with(FunctionName,'$P')].FunctionName" --output text); do
d=$(aws lambda get-function-event-invoke-config --function-name "$f" --query DestinationConfig.OnFailure.Destination --output text 2>/dev/null)
if [ -n "$d" ] && [ "$d" != None ]; then echo " ok function $f sends failed async events to $d"; else echo " MED function $f drops failed async events (no on-failure destination)"; fi
done
for b in $(aws s3api list-buckets --query "Buckets[?starts_with(Name,'oncall-$P')].Name" --output text); do
v=$(aws s3api get-bucket-versioning --bucket "$b" --query Status --output text)
if [ "$v" = Enabled ]; then echo " ok bucket $b is versioned"; else echo " HIGH bucket $b is not versioned: one delete or overwrite loses data"; fi
done
echo "== Operational excellence"
n=$(aws cloudwatch describe-alarms --alarm-name-prefix "$P" --query 'length(MetricAlarms)' --output text)
$ bash review.sh
== Reliability
HIGH queue try-orders-in has no DLQ: a poison message is retried until it expires
MED function try-intake drops failed async events (no on-failure destination)
MED function try-notify drops failed async events (no on-failure destination)
HIGH bucket oncall-try-assets-111122223333 is not versioned: one delete or overwrite loses data
== Operational excellence
HIGH no alarms: users will tell you about outages
== Security
MED role try-wa-role of try-intake allows actions on every resource (policy app)
== Cost optimization
HIGH no budget: nobody is told when spending jumps
== Performance efficiency and sustainability
info function try-intake: 128 MB, x86_64
info function try-notify: 1024 MB, x86_64
A script will not answer the questions for you - "how do you know when a deployment is bad?" is a conversation - but it turns the review from "I think we have alarms" into "there are zero alarms". Run the same script after the fixes and save it as the milestone.
From findings to an improvement plan
Rank by risk x effort, give each an owner and a date, and fix the cheap high risks first. For the try- workload, with where this course taught the fix:
| Finding | Pillar | Fix | Taught |
|---|---|---|---|
| try-orders-in has no DLQ | reliability | redrive policy + DLQ + an alarm on its depth | this chapter, decoupling |
| no alarms | operational excellence | alarms on queue age, function errors and throttles, API 5XX; to a topic that pages | AWS III |
| failed async events dropped | reliability | on-failure destination | this chapter, event sources |
| no budget | cost | a monthly budget with forecast alerts, cost allocation tags | AWS III |
| bucket without versioning | reliability, security | versioning, lifecycle for old versions, Block Public Access | AWS I, AWS V |
| x86 functions | sustainability, cost | arm64 (Graviton), right-sized memory | this chapter, Lambda |
function with sqs:* on * | security | one role per function, scoped actions and resources | this chapter, security |
Then the questions only people can answer, the ones reviews exist for:
- Operational excellence: How do you deploy - and roll back? What does on-call see first when this breaks? When did you last run the runbook?
- Security: Who can change production? How are secrets rotated? What would tell you about a leaked key?
- Reliability: What are the RPO and RTO, who agreed them, and when was a restore last tested? What happens when the payment provider is down for an hour?
- Performance: What is the expected peak, and has it been load-tested? Where is the bottleneck at 10x?
- Cost: Who looks at this workload's bill, and how often? What is idle at night?
- Sustainability: What data can be deleted or archived? Does anything run that nobody uses?
Making reviews stick
- Review before launch and at least once a year, and after a major incident or redesign.
- Keep it short: one workload, the people who build and run it, 2-4 hours, an improvement plan of the top 5 risks - not 60.
- Turn findings into automation where you can: Config rules and conformance packs (AWS IV), Security Hub controls, Trusted Advisor checks, budgets, so the next review starts from a dashboard.
- Pair with an architecture decision record for the trade-offs you accept on purpose ("one AZ for the dev environment, accepted").
On the exam (SAA-C03 all domains; SOA-C03 1.3 and 2.x; CLF-C02 1.1 "the AWS Well-Architected Framework"): the six pillars by name and what each covers (sustainability is the sixth, added in 2021), design principles such as "stop guessing capacity", "test recovery procedures", "apply security at all layers", "go global in minutes"; the Well-Architected Tool, lenses, HRI/MRI and milestones.
In an interview: "How would you review an existing AWS architecture you just inherited?" - "Walk it with the team pillar by pillar, using the Well-Architected questions but with evidence from the account: CloudTrail and Config for what changes and how, IAM Access Analyzer for who can do what, the alarms that exist, the backup and restore history, Compute Optimizer and Cost Explorer for waste. Then rank the risks by impact and effort, fix the cheap high risks first, record what we consciously accept, and repeat the review as a milestone."
You can now: name the six pillars and what each asks, run a review as a conversation backed by evidence from the account, classify findings as high or medium risk, turn them into a ranked improvement plan with owners, use the Well-Architected Tool's lenses and milestones, and keep reviews short and recurring.