🦀 Hello again, awesome Rustaceans of the Lambda realm

Hello, friend!

It has been a while. Our last update went out in May, which means things have been quiet here for a little over three months. You deserve an honest update on where we are, what is coming next, and a warm reassurance that the project is very much alive.

A quick personal note from Luciano

First, accountability. I, Luciano, have been the main blocker lately. James shipped an epic chapter on configuration for Lambda functions. If you have not read it yet, please do. It is packed with practical patterns for separating config from code, handling secrets safely, and keeping deployments clean.

My turn was next. The following chapter is about asynchronous processing with Lambda and Rust, and most of the heavy lifting for that chapter has been on my plate these past months.

This book is a side venture for both of us. We each have full-time jobs, and we carve out personal time to keep the book moving. Over the summer I juggled a few extra commitments and some personal life events. All good news, just time consuming. The good part is that several of those commitments are wrapping up in the next couple of weeks, which means I can free up proper focus time and push this chapter forward. I am genuinely excited to dive back in.

Thank you for your patience and for sticking with us! 💕 

What is coming next (tiny spoiler)

Our URL shortener works, but some parts are still synchronous and not ideal at scale.

• When a new short link is created, the source URL is crawled synchronously.

• When a short link is clicked, the click counter is updated synchronously.

The next chapter tackles both. We will move toward an event driven design and show a couple of ways to process these tasks asynchronously. The plan is to explore patterns and tradeoffs so you can mix and match approaches in real projects:

• Queue or bus: SQS vs EventBridge and when each shines

• Idempotency, retries, and backoff so work is safe and repeatable

• Fan out and back pressure with workers that scale

• Cost and latency profiles so you do not pay for idle time

• How these choices look in Rust with real code you can run

If building efficient, scalable, and cost conscious serverless apps sounds fun, you will like this chapter.

Of course, if you have any suggestion on what else we should cover, we are all ears 👂️👂️!

How you can help

This book is ours and yours. Your feedback has already made a big difference.

• Keep the suggestions coming. Report typos, unclear bits, and anything that could be sharper.

• If you have been working on a Rusty Lambda project, please share it with us and in the Discord community. We would love to feature more community work, talk about what is cool in your approach, and spread the lessons.

Just hit reply or drop a note in Discord.

One more way to help: we need your take on observability!

One of the upcoming chapters will be on observability for Lambda functions written in Rust. This topic is still under-explored, and your input will help shape the direction.

• What do you use for logs, metrics, and traces in Lambda today?

• CloudWatch only or an external vendor as well?

• Any OpenTelemetry in the mix or not yet?

• Do you prefer a minimal setup or do you aim for full coverage?

• Any rough edges you hit when instrumenting Rust in Lambda?

Send us an email or share your thoughts in the Discord community. Every data point helps.

What to expect next

The short version: I should regain solid focus time in the next couple of weeks and push the async chapter over the line. Please bear with us a little longer while we get this into your hands.

Thank you for your patience, your enthusiasm, and the steady stream of ideas. You keep us motivated to make this the most practical guide to building Lambda functions in Rust.

Onward and upward,
Luciano and James

P.S. If you found the configuration chapter useful, tell us what clicked for you. Those notes help us decide where to double down in future chapters.