Why advanced patterns solve edge cases in Microservices - Design It to Understand It

Design: Microservices Edge Case Handling

Focus on microservices communication patterns and fault tolerance. Out of scope: UI design, database internal optimizations.

Functional Requirements

FR1: Support multiple microservices communicating reliably

FR2: Handle failures gracefully without data loss

FR3: Ensure data consistency across services

FR4: Manage service discovery and load balancing

FR5: Allow for scaling and independent deployment

Non-Functional Requirements

NFR1: System must handle 10,000 requests per second

NFR2: API response latency p99 under 300ms

NFR3: Availability target 99.9% uptime

NFR4: Services may fail or be temporarily unreachable

NFR5: Data consistency must be eventual but predictable

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

API Gateway

Service Registry and Discovery

Message Broker or Event Bus

Circuit Breaker

Retry Mechanism

Saga Pattern Coordinator

Load Balancer

Monitoring and Logging

Design Patterns

Circuit Breaker Pattern

Retry Pattern with Exponential Backoff

Saga Pattern for distributed transactions

Bulkhead Pattern for isolation

Event Sourcing and CQRS

Service Mesh for observability and control

Reference Architecture

Client
  |
  v
API Gateway
  |
  v
+-------------------+       +-------------------+
|  Service Registry  |<----->|  Microservice A    |
+-------------------+       +-------------------+
          |                          |
          v                          v
   +--------------+          +--------------+
   | Message Bus  |<-------->| Microservice B|
   +--------------+          +--------------+
          |
          v
   +----------------+
   | Saga Coordinator|
   +----------------+

Components

API Gateway

Nginx or Kong

Entry point for clients, routes requests to microservices, handles authentication and rate limiting

Service Registry

Consul or Eureka

Keeps track of available microservices and their locations for discovery

Message Bus

Kafka or RabbitMQ

Enables asynchronous communication and event-driven patterns between services

Microservices

Spring Boot / Node.js / Go

Independent services handling specific business capabilities

Saga Coordinator

Custom or framework-based (e.g., Axon Framework)

Manages distributed transactions across services to maintain data consistency

Circuit Breaker

Resilience4j or Hystrix

Prevents cascading failures by stopping calls to failing services temporarily

Request Flow

1. Client sends request to API Gateway

2. API Gateway routes request to appropriate microservice using Service Registry

3. Microservice processes request; if it needs to call other services, it publishes events to Message Bus

4. Other microservices consume events asynchronously and perform their tasks

5. Saga Coordinator tracks distributed transaction steps and triggers compensating actions if needed

6. Circuit Breaker monitors service health and opens to prevent calls to failing services

7. Retries with exponential backoff are used for transient failures

8. Responses flow back through API Gateway to client

Database Schema

Entities are decentralized per microservice. Key entities include: - Order (Microservice A) - Payment (Microservice B) - Event Log (for event sourcing) Relationships are managed via events and sagas rather than direct foreign keys to maintain loose coupling.

Scaling Discussion

Bottlenecks

API Gateway becoming a single point of failure under high load

Message Bus overload with too many events

Saga Coordinator complexity and state management

Service Registry latency causing discovery delays

Circuit Breaker misconfiguration causing unnecessary service blocking

Solutions

Deploy multiple API Gateway instances behind a load balancer

Partition and scale Message Bus clusters, use topic sharding

Distribute Saga Coordinator or use stateless choreography where possible

Use caching and replication for Service Registry

Tune Circuit Breaker thresholds carefully and monitor metrics

Interview Tips

Time: Spend 10 minutes understanding requirements and clarifying edge cases, 20 minutes designing architecture and explaining patterns, 10 minutes discussing scaling and trade-offs, 5 minutes for questions.

Explain why simple request-response is not enough for microservices

Describe how circuit breakers prevent cascading failures

Show how sagas handle distributed transactions without locking

Discuss retry strategies and their impact on latency

Highlight importance of asynchronous communication for resilience

Mention monitoring and observability for detecting edge cases