DRY (Don't Repeat Yourself) in LLD - Scalability & System Analysis

Scalability Analysis - DRY (Don't Repeat Yourself)

Growth Table: DRY Principle Impact

Users / Scale	Codebase Size	Bug Rate	Development Speed	Maintenance Effort
100 users	Small, some repetition	Moderate bugs due to copy-paste	Moderate speed	Manageable
10,000 users	Medium, repetition grows	Increased bugs, inconsistent fixes	Slower due to duplicated logic	Higher effort, more errors
1,000,000 users	Large, many repeated code blocks	High bug rate, hard to fix	Slow, complex merges	Very high, costly maintenance
100,000,000 users	Very large, unmanageable repetition	Critical bugs, system instability	Very slow, risky deployments	Extremely high, technical debt

First Bottleneck: Code Duplication Impact

As the system grows, the main bottleneck caused by ignoring DRY is the maintenance overhead. Repeated code means bugs appear in multiple places. Fixing one place but missing others causes inconsistent behavior. This slows down development and increases risk of failures.

At small scale, this is manageable. But at medium to large scale, duplicated logic causes high bug rates and slow feature delivery. The team spends more time fixing repeated bugs than adding value.

Scaling Solutions: Applying DRY

• Refactor common logic: Extract repeated code into reusable functions, classes, or modules.
• Use libraries and frameworks: Leverage shared components to avoid rewriting code.
• Automate testing: Ensure changes in shared code do not break dependent parts.
• Code reviews and standards: Enforce DRY principles to prevent new duplication.
• Modular design: Design system components with clear responsibilities to reduce overlap.

These solutions reduce bugs, speed up development, and make scaling easier.

Back-of-Envelope Cost Analysis

• At 1,000 users: ~10,000 lines of code with ~10% duplication -> ~1,000 lines repeated.
• At 1,000,000 users: ~1,000,000 lines with ~30% duplication -> ~300,000 lines repeated.
• Bug fixing time increases linearly with duplicated code; fixing one bug may require multiple fixes.
• Maintenance cost grows significantly due to duplicated logic, increasing developer hours and delaying releases.
• Bandwidth and storage are less affected directly by DRY, but indirect costs rise due to slower deployments and more bugs.

Interview Tip: Structuring DRY Scalability Discussion

1. Explain DRY: Define the principle simply as avoiding repeated code to reduce bugs and improve maintainability.

2. Identify bottleneck: Show how duplication causes maintenance overhead and slows development as users grow.

3. Discuss scaling impact: Use examples of bug multiplication and slower feature delivery at larger scale.

4. Propose solutions: Refactoring, modular design, testing, and code reviews to enforce DRY.

5. Summarize benefits: Faster development, fewer bugs, easier scaling.

Self Check Question

Your database handles 1000 QPS. Traffic grows 10x. What do you do first?

Note: This question is unrelated to DRY principle. For DRY, a better self-check is:

Self Check: You notice repeated code causing bugs in multiple places. How do you fix it to improve scalability?

Key Result

Ignoring DRY causes maintenance overhead and bugs to grow rapidly with scale, slowing development and increasing costs. Applying DRY by refactoring and modular design keeps the system maintainable and scalable.

Practice

1. What is the main goal of the DRY principle in system design?

easy

A. To avoid repeating code or design to keep systems simple

B. To write as much code as possible for clarity

C. To duplicate modules for faster development

D. To create multiple versions of the same component

Solution

1. Step 1: Understand the meaning of DRY

   DRY stands for "Don't Repeat Yourself," which means avoiding repeated code or design.

2. Step 2: Identify the goal of DRY

   The goal is to keep systems simple, maintainable, and reduce bugs by reusing components.

3. Final Answer:

   To avoid repeating code or design to keep systems simple -> Option A

4. Quick Check:

   DRY = Avoid repetition [OK]

Hint: DRY means write once, use many times [OK]

Common Mistakes:

• Thinking DRY means writing more code
• Believing duplication speeds development
• Confusing DRY with writing multiple versions

2. Which of the following is a correct way to follow DRY in system design?

easy

A. Creating reusable components or modules

B. Ignoring code reuse to save time

C. Writing separate code for each similar task

D. Copy-pasting the same code in multiple modules

Solution

1. Step 1: Identify DRY best practice

   DRY encourages reuse by creating components or modules that can be used multiple times.

2. Step 2: Evaluate options

   Copy-pasting or writing separate code repeats work, which breaks DRY. Ignoring reuse wastes effort.

3. Final Answer:

   Creating reusable components or modules -> Option A

4. Quick Check:

   Reuse = DRY [OK]

Hint: Reuse code with modules/components [OK]

Common Mistakes:

• Copy-pasting code instead of reusing
• Writing separate code for similar tasks
• Ignoring reuse to save time

3. Consider this pseudocode snippet following DRY:

function calculateTax(amount) {
  return amount * 0.1;
}

function calculateTotal(amount) {
  return amount + calculateTax(amount);
}

print(calculateTotal(100));

What is the output?

medium

A. 10

B. 100

C. 110

D. Syntax Error

Solution

1. Step 1: Calculate tax for amount 100

   Tax = 100 * 0.1 = 10

2. Step 2: Calculate total using tax

   Total = 100 + 10 = 110

3. Final Answer:

   110 -> Option C

4. Quick Check:

   100 + 10 = 110 [OK]

Hint: Add tax to amount using reusable function [OK]

Common Mistakes:

• Forgetting to add tax to amount
• Confusing tax amount with total
• Assuming syntax error without checking code

4. You see this code snippet violating DRY:

function sendEmailToUser1() {
  // send email logic
}

function sendEmailToUser2() {
  // send email logic
}

What is the best fix to follow DRY?

medium

A. Copy-paste send email logic in more functions

B. Create one function sendEmail(user) and reuse it

C. Keep both functions as is for clarity

D. Remove email sending completely

Solution

1. Step 1: Identify repeated code

   Both functions have the same email sending logic repeated.

2. Step 2: Refactor to reusable function

   Create one function with a parameter for user to reuse the logic.

3. Final Answer:

   Create one function sendEmail(user) and reuse it -> Option B

4. Quick Check:

   Refactor repeated code = DRY [OK]

Hint: Use parameters to reuse functions [OK]

Common Mistakes:

• Leaving duplicate functions unchanged
• Copy-pasting code more times
• Removing needed functionality

5. You design a system with multiple services needing user authentication. To follow DRY, which approach is best?

hard

A. Implement authentication logic separately in each service

B. Skip authentication to reduce complexity

C. Copy authentication code into each service for speed

D. Create a shared authentication service used by all services

Solution

1. Step 1: Identify repeated authentication logic

   Multiple services need the same authentication, so repeating code breaks DRY.

2. Step 2: Use a shared authentication service

   Centralizing authentication logic in one service allows reuse and easier maintenance.

3. Final Answer:

   Create a shared authentication service used by all services -> Option D

4. Quick Check:

   Shared service = DRY in system design [OK]

Hint: Centralize common logic in shared services [OK]

Common Mistakes:

• Duplicating authentication code in each service
• Skipping authentication for simplicity
• Copy-pasting code instead of sharing