Best Books on Serverless Computing, in Order
This curriculum builds a rigorous, end-to-end mastery of serverless computing across four progressive stages. Starting from the architectural principles and event-driven patterns, it moves through operational realities like cold starts and cost, then into serverless data strategies, and finally to advanced trade-offs and production-grade design — giving the intermediate learner both the mental models and the hard-won practical wisdom needed to build and operate serverless systems confidently.
Serverless Foundations & Event-Driven Thinking
IntermediateUnderstand what serverless truly means architecturally, how functions-as-a-service work, and how event-driven design replaces traditional request/response thinking.
▸ Study plan for this stage
Pace: 6–8 weeks, ~40–50 pages/day (mix of dense architectural chapters and practical examples). Allocate 3–4 weeks to Sbarski, then 2–3 weeks to Urquhart, with 1 week for integration and review.
- Serverless as an architectural paradigm: functions as the unit of deployment, not servers or containers; pay-per-execution and automatic scaling
- AWS Lambda fundamentals: invocation models (synchronous, asynchronous, polling), execution context, cold starts, and memory/timeout tradeoffs
- Event-driven architecture: decoupling producers from consumers via events; replacing request/response chains with event streams and message brokers
- Function composition and orchestration: how to chain Lambda functions together using AWS Step Functions, SNS, SQS, and API Gateway
- Statelessness and idempotency: designing functions to be stateless, handling retries safely, and managing side effects in distributed systems
- Flow-based thinking: viewing applications as flows of data and events rather than monolithic request handlers; designing for asynchronous, non-blocking patterns
- Serverless trade-offs: cold starts, vendor lock-in, observability challenges, and when serverless is (and isn't) the right choice
- Real-world patterns: API backends, data processing pipelines, IoT event ingestion, and scheduled tasks using serverless
- What is serverless computing, and how does it differ from traditional server-based and container-based architectures in terms of operational responsibility and billing?
- Explain the difference between synchronous and asynchronous Lambda invocation models, and give an example of when you'd use each.
- How does event-driven architecture decouple application components, and what role do services like SNS, SQS, and EventBridge play in this decoupling?
- What is a cold start, why does it occur, and what strategies can you use to mitigate its impact on latency-sensitive workloads?
- Describe how you would design a multi-step workflow (e.g., image processing, order fulfillment) using Lambda and Step Functions, and explain why this is preferable to a monolithic function.
- What does it mean for a Lambda function to be idempotent, and why is this critical when designing for retries and asynchronous processing?
- Deploy a simple HTTP API using Lambda and API Gateway; test both synchronous invocation and response times under load to observe cold starts.
- Build a multi-function workflow: create three Lambda functions (e.g., validate input → process data → send notification) and orchestrate them using AWS Step Functions; test error handling and retries.
- Design and implement an event-driven data pipeline: set up an S3 bucket to trigger a Lambda function on object upload, which processes the file and publishes results to SNS for downstream consumers.
- Create an idempotent function that writes to a database; test it with duplicate events to verify it handles retries correctly without creating duplicate records.
- Implement a scheduled task using CloudWatch Events (EventBridge) to trigger a Lambda function; monitor execution and logs to understand asynchronous invocation patterns.
- Refactor a traditional request/response application (e.g., a REST API handler) into an event-driven architecture using SQS and Lambda workers; document the decoupling benefits and trade-offs.
Next up: This stage establishes the mental model and practical foundations of serverless and event-driven systems, preparing you to explore advanced patterns (resilience, security, cost optimization, and production observability) and to design complex, scalable systems that leverage serverless as a core architectural principle.
A concrete, platform-grounded introduction to serverless concepts — functions, triggers, and event flows — that gives intermediate readers a working vocabulary without assuming prior cloud-native experience.
Broadens the mental model from 'functions' to 'event streams and flows,' establishing the event-driven design thinking that underpins every serious serverless system.
Functions, Patterns & Real-World Design
IntermediateLearn canonical serverless patterns — fan-out, saga, choreography vs. orchestration — and understand how to compose functions into reliable, maintainable systems.
▸ Study plan for this stage
Pace: 6–8 weeks, ~40–50 pages/day (mix of dense pattern chapters and practical examples)
- Serverless design patterns: fan-out/fan-in, saga, choreography vs. orchestration, and circuit breaker for resilience
- Event-driven architecture and asynchronous communication as the foundation for composing serverless functions
- Saga pattern for distributed transactions across multiple functions without a central coordinator
- Choreography (event-driven) vs. orchestration (centralized control) trade-offs in serverless workflows
- Enterprise integration patterns: message routing, transformation, and correlation in function-to-function communication
- Idempotency, retry strategies, and dead-letter queues for building reliable serverless systems
- State management and long-running processes in serverless architectures
- Composing functions into maintainable, testable, loosely-coupled systems
- What is the fan-out/fan-in pattern, and when should you use it instead of sequential function invocation?
- Explain the saga pattern: how does it enable distributed transactions without a two-phase commit, and what are the compensating transaction implications?
- Compare choreography and orchestration: what are the trade-offs in terms of coupling, observability, and complexity in a serverless context?
- How do enterprise integration patterns (message routing, transformation, correlation) apply to serverless function composition?
- What strategies ensure idempotency and reliable retry behavior when functions invoke other functions asynchronously?
- Design a multi-step serverless workflow (e.g., order processing) using either choreography or orchestration; justify your choice.
- Implement a fan-out/fan-in pattern: trigger multiple parallel Lambda functions from a single event, aggregate results, and handle partial failures.
- Build a saga pattern example (e.g., booking system): define compensating transactions and implement rollback logic when a step fails.
- Refactor a sequential workflow into a choreography-based system using event streams; document the event contracts between functions.
- Implement an orchestration-based workflow using AWS Step Functions or equivalent; compare complexity and observability against the choreography version.
- Apply enterprise integration patterns: design a message transformation pipeline where functions normalize data formats and route messages based on content.
- Create an idempotent function that handles duplicate invocations gracefully; test with intentional retries and verify no side effects occur.
Next up: This stage equips you with the architectural patterns and integration principles needed to design complex, production-grade serverless systems; the next stage will deepen your ability to deploy, monitor, and optimize these patterns at scale.
Catalogs the core patterns (async processing, fan-out, event sourcing with functions) with worked examples, building directly on the vocabulary established in Stage 1.
The canonical reference for messaging and event-driven integration patterns; serverless choreography and orchestration patterns are direct descendants of these ideas, and reading this here gives them a rigorous foundation.
Serverless Data & Advanced Architecture
ExpertMaster serverless data patterns — event sourcing, CQRS, stateful workflows, and database choices — and synthesize everything into principled architectural trade-off decisions for complex systems.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (mix of dense technical content and architectural synthesis). Allocate ~5–6 weeks to Kleppmann (Parts II–III focus), then ~3–4 weeks to Richards with concurrent review and integration.
- Data replication, partitioning, and consistency models (eventual, strong, causal) as foundations for serverless event-driven systems
- Event sourcing and CQRS patterns: how to model state changes as immutable events and separate read/write concerns in distributed systems
- Stateful workflow orchestration: managing long-running processes, saga patterns, and compensation logic in serverless architectures
- Database selection trade-offs: relational vs. NoSQL, ACID vs. BASE, and fitting data stores to serverless constraints (latency, cost, scalability)
- Distributed systems fundamentals: consensus, failure modes, and recovery strategies essential for reliable serverless data pipelines
- Architectural decision-making: evaluating complexity, operational burden, and business requirements when choosing between monolithic, microservices, and event-driven topologies
- Serverless-specific data patterns: stream processing, event aggregation, and handling out-of-order/duplicate events in cloud-native systems
- Observability and resilience in data-intensive serverless systems: monitoring, tracing, and designing for partial failures
- What are the key differences between strong consistency, eventual consistency, and causal consistency, and when would you choose each in a serverless event-driven system?
- How do event sourcing and CQRS complement each other, and what are the trade-offs (complexity, latency, operational cost) of implementing them in serverless architectures?
- Describe a stateful workflow scenario (e.g., order processing) and explain how you would implement it using sagas, compensating transactions, and serverless functions.
- Given a choice between a relational database, DynamoDB, and an event store for a serverless application, what factors would drive your decision and what are the implications for consistency, scalability, and cost?
- How do distributed consensus algorithms (Raft, Paxos) relate to achieving reliability in serverless data systems, and what practical trade-offs exist?
- What are the architectural trade-offs between a monolithic, microservices, and event-driven topology for a data-intensive serverless system, and how do you evaluate them?
- Implement a simple event store (in-memory or file-based) that captures immutable events for a domain (e.g., bank account, shopping cart); then build a read model that projects events into a queryable state.
- Design and code a CQRS example: separate write operations (commands that produce events) from read operations (queries against projections); test eventual consistency lag.
- Build a stateful workflow using AWS Step Functions or a serverless orchestration tool: model an order-to-fulfillment process with compensation logic for cancellations and failures.
- Compare data store performance and cost: load test a relational database, DynamoDB, and a document store with a realistic serverless workload; document latency, throughput, and monthly cost.
- Implement a distributed saga pattern: create two serverless functions that coordinate a multi-step transaction (e.g., payment + inventory reservation) with rollback on failure.
- Architect a streaming data pipeline: ingest events from a source (e.g., Kinesis, Kafka), apply transformations, handle out-of-order and duplicate events, and write to multiple read models.
Next up: This stage equips you with principled patterns and trade-off frameworks for data and architecture in serverless systems; the next stage will apply these patterns to specific cloud platforms, operational concerns (cost optimization, security, compliance), and real-world case studies to solidify production-ready decision-making.
The definitive guide to data systems at scale; reading it here lets you apply its lessons on event logs, stream processing, and consistency directly to serverless data architecture choices.
Equips the reader with a structured trade-off analysis framework — fitness functions, architecture styles, coupling — so serverless can be evaluated honestly against microservices, monoliths, and event-driven alternatives.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
