Design Inventory Management Infrastructure for global users

Question

Design a event-driven inventory management system that handles millions of requests. Discuss trade-offs in consistency, availability, and performance.

Codemia · Accepted Answer

### Functional Requirements
1. **Event Handling**: The system must handle events related to inventory updates, such as additions, deletions, and modifications.
2. **User Authentication**: Secure access for global users via OAuth2.0 tokens.
3. **Real-Time Updates**: Users should receive real-time notifications on inventory changes.
4. **Reporting**: Generate reports on inventory levels, trends, and usage patterns.
5. **Search Functionality**: Users should be able to search inventory items based on various attributes (e.g., name, SKU, category).

### Non-Functional Requirements
1. **Scalability**: The system must scale to handle millions of requests per day.
2. **Availability**: Aim for 99.99% uptime to ensure global users can access inventory at all times.
3. **Consistency**: Strong consistency for inventory counts must be maintained to avoid stockouts.
4. **Latency**: Response time for any inventory operation should be under 200ms.
5. **Security**: Sensitive data must be encrypted in-transit and at-rest.

Assuming PayPal's inventory management system needs to support 10 million global users with an average of 100 inventory transactions per user per month:
- **Total Transactions** = 10,000,000 users * 100 transactions = 1,000,000,000 transactions/month.
- This translates to approximately 33 million transactions/day.
- Assuming an even spread, we estimate around 400 transactions/second.
- Considering peak load scenarios, we should plan for up to 1,000 transactions/second to handle spiky traffic. 
- Storage needs: If each transaction generates around 1KB of data, we need roughly 1TB of storage per month, necessitating a scalable storage solution.

### Component Diagram
- **API Gateway**: Handles incoming requests, performs authentication, and forwards them to appropriate services.
- **Event Bus (Kafka)**: An event-driven architecture using Kafka for handling event streams related to inventory updates.
- **Microservices**:
  - **Inventory Service**: Manages CRUD operations on inventory items.
  - **Notification Service**: Sends real-time notifications to users on inventory changes.
  - **Reporting Service**: Aggregates data for generating reports.
- **Database (Cassandra)**: A distributed NoSQL database for high write and read throughput, ensuring strong consistency with eventual consistency options.
- **Caching Layer (Redis)**: To cache frequently accessed inventory data and reduce load on the database.

### Technology Choices
- **API Gateway**: AWS API Gateway
- **Event Bus**: Apache Kafka
- **Microservices**: Spring Boot for Java microservices
- **Database**: Apache Cassandra
- **Caching**: Redis

### Schema Design
- **Inventory Table**:
  - `item_id` (UUID, Primary Key)
  - `item_name` (String)
  - `quantity` (Integer)
  - `price` (Decimal)
  - `last_updated` (Timestamp)
  - `category` (String)

- **Event Log Table**:
  - `event_id` (UUID, Primary Key)
  - `item_id` (UUID, Foreign Key)
  - `event_type` (String: ADD, REMOVE, UPDATE)
  - `timestamp` (Timestamp)
  - `user_id` (UUID)

### Access Patterns
- Frequent access to the inventory table for reads and updates.
- The event log serves for auditing and reporting purposes.

### Architectural Decisions
1. **Consistency vs. Availability**: Choosing Cassandra allows us to have eventual consistency, which is suitable for high availability but may lead to stale reads. We can implement read repair strategies to mitigate this.
2. **Caching Strategy**: Using Redis for caching improves read performance but requires handling cache invalidation carefully to prevent stale data from being served.
3. **Eventual Consistency**: While we aim for strong consistency during inventory updates, the asynchronous nature of the event-driven architecture may lead to temporary discrepancies. We will need to manage reconciliation effectively.
4. **Microservices**: Building microservices enhances scalability and maintainability but introduces complexity in managing inter-service communication and data consistency.

Design Inventory Management Infrastructure for global users

PayPal

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Practice a Similar Problem on Codemia

Sample Answer

Requirements

Functional Requirements

Capacity Estimation

Submit Your Answer

PayPal Software Engineer Interview Guide

Related Questions

Design a high-throughput Inventory Management System

Design a low-latency Rate Limiting System

Design a fault-tolerant Payment System

Design a fault-tolerant Messaging System

Design Walmart Product Search