Inventory management in LLD - Scalability & System Analysis

Scalability Analysis - Inventory management

Growth Table: Inventory Management System

Scale	Users	Inventory Items	Transactions per Second	Data Size	Key Changes
Small	100	10,000	10 TPS	~100 MB	Single server, simple DB, no caching
Medium	10,000	1,000,000	1,000 TPS	~10 GB	DB indexing, read replicas, caching introduced
Large	1,000,000	100,000,000	50,000 TPS	~1 TB	Sharding, distributed cache, load balancers, async processing
Very Large	100,000,000	10,000,000,000	5,000,000 TPS	~100 TB+	Multi-region deployment, advanced sharding, event sourcing, CQRS, CDN for static data

First Bottleneck

At small to medium scale, the database is the first bottleneck. Inventory management requires frequent updates (stock changes, orders) and queries (availability checks). A single database instance can handle only up to ~5,000 queries per second reliably. As users and transactions grow, the DB CPU, disk I/O, and connection limits are reached first.

Scaling Solutions

• Read Replicas: Offload read queries to replicas to reduce load on primary DB.
• Caching: Use in-memory caches (e.g., Redis) for frequently accessed inventory data to reduce DB hits.
• Sharding: Partition inventory data by product ID or region to distribute load across multiple DB servers.
• Horizontal Scaling: Add more application servers behind load balancers to handle increased user requests.
• Asynchronous Processing: Use message queues for inventory updates to smooth spikes and improve throughput.
• CDN: For static assets like product images, use CDN to reduce bandwidth and latency.

Back-of-Envelope Cost Analysis

• At 10,000 users with 1,000 TPS, DB needs to handle ~1,000 writes/reads per second.
• Storage: 1 million items x ~10 KB per item = ~10 GB data.
• Bandwidth: Assuming 1 KB per request, 1,000 TPS x 1 KB = ~1 MB/s (~8 Mbps).
• Cache memory: To hold hot inventory data, ~1-2 GB Redis instance.
• Network: 1 Gbps network interface sufficient for medium scale.

Interview Tip

Start by defining the scale and key operations (reads vs writes). Identify the bottleneck (usually DB). Discuss scaling strategies step-by-step: caching, read replicas, sharding, async processing. Mention trade-offs like consistency vs availability. Use real numbers to justify choices.

Self Check Question

Your database handles 1000 QPS. Traffic grows 10x to 10,000 QPS. What do you do first and why?

Answer: Introduce read replicas and caching to reduce load on the primary database. This helps scale reads horizontally without immediate complex sharding.

Key Result

Inventory management systems first hit database bottlenecks as users and transactions grow. Scaling requires caching, read replicas, and sharding to handle increased load efficiently.

Practice

1. What is the primary purpose of an inventory management system?

easy

A. To track product quantities and prevent stock issues

B. To design product packaging

C. To manage employee schedules

D. To create marketing campaigns

Solution

1. Step 1: Understand inventory management goals

   Inventory management focuses on tracking product quantities to avoid running out or overstocking.

2. Step 2: Eliminate unrelated options

   Options about packaging, schedules, and marketing do not relate to inventory tracking.

3. Final Answer:

   To track product quantities and prevent stock issues -> Option A

4. Quick Check:

   Inventory management = tracking stock [OK]

Hint: Inventory systems track stock levels, not unrelated tasks [OK]

Common Mistakes:

• Confusing inventory with marketing or HR tasks
• Thinking inventory manages packaging design
• Assuming inventory handles employee schedules

2. Which of the following is the correct way to check if an item exists in an inventory dictionary named stock in Python?

easy

A. if stock.has_key('item'):

B. if 'item' in stock:

C. if stock.contains('item'):

D. if stock.exists('item'):

Solution

1. Step 1: Recall Python dictionary syntax

   To check if a key exists in a dictionary, use the in keyword.

2. Step 2: Identify correct syntax

   stock.has_key() is deprecated, and contains or exists are invalid methods.

3. Final Answer:

   if 'item' in stock: -> Option B

4. Quick Check:

   Use 'in' to check keys in dict [OK]

Hint: Use 'in' keyword to check keys in Python dicts [OK]

Common Mistakes:

• Using deprecated has_key() method
• Using non-existent methods like contains()
• Confusing method names for key checks

3. Given the Python code below, what will be the output?

stock = {'apple': 10, 'banana': 5}
stock['apple'] -= 3
print(stock['apple'])

medium

A. Error

B. 13

C. -3

D. 7

Solution

1. Step 1: Understand the initial stock

   Initially, 'apple' has quantity 10.

2. Step 2: Apply the subtraction operation

   Subtracting 3 from 10 results in 7.

3. Final Answer:

   7 -> Option D

4. Quick Check:

   10 - 3 = 7 [OK]

Hint: Subtract quantity correctly to find updated stock [OK]

Common Mistakes:

• Adding instead of subtracting
• Confusing keys or values
• Expecting an error due to subtraction

4. Identify the error in the following inventory update code snippet:

stock = {'apple': 5}
stock['banana'] -= 2
print(stock)

medium

A. No error, banana quantity becomes -2

B. SyntaxError due to invalid subtraction

C. KeyError because 'banana' does not exist in stock

D. TypeError because stock is not a list

Solution

1. Step 1: Check if 'banana' key exists

   'banana' is not in the stock dictionary initially.

2. Step 2: Understand dictionary behavior on missing keys

   Subtracting from a missing key causes a KeyError in Python.

3. Final Answer:

   KeyError because 'banana' does not exist in stock -> Option C

4. Quick Check:

   Missing key access = KeyError [OK]

Hint: Accessing missing dict keys causes KeyError [OK]

Common Mistakes:

• Assuming missing keys default to zero
• Expecting negative values without initialization
• Confusing error types

5. You are designing an inventory system that must handle multiple warehouses. Which design approach best ensures accurate stock counts across warehouses and prevents overselling?

hard

A. Maintain separate stock counts per warehouse and use transactions to update atomically

B. Keep a single global stock count without warehouse details

C. Update stock counts asynchronously without locking

D. Allow negative stock counts to handle overselling

Solution

1. Step 1: Consider multi-warehouse stock tracking

   Each warehouse should have its own stock count to track inventory accurately.

2. Step 2: Ensure atomic updates to prevent overselling

   Using transactions or locks ensures stock updates are consistent and prevent race conditions.

3. Final Answer:

   Maintain separate stock counts per warehouse and use transactions to update atomically -> Option A

4. Quick Check:

   Atomic updates + per-warehouse stock = accurate inventory [OK]

Hint: Use atomic transactions and per-warehouse counts [OK]

Common Mistakes:

• Using global stock ignores warehouse differences
• Updating asynchronously causes race conditions
• Allowing negative stock hides overselling problems