Book Review: Serverless Architectures on AWS (second edition)

At the date of writing this, the second edition (and a very different book from the first edition) of Serverless Architectures on AWS has been around for less than six months, and there are hardly any reviews about this to be found.

Therefore, this post summarizes the book parts of the book and presents what I liked and disliked about the chapter. In the end, I will give a short verdict on the book.

Let me start off by stating that I am not new to serverless, distributed systems and microservices. These are topics I have been dealing with for quite a while now and over the past six months, I have focused almost exclusively on the topic of serverless. Therefore, your experience might be very different, but I will try my best to point out whom a chapter might be (un)suited for.

A Summary in Four Parts

Serverless Architectures on AWS is divided into four major parts: “First Steps”, “Use Cases”, “Practicum” and “The Future”. The following sections will present each part and its corresponding chapters.

Part 1: First Steps

Summary
First, gives a quick introduction to and an overview of serverless. This includes a definition of the term, pros and cons and the history of serverless (which ties into SOA and FaaS).

After this, it contains a walkthrough on how to create a serverless video-encoding pipeline, which includes many screenshots of the AWS console, presented in a style very similar to online tutorials.

In the end, the chapter briefly (~1/2 page per item) presents a few use cases like Backend compute, Internet of Things, Data processing and manipulation, Real-time analytics, Legacy API Proxy, Scheduled services, Bots and skills and Hybrids.

This part concludes with a few pages about important patterns in (serverless) architectures like GraphQL (acting as a Backend for Frontend), Command pattern, Messaging pattern, Priority queue pattern, Fan-out pattern, Compute as glue, Pipes and filters pattern.

Opinion
Personally, I found the walkthrough to be too long and didn’t expect something like it in a book on Serverless Architectures. While the tutorial might be useful for somebody who has never worked with serverless technologies on AWS (and wants to follow a tutorial in a book for whatever reason), it felt too basic for an Architecture book.

I would have preferred if the book would talk in more detail about the patterns in the end. Those patterns are of course also covered in other similar books in the microservices/architecture space, but this would have been a great place to go into depth about them.

Part 2: Use Cases

Summary
The second part is about three real companies that use serverless. Each chapter introduces a company, its goals, constraints and needs. This is then followed by a discussion of how the specific company migrated to serverless (if it did), which services it uses, challenges and lessons learned.

Opinion
It’s no secret that I really enjoy real-world examples and stories about how companies use specific technologies and how their architecture evolved over time. This part was definitely one of the highlights of the book and should be interesting for any reader.

Part 3: Practicum

Summary
Practicum consists of three, somewhat distinct chapters.

The first, and longest chapter of the book, is about building a scheduling service for ad hoc tasks. Here, the authors discuss different ways of scheduling jobs in a serverless AWS environment and the pros and cons of each approach.

The strategies here are:

1. Cron job with EventBridge
2. DynamoDB TTL
3. Step Functions
4. SQS
5. DynamoDB TTL + SQS

Following chapter one, there is a presentation of serverless parallel MapReduce in the context of a (fictional) video encoding application.

The part ends with a chapter on a (semi-fictional) coding sandbox application with a few microservices.

Opinion
The first chapter went into great detail and is fascinating, as it discusses a topic where we need to push the boundaries of serverless services while discussing the approaches and their trade-offs in great depth. Task Scheduling is really something we all have to deal with, especially in event-driven architectures. Therefore, the chapter is highly relevant to most readers, while also providing the reader with general information and a mental framework about making trade-offs between different serverless service approaches.

The idea in chapter two to use serverless (especially FaaS) for parallel MapReduce was interesting, but the chapter was shorter and the use-case feels a bit exotic.

The third chapter felt a bit out of place.

Part 4: The Future

Summary
This part with the intriguing name consists of two different chapters. The first one goes (slightly) into detail about Lambda, its cold-starts, latency and performance optimization. The last chapter and the end of the book contain 4 best practices for serverless applications:

1. Using multiple AWS accounts (in contrast to one account for all services and environments)
2. Using temporary stacks (temporary environments via IaC)
3. Avoid sensitive data in plain text environment variables
4. Use EventBridge in event-driven architectures

Opinion
It felt a bit random how the first part was about Lambda specifically. The points made in this chapter were useful, yet, if someone gets into a situation where they need to know the nitty-gritty details of Lambda, they would need to do their own research anyways (and read the Lambda whitepapers).

The tips in the second part are definitely useful. However, I would consider them pretty much common knowledge in the AWS and Serverless world. But, maybe, a reader from one of the many companies out there who still don’t follow these best practices will find them here for the first time.

Verdict

Serverless Architectures on AWS was an enjoyable, short (200 pages in my print version), read for a weekend.

I enjoyed the case studies in Part 2 and the detailed discussion on Scheduled Tasks. Most of the other chapters were a bit more shallow and shorter than I expected. Maybe I wasn’t exactly the target audience for this book. Somebody with experience in distributed systems, but who wants yet to get started with serverless might enjoy this book more than I did.

While it won’t make it to my all-time top 5, I might revisit the two parts I liked at some point in the future and there might be another article from me on the fascinating Scheduled Tasks chapter.