Restaurant, Menu, Order classes in LLD - Scalability & System Analysis

Scalability Analysis - Restaurant, Menu, Order classes

Growth Table: Restaurant, Menu, Order Classes

Scale	Users	Orders per Second	Menu Items	Data Size	System Changes
Small	100 users	10 orders/sec	100 items	MBs	Single server, simple DB, no caching
Medium	10,000 users	1,000 orders/sec	1,000 items	GBs	DB read replicas, caching menu, load balancer
Large	1,000,000 users	50,000 orders/sec	10,000 items	TBs	Sharded DB, distributed cache, multiple app servers
Very Large	100,000,000 users	5,000,000 orders/sec	100,000+ items	Petabytes	Microservices, global CDN, event-driven architecture, data partitioning

First Bottleneck

At small scale, the database is the first bottleneck because it handles all order writes and menu reads. As users grow, the DB CPU and disk I/O limit throughput. The application server can handle more connections, but DB queries slow down.

Scaling Solutions

• Database Read Replicas: Use replicas to serve menu reads and reduce load on primary DB.
• Caching: Cache menu data in memory (e.g., Redis) to reduce DB hits.
• Horizontal Scaling: Add more app servers behind a load balancer to handle more users.
• Sharding: Partition orders by restaurant or region to distribute DB load.
• Event-Driven Architecture: Use message queues to process orders asynchronously at large scale.
• CDN: Use CDN to serve static menu images and reduce bandwidth.

Cost Analysis

• At 10,000 orders/sec, DB needs to handle ~10,000 writes/sec plus reads.
• Menu data size grows with items; caching reduces DB storage cost.
• Network bandwidth must support order data and menu images; estimate 1 Gbps for medium scale.
• Storage for orders grows linearly; archiving old orders reduces DB size.

Interview Tip

Start by describing the system components and their roles. Then discuss expected traffic and data growth. Identify the first bottleneck logically (usually DB). Propose scaling solutions step-by-step, explaining why each helps. Mention trade-offs and cost considerations. Keep answers structured and clear.

Self Check

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

Answer: Add read replicas and implement caching for menu data to reduce DB load. Also, consider connection pooling and optimize queries before scaling vertically.

Key Result

The database is the first bottleneck as user and order volume grows; scaling requires read replicas, caching, and sharding to maintain performance.

Practice

1. Which class should primarily hold the list of available food items and their prices in a restaurant system?

easy

A. Restaurant

B. Menu

C. Order

D. Customer

Solution

1. Step 1: Understand the role of Menu class

   The Menu class is designed to store food items and their prices, acting as the restaurant's catalog.

2. Step 2: Differentiate from other classes

   Order tracks customer requests, Restaurant manages overall operations, Customer represents the diner. Only Menu holds items and prices.

3. Final Answer:

   Menu -> Option B

4. Quick Check:

   Menu = items and prices [OK]

Hint: Menu holds items and prices, not orders or customers [OK]

Common Mistakes:

• Confusing Order with Menu
• Thinking Restaurant holds item prices
• Assuming Customer stores menu data

2. Which of the following is the correct way to add a new item to the Menu class in a typical object-oriented design?

easy

A. menu.addItem('Pizza', 12.99)

B. Menu.add('Pizza', 12.99)

C. menu.insertItem('Pizza', 12.99)

D. addItem(menu, 'Pizza', 12.99)

Solution

1. Step 1: Identify instance method usage

   Adding an item to a Menu instance uses the instance method, so calling menu.addItem(...) is correct.

2. Step 2: Eliminate incorrect syntax

   Menu.add(...) suggests a static method which is unlikely; insertItem is not standard; addItem(menu, ...) is procedural, not OOP style.

3. Final Answer:

   menu.addItem('Pizza', 12.99) -> Option A

4. Quick Check:

   Instance method call = menu.addItem(...) [OK]

Hint: Use instance.method() to add items, not static or procedural calls [OK]

Common Mistakes:

• Using static method call instead of instance method
• Confusing method names
• Calling functions outside class context

3. Given the following code snippet, what will be the total cost of the order?

menu = Menu()
menu.addItem('Burger', 5.0)
menu.addItem('Fries', 2.5)
order = Order(menu)
order.addItem('Burger', 2)
order.addItem('Fries', 3)
total = order.calculateTotal()

medium

A. 17.5

B. 15.0

C. 20.0

D. 12.5

Solution

1. Step 1: Calculate cost for each item

   Burger price is 5.0, quantity 2 -> 5.0 * 2 = 10.0; Fries price is 2.5, quantity 3 -> 2.5 * 3 = 7.5.

2. Step 2: Sum the costs

   Total cost = 10.0 + 7.5 = 17.5.

3. Final Answer:

   17.5 -> Option A

4. Quick Check:

   (5*2)+(2.5*3) = 17.5 [OK]

Hint: Multiply price by quantity, then add all items [OK]

Common Mistakes:

• Adding quantities instead of multiplying by price
• Forgetting to multiply price by quantity
• Mixing up item prices

4. In a system where the Order class adds items without checking the Menu, what is the main issue that can occur?

medium

A. Order will reject all items by default

B. Menu prices will automatically update in Order

C. Order may include items not available in the Menu

D. Restaurant will close automatically

Solution

1. Step 1: Understand the role of validation

   Order should verify items exist in Menu to avoid invalid orders.

2. Step 2: Identify consequence of missing check

   Without checking, Order can contain items not on Menu, causing errors or confusion.

3. Final Answer:

   Order may include items not available in the Menu -> Option C

4. Quick Check:

   Missing validation = invalid items in Order [OK]

Hint: Always check Menu before adding items to Order [OK]

Common Mistakes:

• Assuming automatic price updates
• Thinking Order rejects items by default
• Confusing system behavior with unrelated effects

5. How would you design the Order class to handle multiple orders from different customers simultaneously in a scalable restaurant system?

hard

A. Store all orders in a single list without identifiers

B. Keep orders only in memory without persistence

C. Allow only one order at a time to avoid conflicts

D. Use unique order IDs and store orders in a centralized database with concurrency control

Solution

1. Step 1: Identify need for unique order tracking

   Each order must have a unique ID to distinguish between multiple customers' orders.

2. Step 2: Ensure scalability and data integrity

   Storing orders in a centralized database with concurrency control allows multiple orders simultaneously without conflicts.

3. Final Answer:

   Use unique order IDs and store orders in a centralized database with concurrency control -> Option D

4. Quick Check:

   Unique IDs + concurrency = scalable order handling [OK]

Hint: Use unique IDs and concurrency-safe storage for multiple orders [OK]

Common Mistakes:

• Ignoring concurrency issues
• Using single list causing data overwrite
• Not persisting orders leads to data loss