Order state machine in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identify the correct next state for an order

An order is currently in the "Processing" state. Which state should it transition to next if the payment is successful?

A Returned

B Cancelled

C Delivered

D Shipped

💡 Hint

Think about the typical flow of an order after payment is confirmed.

After payment is successful, the order moves from Processing to Shipped before it can be Delivered.

❓ Architecture

intermediate

Choose the best component to handle order state transitions

In designing an order state machine, which component is best suited to manage state transitions and enforce valid state changes?

A A dedicated State Machine Service that validates and updates order states

B A UI component that changes states based on user clicks

C A database trigger that automatically changes states

D A logging service that records state changes

💡 Hint

Consider where the logic for valid state changes should reside for consistency and control.

A dedicated State Machine Service centralizes state transition logic, ensuring valid and consistent changes.

❓ scaling

advanced

Scaling order state machine for high traffic

Your order system handles thousands of orders per second. Which approach best ensures the order state machine scales without losing consistency?

A Handle state transitions only on the client side to reduce server load

B Use a distributed state machine with event sourcing and a message queue

C Use local in-memory state machines on each server without synchronization

D Store all states in a single database table with frequent polling

💡 Hint

Think about how to keep state consistent across multiple servers and handle high throughput.

Event sourcing with message queues allows distributed systems to process state changes reliably and scalably.

❓ tradeoff

advanced

Tradeoff between strict and eventual consistency in order states

Choosing between strict consistency and eventual consistency for order state updates impacts system design. Which statement best describes a tradeoff?

A Strict consistency allows faster processing but risks stale data

B Eventual consistency guarantees immediate state accuracy but increases latency

C Strict consistency ensures immediate state accuracy but may reduce system availability under load

D Eventual consistency prevents any state conflicts by locking all orders

💡 Hint

Consider how consistency models affect availability and latency.

Strict consistency provides accurate state immediately but can reduce availability during high load or failures.

❓ estimation

expert

Estimate storage needed for order state history

Your system processes 1 million orders daily. Each order has on average 5 state transitions. Each state transition record requires 200 bytes. Estimate the storage needed to keep 30 days of order state history.

A 30 GB

B 3 GB

C 300 GB

D 60 GB

💡 Hint

Calculate total records and multiply by size per record, then convert bytes to GB.

1,000,000 orders/day × 5 transitions = 5,000,000 records/day. 5,000,000 × 200 bytes = 1,000,000,000 bytes/day ≈ 1 GB/day. For 30 days: ≈ 30 GB (D).

Practice

1.

What is the main purpose of an Order State Machine in a system?

easy

A. To track and control the valid states an order can be in during its lifecycle

B. To store customer payment details securely

C. To calculate the total price of an order

D. To manage user login sessions

Solution

1. Step 1: Understand the role of state machines

   State machines define allowed states and transitions for an entity, ensuring valid progress.

2. Step 2: Apply to order lifecycle

   For orders, the state machine controls stages like 'Pending', 'Shipped', 'Delivered', preventing invalid jumps.

3. Final Answer:

   To track and control the valid states an order can be in during its lifecycle -> Option A

4. Quick Check:

   Order state machine = control order states [OK]

Hint: State machines control valid order stages only [OK]

Common Mistakes:

• Confusing state machine with payment processing
• Thinking it calculates prices
• Mixing with user session management

2.

Which of the following is the correct way to represent a state transition in an order state machine?

class OrderStateMachine:
    def __init__(self):
        self.state = 'Pending'

    def ship(self):
        # Transition from Pending to Shipped
        ?

easy

A. if self.state == 'Pending': self.state = 'Shipped' else: raise Exception('Invalid transition')

B. self.state == 'Shipped'

C. self.state = 'Pending' if self.state == 'Shipped' else 'Shipped'

D. self.ship = 'Shipped'

Solution

1. Step 1: Understand valid state change syntax

   Assign new state only if current state allows it; else raise error.

2. Step 2: Check each option

   if self.state == 'Pending': self.state = 'Shipped' else: raise Exception('Invalid transition') correctly assigns 'Shipped' if current is 'Pending', else raises exception.

3. Final Answer:

   if self.state == 'Pending': self.state = 'Shipped' else: raise Exception('Invalid transition') -> Option A

4. Quick Check:

   Valid transition check = if self.state == 'Pending': self.state = 'Shipped' else: raise Exception('Invalid transition') [OK]

Hint: Assign new state only if current state matches [OK]

Common Mistakes:

• Using comparison (==) instead of assignment (=)
• Assigning wrong state based on condition
• Changing method name instead of state

3.

Given the following code snippet for an order state machine, what will be the output after calling cancel() twice?

class OrderStateMachine:
    def __init__(self):
        self.state = 'Pending'

    def cancel(self):
        if self.state in ['Pending', 'Shipped']:
            self.state = 'Cancelled'
        else:
            print('Cannot cancel from', self.state)

order = OrderStateMachine()
order.cancel()
order.cancel()
print(order.state)

medium

A. Cancelled

B. Pending

C. Cannot cancel from Cancelled\nCancelled

D. Error

Solution

1. Step 1: Trace first cancel call

   Initial state is 'Pending', so state changes to 'Cancelled'.

2. Step 2: Trace second cancel call

   State is now 'Cancelled', so print message 'Cannot cancel from Cancelled' and state stays 'Cancelled'.

3. Final Answer:

   Cannot cancel from Cancelled\nCancelled -> Option C

4. Quick Check:

   Second cancel prints message, state remains Cancelled [OK]

Hint: Check state before transition; print if invalid [OK]

Common Mistakes:

• Assuming second cancel changes state again
• Ignoring printed message
• Expecting error instead of print

4.

Identify the bug in this order state machine method that allows invalid state transitions:

def deliver(self):
    if self.state == 'Shipped' or 'Out for Delivery':
        self.state = 'Delivered'
    else:
        raise Exception('Invalid transition');

medium

A. The method should use 'and' instead of 'or'

B. The method does not change the state

C. The exception message is missing

D. The condition always evaluates to True due to incorrect or usage

Solution

1. Step 1: Analyze the condition logic

   The condition uses 'if self.state == 'Shipped' or 'Out for Delivery'', which always evaluates True because non-empty strings are truthy.

2. Step 2: Correct the condition

   It should be 'if self.state == 'Shipped' or self.state == 'Out for Delivery'' to check both states properly.

3. Final Answer:

   The condition always evaluates to True due to incorrect or usage -> Option D

4. Quick Check:

   Incorrect or condition causes always True [OK]

Hint: Check boolean conditions carefully for correct comparisons [OK]

Common Mistakes:

• Using 'or' with string literals incorrectly
• Forgetting to compare both sides explicitly
• Assuming condition works as intended

5.

You are designing an order state machine for an online store. The order states are Pending, Confirmed, Shipped, Delivered, and Cancelled. Which design ensures scalability and prevents invalid transitions?

Choose the best approach:

1. Use a dictionary mapping each state to allowed next states.
2. Hardcode all transitions in if-else blocks.
3. Allow any state to transition to any other state.
4. Use a single variable without validation.

hard

A. Use a single variable without validation

B. Use a dictionary mapping each state to allowed next states

C. Allow any state to transition to any other state

D. Hardcode all transitions in if-else blocks

Solution

1. Step 1: Evaluate scalability and validation needs

   Hardcoding transitions is error-prone and hard to maintain; allowing any transition breaks rules.

2. Step 2: Choose dictionary mapping

   Mapping states to allowed next states centralizes rules, making it easy to update and validate transitions.

3. Final Answer:

   Use a dictionary mapping each state to allowed next states -> Option B

4. Quick Check:

   Dictionary mapping = scalable, validated transitions [OK]

Hint: Map states to allowed next states for clean validation [OK]

Common Mistakes:

• Hardcoding transitions everywhere
• Skipping validation of transitions
• Allowing invalid state jumps