The version I memorized vs. the version I needed
Before building anything real, my understanding of the Shared Responsibility Model was basically: "AWS handles the hardware, I handle my code." True, but useless in the moment something actually breaks — it doesn't tell you which side of the line a specific problem sits on.
Building a VPC with an Application Load Balancer and an Auto Scaling group across two Availability Zones forced me to get specific about it, because when something didn't work, I had to know where to even start looking.
What was never going to be my problem
AWS guarantees the existence and independence of the Availability Zones themselves — the physical facilities, power, cooling, and the network backbone connecting them. I didn't provision any of that, can't see it, and importantly, can't misconfigure it. If an entire AZ has a genuine outage, that's inside AWS's side of the line, and no setting in my account would have prevented or caused it.
This mattered practically: early on, when a health check started failing, I briefly wondered if it was an AWS-side networking issue. It wasn't, and it almost never is. Ruling that out quickly meant looking at my own configuration first — which turned out to be exactly right.
What was absolutely my problem
Everything that actually went wrong while building this lived entirely on my side of the line:
- Whether I was actually spanning two Availability Zones, or only thought I was. Multi-AZ isn't automatic — it depends on which subnets I attached to the Auto Scaling group. Getting this wrong doesn't throw an error; it just quietly defeats the entire point of the architecture.
- Security group rules controlling what could reach my EC2 instances. AWS provides the mechanism; every rule inside it was a decision I had to make and could get wrong.
- The IAM role attached to my Auto Scaling launch template. If instances launch without the right permissions, that's not a platform failure — that's a role I configured incorrectly.
- Whether my route tables correctly classified subnets as public or private. This is pure configuration, entirely on my side, and it's exactly the kind of mistake that looks like a "networking problem" but is actually just a "my problem" problem.
The realization that made it click
The Shared Responsibility Model isn't really about AWS vs. you as two teams working on separate parts of the same system. It's closer to: AWS guarantees the primitives are real and available; you guarantee you're using them correctly. AWS guarantees two independent Availability Zones exist. It does not guarantee that your Auto Scaling group is actually configured to use both of them — that's a decision, and decisions are always your responsibility.
Once I started treating every debugging session with that question — "is this a primitive that AWS guarantees, or a decision I made?" — I stopped wasting time looking in the wrong place. Almost everything that goes wrong in an early AWS project is a decision, not a platform failure.
What I'd tell someone learning this for the first time
Don't try to memorize the line — build something that forces you to find it. A single-AZ static site won't teach you this, because there's barely a line to find. A multi-AZ deployment will, because half your bugs will be "which side is this even on" before they're "how do I fix this."
Loading article