When to use which creational pattern in LLD - Architecture Diagram

System Overview - When to use which creational pattern

This system helps developers decide which creational design pattern to use based on their software creation needs. It guides through common scenarios like object creation complexity, reuse, and flexibility requirements.

Architecture Diagram

User
  |
  v
Load Balancer
  |
  v
API Gateway
  |
  v
Decision Service
  |
  +-----------------------------+
  |                             |
  v                             v
Factory Pattern Module      Singleton Pattern Module
  |                             |
  v                             v
Prototype Pattern Module    Builder Pattern Module
  |
  v
Response Module
  |
  v
User

Components

User

actor

Developer or system requesting pattern recommendation

Load Balancer

load_balancer

Distributes incoming requests evenly to API Gateway instances

API Gateway

api_gateway

Handles client requests and routes them to the Decision Service

Decision Service

service

Analyzes input criteria and selects the appropriate creational pattern

Factory Pattern Module

service_module

Provides logic and examples for Factory pattern usage

Singleton Pattern Module

service_module

Provides logic and examples for Singleton pattern usage

Prototype Pattern Module

service_module

Provides logic and examples for Prototype pattern usage

Builder Pattern Module

service_module

Provides logic and examples for Builder pattern usage

Response Module

service_module

Formats and sends the pattern recommendation back to the user

Request Flow - 9 Hops

User → Load Balancer

Load Balancer → API Gateway

API Gateway → Decision Service

Decision Service → Factory Pattern Module

Decision Service → Singleton Pattern Module

Decision Service → Prototype Pattern Module

Decision Service → Builder Pattern Module

Decision Service → Response Module

Response Module → User

Failure Scenario

Component Fails:Decision Service

Impact:Pattern recommendation cannot be made; user receives error or no response

Mitigation:Use service replication and health checks to failover to a healthy instance; cache last successful recommendations for fallback

Architecture Quiz - 3 Questions

Which component decides which creational pattern to recommend?

A Decision Service

B Load Balancer

C API Gateway

D Response Module

Design Principle

This architecture demonstrates modular decision-making by separating pattern evaluation into dedicated modules. It uses load balancing and API gateway to ensure scalability and manageability. The system isolates concerns, making it easier to maintain and extend with new patterns.

Practice

1. Which creational pattern is best when you need only one instance of a class throughout the application?

easy

A. Singleton pattern

B. Factory pattern

C. Builder pattern

D. Prototype pattern

Solution

1. Step 1: Understand the requirement for a single instance

   The question asks for a pattern that ensures only one instance of a class exists.

2. Step 2: Match the pattern to the requirement

   Singleton pattern restricts instantiation to one object and provides a global access point.

3. Final Answer:

   Singleton pattern -> Option A

4. Quick Check:

   Single instance = Singleton [OK]

Hint: Single instance? Think Singleton pattern [OK]

Common Mistakes:

• Confusing Factory with Singleton
• Using Builder for single instance
• Thinking Prototype creates single instance

2. Which creational pattern allows creating different types of objects without specifying their concrete classes directly?

easy

A. Singleton pattern

B. Factory pattern

C. Builder pattern

D. Adapter pattern

Solution

1. Step 1: Identify the pattern for flexible object creation

   The question wants a pattern that creates objects without exposing the creation logic.

2. Step 2: Match the pattern to the description

   Factory pattern provides an interface to create objects but lets subclasses decide which class to instantiate.

3. Final Answer:

   Factory pattern -> Option B

4. Quick Check:

   Flexible object creation = Factory [OK]

Hint: Flexible creation? Use Factory pattern [OK]

Common Mistakes:

• Choosing Singleton for flexible creation
• Confusing Builder with Factory
• Selecting Adapter which is not creational

3. Consider this code snippet using the Builder pattern:

class CarBuilder {
  constructor() {
    this.car = new Car();
  }
  setColor(color) {
    this.car.color = color;
    return this;
  }
  setWheels(wheels) {
    this.car.wheels = wheels;
    return this;
  }
  build() {
    return this.car;
  }
}

const car = new CarBuilder().setColor('red').setWheels(4).build();
console.log(car.color, car.wheels);

What will be the output?

medium

A. red 4

B. undefined undefined

C. red undefined

D. Error: Car is not defined

Solution

1. Step 1: Check if Car class is defined

   The code uses new Car() but Car class is not defined anywhere, causing a runtime error.

2. Step 2: Understand the consequence of missing class

   Since Car is undefined, the code throws a ReferenceError before any properties are set.

3. Final Answer:

   Error: Car is not defined -> Option D

4. Quick Check:

   Missing class definition = ReferenceError [OK]

Hint: Check if all classes are defined before use [OK]

Common Mistakes:

• Assuming output is 'red 4' without Car class
• Ignoring missing class error
• Confusing Builder pattern with Factory output

4. You have a Singleton class implemented as below:

class Logger {
  constructor() {
    if (Logger.instance) {
      return Logger.instance;
    }
    this.logs = [];
    Logger.instance = this;
  }
  log(message) {
    this.logs.push(message);
  }
}

What is the main issue with this implementation?

medium

A. It creates a new instance every time

B. It does not store logs properly

C. It does not prevent multiple instances

D. It lacks a method to retrieve logs

Solution

1. Step 1: Analyze Singleton enforcement

   The constructor returns existing instance if present, but the implementation does not fully prevent multiple instances.

2. Step 2: Identify the issue in JavaScript context

   In JavaScript, this pattern works but can be bypassed by other means; better to use static method to get instance.

3. Final Answer:

   It does not prevent multiple instances -> Option C

4. Quick Check:

   Singleton enforcement flaw = It does not prevent multiple instances [OK]

Hint: Singleton needs controlled instance creation [OK]

Common Mistakes:

• Thinking logs are not stored
• Assuming new instance is always created
• Ignoring missing retrieval method

5. You are designing a system to create complex meal orders with many optional parts (drink, main dish, dessert). Which creational pattern is most suitable and why?

hard

A. Builder pattern, because it simplifies creating complex objects step-by-step

B. Singleton pattern, because only one meal order should exist

C. Factory pattern, because it creates different meal types without specifying details

D. Prototype pattern, because it clones existing meal orders

Solution

1. Step 1: Understand the complexity of the object

   Meal orders have many optional parts and require step-by-step construction.

2. Step 2: Match pattern to complex object creation

   Builder pattern is designed to build complex objects step-by-step, allowing optional parts to be added flexibly.

3. Final Answer:

   Builder pattern, because it simplifies creating complex objects step-by-step -> Option A

4. Quick Check:

   Complex object with options = Builder [OK]

Hint: Complex object? Use Builder pattern [OK]

Common Mistakes:

• Choosing Singleton for multiple orders
• Confusing Factory with Builder for complex objects
• Using Prototype without cloning need