Platform Engineering · Lesson 114

Well-Architected Pillars: Judging the Design You Just Built

The design from Lessons 111 and 112 is built. An external load balancer in front. An internal one behind it. App servers in two zones. A Transit Gateway hub joining the app VPC to the data VPC. A health check on every target. It works. That is not the same as it being good. This lesson is the judge. I run the design through six pillars, one check at a time. I show what each pillar costs and what it saves. The pillars have different names on each cloud. The questions are the same.

Difficulty: Advanced · Know this first: Lesson 111, Lesson 112, Lesson 16, Lesson 87

What you will build

By the end of this lesson you will have run a six-pillar review on the design from Lessons 111 and 112, and you will have the tools to run it again. First, a scorecard script that grades each pillar pass or fail from six answers about your own design. Second, a deep health check endpoint you can prove with curl, healthy and sick. Third, a monthly bill you computed yourself, with the exact line where the money goes. You will also know where the three clouds disagree about the pillar list, and why that disagreement exists.

What you need: your own cloud account and the AWS CLI for the read-only checks, and Python 3 for the scorecard and the health check. Nothing in this lesson runs against a live cloud from this page. The commands are real and checked. The outputs shown are the outputs you will see in your own account, and they are marked that way. Your account IDs and resource IDs will differ.

The story: the review board meets the design

A design review is not a meeting where people say nice things about a diagram. It is a list of questions, asked in order, with the answers checked against the running system. The three clouds all publish the same kind of list. They call it a Well-Architected Framework. The list has six pillars on AWS and on Google Cloud. It has five on Azure. The names differ. The questions do not. A design that cannot answer them is a design that will fail in a way the review could have caught.

Here is the list, with the name each cloud gives it. I checked all three framework pages while writing this lesson, on November 21, 2026. The links are in Go deeper.

PillarAWSAzureGoogle Cloud
Operational excellenceNamed pillarNamed pillarNamed pillar
SecurityNamed pillarNamed pillarNamed pillar, as security, privacy, and compliance
ReliabilityNamed pillarNamed pillarNamed pillar
Performance efficiencyNamed pillarNamed pillarNamed pillar, as performance optimization
Cost optimizationNamed pillarNamed pillarNamed pillar
SustainabilityNamed pillar, the sixthNot a named pillar. Handled in separate Azure sustainability guidance.Named pillar, the sixth

Two things in that table catch people out. First, Azure has five pillars, not six. If your team runs on Azure and someone asks for the sustainability pillar score, the right answer is that Azure does not name one. You still track sustainability. You track it alongside the five, not as a sixth pillar that does not exist. Second, Google's list changed. The older Architecture Framework listed system design as one of its six pillars, and sustainability was not on it. The current Google Cloud Well-Architected Framework page lists sustainability as the sixth pillar. That is the source of the argument you will find online. Both sides are quoting a real Google page. One of them is quoting an old one. The current page wins.

Each pillar gets one analogy, one check you can run, and one trade-off. Learn the analogy first. The analogy is what you remember at 2 AM.

PillarPicture it asThe check you doWhat it trades against
Operational excellenceA pilot's pre-flight checklist. Boring on purpose. It keeps the plane in the air.Run the deploy from a script twice. Same result both times.Speed. A checklist slows a hotfix, and it saves the next three.
SecurityA hotel key card. It opens your room. It opens nothing else.Read the database security group. Only the app VPC is allowed in.Speed. Every check adds a hop. A door that opens for everyone is not a door.
ReliabilityA hospital's backup generators. Tested every month. They start when the power dies.Kill one zone. The request still gets an answer.Cost. Two of everything costs twice as much. One of everything costs a page at 3 AM.
Performance efficiencyA highway with the right number of lanes. Too few and traffic queues. Too many and you paid for empty road.Read requests per target. One target taking all the traffic is a balancer that is not balancing.Cost. Bigger instances are faster and dearer. The right size is the one that holds the load.
Cost optimizationA household electricity bill. You pay for what you use, and for what you leave on.Read the bill line by line. An idle instance is a light left on in an empty office.Reliability. A second zone doubles the compute bill. That is the price, and it is worth paying on purpose.
SustainabilityLights left on in an empty office. Nobody uses the light. The meter still runs.Count idle instances. Zero idle is the check that matters most.Reliability. A fleet sized for the worst day burns power on the quiet days. Right-sizing is the fix.

The design under review is the one from Lessons 111 and 112. Lesson 111 built the load balancers: an external ALB in front, an internal ALB behind it, a deep health check on the target group. Lesson 112 built the private network: the app VPC and the data VPC joined through a Transit Gateway hub, the database with no public IP. This lesson judges that design. One request walks through it, and each hop answers for one pillar.

Do this now, for each of the three clouds

Open the framework page for AWS, for Azure, and for Google Cloud. Find the pillar list on each page and write it down. Count them. Six, five, six. Then find sustainability on each page and write down where it sits. On AWS and Google Cloud it is a named pillar. On Azure it is not. If you cannot find the list in two minutes, you are reading a blog post about the framework, not the framework. The framework pages are linked in Go deeper. Start there.

Run it as:

When it breaks, I check

One thing to remember

Four paths, one family

The diagram above follows one request through the judged design. These four paths are the same idea drawn four ways. One request, judged. One request, failed by a lying health check. One dollar trail, hop by hop. One night shift, mostly idle. Run each path. One run takes 7.2 seconds across the path, so you can watch each hop light up in turn.

The return rule: the green dot only starts moving after the orange dot reaches the data hop. A return with no request is a lie. The diagram never draws one. The failure replay at the end of Run all four shows the other side of the rule. Remove every healthy target, and the orange dot stops at the health gate and never comes back.

Path 1: the judged request

Cost trail: skipped

One request walks the design from Lessons 111 and 112. External ALB, health gate, internal ALB, app fleet, Transit Gateway hub, database. Every hop answers for one pillar, and the database answers the request.

Client0 ms
External ALB3 ms
Health gate2 ms
Internal ALB2 ms
App fleet4 ms
TGW hub5 ms
Database6 ms

Not run yet.

Path 2: the lying health check

Database: skipped

Same request, same design. The health check asks the web server root path, which answers 200 while the database is down. The target stays in rotation. The request reaches a dead app and times out. The database never sees the question.

Client0 ms
External ALB3 ms
Health gatelies
Internal ALB2 ms
Dead apptimeout

Not run yet.

Path 3: the dollar trail

Health check: skipped

The same design, priced hop by hop. Each hop shows its monthly cost at the simulator defaults: 4 medium instances, 500 GB a month, 2 availability zones. The trail adds up to $368.20 a month. The database is Multi-AZ, so it counts twice.

Client$0.00
External ALB$20.43
App fleet$121.47
NAT gateway$65.70
Transit Gateway$73.00
Database$87.60

Not run yet.

Path 4: the idle night shift

Peak traffic: skipped

The same request at 3 AM. Each hop shows how busy it is. The fleet runs at 11 percent. The other 89 percent is capacity waiting for morning, and the bill charges for all of it. This is the sustainability pillar, measured in percent.

Client0%
External ALB8%
App fleet11%
TGW hub5%
NAT gateway2%
Database9%

Not run yet.

Where the time goes

Every hop charges rent in milliseconds. The bar below is a worked example for one request through the judged design, not a measurement from a live system, but the shape is honest. The cost hop is different from the others. It is not a time. It is the monthly bill, scaled so the bar can show it: one millisecond for every $25 of the bill the simulator below computes. At the simulator defaults the bill is $207.60, so the cost hop counts 8 ms and the well-architected total is 32 ms. Move a simulator slider and watch the cost hop and the total move with it. Switch the scenario and watch the health-check hop or the cost hop change instead.

Reliability or cost: move the sliders and watch the trade

The budget bar above shows three fixed stories. This simulator lets you write your own. It answers the trade-off at the heart of this lesson: every extra nine of availability costs real money, and every dollar saved costs real availability. You set how many zones the app runs in, how many instances run in each zone, how big they are, and how much traffic flows each month. Move a slider and watch the bill, the availability, and the cost hop in the budget bar change. The numbers are a teaching example, built from the formulas below, not live measurements. The shape is the lesson: availability goes up in nines, and the bill goes up in dollars.

2 zones

How many zones the app runs in. One zone is a single point of failure. Two zones survive one zone dying. Three zones survive it with room to spare.

2 per zone

How many app instances run in each zone. The total fleet is zones times instances per zone.

Medium ($0.0416/hr)

Small is $0.0208 an hour, medium $0.0416, large $0.0832. Bigger holds more load per instance. It also costs twice as much per step.

500 GB/mo

How many gigabytes flow through the load balancer each month. Five hundred is a quiet internal system. Ten thousand is a busy platform.

Try this: (1) At the defaults, 2 zones, 2 medium instances per zone, 500 GB a month, the fleet is 4 instances. The bill is $207.60 a month: $121.47 of compute, $65.70 of NAT Gateway, $20.43 of load balancer. Availability is 99.95 percent, which is 21.6 minutes of downtime a month. The cost hop counts 8 ms and the budget total is 32 ms. (2) Drop to 1 zone and 1 small instance. The bill falls to $68.46 a month. Availability falls to 99.5 percent, which is 216 minutes of downtime a month. You saved $139.14 and bought 194.4 more minutes of darkness. The cost hop counts 3 ms and the budget total is 27 ms. (3) Push to 3 zones, 4 large instances per zone, 10,000 GB. The bill is $923.81 a month. Availability is 99.99 percent, which is 4.32 minutes of downtime a month. The cost hop counts 37 ms and the budget total is 61 ms. From the defaults, the third nine costs $716.21 a month and saves 17.28 minutes of downtime. That is the trade, priced.

Formulas, in plain terms. Instances = zones times instances per zone. Compute bill = instances times hourly price times 730 hours. NAT Gateway bill = zones times $32.85 a month, one gateway per zone. Load balancer bill = $16.43 a month plus $0.008 per gigabyte. Availability is a teaching model: 1 zone is 99.5 percent, 2 zones is 99.95 percent, 3 zones is 99.99 percent. Downtime minutes a month = 100 minus availability, over 100, times 43,200 minutes. The cost hop in the budget bar is the total bill divided by $25, rounded to the nearest millisecond. Prices are the teaching prices from AWS published pricing at the time of writing. Your cloud and your region will differ. The shape will not.

Lab: run the review yourself

Do this now, in your own account and on your own machine. You will run the scorecard, prove a deep health check with curl, read the live state of the load balancer, and compute the bill. The Python parts run on this machine and their outputs are shown exactly as they ran. The cloud parts run in your own account, and their outputs are marked that way. Your IDs will differ. The shapes will not.

Step 0: run the scorecard on your own machine

Save this file as scorecard.py. It asks six questions about your design and grades each pillar pass or fail. The inputs below describe the design as built in Lessons 111 and 112. Run it and check the total.

"""Pillar scorecard for the Lesson 111/173 design.

No cloud account is used. You answer six questions about your own
design, and the script scores each pillar pass or fail. The inputs
below describe the design as built in Lessons 111 and 112: an external
ALB, an internal ALB, a deep health check, two AZs, a Transit Gateway
hub, a Multi-AZ database, and a monthly bill of $207.60.
"""


def score(name, checks):
    passed = sum(1 for _, ok in checks if ok)
    print(f"{name}: {passed} of {len(checks)}")
    for label, ok in checks:
        print(f"  [{'PASS' if ok else 'FAIL'}] {label}")
    return passed, len(checks)


design = {
    "azs": 2,
    "deep_health_check": True,
    "internal_alb_private": True,
    "db_multi_az": True,
    "monthly_cost": 207.60,
    "monthly_budget": 250.00,
    "idle_instances": 0,
    "deploys_per_week": 3,
    "runbook_written": True,
}

total_pass = 0
total_checks = 0

for name, checks in [
    ("Operational excellence", [
        ("deploys run from a script, not from memory", design["deploys_per_week"] >= 1),
        ("the runbook for a dead target is written down", design["runbook_written"]),
    ]),
    ("Security", [
        ("the internal ALB has no public IP", design["internal_alb_private"]),
        ("the database security group allows only the app VPC", True),
    ]),
    ("Reliability", [
        ("the app runs in 2 availability zones", design["azs"] >= 2),
        ("the health check asks the database, not just the web server", design["deep_health_check"]),
        ("the database is Multi-AZ", design["db_multi_az"]),
    ]),
    ("Performance efficiency", [
        ("the ALB spreads load instead of one server taking it all", True),
        ("instances are right-sized, not 3x the load", design["idle_instances"] == 0),
    ]),
    ("Cost optimization", [
        ("the monthly bill is inside the $250 budget", design["monthly_cost"] <= design["monthly_budget"]),
        ("no idle instance is running", design["idle_instances"] == 0),
    ]),
    ("Sustainability", [
        ("no idle instance burns power for nothing", design["idle_instances"] == 0),
        ("the smallest instance that holds the load is the one running", design["idle_instances"] == 0),
    ]),
]:
    p, n = score(name, checks)
    total_pass += p
    total_checks += n

print(f"Total: {total_pass} of {total_checks} checks pass")
python3 scorecard.py

Expected output, exactly as it ran on this machine:

Operational excellence: 2 of 2
  [PASS] deploys run from a script, not from memory
  [PASS] the runbook for a dead target is written down
Security: 2 of 2
  [PASS] the internal ALB has no public IP
  [PASS] the database security group allows only the app VPC
Reliability: 3 of 3
  [PASS] the app runs in 2 availability zones
  [PASS] the health check asks the database, not just the web server
  [PASS] the database is Multi-AZ
Performance efficiency: 2 of 2
  [PASS] the ALB spreads load instead of one server taking it all
  [PASS] instances are right-sized, not 3x the load
Cost optimization: 2 of 2
  [PASS] the monthly bill is inside the $250 budget
  [PASS] no idle instance is running
Sustainability: 2 of 2
  [PASS] no idle instance burns power for nothing
  [PASS] the smallest instance that holds the load is the one running
Total: 13 of 13 checks pass

Now break it on purpose. Change deep_health_check to False and run it again. Reliability drops to 2 of 3, and the total drops to 12 of 13. One line changed, one pillar failed. That is how a review catches a shallow check. Change it back when you are done.

Step 1: prove a deep health check with curl

Save this file as healthz.py. It is a small web server using only the Python standard library. It answers /healthz with 200 when the database is up and 503 when it is down. The database here is an environment variable. On a real target it is a real database query. The shape is the same.

"""Deep health check endpoint. Standard library only.

Run it, then curl it twice: once with the database up, once with it
down. The load balancer only trusts the first answer.
"""
import json
import os
from http.server import BaseHTTPRequestHandler, HTTPServer


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/healthz":
            self.send_response(404)
            self.end_headers()
            return
        db_ok = os.environ.get("DB_OK", "1") == "1"
        body = json.dumps({"status": "ok" if db_ok else "fail",
                           "db": "ok" if db_ok else "down"}).encode()
        self.send_response(200 if db_ok else 503)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, *args):
        pass


if __name__ == "__main__":
    HTTPServer(("127.0.0.1", 8765), Handler).serve_forever()

Run it with the database up, in one terminal:

DB_OK=1 python3 healthz.py

In a second terminal, curl it:

curl -s -w "\nHTTP %{http_code}\n" http://127.0.0.1:8765/healthz

Expected output, exactly as it ran on this machine:

{"status": "ok", "db": "ok"}
HTTP 200

Now stop the server and run it with the database down:

DB_OK=0 python3 healthz.py
curl -s -w "\nHTTP %{http_code}\n" http://127.0.0.1:8765/healthz

Expected output, exactly as it ran on this machine:

{"status": "fail", "db": "down"}
HTTP 503

The load balancer reads the status code, not the body. 200 keeps the target in rotation. 503 takes it out. A check on the root path would have answered 200 in both cases, and the dead target would have kept receiving traffic. That is the difference between a deep check and a decoration.

Step 2: read the live state in your own account

These commands run in your own AWS account. They only read. They create nothing. Replace the IDs with your own from Lessons 111 and 112. The flags were checked against the AWS CLI documentation while writing this lesson. The outputs below are samples from a reader's cloud account, with IDs changed. Your IDs will differ.

Check the target group health. Every target must say healthy.

aws elbv2 describe-target-health --target-group-arn arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/app-tg/abc123def4567890

Expected output, from your own account:

{
  "TargetHealthDescriptions": [
    {
      "Target": { "Id": "i-0aaa1111bbb2222cc", "Port": 80 },
      "TargetHealth": { "State": "healthy" }
    },
    {
      "Target": { "Id": "i-0ddd3333eee4444ff", "Port": 80 },
      "TargetHealth": { "State": "healthy" }
    }
  ]
}

Check the internal ALB has no public address. The scheme must say internal.

aws elbv2 describe-load-balancers --load-balancer-arns arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/internal-alb/abc123def4567890

Expected output, from your own account:

{
  "LoadBalancers": [
    {
      "LoadBalancerName": "internal-alb",
      "Scheme": "internal",
      "State": { "Code": "active" },
      "Type": "application"
    }
  ]
}

Check the database security group. The only inbound rule on the database port must come from the app VPC.

aws ec2 describe-security-groups --group-ids sg-0aaa1111bbb2222cc

Read the IpPermissions list. The source must be 10.1.0.0/16 or the app security group. A source of 0.0.0.0/0 on port 5432 is a finding, not a fix.

Step 3: compute the bill by hand

Run the same arithmetic the simulator uses, on your own machine. Change the numbers to your own design and read the total.

python3 -c "azs=2; inst=4; hourly=0.0416; gb=500; print('compute \$%.2f' % (inst*hourly*730)); print('nat \$%.2f' % (azs*32.85)); print('alb \$%.2f' % (16.43+gb*0.008)); print('total \$%.2f' % (inst*hourly*730 + azs*32.85 + 16.43+gb*0.008))"

Expected output, exactly as it ran on this machine:

compute $121.47
nat $65.70
alb $20.43
total $207.60

That total is the same $207.60 the simulator shows at its defaults. Two different paths, one number. When two paths agree, the number is worth trusting.

Check yourself

Point the target group health check at / instead of /healthz and run the curl test again with DB_OK=0. The endpoint answers 404 on the root path, and the load balancer reads 404 as unhealthy, so the target still comes out. That is luck, not design. Now point the check at a path that always answers 200 and watch a dead target stay in rotation. A check you cannot break on purpose is a check you do not understand yet.

Clean up

Stop the healthz.py server. Delete nothing in the cloud. This lab only read from your account, so there is nothing to destroy. The scorecard and the health check live on your machine, and you can run them again on the next design.

Check yourself

Three questions. No score is saved anywhere. This is just you against the material.

Basic to master

Running a Well-Architected review is not one skill. It is four levels of the same job, and every team I have worked with sits on one of them. The levels are not about how many pillars you can name. They are about whether the review changes what gets built. Read them in order. Each level fixes the failure that hurt the most at the level below it.

Basic · One pillar, checked by hand

At the basic level, you pick one pillar and check it against the running system. Reliability is the best first pick, because it fails the loudest. You run the health check test from the lab and you read the bill. You write the two answers down. The failure that ends this level is the second pillar. One checked pillar feels like a review. It is not. It is a start.

Types:

  • Operational excellence: running and improving the system.
  • Security: protecting data, systems, and access.
  • Reliability: recovering from failure and meeting demand.
  • Performance efficiency, cost optimisation, and sustainability.

Uses: A structured way to ask "what could go wrong, and what does it cost?" about a design before and after it ships.

Scale and failure: Checking one pillar finds the loudest problems; the quiet ones, like an over-provisioned fleet or a missing restore test, only show up when every pillar is checked. The failure at this level is treating one checked pillar as a review.

Trade-off: The pillars pull against each other: more reliability usually costs more money and energy. A review that improves every pillar at once has probably not looked closely.

Do this: run step 1 of the lab. Curl /healthz with the database up and with it down. Write down the two status codes. Then run step 3 and write down the monthly total. Two numbers, two pillars, one page.

Try it: Basic

I pick one pillar to check first against the running system. Which one, and why?

Now do it: Run step 1 of the lab above. Curl /healthz with the database up and with it down, write down the two status codes, then run step 3 and write down the monthly total.

Intermediate · The scorecard, run on a schedule

At the intermediate level, the review is a script and a date. You run scorecard.py against your design every month, and the score is written down where the team can see it. A pillar that drops from pass to fail gets a ticket the same week. The cost check reads the real bill, not the estimate. The security check reads the real security groups, not the diagram.

Types:

  • Scorecards: one line per check, pass or fail, with the evidence.
  • Scheduled reviews, monthly or per release.
  • Real inputs: the actual bill and the actual security groups, not the diagram.
  • Tickets created automatically for checks that move from pass to fail.

Uses: Keeping a design honest as it changes, so drift is found in a review rather than in an incident.

Scale and failure: Manual reviews of a few systems a year cannot keep up with hundreds of changes a week; automated checks against live configuration can. The failure is a scorecard that reads the design document, which is always correct and often out of date.

Trade-off: Frequent automated reviews catch drift early and need maintained checks; occasional deep reviews catch design problems that automated checks cannot see. Most teams need both.

Do this: run the scorecard, then change one input to match your own design and run it again. Set the AZ count to 1 and watch reliability fail. Set the idle instances to 2 and watch cost and sustainability fail together. Put the date on the run. A review with no date is a review nobody did.

Try it: Intermediate

I set the AZ count to 1 in the scorecard and run it again. What fails?

Now do it: Run the scorecard above, set the AZ count to 1 and watch reliability fail, then set the idle instances to 2 and watch cost and sustainability fail together. Put the date on the run.

Advanced · Trade-offs, written down per environment

At the advanced level, every trade-off is written down, and it is written down per environment. Development trades reliability for cost and sustainability: one zone, small instances, the fleet sleeps at night. Production trades cost for reliability: two zones, Multi-AZ database, the bill is higher on purpose. The same design never gets one review. It gets one review per environment, because the priorities are different.

Types:

  • Per-environment priorities: development trades reliability for cost, production the reverse.
  • Explicit trade-off records: which pillar was given up for which.
  • Lenses for specific workloads, such as serverless or machine learning.
  • Risk acceptance with an owner and an expiry date.

Uses: Mature teams where "best practice" in every pillar is too expensive, and the real question is which risks to accept, where, and for how long.

Scale and failure: A single review standard applied to every environment either makes development too expensive or production too fragile. Accepted risks without expiry dates accumulate until nobody remembers why they were accepted.

Trade-off: Writing trade-offs down is slower than deciding in a meeting, and it means the next team can tell a deliberate risk from an oversight.

Do this: write the trade-off table for your own design, one row per environment. For each row, name the pillar you are giving up and the pillar you are buying. If a row has no trade-off in it, you have not looked hard enough. Every design trades something.

Try it: Advanced

Development runs one zone with small instances and the fleet sleeps at night. What is development trading away?

Now do it: Write the trade-off table for your own design, one row per environment, and name the pillar you are giving up and the pillar you are buying in each row.

Master · The review in CI, the budget as code

At the master level, the review runs itself. The scorecard runs in CI on every infrastructure change. A security group that opens the database to the world fails the build. A bill that crosses the budget fails the build. The budget is code, the pillars are tests, and the review is a gate, not a meeting. The team still holds a review every quarter. The review reads the gate history. It does not start from zero.

Types:

  • Policy as code: rules such as "no database open to 0.0.0.0/0" enforced in CI.
  • Cost budgets as code, failing changes that exceed them.
  • Continuous review: findings from every change, aggregated per team.
  • Quarterly reviews that start from the gate history rather than from scratch.

Uses: Organisations with many teams and accounts, where a central architecture team cannot review every change by hand.

Scale and failure: At scale the review becomes a set of automated controls plus a small number of human reviews for novel designs. The failure is a gate nobody understands, which teams learn to bypass; every rule needs an owner and a reason.

Trade-off: Gates make the important rules impossible to forget and can block legitimate exceptions. A documented exception process keeps the gate respected.

Do this: write one test for one rule. Assert the internal ALB scheme is internal. Assert the database security group has no rule with source 0.0.0.0/0. Run it in CI. A pillar that is only a document will drift. A pillar that is a test will hold.

Try it: Master

A security group opens the database to the world. What should happen?

Now do it: Write one test for one rule from the tier above. Assert the internal ALB scheme is internal and the database security group has no rule with source 0.0.0.0/0, and run it in CI.

Go deeper

The trade-off table, in full

Every pillar trades against another, and the trade is the design decision. Reliability trades against cost. Two zones double the compute bill. A Multi-AZ database doubles the database bill. That is the price, and you pay it on purpose in production. Performance trades against cost too. A larger instance answers faster and costs more per hour. The right size is the smallest one that holds the load with room for a spike. Security trades against speed. Every check adds a hop. TLS ends at the balancer, the security group reads every packet, the WAF reads the request. Each one costs milliseconds. You pay them because the alternative is an open door.

Two pillars usually point the same way. Cost and sustainability both want the fleet right-sized. An idle instance wastes money and power at the same time. Cutting it helps both pillars at once. That is the cheapest win in this lesson. It is also the most common one to miss, because nobody gets paged for an idle instance.

Security and operational excellence are not traded

AWS says this plainly in its framework definitions, and it is worth quoting in plain words: security and operational excellence are generally not traded off against the other pillars. You do not trade away the locked door to save money. You do not trade away the runbook to ship faster. The other four pillars trade against each other all day. These two do not. When a review asks you to cut a security control to meet a budget, the answer is no, and the budget is the thing that moves.

The naming difference is real, and it matters

The three clouds do not list the pillars the same way, and the difference has bitten teams that copy a review checklist from one cloud to another. AWS names six pillars, with sustainability as the sixth. Google Cloud names six too, with sustainability as the sixth, on the current Well-Architected Framework page. Azure names five, and sustainability is handled in separate Azure guidance, not as a pillar. Google's older Architecture Framework listed system design as one of its six pillars instead of sustainability. That older list is still quoted in blog posts and third-party guides. I checked the current pages on November 21, 2026. The current Google page lists sustainability. If your checklist has system design where sustainability should be, your checklist is out of date.

What changes at 10x and 100x

At 10x the traffic, the trade-offs get sharper. The load balancer bill grows with gigabytes, so the $0.008 per gigabyte line starts to matter. The NAT Gateway data processing grows with it, and the fix is a VPC endpoint for the traffic that never needed the internet. At 10x the fleet, the review stops being a script you run by hand and becomes a gate in CI, because no one person can hold a hundred instances in their head. At 100x, the pillars stop being a review and become a team. Cost gets a person. Reliability gets a person. The framework does not change. The number of people reading it does.

Further reading

AWS Well-Architected Framework, Definitions. The pillar table and the trade-off paragraph are the two parts to read. Azure Well-Architected Framework, What is the Well-Architected Framework. The five pillars are named in the first section. Google Cloud Well-Architected Framework. The pillar list, including sustainability as the sixth pillar, is on the first page. All three pages were checked on November 21, 2026.

One time it broke

What broke

A design passed its review on paper. Every pillar had a tick next to it. The load balancer had a health check. The app ran in two zones. The database was Multi-AZ. The bill was inside budget. Then a deploy broke the database connection on one target. The web server on that target kept answering 200. The health check asked the web server root path, so it kept passing. The balancer kept sending one request in four to a target that could not serve it. One request in four failed for a day before anyone looked at the target list.

Timeline

  • 09:00Deploy ships. One target loses its database connection.
  • 09:05Users report errors. One in four requests fails.
  • 09:20The dashboard shows all targets healthy. The health check passes. I blame the database.
  • 10:15The database is fine. I blame the deploy, then the network.
  • 11:40I open the target group. All four targets are in service. I open the health check. It asks the root path.
  • 11:45I curl the root path on the sick target. It answers 200. I curl the database from that target. It refuses.
  • 12:00The health check is pointed at a deep endpoint. The sick target leaves rotation. The errors stop.

What changed after

Two things. First, the health check rule. A check must ask the thing the target depends on. A web server check that never touches the database is a check that cannot see the failure that matters. Second, the review rule. A review that reads the diagram passes. A review that reads the running system catches it. The review now asks for the health check path and the curl output, not the architecture slide. The diagram still exists. It is no longer the evidence.

If you remember nothing else

Design exercise

Judge this design. A team runs an ordering app on one load balancer in one availability zone, with 8 large instances. The health check asks the root path. The database runs on one instance with no standby. The database security group allows the app VPC and one office IP. The monthly bill is $1,100 against a $400 budget. The team says the app never fails and the review can wait. Run the six-pillar review. Name every failure, name the trade-off behind each one, and say what you fix first.

Clarifying questions to ask

  • What happens when the one zone goes down? Who gets paged, and what do they do?
  • What does the health check actually ask? Has anyone curled it on a target whose database is down?
  • Why 8 large instances? What is the load per instance at peak, and what is it at 3 AM?
  • What is the $1,100 made of? Which line on the bill is the biggest, and what does it buy?

Worked approach

Score it first. Operational excellence fails. There is no runbook and no deploy script mentioned, only a team that says the app never fails. Security passes, barely. The database allows the app VPC and one office IP, which is a reasonable rule, but the single database instance is one failure away from losing the data. Reliability fails twice. One zone and one database instance. One failure takes the whole app down. Performance efficiency fails. Eight large instances for a load nobody measured is a guess, not a size. Cost fails. $1,100 against a $400 budget is nearly three times over. Sustainability fails with it. Eight large instances at 3 AM burn power for nothing. That is 1 of 6, and the one pass is shaky.

Then the money. Eight large instances cost 8 times $0.0832 times 730 hours, which is $485.89 a month. The rest of the $1,100 is the load balancer, the NAT Gateway, and the database. The fleet is the biggest line and the easiest cut. Four medium instances hold the same load for $121.47 a month if the load is what the team claims. That one change saves $364.42 a month. The budget is $400. The fleet cut alone does not get there, but it is the first step, and it is the step that also fixes sustainability.

Then the failures. Fix the database first, not the bill. A second zone and a Multi-AZ database cost money, and they are the fix that keeps the app up. The bill goes up before it comes down. That is the reliability versus cost trade, and it is the trade the team has been refusing to make. Then fix the health check. Point it at a deep endpoint. Then cut the fleet. Then write the runbook.

Trade-offs to name. Reliability versus cost is the big one. Two zones and a standby database raise the bill, and they are still worth it, because one zone going down costs more than the bill ever will. Performance versus cost is the second. Large instances are faster than the app needs, and the money is better spent on the second zone. Security versus speed does not come up here, and that is worth saying out loud. The security rule is fine. Do not break it to save money.

Saved in this browser, so the Lessons index can show your progress across the course.

Next in this series · Lesson 115
Jenkins

Lesson 60 gave you the pipeline. This lesson gives you the tool that has run more pipelines than any other. Jenkins is a controller that watches your repo, and agents that do the work. A push lands.

Go to Lesson 115 →

Or browse the full course from the Lessons index.