YAGNI (You Aren't Gonna Need It) in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identifying YAGNI Violations in Feature Planning

You are designing a simple note-taking app. The team suggests adding a complex tagging system with nested tags and tag analytics before the app's first release. Which statement best reflects the YAGNI principle?

A Implement the tagging system now to avoid rework later.

B Design the app assuming the tagging system will be needed soon.

C Add the tagging system partially to test user interest.

D Skip the tagging system until users request it or it becomes necessary.

💡 Hint

YAGNI encourages avoiding building features before they are truly needed.

YAGNI means you should not add functionality until it is necessary. Adding complex features early can waste time and resources.

❓ Architecture

intermediate

Applying YAGNI in System Architecture Decisions

You are designing a web service expected to handle 100 requests per second initially. The team suggests building a microservices architecture with complex service discovery and load balancing from the start. According to YAGNI, what is the best approach?

A Build the microservices architecture now to prepare for future growth.

B Implement microservices but disable service discovery until needed.

C Start with a simple monolithic design and refactor if scaling is needed.

D Design the system with microservices but use a single database for simplicity.

💡 Hint

Consider starting simple and only adding complexity when justified.

YAGNI advises against premature optimization or over-engineering. Starting simple reduces complexity and development time.

❓ scaling

advanced

Estimating Capacity Without Over-Engineering

Your team plans to build a chat application. They want to provision servers to handle 1 million concurrent users immediately, but current projections estimate only 10,000 users in the first year. How does YAGNI guide your capacity planning?

A Provision servers for 500,000 users as a compromise.

B Provision capacity for 10,000 users and scale up as demand grows.

C Provision servers for 1 million users now to avoid downtime later.

D Use cloud auto-scaling but configure it for maximum capacity upfront.

💡 Hint

Think about starting with what is needed, not what might be needed.

YAGNI suggests not preparing for unlikely future scenarios prematurely. Start with realistic capacity and scale as needed.

❓ tradeoff

advanced

Balancing YAGNI with Future-Proofing

You are designing a payment processing system. The team debates whether to support multiple currencies now or add it later. Supporting multiple currencies adds complexity but may attract more users in the future. How should YAGNI influence this decision?

A Design the system with multi-currency in mind but implement only one currency initially.

B Build the system for one currency and add multi-currency support only if needed.

C Implement multi-currency support now to avoid costly refactoring later.

D Ignore multi-currency support entirely as it is not needed now.

💡 Hint

Consider designing for flexibility without adding unnecessary features immediately.

YAGNI encourages avoiding unnecessary features but does not forbid designing for easy extension later.

❓ component

expert

Identifying YAGNI Violations in Low-Level Design

Examine the following class design for a user profile component. Which part violates YAGNI?

class UserProfile {
  String username;
  String email;
  String phoneNumber;
  String address;
  Map socialMediaLinks; // planned for future use
  List favoriteGenres; // planned for future use

  void updateEmail(String newEmail) { /* ... */ }
  void updatePhoneNumber(String newPhone) { /* ... */ }
  // Methods for socialMediaLinks and favoriteGenres not implemented yet
}

LLD

class UserProfile {
  String username;
  String email;
  String phoneNumber;
  String address;
  Map<String, String> socialMediaLinks; // planned for future use
  List<String> favoriteGenres; // planned for future use

  void updateEmail(String newEmail) { /* ... */ }
  void updatePhoneNumber(String newPhone) { /* ... */ }
  // Methods for socialMediaLinks and favoriteGenres not implemented yet
}

A Including socialMediaLinks and favoriteGenres fields before they are needed.

B Not implementing update methods for socialMediaLinks and favoriteGenres yet.

C Having updateEmail and updatePhoneNumber methods implemented.

D Including username, email, phoneNumber, and address fields.

💡 Hint

YAGNI warns against adding unused features or data structures prematurely.

Adding fields for future features that are not yet needed or implemented violates YAGNI by increasing complexity unnecessarily.