Shopping cart and session management in HLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Architecture

intermediate

Designing a scalable shopping cart system

You are tasked with designing a shopping cart system that supports millions of users simultaneously. Which architectural choice best ensures scalability and low latency?

A Store shopping cart data in a centralized relational database accessed synchronously for every user action.

B Use client-side cookies to store the entire shopping cart data to avoid server load.

C Implement a distributed in-memory cache (like Redis) to store shopping cart sessions with periodic persistence to a database.

D Save shopping cart data only after checkout to reduce storage needs during browsing.

💡 Hint

Think about fast access and handling many users without bottlenecks.

Using a distributed in-memory cache allows fast read/write access to shopping cart data, reducing latency and supporting high concurrency. Periodic persistence ensures data durability.

🧠 Conceptual

intermediate

Session management strategies for shopping carts

Which session management approach best balances security and user experience for a shopping cart on a web application?

A Store session IDs in secure, HttpOnly cookies with a short expiration time and renew on activity.

B Use URL rewriting to pass session IDs in every link to track user sessions.

C Keep session data entirely on the client side without any server validation.

D Use long-lived sessions without expiration to avoid forcing users to log in repeatedly.

💡 Hint

Consider security risks like session hijacking and user convenience.

Storing session IDs in secure, HttpOnly cookies prevents client-side scripts from accessing them, reducing attack risk. Short expiration with renewal balances security and usability.

❓ scaling

advanced

Handling session data in a load-balanced environment

In a load-balanced web application with multiple servers, what is the best way to manage shopping cart sessions to ensure consistency and availability?

A Keep session data on the client side and send it with every request to avoid server-side session management.

B Store session data only in the database and query it on every request to ensure consistency.

C Use sticky sessions so that each user always connects to the same server storing their session data locally.

D Store session data in a shared distributed cache accessible by all servers to avoid dependency on any single server.

💡 Hint

Consider fault tolerance and server failures in your design.

Using a shared distributed cache allows any server to access session data, improving availability and fault tolerance compared to sticky sessions or database-only storage.

❓ tradeoff

advanced

Tradeoffs in session persistence frequency

What is the main tradeoff when choosing how frequently to persist shopping cart session data from cache to permanent storage?

A Persisting too frequently increases database load but reduces data loss risk; persisting too infrequently reduces load but risks losing recent cart changes.

B Persisting frequently reduces database load but increases network latency; infrequent persistence improves latency but increases storage costs.

C Frequent persistence improves user experience but causes session data fragmentation; infrequent persistence consolidates data but slows checkout.

D Persistence frequency does not affect system performance or data safety significantly.

💡 Hint

Think about balancing system load and data durability.

Persisting session data too often can overload the database, while persisting too rarely risks losing recent user changes if the cache fails.

❓ estimation

expert

Estimating storage requirements for shopping cart sessions

Your e-commerce platform expects 10 million active users daily. Each shopping cart session averages 5 items, with each item record requiring 200 bytes. Sessions are stored in cache for 24 hours. Estimate the approximate memory needed to store all active shopping cart sessions in the cache.

A Approximately 50 GB

B Approximately 100 GB

C Approximately 1 TB

D Approximately 10 GB

💡 Hint

Calculate total bytes: users × items per cart × bytes per item, then convert to GB.

10 million users × 5 items × 200 bytes = 10,000,000 × 1,000 bytes = 10,000,000,000 bytes ≈ 10 GB. But this is raw data; overhead and indexing typically multiply memory needs by about 10, so ~100 GB is realistic.

Practice

1. What is the primary purpose of session management in a shopping cart system?

easy

A. To keep track of user activity and cart contents securely

B. To permanently store all user purchases in the database

C. To display advertisements based on user preferences

D. To manage payment processing and billing

Solution

1. Step 1: Understand session management role

   Sessions keep temporary data about a user's interaction, such as cart contents and login status.

2. Step 2: Identify the main goal in shopping cart context

   The main goal is to track user activity and cart items securely during their visit.

3. Final Answer:

   To keep track of user activity and cart contents securely -> Option A

4. Quick Check:

   Session = Track user and cart data [OK]

Hint: Sessions track temporary user data like cart items [OK]

Common Mistakes:

• Confusing session with permanent storage
• Thinking sessions handle payment processing
• Assuming sessions display ads

2. Which of the following is the correct way to maintain a user's shopping cart session in a web application?

easy

A. Store cart data only in browser cookies without server validation

B. Require user to log in before adding items to cart

C. Save cart data directly in the URL query parameters

D. Use a unique session ID stored in a cookie linked to server-side cart data

Solution

1. Step 1: Review session management best practice

   Best practice is to store a unique session ID in a cookie that references server-side data.

2. Step 2: Evaluate options for security and scalability

   Storing cart data only in cookies or URLs is insecure and limited in size; requiring login is not always needed.

3. Final Answer:

   Use a unique session ID stored in a cookie linked to server-side cart data -> Option D

4. Quick Check:

   Session ID cookie + server data = Correct [OK]

Hint: Session ID cookie links to server cart data securely [OK]

Common Mistakes:

• Storing sensitive data only in cookies
• Putting cart info in URL causing security risks
• Assuming login is mandatory for cart usage

3. Consider this simplified flow for a shopping cart session:

1. User adds item A to cart
2. Server stores cart in session store
3. User adds item B
4. Server updates session
5. User refreshes page
6. Server retrieves session cart

What will the cart contain after step 6?

medium

A. Only item B

B. Only item A

C. Both item A and item B

D. Empty cart

Solution

1. Step 1: Track items added to cart in session

   Item A is added first and stored in session, then item B is added and session updated.

2. Step 2: Understand session retrieval on refresh

   On refresh, server retrieves the session cart which includes both items added previously.

3. Final Answer:

   Both item A and item B -> Option C

4. Quick Check:

   Session stores cumulative cart items [OK]

Hint: Session updates accumulate cart items, not replace [OK]

Common Mistakes:

• Assuming new item replaces old in session
• Thinking refresh clears session data
• Confusing client-side and server-side storage

4. A developer notices that users lose their shopping cart items after closing the browser. What is the most likely cause?

medium

A. Cart data is stored permanently in the database

B. Session cookie is set as a session-only cookie without expiration

C. User authentication is required to save cart

D. Server is caching cart data incorrectly

Solution

1. Step 1: Understand session cookie behavior

   Session cookies without expiration are deleted when browser closes, losing session data.

2. Step 2: Identify cause of cart loss

   Because cart data is linked to session cookie, losing cookie means losing cart info.

3. Final Answer:

   Session cookie is set as a session-only cookie without expiration -> Option B

4. Quick Check:

   Session cookie expires on browser close [OK]

Hint: Session cookies without expiry vanish on browser close [OK]

Common Mistakes:

• Assuming database storage causes cart loss
• Thinking authentication affects session persistence
• Blaming server cache without evidence

5. You are designing a scalable shopping cart system for millions of users. Which approach best balances performance and reliability for session and cart management?

hard

A. Use a distributed in-memory session store with periodic database backups

B. Store cart data in client-side cookies only to reduce server load

C. Save all cart data directly in the main database synchronously on every change

D. Require users to log in before adding items to cart to simplify session handling

Solution

1. Step 1: Evaluate client-side vs server-side storage

   Client-only storage risks security and size limits; main DB sync on every change causes latency.

2. Step 2: Consider scalability and reliability

   Distributed in-memory store (like Redis) offers fast access and can be backed up to DB for durability.

3. Step 3: Assess login requirement impact

   Requiring login reduces friction and scalability; anonymous carts improve UX.

4. Final Answer:

   Use a distributed in-memory session store with periodic database backups -> Option A

5. Quick Check:

   Distributed cache + DB backup = Scalable & reliable [OK]

Hint: Use distributed cache with DB backup for scalable sessions [OK]

Common Mistakes:

• Relying only on client cookies for cart data
• Writing to DB synchronously on every cart update
• Forcing login before cart usage unnecessarily