🦀 New book release: 100+ pages on event-driven architectures + full-revamp!

Hello again, awesome Rustaceans of the Lambda realm! 🦀

We’re back with a shiny new release, and this one is a big one.

Also, it’s that time of the year when calendars get chaotic, mugs get larger, and “I’ll read that later” turns into “actually, tonight by the fireplace sounds perfect”. If you are carving out a bit of quiet time during the holiday season, we hope this release makes for a cozy and satisfying read. Bonus points if you pair it with a warm drink and some festive background music.

TLDR; for the busy ones:

• Chapter 8 is out: Event-driven systems with Rust and Lambda (SQS, EventBridge, Kinesis, and friends).

• It’s hefty: we would not be surprised if it lands close to 100 dense, practical pages, filled with tons of code samples and figures!

• Full revamp: we peer-reviewed and polished the entire book. Fewer typos, more consistency, clearer code, and more production guidance.

Alright, do you want the full details? Let’s jump in!

Chapter 8 is here! Event-driven systems with Rust and Lambda ⚡️

This chapter is dedicated to one of the most useful shifts you can make when building real systems. Moving from “do everything synchronously in one request” to event-driven flows that scale, recover, and evolve more gracefully.

We start from the philosophy of event-driven systems. Why you might want them, and what trade-offs you are really making. No hand-waving, no “just add a queue” fairy tales.

Then we map out the AWS eventing toolbox: SQS, EventBridge, Kinesis Data Streams, and a few related building blocks. We add a bit of taxonomy first, so when we write code we are not just randomly throwing services at the problem.

After that, we dive into three concrete pillars:

SQS
Reliable queues, worker patterns, and backpressure.

EventBridge
Pub/sub and integrating multiple services in a loosely coupled way.

Kinesis Data Streams
Ordered, high-throughput event streams.

And of course, we do all of this in Rust with real Lambda functions you can actually learn from.

Along the way, we upgrade our URL shortener so it behaves like a grown-up system:

• No more doing everything synchronously in the request path

• Offloading crawling, click tracking, and other “nice but not urgent” work to asynchronous flows

• Making the code more extensible, so it is easy to add new functionality later without big breaking changes

We’ll be honest. This chapter turned into a bit of a monster, hopefully in the best way. The goal is not 100+ pages of fluff. The goal is 100+ pages of dense, practical material, plus diagrams that make the concepts click.

We hope you’ll enjoy it and that it will pay off for the long wait since the latest release!

Other improvements across the book 💅

This release is not just Chapter 8. We also did a serious pass across the entire manuscript.

We peer-reviewed every existing chapter, fixed tons of typos, and made the language more consistent. Yes, we settled on British English, of course (Luciano suggested Italenglish at some point, but James didn’t take him too seriously… 😛). We also made verb tenses, pronouns, and general phrasing more consistent. The reading experience should feel smoother end to end.

On the code side, we simplified quite a few Rust snippets. We added more notes, deep dives, and security or production warnings. The book should now do a better job at taking you from a silly little demo all the way to something you can confidently ship.

Finally, we fixed code references and other small linking issues between the book and the repository, so it is easier to follow along without tripping over mismatches.

📦 How to get the new release

If you already have a copy of Crafting Lambda Functions in Rust, grabbing the latest release is easy!

1. Head over to Gumroad, log in, and open up your product library.

2. You’ll see a list of all your purchased products. Look for “Crafting Lambda Functions in Rust (e-book)”.

3. Click on it, and voilà! You’ll find all the updated download links right there.

If you have the Gumroad mobile app the process should be similar!

All updated code examples are also available in our code repository, so you can dive into the latest examples straight away.

If you hit any snags along the way, reach out, we’re here to help!

🔮 What’s next: Chapter 9 (Observability) 👀

We already have a first draft of Chapter 9, fully focused on the art (and sometimes pain 🥲) of observability.

It is an ever-evolving topic. It also took us a lot of research. We think we finally have solid material that covers the basics and gives you realistic options for production needs, but we need a bit more time to complete it, polish it and review it internally before it’s ready for your consumption!

Here’s a peek at what’s coming:

• Why you need to care about observability

• What observability is (spoiler: you do not just need logs)

• The challenges of observing serverless and event-driven systems

• OpenTelemetry and the power of standardisation, including semantic conventions

• Implementing OpenTelemetry in Rust

• Why traditional approaches often fall short in serverless

• Observability on your local machine

• Dealing with PII data

• Opinionated guidance on your serverless observability strategy

As with every other chapter, you will do this in the context of our URL shortener application. That includes both the synchronous and the asynchronous components. While it is not getting as monstrous as Chapter 8, it is still coming in pretty big.

We do not expect it will take too long to have it released, so watch this space.

🫶 We need your help

This book is a project of love that we build off-hours, so any help you can give is golden.

If you want to contribute, here are a few high-impact ways:

Tell us what works and what does not.
If you spot typos, confusing sections, or places where you think “this could be explained better,” please tell us.

Show us your Rust and Lambda creations.
If you are building something with Rust on Lambda, we would love to see it. Share your projects in our Discord community or reply with a short description and links. With your permission, we might feature some of them as examples or case studies.

Join the conversation on Discord.
That is where we bounce ideas, discuss patterns, and occasionally rant about tooling. If you are not there yet, this is your invitation to join, say hi, and tell us what you would like to see more of in the book.

Thank you again for reading, for experimenting with Rust on Lambda, and for keeping us accountable and motivated to make this book the most practical guide we can.

We hope this release keeps you good company during the festive season, maybe in a quiet evening, next to a fireplace, or just under a warm blanket while the world outside gets noisy.

Happy holidays, happy festivities, and see you in the new year! 🎄✨🦀

— Luciano & James