Envoy·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say

Apr 2026

Summary

System design round at Envoy for a software engineering role. The prompt was a shopping cart implementation, which sounds boring until you realize how many rabbit holes it opens up. Spent most of the time debating my own design decisions out loud, which felt awkward but seemed to be the point.

Questions Asked (1)

Design and implement a Shopping Cart system that supports adding/updating/removing items, computing subtotals, applying multiple coupon types, computing tax by state, and locking the cart after checkout so further mutations throw an error.

System DesignTechnical Trade-offsData Modeling

Author's notes

The spec was intentionally left vague, which I did not fully appreciate until I was ten minutes in and already committed to a design that had no coupon precedence rules.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and defining core entities (Cart, Item, Coupon, TaxCalculator) and their relationships. Then walk through the main operations (add/update/remove, subtotal, coupon application, tax, checkout lock) while discussing data structures, state management, and trade-offs. Emphasize extensibility for coupons and tax rules, and ensure the locking mechanism is robust and thread-safe.

Pro tip: Demonstrate awareness of concurrency and idempotency: mention how you'd handle simultaneous cart mutations and ensure checkout is atomic. Also, discuss how coupon stacking rules and tax calculations can be abstracted for easy addition of new types.

1. Clarify Requirements and Scope

Ask questions to understand expected scale, coupon types (percentage, fixed, BOGO), tax rules (by state, possibly by item category), and whether the cart is per-user and persisted. Confirm that locking means no further mutations after checkout.

2. Define Data Model and Interfaces

Outline classes/interfaces: Cart (with items, coupons, state), Item (id, name, price, quantity), Coupon (apply method), TaxCalculator (by state). Specify methods: addItem, updateItem, removeItem, getSubtotal, applyCoupon, getTax, checkout.

3. Implement Core Operations

Describe how to manage items (e.g., using a map for O(1) updates), compute subtotal, and apply coupons sequentially with validation (e.g., expiration, minimum purchase). Discuss coupon stacking order and potential conflicts.

4. Handle Tax and Checkout Locking

Explain tax calculation based on state (e.g., strategy pattern for different states). For locking, use a state flag (e.g., isCheckedOut) and throw an exception on mutation attempts. Ensure thread-safety with locks or atomic operations if needed.

5. Discuss Trade-offs and Extensibility

Talk about design choices: mutable vs immutable cart, coupon application order, tax calculation complexity, and how to extend for new coupon types or tax rules. Mention testing strategies and edge cases.

Key Points to Mention

Use of appropriate data structures (e.g., Map for items) for efficient updates and removals.
Coupon application logic: order of application, stacking rules, and validation (e.g., expiration, minimum spend).
Tax calculation: strategy pattern or similar for state-specific rules, and handling of taxable vs non-taxable items.
Checkout locking: state flag with exception throwing, and thread-safety considerations (e.g., synchronized methods or locks).
Extensibility: designing interfaces for coupons and tax calculators to allow easy addition of new types.
Edge cases: empty cart, invalid coupons, concurrent modifications, and idempotent checkout.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.