Anti-patterns to avoid in LLD - System Design Exercise

Design: System Design Anti-patterns Awareness

Discuss common system design anti-patterns, their impact, and avoidance strategies. Out of scope: deep technical implementation details.

Functional Requirements

FR1: Identify common anti-patterns in system design and architecture

FR2: Explain why these anti-patterns cause problems

FR3: Provide guidance on how to avoid these anti-patterns in real projects

Non-Functional Requirements

NFR1: Focus on practical, realistic examples

NFR2: Use simple language accessible to beginners

NFR3: Cover anti-patterns relevant to scalable and maintainable systems

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

Key Components

Monolithic architecture

Tight coupling between components

Ignoring caching strategies

Overusing synchronous calls

Lack of proper data partitioning

Design Patterns

Modular design

Loose coupling

Caching patterns

Asynchronous communication

Database sharding and partitioning

Reference Architecture

Anti-patterns Awareness System

+---------------------+
| User / Learner      |
+----------+----------+
           |
           v
+----------+----------+
| Anti-patterns Guide |
+----------+----------+
           |
           v
+----------+----------+
| Examples & Solutions |
+---------------------+

Components

User Interface

Web or CLI

Allows learners to explore anti-patterns and their impacts

Anti-patterns Repository

Document or database

Stores descriptions and examples of common anti-patterns

Solution Suggestions Module

Logic layer

Provides alternatives and best practices to avoid anti-patterns

Request Flow

1. User requests information about a specific anti-pattern

2. System retrieves anti-pattern description and examples from repository

3. System presents problems caused by the anti-pattern

4. System suggests better design patterns or solutions

5. User reviews and learns how to avoid the anti-pattern

Database Schema

Entities: - AntiPattern { id, name, description, impact, example } - Solution { id, anti_pattern_id, description, best_practice } Relationships: - One AntiPattern has many Solutions

Scaling Discussion

Bottlenecks

Large number of anti-pattern entries causing slow retrieval

Complexity in linking anti-patterns to multiple solutions

Difficulty in updating content as best practices evolve

Solutions

Use indexing and caching for fast lookups

Design flexible schema to support many-to-many relationships if needed

Implement content versioning and easy update mechanisms

Interview Tips

Time: Spend 10 minutes explaining common anti-patterns, 15 minutes discussing their impact and avoidance, 10 minutes on examples and alternatives, and 10 minutes on scaling and maintenance.

Explain what an anti-pattern is and why it matters

Describe specific anti-patterns with real-world examples

Discuss the negative effects on system scalability and maintainability

Show understanding of better design alternatives

Highlight importance of continuous learning and updating design knowledge

Practice

1. Which of the following best describes the God Object anti-pattern in system design?

easy

A. Separating data storage and business logic into different layers.

B. A system design where components are loosely connected and communicate via events.

C. A single component that handles too many responsibilities, making the system hard to maintain.

D. Using multiple small services to handle different tasks independently.

Solution

1. Step 1: Understand the God Object concept and compare options

   The God Object anti-pattern occurs when one component or class takes on too many responsibilities, leading to complex, hard-to-maintain code. A single component that handles too many responsibilities, making the system hard to maintain. matches this description exactly, while others describe good design practices.

2. Final Answer:

   A single component that handles too many responsibilities, making the system hard to maintain. -> Option C

3. Quick Check:

   God Object = Single overloaded component [OK]

Hint: God Object means one part does too much [OK]

Common Mistakes:

• Confusing God Object with microservices
• Thinking God Object is a good modular design
• Mixing God Object with event-driven architecture

2. Which of the following is an example of a hardcoding anti-pattern in system design?

easy

A. Storing configuration values directly inside the source code.

B. Using environment variables for configuration.

C. Separating configuration into external files.

D. Using feature flags to toggle functionality.

Solution

1. Step 1: Identify what hardcoding means and match options

   Hardcoding means embedding fixed values directly in the code, making changes difficult and error-prone. Storing configuration values directly inside the source code. shows storing config inside code, which is hardcoding. Others are best practices.

2. Final Answer:

   Storing configuration values directly inside the source code. -> Option A

3. Quick Check:

   Hardcoding = fixed values in code [OK]

Hint: Hardcoding means fixed values inside code [OK]

Common Mistakes:

• Confusing hardcoding with using environment variables
• Thinking external config files are hardcoding
• Mixing feature flags with hardcoding

3. Consider a system where all modules directly access a single shared database without any abstraction layer. What is the main anti-pattern here?

medium

A. Tight Coupling

B. God Object

C. Spaghetti Architecture

D. Event-Driven Design

Solution

1. Step 1: Analyze direct database access and identify the anti-pattern

   When modules directly access the database without abstraction, they become tightly coupled to the database schema. Tight Coupling means components depend heavily on each other, reducing flexibility and increasing maintenance difficulty.

2. Final Answer:

   Tight Coupling -> Option A

3. Quick Check:

   Direct DB access = Tight Coupling [OK]

Hint: Direct DB access causes tight coupling [OK]

Common Mistakes:

• Confusing tight coupling with God Object
• Thinking event-driven design fits here
• Mixing spaghetti architecture with tight coupling

4. You find a system where many components are tightly interconnected with complex dependencies, making it hard to change one without breaking others. What anti-pattern is this, and how can you fix it?

medium

A. God Object; merge all components into one big class.

B. Spaghetti Architecture; refactor to modular design with clear interfaces.

C. Hardcoding; move all values into source code.

D. Tight Coupling; remove all interfaces and use direct calls.

Solution

1. Step 1: Identify the anti-pattern from description and determine the fix

   Complex interdependencies causing fragility is typical of Spaghetti Architecture. Refactoring to modular design with clear interfaces reduces dependencies and improves maintainability.

2. Final Answer:

   Spaghetti Architecture; refactor to modular design with clear interfaces. -> Option B

3. Quick Check:

   Spaghetti Architecture = tangled dependencies [OK]

Hint: Tangled dependencies = spaghetti; modularize [OK]

Common Mistakes:

• Thinking God Object means merging components
• Confusing hardcoding with architecture issues
• Believing removing interfaces reduces coupling

5. A startup built a monolithic system with many hardcoded values and a God Object managing most logic. They want to scale and maintain it easily. What is the best approach to fix these anti-patterns?

hard

A. Ignore scalability and focus only on adding new features.

B. Keep the monolith but add more hardcoded values for speed.

C. Merge all logic into one bigger God Object for simplicity.

D. Refactor into microservices, externalize configuration, and split responsibilities into smaller components.

Solution

1. Step 1: Identify problems in current system and choose best solution to fix anti-patterns

   Monolith with hardcoded values and God Object causes poor scalability and maintainability. Refactoring into microservices splits responsibilities, externalizing config removes hardcoding, improving scalability and maintainability.

2. Final Answer:

   Refactor into microservices, externalize configuration, and split responsibilities into smaller components. -> Option D

3. Quick Check:

   Microservices + external config fix anti-patterns [OK]

Hint: Split monolith, externalize config, avoid God Object [OK]

Common Mistakes:

• Thinking bigger God Object improves simplicity
• Adding more hardcoding for speed
• Ignoring scalability needs