Pricing strategy (discounts, coupons) in LLD - System Design Guide

Problem Statement

Without a clear pricing strategy, applying discounts and coupons can lead to inconsistent pricing, revenue loss, and customer confusion. Naive implementations often mix pricing logic with business logic, making it hard to update or extend discount rules without risking bugs or errors.

Solution

A well-designed pricing strategy separates discount and coupon logic into modular components that calculate final prices based on defined rules. This approach allows flexible, reusable, and testable discount policies that can be combined or extended without affecting core business logic.

Architecture

Order Item

→Discount Rule

↓

Coupon Rule

→Final Price

This diagram shows how order items are processed through discount and coupon rules, which the price engine uses to calculate the final price.

Trade-offs

✓ Pros

→

Enables flexible addition and combination of multiple discount and coupon rules.

→

Separates pricing logic from business logic, improving maintainability and testability.

→

Supports complex pricing strategies like stacking discounts or conditional coupons.

✗ Cons

→

Adds complexity to the codebase compared to hardcoded discounts.

→

Requires careful design to avoid conflicts or unintended discount stacking.

→

Performance overhead if many rules are evaluated for each pricing calculation.

Use when your system needs to support multiple, changing discount and coupon rules, especially if discounts depend on conditions like user type, order size, or time.

Avoid if your pricing is simple and static, such as a fixed discount applied uniformly without conditions, or if discount logic rarely changes.

Real World Examples

Amazon

Amazon uses modular pricing strategies to apply various discounts and coupons dynamically based on user segments, promotions, and product categories.

Shopify

Shopify's platform allows merchants to define complex discount rules and coupon codes that combine multiple conditions and actions.

Uber

Uber applies promotional coupons and discounts through a flexible pricing engine that considers user history, location, and time.

Code Example

The before code mixes discount logic directly in the order class, making it hard to extend. The after code separates discount and coupon rules into classes, and a price engine applies them in sequence. This modular design allows easy addition of new discount types without changing core order logic.

LLD

### Before: naive discount logic mixed in order processing
class Order:
    def __init__(self, items):
        self.items = items

    def calculate_total(self):
        total = sum(item.price for item in self.items)
        # Apply 10% discount if total > 100
        if total > 100:
            total *= 0.9
        return total


### After: modular pricing strategy with discount and coupon rules
from abc import ABC, abstractmethod

class DiscountRule(ABC):
    @abstractmethod
    def apply(self, price, order):
        pass

class TenPercentOver100(DiscountRule):
    def apply(self, price, order):
        total = sum(item.price for item in order.items)
        if total > 100:
            return price * 0.9
        return price

class CouponRule(ABC):
    @abstractmethod
    def apply(self, price):
        pass

class FixedCoupon(CouponRule):
    def __init__(self, amount):
        self.amount = amount

    def apply(self, price):
        return max(price - self.amount, 0)

class PriceEngine:
    def __init__(self, discount_rules, coupon_rules):
        self.discount_rules = discount_rules
        self.coupon_rules = coupon_rules

    def calculate_final_price(self, order):
        price = sum(item.price for item in order.items)
        for rule in self.discount_rules:
            price = rule.apply(price, order)
        for coupon in self.coupon_rules:
            price = coupon.apply(price)
        return price

# Usage example
class Item:
    def __init__(self, price):
        self.price = price

order = Order([Item(60), Item(50)])
discounts = [TenPercentOver100()]
coupons = [FixedCoupon(5)]
engine = PriceEngine(discounts, coupons)
final_price = engine.calculate_final_price(order)
print(final_price)  # Outputs discounted and coupon-applied price

Alternatives

Hardcoded Discounts

Discount logic is embedded directly in business code without abstraction.

Use when: Choose when discount rules are very simple, rarely change, and system complexity must be minimal.

Rule Engine

Uses an external or dedicated rule engine to evaluate discount conditions and actions.

Use when: Choose when discount logic is very complex, requires non-developers to update rules, or must integrate with other business rules.

Summary

A modular pricing strategy separates discount and coupon logic from core business code.

This design enables flexible, maintainable, and testable pricing rules that can combine multiple conditions.

It prevents revenue loss and confusion caused by inconsistent or hardcoded discount implementations.

Practice

1. What is the primary purpose of implementing discounts and coupons in a pricing strategy?

easy

A. To reduce product quality

B. To increase the base price of products

C. To make the checkout process slower

D. To attract more customers and increase sales volume

Solution

1. Step 1: Understand the role of discounts and coupons

   Discounts and coupons are marketing tools used to lower prices temporarily.

2. Step 2: Identify the business goal

   Lower prices attract more customers, which can increase sales volume and customer loyalty.

3. Final Answer:

   To attract more customers and increase sales volume -> Option D

4. Quick Check:

   Discounts and coupons = attract customers [OK]

Hint: Discounts attract customers by lowering prices [OK]

Common Mistakes:

• Thinking discounts increase prices
• Confusing discounts with product quality
• Assuming coupons slow checkout

2. Which of the following is the correct way to represent a discount of 20% in a pricing system?

easy

A. discount = 20

B. discount = 2

C. discount = 0.2

D. discount = 200

Solution

1. Step 1: Understand percentage representation in code

   Percentages are usually represented as decimals for calculations, so 20% is 0.2.

2. Step 2: Check each option

   discount = 0.2 uses 0.2 which is correct; others are incorrect as they represent wrong values.

3. Final Answer:

   discount = 0.2 -> Option C

4. Quick Check:

   20% = 0.2 decimal [OK]

Hint: Use decimal for percentage (20% = 0.2) [OK]

Common Mistakes:

• Using whole number 20 instead of decimal
• Confusing 2 or 200 as percentage
• Not converting percentage to decimal

3. Consider this code snippet for applying a coupon discount:

price = 100
coupon_discount = 15  # fixed amount
final_price = price - coupon_discount
print(final_price)

What will be the output?

medium

A. 85

B. 15

C. 100

D. 115

Solution

1. Step 1: Understand the variables

   Price is 100, coupon_discount is 15 fixed amount.

2. Step 2: Calculate final price

   final_price = 100 - 15 = 85.

3. Final Answer:

   85 -> Option A

4. Quick Check:

   100 - 15 = 85 [OK]

Hint: Subtract fixed coupon value from price [OK]

Common Mistakes:

• Confusing discount as percentage
• Adding instead of subtracting discount
• Printing coupon_discount instead of final price

4. In the following code, what is the error that prevents correct discount application?

price = 200
discount = 20  # intended as 20%
final_price = price - discount
print(final_price)

medium

A. Price should be multiplied by discount directly

B. Discount should be converted to decimal before calculation

C. Discount should be added to price

D. No error, code is correct

Solution

1. Step 1: Identify discount representation

   Discount is 20 but intended as 20%, so it should be 0.2 in decimal.

2. Step 2: Correct calculation method

   final_price should be price - (price * discount_decimal), not price - discount integer.

3. Final Answer:

   Discount should be converted to decimal before calculation -> Option B

4. Quick Check:

   20% = 0.2 decimal needed [OK]

Hint: Convert percentage to decimal before subtracting [OK]

Common Mistakes:

• Subtracting integer discount directly
• Adding discount instead of subtracting
• Ignoring percentage to decimal conversion

5. You are designing a system that applies multiple discounts: a 10% seasonal discount and a $5 coupon. If the original price is $50, what is the correct final price after applying both discounts sequentially?

hard

A. $40.5

B. $45

C. $40

D. $42

Solution

1. Step 1: Apply the $5 coupon discount first

   $50 - $5 = $45.

2. Step 2: Apply the 10% seasonal discount

   $45 * 0.9 = $40.5.

3. Step 3: Sequential discounts

   Coupon before percentage discount yields $40.5.

4. Final Answer:

   $40.5 -> Option A

5. Quick Check:

   Coupon then percentage = 40.5 [OK]

Hint: Order of discounts affects final price [OK]

Common Mistakes:

• Applying discounts in wrong order
• Adding discounts instead of subtracting
• Ignoring percentage vs fixed discount difference