Stateless

Four standard steps for system design interview. However, I would think about them wider: as about four initial steps to design the software.

• Step 1. Understand the problem and establish design scope
• Step 2. Propose high-level design and get buy-in
• Step 3. Design deep dive
• Step 4. Wrap up

The chapter 3 of the book discovers details about each step, good questions to ask (to think about), DO’s and DONT’s. It also shows good example of the process of designing a news feed system.

A great generic plan for scaling any app from zero to millions of users.

• Single server setup
• Selection and usage of database
• Vertical scaling vs horizontal scaling approaches. And why you should prefer horizontal
• Adding load balancer for horizontal scaling
• Adding database replication for horizontal scaling
• Adding cache
• Adding CDN
• Stateless vs Stateful architecture and using external state storage
• Adding extra Data Centers
• Adding Message queue
• Adding Logging, Metrics, and Automation
• Scaling database (sharding)
• and futher steps…

All of these is carefully but briefly disclosed in the Chapter 1 of the book:

Testing event-driven solutions is a challenging task. It includes:

• Common principles
• Unit testing: stateless and stateful
• Testing the Topology (I bet you didn’t do it! ;)
• Testing Schema Evolution and Compatibility
• Integration testing: Local, Remote and Hybrid - a set of common sense considerations not to forgot about
• Choosing the testing strategy

All of these is disclosed in the Chapter 15 of the book:

“Building Event-Driven Microservices: Leveraging Organizational Data at Scale” by Adam Bellemare

Basic Producer and Consumer (BPC) is a simple pattern for creating microservices. It forms the foundation of stateless and stateful services.

You can use it for:

• interfacing layer between event streams and legacy systems
• leverage external stream processing systems to augment capabilities.

But it requires your extra effort for:

• simple state materialization
• event scheduling
• timestamp-based decision making

All of these is disclosed in the Chapter 10 of the book we are currently studying:

Overviewing basics of event processing in Event-Driven Architectures:

• Typical structure of microservice
• Typical types of event transformations, 2 branching scenarios, merging streams
• Repartitioning events and when it can be useful
• Copartitioning events and when it is needed
• Assigning Partitions to a Consumer Instance. Three strategies to do this.
• Recovering from stateless processing instance failures.

These topics are disclosed in the Chapter 5 of the book we are currently studying:

“Building Event-Driven Microservices: Leveraging Organizational Data at Scale” by Adam Bellemare