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

Design: Pricing Strategy System

Design covers discount and coupon management, validation, application logic, and usage tracking. Payment processing and product catalog are out of scope.

Functional Requirements

FR1: Support multiple types of discounts: percentage off, fixed amount off, buy-one-get-one (BOGO)

FR2: Allow creation and management of coupons with unique codes

FR3: Coupons can have constraints: expiration date, usage limits per user and overall

FR4: Apply discounts and coupons during checkout to calculate final price

FR5: Support stacking rules: which discounts can be combined or are exclusive

FR6: Track coupon usage for analytics and enforcement

FR7: Provide APIs for frontend to validate and apply discounts in real-time

Non-Functional Requirements

NFR1: Handle up to 10,000 concurrent users applying discounts

NFR2: API response time for discount validation must be under 100ms p99

NFR3: System availability target 99.9% uptime

NFR4: Ensure data consistency for coupon usage counts to prevent overuse

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

Key Components

Discount and coupon management service

Validation engine for applying rules

API gateway for frontend integration

Database for storing coupons, discounts, and usage data

Cache layer for fast lookup of active coupons

Analytics and reporting module

Design Patterns

Rule engine pattern for flexible discount logic

Cache aside pattern for coupon data caching

Circuit breaker for external dependencies

Event sourcing or transactional outbox for usage tracking

Rate limiting to prevent abuse

Reference Architecture

  +-------------+       +---------------------+       +----------------+
  |  Frontend   | <---> | API Gateway / Proxy | <---> | Discount Service|
  +-------------+       +---------------------+       +----------------+
                                                      |        |
                                                      |        v
                                                      |   +------------+
                                                      |   | Cache (Redis)|
                                                      |   +------------+
                                                      |        |
                                                      v        v
                                                +---------------------+
                                                |  Relational Database |
                                                | (Coupons, Discounts, |
                                                |  Usage Tracking)     |
                                                +---------------------+

  +---------------------+
  | Analytics & Reporting|
  +---------------------+

Components

Frontend

Any web/mobile client

User interface to enter coupon codes and see discounted prices

API Gateway / Proxy

Nginx, Envoy, or cloud API Gateway

Route requests, handle authentication, rate limiting

Discount Service

Microservice in preferred language (e.g., Node.js, Python)

Core logic for discount and coupon validation, application, and usage tracking

Cache (Redis)

Redis

Store active coupons and discount rules for fast validation

Relational Database

PostgreSQL or MySQL

Persist coupons, discount definitions, usage counts, and constraints

Analytics & Reporting

Data warehouse or BI tools

Analyze coupon usage patterns and effectiveness

Request Flow

1. User enters coupon code at checkout in frontend.

2. Frontend sends coupon code and cart details to API Gateway.

3. API Gateway forwards request to Discount Service.

4. Discount Service checks Redis cache for coupon validity and rules.

5. If not in cache, Discount Service queries database and updates cache.

6. Discount Service validates coupon constraints (expiration, usage limits).

7. Discount Service applies discount rules to calculate final price.

8. Discount Service updates usage count transactionally in database.

9. Discount Service returns discounted price and validation status to frontend.

10. Frontend displays final price and discount details to user.

Database Schema

Entities: - Coupon: id (PK), code (unique), type (percentage, fixed, BOGO), value, expiration_date, max_usage, max_usage_per_user, combinable (bool) - DiscountRule: id (PK), coupon_id (FK), rule_type, parameters (JSON) - CouponUsage: id (PK), coupon_id (FK), user_id, usage_count - User: id (PK), user details Relationships: - Coupon has many DiscountRules - CouponUsage tracks usage per user per coupon - Constraints enforced via Coupon fields and CouponUsage counts

Scaling Discussion

Bottlenecks

Database write contention on coupon usage counts under high concurrency

Cache invalidation delays causing stale coupon data

API Gateway becoming a bottleneck with many concurrent requests

Complex discount rule evaluation increasing response latency

Solutions

Use optimistic locking or atomic counters in database to handle concurrent usage updates

Implement cache expiration and event-driven cache invalidation on coupon updates

Scale API Gateway horizontally with load balancing

Precompute discount rules where possible and optimize rule engine for performance

Interview Tips

Time: 10 minutes for requirements and clarifications, 20 minutes for architecture and data flow, 10 minutes for scaling and trade-offs, 5 minutes for questions

Clarify discount types and stacking rules early

Explain how caching improves performance and reduces DB load

Discuss data consistency strategies for usage tracking

Highlight how the system prevents coupon abuse

Mention scalability considerations and bottleneck mitigation

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