Boot.dev AWS DevOps Course: A Hands-On Cloud Guide

There's a specific kind of developer frustration that Boot.dev's new AWS course opens with, and it lands because it's real: you have a web app, it works, and now someone is telling you that you need to understand VPCs, IAM policies, NAT gateways, and roughly forty other acronyms before you can deploy it anywhere serious. The managed hosting platforms will absorb all that complexity for you—until they won't, or until the bill arrives, or until the company you just joined has opinions about running its own infrastructure.

The course, a nearly six-hour walkthrough created by Zach Gates—a cloud infrastructure and DevOps consultant with experience across AWS, Azure, and GCP—positions itself as the answer to a different question than most AWS tutorials. Not "what does this service do?" but "what does a mid-to-large engineering org actually build, and why?"

What's Actually Being Taught

The course is structured around a fictional healthcare app called Patient Ping, a Python web server that sends appointment reminders. The conceit works. Instead of provisioning infrastructure in a vacuum, you're always asking: does this database need to be internet-facing? Should this subnet have a route to the internet gateway? The decisions feel consequential because they're grounded in a system that has to actually function.

Gates walks through eleven chapters: cloud fundamentals, VPC networking, EC2, RDS, IAM, CloudWatch monitoring, Route 53 DNS, S3 storage, CloudFront CDN, ECS with Fargate, and Lambda. That's a reasonable cross-section of the services a backend or DevOps engineer will encounter on the job.

What's notable about the pedagogy is the emphasis on the CLI alongside the console. Gates is explicit about this: clicking around in the AWS web console is fine for learning, but the command line is what separates someone who understands the platform from someone who can navigate its menus. Boot.dev's interactive CLI tool inspects actual resources in a real AWS account as you go—so there's no simulated environment, no sandboxed pretend-cloud. You're making real things, which means you can also make real mistakes and incur real, if small, costs.

The Money Question, Honestly Addressed

Most AWS learning content either ignores cost or hand-waves it. This course does neither. Gates is upfront that the whole thing should run under $10 if you move at a reasonable pace, and the AWS free tier covers most of it for eligible accounts.

But the more interesting move is the cost-consciousness woven into the lessons themselves. NAT gateways—the service that lets private subnet resources reach the internet without being exposed to it—get called out explicitly as a billing landmine: "You can spend a ton of money, right? One, because the NAT itself costs money every hour regardless of whether you're using it or not." Gates says he's paying for his own AWS account while recording, which gives the cost warnings a different texture than the usual boilerplate disclaimer.

The cleanup lessons aren't an afterthought. The course actively frames them as part of the skill set—knowing when to tear something down is as important as knowing how to build it. Amazon, as Gates notes, "will happily keep your load balancer alive forever if you want to keep paying for it."

The Cloud-vs-Bare-Metal Question, Left Open

One of the more intellectually honest moments in the course is when Gates invokes DHH's well-documented decision to move Hey and Basecamp off cloud hosting and onto owned hardware, saving significant money in the process. Gates doesn't dismiss it:

"Don't hear from this course and don't take into your workplace or into your world that cloud is absolutely the answer to every possible solution. It will always save you money."

This is worth sitting with. The standard AWS training materials—including Amazon's own certifications—have a structural incentive to present cloud as the default-correct answer. Gates at least puts the trade-offs on the table: vendor lock-in, the opacity of costs at scale, the genuine viability of bare metal for stable, predictable workloads.

His framing of OpEx versus CapEx ("Are you buying a candy bar or are you buying a house?") is blunt but accurate. Cloud computing makes the most economic sense when demand is unpredictable, when you need to scale fast, or when you're not sure whether the project will survive long enough to justify the hardware investment. It makes less sense for mature systems with known, stable resource requirements. The course teaches AWS; it doesn't pretend AWS is always right.

Networking: The Part Everyone Skips

The networking section—VPCs, subnets, CIDR blocks, route tables, internet gateways—is where a lot of AWS tutorials lose people, or quietly skip the hard parts. Gates spends significant time here, partly because it's foundational and partly because it's the section where most developers who've only done managed deployments have the largest gap.

The public/private subnet distinction is the clearest illustration of why this matters. Public subnets have routes to an internet gateway; private subnets route outbound traffic through a NAT gateway and can't receive inbound connections from the internet directly. Databases live in the private subnet. Web servers live in the public one. Security groups control what traffic actually reaches each resource. None of this is conceptually complicated, but the number of times credentials get committed to git repos or databases get accidentally exposed suggests that developers are regularly deploying without having actually built this mental model.

Gates makes the default VPC point a recurring theme: delete it, don't use it, do your work on purpose. The sentiment is about cultivating intentionality with infrastructure decisions—the kind that distinguishes an engineer who understands what they're deploying from one who accepts defaults until something breaks.

On the Format and Its Trade-Offs

The course is both a free YouTube video and part of Boot.dev's paid interactive platform—the content is the same, but the paid membership gets you Boot.dev's CLI-based assignment checking, progress tracking, and a certificate of completion. That's a reasonable split, and Gates is transparent about it. Boot.dev notes the course took over a year of collective work across roughly six people, which is worth acknowledging when evaluating what "free" means here.

The walkthrough format—Gates working through the platform in real time, hitting the same snags learners will hit—has a particular honesty to it. There are credentials that expire mid-session, subnet assignments that need to be redone, moments where Gates pauses to re-read the instructions. It's not polished tutorial theater. Whether that's a feature or a bug depends entirely on whether you learn better from watching someone solve problems or from watching someone explain problems they've already solved.

"Cloud infrastructure only starts making sense once you've actually connected all the pieces and sometimes even broken a few of them."

That's the Boot.dev intro narration, but Gates earns it by modeling exactly that—debugging in real time, acknowledging mistakes, moving on without performing distress about it.

The Transferability Argument

Gates makes a point that often gets buried in platform-specific training: the concepts are portable. He works across AWS, Azure, and GCP professionally, and the mental models he built on AWS—networking primitives, identity and permission systems, the difference between managed and unmanaged services—translated. AWS is the starting point because it's the most common in job listings, not because the concepts are AWS-exclusive.

This is a reasonable argument for the course's chosen scope, and it's also a useful frame for thinking about what cloud certifications actually certify. An AWS certification tells an employer you've learned AWS. Whether you've learned to think about infrastructure—to understand why a private subnet exists, not just how to create one—is a different question, and it's the one this course seems more interested in.

The IAM section, covering users, groups, roles, policies, and the SSM Parameter Store for configuration management, gets at this directly. The lesson on why you don't commit API keys to a git repo isn't really about AWS—it's about understanding what credentials represent and why their exposure surface should be minimal by design.

By the time the course reaches ECS with Fargate and Lambda, you're not just deploying containers and serverless functions. You're placing them into the network stack you built from scratch, behind the IAM roles you configured, observable through the CloudWatch dashboards you wired up. Whether that architecture makes sense is a judgment call that depends on your actual requirements—which is, quietly, the thing the course is trying to teach you to make.