AWS in Practice: Services, Limits, and Failure Modes

Work AWS as an engineer, not a diagram. IAM policy evaluation, instance families and pricing models, Lambda cold starts, DynamoDB capacity and key design, VPC routing, EventBridge and Kinesis, IaC, quotas and throttling, and the bill.
Level: Intermediate
Study Time: 14h
Lessons: 27
Quizzes: 459
Course Overview

Most AWS material teaches the console and the diagram. You learn that there is a box called a load balancer, a box called an auto scaling group and a box called a database, and that arrows go between them. Then you ship something, and the problems that arrive have nothing to do with boxes. A deploy fails because a role in another account cannot assume the role you thought it could. A Lambda function times out because its first request after a quiet hour paid for a cold start inside a VPC. A DynamoDB table that was provisioned for ten thousand writes a second throttles at nine hundred, because every write went to the same partition key. A NAT gateway shows up as the third largest line on the bill. This course is about those problems, taught as engineering with real quotas, real pricing units and real failure modes.

It opens with the account, because the account is the unit AWS actually isolates. Blast radius, service quotas, billing and the permission boundary all stop at the account edge, which is why serious organisations run dozens or hundreds of them under AWS Organizations and constrain them with service control policies. The IAM lesson works through policy evaluation in the order AWS performs it, from explicit deny through organisation guardrails, resource policies, permission boundaries and session policies, so that you can predict an access decision rather than discover it. Roles and STS follow, because nothing in a well run account should hold a long lived key. Regions and availability zones close the section, treated as failure domains with independent power and networking rather than as dropdown menus.

Compute is taught as a set of trade offs with prices attached. Instance families are read from their names, and the difference between on demand, savings plans, reserved capacity and spot is worked out as arithmetic on a real fleet. Auto scaling groups are treated as control loops with warm up, cooldown and health check grace periods that decide whether a scale out arrives in time. Lambda gets its execution model in full: the execution environment, the init phase, concurrency as a quota, provisioned concurrency, and why a function that is fast in testing is slow on Monday morning. The section closes by comparing ECS, EKS and Fargate on what you operate, what you pay and what fails.

Storage covers S3 storage classes and lifecycle rules with the minimum durations and retrieval fees that make the cheap classes expensive when misused, EBS volume types with their IOPS and throughput limits and the burst bucket that empties at the worst time, and EFS as a shared filesystem with throughput modes that surprise people. The database section treats RDS and Aurora as different architectures rather than different price points, works DynamoDB key design and capacity with the partition arithmetic written out, places ElastiCache correctly as a cache rather than a database, and ends with a lesson on choosing among them from access patterns.

Networking is where most production AWS confusion lives, so it gets its own section. VPCs, subnets and route tables are taught as longest prefix match on a table you wrote, with the internet gateway, NAT gateway and endpoints as targets that have very different costs. Application and network load balancers are compared on what they terminate, what they preserve and how they fail. PrivateLink, peering and Transit Gateway are compared on topology, transitivity and the per gigabyte charges that decide which one you can afford.

Integration covers SQS, SNS and EventBridge as three different contracts rather than three ways to send a message, Kinesis and managed Kafka on shards, partitions and the throughput each one sells, and Step Functions as orchestration with the cost model of standard and express workflows. Delivery and visibility covers CloudFormation, CDK and Terraform on state and drift, deployment strategies using CodeDeploy, weighted target groups and Lambda aliases, and CloudWatch and X-Ray with the metric resolution, log ingestion pricing and trace sampling that decide what you can see.

The final section is the one most courses leave out. Service quotas and throttling explain why a healthy system starts returning errors at a round number, and how retries with exponential backoff and jitter keep a throttle from becoming an outage. The cost lesson reads a real shaped bill line by line, from data transfer and NAT processing to idle volumes and forgotten snapshots. The course ends with multi region architecture and disaster recovery, from backup and restore through pilot light and warm standby to active active, with the recovery time and recovery point each one actually buys. By the end you will be able to predict an IAM decision, size a DynamoDB table, trace a packet through a VPC, explain a throttle, and defend a line on the bill.

AWS in Practice: Services, Limits, and Failure Modes
Enroll Now

Get instant access to all current and upcoming courses by subscribing.