YAGNI (You Aren't Gonna Need It) in LLD - System Design Guide

Problem Statement

Developers often add features or code for future needs that never happen. This leads to bloated, complex code that is hard to maintain and slows down development.

Solution

YAGNI advises to only build what is needed right now. By focusing on current requirements, the code stays simple and easier to understand. Future features are added only when they become necessary.

Architecture

Current Need

→Build Feature

↓

Future Assumptions

─────────┘

This diagram shows that only current needs trigger feature development, while future assumptions are ignored until they become real needs.

Trade-offs

✓ Pros

→

Keeps codebase simple and easier to maintain.

→

Reduces wasted development time on unused features.

→

Improves focus on delivering immediate value.

✗ Cons

→

May require refactoring when future needs arise.

→

Can cause repeated work if assumptions change frequently.

→

Some upfront design for extensibility might be missed.

Use when requirements are unclear or likely to change, and when rapid delivery of core features is critical.

Avoid when building safety-critical systems where anticipating future needs is essential to prevent failures.

Real World Examples

Basecamp

Basecamp emphasizes YAGNI to keep their project management tool simple and avoid feature bloat that confuses users.

Spotify

Spotify uses YAGNI to focus on core music streaming features first, adding new capabilities only when user demand is proven.

Code Example

The before code adds address and phone fields anticipating future needs, increasing complexity. The after code keeps only the current requirement, making the class simpler and easier to maintain.

LLD

### Before applying YAGNI (violating) ###
class UserProfile:
    def __init__(self, name):
        self.name = name
        self.address = None  # planned for future use
        self.phone = None    # planned for future use

    def set_address(self, address):
        self.address = address

    def set_phone(self, phone):
        self.phone = phone

### After applying YAGNI (applying) ###
class UserProfile:
    def __init__(self, name):
        self.name = name

# Add address and phone only when needed

Alternatives

Big Design Up Front (BDUF)

BDUF plans and designs all features before coding, unlike YAGNI which builds only what is needed now.

Use when: Choose BDUF when requirements are stable and system safety or compliance demands thorough upfront design.

Incremental Design

Incremental Design evolves the system step-by-step, balancing some upfront planning with YAGNI's minimal initial design.

Use when: Choose Incremental Design when some foresight is needed but flexibility is still important.

Summary

YAGNI prevents wasted effort by building only what is needed now.

It keeps code simple and focused on current requirements.

YAGNI requires balancing simplicity with readiness for future changes.

Practice

1. What does the YAGNI principle primarily encourage in system design?

easy

A. Build only features you currently need

B. Plan and build all possible future features

C. Add complex layers for scalability upfront

D. Write extra code for potential edge cases

Solution

1. Step 1: Understand YAGNI meaning

   YAGNI stands for "You Aren't Gonna Need It" and advises to avoid building features before they are necessary.

2. Step 2: Match principle to options

   Build only features you currently need matches the idea of building only what is needed now, while others suggest building for future or complexity.

3. Final Answer:

   Build only features you currently need -> Option A

4. Quick Check:

   YAGNI = Build only what you need now [OK]

Hint: YAGNI means avoid future guesswork, build now only [OK]

Common Mistakes:

• Thinking YAGNI means planning for all future needs
• Confusing YAGNI with over-engineering
• Assuming YAGNI discourages any planning

2. Which of the following is the correct way to apply YAGNI when designing a new feature in a system?

easy

A. Add detailed logging for every possible error before deployment

B. Design the database schema to handle all future data types

C. Write unit tests for features you plan to add later

D. Implement only the core functionality needed for the feature now

Solution

1. Step 1: Identify core YAGNI practice

   YAGNI advises to implement only what is necessary now, avoiding premature additions.

2. Step 2: Evaluate options for current need focus

   Implement only the core functionality needed for the feature now focuses on core functionality now, while others add future or unnecessary work.

3. Final Answer:

   Implement only the core functionality needed for the feature now -> Option D

4. Quick Check:

   YAGNI = Build core now, skip extras [OK]

Hint: Focus on core feature first, skip extras [OK]

Common Mistakes:

• Adding features or tests for future needs
• Over-engineering database for unknown data
• Writing unnecessary logs before real errors occur

3. Consider this scenario: A team adds a caching layer anticipating high traffic, but the system never reaches that load. What does this violate in terms of YAGNI?

medium

A. They avoided unnecessary complexity

B. They followed YAGNI by preparing for future needs

C. They built a feature they didn't need yet

D. They simplified the system by adding cache

Solution

1. Step 1: Analyze the caching layer addition

   The team added caching before it was needed, anticipating future load.

2. Step 2: Relate to YAGNI principle

   YAGNI discourages building features before they are actually needed, so this is a violation.

3. Final Answer:

   They built a feature they didn't need yet -> Option C

4. Quick Check:

   YAGNI violation = building unneeded features [OK]

Hint: Building features before need breaks YAGNI [OK]

Common Mistakes:

• Thinking preparing for future is YAGNI
• Confusing simplification with premature optimization
• Assuming caching always simplifies system

4. A developer added a complex permission system anticipating many user roles, but the product currently has only one role. What is the main issue here related to YAGNI?

medium

A. The developer ignored YAGNI by adding unnecessary complexity

B. The permission system is too simple for current needs

C. The system is scalable and follows YAGNI

D. The product requires multiple roles immediately

Solution

1. Step 1: Identify the developer's action

   The developer added a complex system for roles not currently needed.

2. Step 2: Connect to YAGNI principle

   YAGNI advises against adding complexity before it's necessary, so this is a violation.

3. Final Answer:

   The developer ignored YAGNI by adding unnecessary complexity -> Option A

4. Quick Check:

   Unneeded complexity violates YAGNI [OK]

Hint: Avoid complexity until it's truly needed [OK]

Common Mistakes:

• Assuming scalability means following YAGNI
• Believing all future roles must be planned now
• Confusing simple with insufficient

5. You are designing a messaging system. You consider adding encryption support now, but the current users do not require it. According to YAGNI, what should you do?

hard

A. Implement encryption now to avoid future rework

B. Skip encryption for now and add it when users need it

C. Design the system assuming all messages are encrypted

D. Build a complex key management system upfront

Solution

1. Step 1: Understand current user needs

   Users do not require encryption now, so it is not immediately necessary.

2. Step 2: Apply YAGNI principle to design decision

   YAGNI advises to avoid building features before they are needed, so skip encryption now.

3. Final Answer:

   Skip encryption for now and add it when users need it -> Option B

4. Quick Check:

   YAGNI = build features only when needed [OK]

Hint: Add features only when users actually need them [OK]

Common Mistakes:

• Building features just to avoid future work
• Assuming all users need encryption immediately
• Over-engineering system upfront