Skip to content
Tutorials Center
My learning

Topics

Lesson 55 of 70 ยท Architecture

Well-Architected Framework

Learn the AWS Well-Architected Framework: the six pillars, design principles, how reviews work and how to weigh trade-offs, with a runnable architecture scorecard.

Every AWS service can be used well or badly, and the difference rarely shows up on day one. A single server with an open port works fine until the night it fails, gets attacked or produces a surprising bill. Experienced engineers carry a mental checklist for these things. The AWS Well-Architected Framework writes that checklist down: a set of questions and best practices for judging whether a workload is built soundly.

The framework is organized into six pillars. It is not a standard to certify against and not a rule that everything must score perfectly. It is a shared vocabulary for finding risks and discussing trade-offs with your team, your manager and AWS. You met a first glimpse of it in the shared responsibility model. This lesson walks through the pillars, how a review runs and how to weigh competing goals.

A Well-Architected review uses the AWS Well-Architected Tool in the console, which needs an account. On this site the questions and scores are your own stand-ins in Python: an architecture scorecard and a trade-off ranker. They illustrate how reviews work. They are not the official question set, and the weights are invented for teaching.

The six pillars

flowchart TD
    W["Well-Architected<br/>Framework"] --> O["Operational excellence"]
    W --> S["Security"]
    W --> R["Reliability"]
    W --> P["Performance efficiency"]
    W --> C["Cost optimization"]
    W --> U["Sustainability"]

Six pillars, each a lens for judging the same workload.

Operational excellence is about running and improving the system. Can you deploy safely and often? Do you notice problems before customers do? Practices include infrastructure as code (CloudFormation, CDK, Terraform), small reversible changes, runbooks, and learning from incidents without blame. Monitoring tools from CloudWatch and Systems Manager belong here.

Security protects data, systems and assets. Core ideas: a strong identity foundation with least privilege (IAM best practices), traceability with CloudTrail, security at every layer, encryption in transit and at rest (KMS), automating security checks, and preparing for incidents.

Reliability is the ability to recover from failure and meet demand. It covers recovery planning, scaling horizontally, and testing failure on purpose. The next lesson, High availability and disaster recovery, goes deep on it.

Performance efficiency is using computing resources well as demand and technology change. Pick the right resource type (a container, a function, a bigger instance), measure instead of guessing, and use managed services and global delivery such as CloudFront where they fit.

Cost optimization is delivering the required value at the lowest price. It means knowing where money goes (cost management), matching supply to demand (auto scaling, purchasing options) and removing waste.

Sustainability is minimizing the environmental impact of running workloads: using resources efficiently, choosing efficient hardware and Regions, and cutting idle capacity. It overlaps with cost optimization, since unused capacity is both expensive and wasteful, but it is its own pillar so that it gets its own questions.

Design principles

Each pillar has principles, and a few recur across the framework.

  • Stop guessing capacity. In the cloud you scale to measured demand instead of buying for a peak you imagined.
  • Test at production scale because you can create a full copy for an hour and delete it.
  • Automate so that environments are reproducible and changes are reviewable.
  • Evolve the architecture. Design for change; no design is final.
  • Drive architectures with data. Collect metrics and let them guide decisions.
  • Practice failure. Run game days, kill instances on purpose and rehearse recovery.
  • Make decisions reversible where possible (small steps, feature flags, blue/green deployments).

Reviews: how the framework is used

A review is a structured conversation about one workload, meaning a set of resources and code that delivers business value, such as "the checkout service". It is a good exercise before launch and again when the system changes a lot.

  1. Define the workload and gather the people who know it (developers, operations, security, the product owner).
  2. Answer the questions pillar by pillar. Questions look like "How do you manage identities for people and machines?" and have lists of best practices to tick or leave unticked.
  3. Find the risks. Each missing best practice becomes a risk flagged as high or medium.
  4. Make an improvement plan. Pick the high risks that are cheapest to fix first, record decisions and owners.
  5. Repeat. A milestone saved in the tool lets you compare progress over time.

Two points keep reviews useful. First, they are blameless: the point is to find gaps, not to grade people. Second, a high risk can be accepted on purpose. A prototype that serves five people does not need multi-Region failover. What matters is that someone decided it, with the cost and impact written down.

An architecture scorecard

The next stand-in models a mini review. Each pillar has a few yes/no practices with an importance weight. A pillar's score is the share of weighted practices you have in place, and each missing practice is a risk, ranked by weight. A real review has many more questions and no single number, because the tool's goal is the list of risks.

Python Score a workload against the six pillars

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

The output shows an uneven profile: security (80%) looks strong, while performance efficiency (20%) is weakest, and reliability and operations (38% each) are missing tested backups, automated deployments and runbooks. The sorted risk list, not the percentages, is what a team would act on first.

Trade-offs

Pillars pull against each other, and no architecture maximizes all six. Multi-AZ databases raise reliability and cost. Aggressive encryption and inspection can add latency. Spot Instances cut cost but can be interrupted. Always-warm Lambda capacity helps performance and costs money when idle.

Good architects make these trade-offs explicit. Ask what the business needs: an internal report tool can tolerate an hour of downtime, while a payment API cannot. Then weigh the options against those needs and write the decision down. Trade-offs are a normal part of design, not a sign that something is wrong. A written decision record ("we accept single-AZ for the staging database to save cost; production is multi-AZ") is worth more than a perfect but undocumented design.

Ranking options by what matters to you

The next stand-in scores three design options against all six pillars (1 is poor, 5 is excellent) and ranks them by importance weights you choose. Change the weights to see the ranking flip. The ratings are illustrative opinions for a small web app, not measurements.

Python Weigh design options against your priorities

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Notice that the winner changes with the weights. A single big instance wins when cost is everything and reliability barely matters, which is the right call for some throwaway projects. Numbers like these never replace judgment, but they force the team to say what it values before arguing about technology.

Making the framework part of your routine

Run a lightweight review before major launches, not only once. Keep the improvement plan in the same tracker as feature work so that risks compete fairly for time. Use Well-Architected Tool milestones to show progress to stakeholders. AWS also publishes "lenses" for specific domains such as serverless, SaaS and machine learning, which add questions for those workloads. Finally, treat pillars as a conversation, not a test: the best outcome of a review is a shared understanding, a short list of fixes and a few decisions you chose consciously.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. How many pillars does the Well-Architected Framework have?

    The pillars are operational excellence, security, reliability, performance efficiency, cost optimization and sustainability.
  2. 2. What is a Well-Architected review mainly for?

    A review is a blameless structured conversation. Its output is a list of risks and decisions, not a pass or fail grade.
  3. 3. A team decides a small internal prototype will run in a single Availability Zone. Which statement fits the framework?

    Trade-offs are normal. Accepting a known risk on purpose, with the impact written down, is good practice. An unnoticed risk is the real problem.
  4. 4. Which pair of pillars most directly trade off in the choice to run a database in Multi-AZ mode?

    Multi-AZ improves availability but adds a standby instance that you pay for, so reliability goes up and so does cost.
  5. 5. Which is a Well-Architected design principle?

    Practicing failure, automating, scaling to measured demand and evolving the architecture are recurring principles.

Summary

  • The framework has six pillars: operational excellence, security, reliability, performance efficiency, cost optimization and sustainability.
  • Reviews are blameless conversations about one workload that produce a prioritized list of risks and an improvement plan.
  • Design principles include scaling to measured demand, automating, driving decisions with data and practicing failure.
  • Pillars conflict, so trade-offs should be explicit, tied to business needs and written down.
  • Repeat reviews at big changes, and accept some risks on purpose rather than by accident.

Next: High Availability and Disaster Recovery