Anti-patterns to avoid in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identifying the God Object Anti-pattern

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

A A pattern where data is stored in multiple redundant databases for fault tolerance.

B A design where multiple small classes each handle a single responsibility.

C A system design that uses microservices to distribute workload evenly.

D A single class or module that handles too many responsibilities, making the system hard to maintain.

💡 Hint

Think about what happens when one part of the system tries to do everything.

The God Object anti-pattern occurs when one class or module takes on too many roles, leading to complex, hard-to-maintain code.

❓ Architecture

intermediate

Recognizing Tight Coupling in System Components

Which option illustrates tight coupling between system components, an anti-pattern to avoid?

A Components directly depend on each other's internal implementations, making changes risky.

B Components are loosely connected via asynchronous messaging.

C Components communicate through well-defined interfaces and abstractions.

D Components are designed as independent microservices with clear APIs.

💡 Hint

Consider what happens when changing one component forces changes in others.

Tight coupling means components rely heavily on each other's internal details, causing fragility and difficulty in maintenance.

❓ scaling

advanced

Impact of the Spaghetti Code Anti-pattern on Scalability

What is the main scalability issue caused by the Spaghetti Code anti-pattern in system design?

A The code is tangled and unstructured, making it hard to isolate and scale individual components.

B The system uses too many microservices, causing overhead in communication.

C The system relies on caching, which can cause stale data issues.

D The database schema is normalized, leading to complex joins.

💡 Hint

Think about how messy code affects the ability to grow parts of the system.

Spaghetti Code is tangled and lacks clear structure, making it difficult to separate and scale parts of the system independently.

❓ tradeoff

advanced

Tradeoff of Premature Optimization Anti-pattern

What is a common negative tradeoff when applying premature optimization in system design?

A It always improves system performance with no downsides.

B It increases complexity and development time without significant performance benefits.

C It reduces code readability but improves scalability automatically.

D It simplifies the codebase by removing unnecessary features early.

💡 Hint

Consider what happens when you optimize before understanding the real bottlenecks.

Premature optimization can make code complex and harder to maintain, often wasting time on parts that don't impact performance much.

❓ component

expert

Detecting the Bottleneck in a Monolithic Architecture

In a monolithic system where the database becomes a bottleneck, which anti-pattern is most likely causing this issue?

A Microservices with independent databases causing data inconsistency.

B Event-driven architecture causing delayed responses.

C Single Point of Failure due to centralized database handling all requests.

D Load balancing distributing requests evenly across multiple databases.

💡 Hint

Think about what happens when one component handles too much traffic alone.

A monolithic system with a single database can create a single point of failure and bottleneck, limiting scalability and reliability.