Design a Inventory Management for Datadog

Question

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

Codemia · Accepted Answer

- **Functional Requirements**:
  - Track inventory levels of various products in real-time.
  - Support CRUD operations for inventory items (create, read, update, delete).
  - Provide endpoints for querying inventory status and history.
  - Allow bulk import/export of inventory data.
  - Implement user authentication and role-based access control.

- **Non-Functional Requirements**:
  - High availability (99.99% uptime) to prevent inventory discrepancies.
  - Low latency (response time under 100ms for API requests).
  - Scalability to handle up to 10 million requests per day.
  - Strong data consistency to ensure accurate inventory counts across distributed systems.
  - Security measures including data encryption at rest and in transit.

- **Requests Per Second (QPS)**:
  - Assuming 10 million requests per day:
    - QPS = 10,000,000 requests / 86,400 seconds = ~115 QPS.
  - Peak traffic might be double that, so we plan for ~230 QPS.

- **Data Storage**:
  - Each inventory item (including metadata) may take ~1 KB.
  - For 1 million items, storage needs = 1,000,000 items * 1 KB = ~1 GB.
  - Considering growth, we estimate 5 GB for the database at launch, scaling to 100 GB in 2 years.

- **Bandwidth**:
  - Assuming an average response payload of 2 KB, total daily transfer = 10M requests * 2 KB = 20 GB/day.

The high-level architecture consists of several key components:

- **API Gateway**: Using AWS API Gateway for request routing, rate limiting, and security.
- **Service Layer**: Microservices architecture using Node.js for inventory management logic.
- **Database**: PostgreSQL for relational data storage with read replicas for scaling reads.
- **Caching Layer**: Redis for caching frequently accessed inventory data to reduce database load.
- **Message Queue**: RabbitMQ for handling asynchronous tasks such as bulk imports and notifications.
- **Monitoring**: Datadog for performance monitoring, logging, and alerting on system health.

The data model will consist of the following tables:

- **InventoryItems**:
  - `item_id` (PK, UUID)
  - `name` (VARCHAR)
  - `quantity` (INTEGER)
  - `last_updated` (TIMESTAMP)
  - `owner_id` (FK to Users)

- **Users**:
  - `user_id` (PK, UUID)
  - `username` (VARCHAR, UNIQUE)
  - `password_hash` (VARCHAR)
  - `role` (ENUM: 'admin', 'user')

- **InventoryHistory**:
  - `history_id` (PK, UUID)
  - `item_id` (FK to InventoryItems)
  - `change_quantity` (INTEGER)
  - `change_type` (ENUM: 'add', 'remove')
  - `timestamp` (TIMESTAMP)

This schema supports efficient querying for both current inventory levels and historical changes.

- **Consistency vs. Availability**:
  - Chose eventual consistency for the caching layer (Redis) to improve response times, accepting slight delays in data accuracy.
- **Database vs. Caching**:
  - Caching frequently accessed data in Redis reduces database load but adds complexity in cache invalidation strategies.
- **Microservices vs. Monolith**:
  - A microservices architecture allows for better scalability and independent deployments but increases operational overhead.
- **Security Measures**:
  - Implemented OAuth2 for user authentication, ensuring secure access but adding latency in user validation.
- **Handling Failures**:
  - Used RabbitMQ for asynchronous operations, which introduces a potential delay but improves system resilience and decouples components.

Design a Inventory Management for Datadog

Datadog

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

Capacity Estimation

Submit Your Answer

Datadog 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