We have reached Chapter 33: Projects to Consolidate, one of the most valuable in Part VIII. Because there is an inescapable truth in this craft: you learn by building. You can read the whole book and understand it, but until you build something real with your own hands, the knowledge doesn't fully settle. This chapter proposes four projects, from least to most complex, that tie together everything you've learned. We start with the most accessible and perfect for beginners: a serverless blog, where you'll combine S3, CloudFront, Lambda, and DynamoDB.

Before the project, let's understand its value. Reading and understanding is necessary, but insufficient: true knowledge is consolidated by applying it. Building a real project forces you to:

Analogy: studying without building is like reading every book about how to ride a bike without ever getting on one. No matter how much you understand the theory of balance and pedaling, you won't know how to ride until you get on, wobble, maybe fall a couple of times, and finally succeed. Projects are "getting on the bike": where theoretical knowledge becomes real skill.

💡 About these projects: the idea is not to give you the exact code step by step (you'll find that in tutorials and documentation), but to show you what to build, which services to combine, and how the book's concepts fit together. The challenge of implementing it is precisely where you learn.

The first project is a serverless blog: a website where you can read articles, built without managing any servers (remember the serverless philosophy from Chapter 14). It's ideal to start with because it's simple, cheap (almost everything fits in the free tier), and combines several fundamental services in a clear way.

This project combines four services you already know, each with its role:

S3 (Chapter 5) stores the website files (HTML, CSS, images... the "static" part that doesn't change). Remember that S3 can serve a static website directly. It's your blog's "warehouse": cheap, durable, and serverless.

CloudFront (subchapter 16.2), AWS's CDN, serves the website from locations close to each visitor, making it fast globally. It also provides HTTPS (remember ACM, subchapter 16.3). You put CloudFront "in front" of S3.

Lambda (Chapter 14) runs the logic of the blog without servers: for example, a function that fetches the articles when someone requests them. It's the "dynamic" part (that does things), and runs only when needed, scaling automatically.

DynamoDB (the serverless NoSQL database we saw in Chapter 8) stores the blog articles. It's serverless (fits perfectly with the rest), fast, and self-managed.

This is how the four pieces fit together in a coherent system:

The visitor arrives via CloudFront; the website (from S3) loads quickly; when they request the articles, a Lambda fetches them from DynamoDB. All serverless: not a single server to maintain, it scales automatically, and costs very little (pay per use).

This project, despite its simplicity, makes you bring together and reinforce many key concepts:

💡 Do it with Terraform: deploy this entire project with Terraform (what you learned in Parts II-V), instead of manually through the console. This way you consolidate both AWS and infrastructure as code. It's the best possible practice: you build something real and do it professionally.

Real world example: someone who just finished the book wants to reinforce what they've learned and have something to show in interviews. They decide to build their personal blog as a serverless blog: storing their articles in DynamoDB, the logic in Lambda, the website in S3, and serving it with CloudFront, all defined in Terraform. While building it, they encounter real problems (how to connect CloudFront with S3, how to give Lambda permissions to read DynamoDB...) and by solving them truly understand how the pieces fit together, much better than just reading about it. They end up with a real, working, super cheap blog, and a portfolio project that proves they know how to build on AWS with Terraform. That "learning by doing" gives them a confidence that theory alone never could.

• You learn by building: reading and understanding is necessary but insufficient; knowledge is consolidated by applying it in real projects. Like learning to ride a bike by getting on, not just reading.
• The serverless blog is an ideal project to start with: simple, cheap (free tier), and combines fundamental services without managing servers.
• It combines four pieces: S3 (hosts the static website, Ch. 5), CloudFront (serves it fast and globally with HTTPS, Ch. 16), Lambda (dynamic logic, Ch. 14), and DynamoDB (stores the articles, Ch. 8).
• Architecture: the visitor arrives via CloudFront → website from S3 → for data, Lambda → which reads from DynamoDB. All serverless: scales automatically, costs little.
• 💡 Deploy it with Terraform (Parts II-V) to consolidate AWS and infrastructure as code at the same time, and have a portfolio project.

In the next subchapter, we'll take it up a notch with a more complete project: a REST API with containers (ECS Fargate, RDS, and ALB).