Serverless Domain Driven Design for the Busy Developer
Serverless Domain Driven Design for the Busy Developer
About the Book
This isn't a 500-page deep dive book; It's around 100 pages for a reason: so you can read it over the weekend and start applying it Monday morning.
Inside, you'll get:
- The core DDD concepts and why they matter.
- Real-world, TypeScript-based examples using AWS Lambda and the CDK, not just diagrams and wishful thinking
- Practical lessons from someone who's wrestled with this stuff in production and made it work
Whether you're new to Domain-Driven Design or just trying to make it fit into your AWS serverless world, this book saves you time, stress, and a few headaches.
About the Author
Table of Contents
- Part I: Foundations of DDD and Serverless
- Chapter 1 Introduction
- Why did I write (this book)?
- Intended Audiences
- How will we learn
- On Design
- Further Reading
- Chapter 2: DDD Lightning Tour
- Domain-Driven Design in a Nutshell
- Further Reading
- Chapter 3 Putting DDD in a Serverless Context
- Understanding Serverless and AWS Lambda
- DDD and Serverless: A Perfect Match
- How does Serverless architecture fit into this picture?
- Further Reading
- Part 2: Strategic Domain-Driven Design
- Chapter 4: Defining the Domains
- Subdomains: The Building Blocks of Your Domain
- Why Should I Care?
- In Summary
- Further Reading
- Chapter 5: Understanding Bounded Contexts
- Introduction
- What Are Bounded Contexts?
- Identifying Bounded Contexts
- Event Storming: Discovering Events and Bounded Contexts
- Practical Example: Travier Plane Ticketing App
- You should not “just share everything”
- In Summary
- Further Reading
- Chapter 6: Context Mapping
- Why Context Maps are usefull?
- How to Create a Context Map
- Common Context Map Relationship Patterns
- Example: The Travier Plane Ticketing App Context Map
- Refining the Context Map
- In Summary
- Further Reading
- Part III: Tactical Domain-Driven Design and Clean Architecture in the Serverless World
- Chapter 7 Tactical DDD: Turning Concepts into Code
- Building Blocks of Tactical DDD
- Refresh Bounded Context
- Example: Plane Ticketing App in Action
- Common Pitfalls
- In Summary
- Further Reading
- Chapter 8: Structuring for Maintainability: Let’s Make it Clean
- Why Does Structure Matter?
- Modules: Reflect your domain in the code
- Layered Architecture: The Clean Architecture Approach
- Survival Guide: Clean Architecture Guideposts
- Where to Put Common Code (Shared Kernel Module)
- Example: Travier Plane Ticketing Application Folder Structure
- In Summary
- Further reading
- Chapter 9: Implementing Core Business Logic with Entities and Value Objects
- Why Entities and Value Objects?
- Understanding Entities
- Implementing Entities: Example
- Understanding Value Objects
- Implementing Value Objects: Example
- Survival Guide: Guideposts for Entities and Value Objects
- In Summary
- Further Reading
- Chapter 10 Encapsulating Transactions with Aggregates
- Why Aggregates?
- Key Concepts of Aggregates
- Survival Guide: Designing Aggregates Guideposts
- Aggregates and Transactions
- In Summary
- Further Reading
- Chapter 11: Orchestrating Operations with Services
- Why Services?
- Types of Services
- Services Survival Guide: Guideposts for Services and Use Cases
- Implementing Services: Examples
- Services in Practice: A Recap
- In Summary
- Chapter 12: Persisting Data with Repositories
- Why Repositories?
- Key Concepts of Repositories
- Repositories Example
- Survival Guide: Guideposts when implementing Repositories
- In Summary
- Further Reading
- Chapter 13: Emitting Domain Events to Decouple Services
- Why Domain Events?
- Characteristics of Domain Events
- Implementing Domain Events
- Common Questions
- Domain Services and Domain Events
- Survival Guide: Guideposts for using Domain Events
- In Summary
- Further Reading
- Chapter 14: Testing
- Unit Tests
- Integration Testing
- End-to-End: Life is Ephemeral
- Survival Tips for Serverless Testing
- Further Reading
- Part 4: Advanced Topics and Patterns
- Chapter 15: Handling Cold Starts in AWS
- Avoid Lambda “Warmers”
- Optimize Your Bundles with TypeScript and esbuild
- Avoid Lambda Layers
- Choose the Right Libraries
- Runtime Matters
- Make it Asynchronous
- Use Provisioned Concurrency Judiciously
- Measure, Measure, Measure
- Practical Example
- Further Reading
- Chapter 16: About Dependency Injection
- What is Dependency Injection?
- You don’t need a DI container when working on AWS Lambdas
- Dependency Injection: Libraries vs. Conventions
- In Summary
- Further Reading
- Chapter 17: About Microservices.
- Closing Words
- Aditional Resources
- Acknowledgement
The Leanpub 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.
You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!
So, there's no reason not to click the Add to Cart button, is there?
See full terms...
Earn $8 on a $10 Purchase, and $16 on a $20 Purchase
We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earnedover $14 millionwriting, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
