Builder pattern in LLD - System Design Exercise

Design: Builder Pattern Implementation

Design and implement the builder pattern for creating complex objects in a low-level design context. Out of scope: integration with UI or persistence layers.

Functional Requirements

FR1: Create complex objects step-by-step with different configurations

FR2: Separate construction logic from the final object representation

FR3: Allow reuse of the construction process for different object types

FR4: Support immutability of the final constructed object

FR5: Enable chaining of builder methods for easy readability

Non-Functional Requirements

NFR1: Construction process should be flexible and extensible

NFR2: Final object creation should be thread-safe if used concurrently

NFR3: Minimize code duplication in object creation

NFR4: Keep the builder interface simple and intuitive

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Builder interface or abstract class defining construction steps

Concrete builder classes implementing the steps

Director class to control the building process (optional)

Product class representing the complex object

Client code that uses the builder to create objects

Design Patterns

Fluent interface for chaining builder methods

Immutable object pattern for the final product

Factory pattern for creating builders

Separation of concerns between construction and representation

Reference Architecture

Client --> Builder Interface --> Concrete Builder --> Product
          \                                   /
           --------> Director (optional) <---

Components

Builder Interface

Abstract class or interface in chosen language

Defines methods for building parts of the product

Concrete Builder

Class implementing Builder Interface

Implements construction steps and assembles the product

Product

Immutable class or data structure

Represents the complex object being built

Director (optional)

Class controlling the building sequence

Encapsulates the order of building steps

Client

User code

Uses builder to create product instances

Request Flow

1. Client creates a Concrete Builder instance

2. Client optionally creates a Director and passes the builder

3. Director calls builder methods in a specific order to build the product

4. Builder assembles parts internally during method calls

5. Client calls builder's getResult() to retrieve the final Product

6. Product is returned as an immutable object

Database Schema

Not applicable for Builder pattern as it is a design pattern for object creation, not data storage.

Scaling Discussion

Bottlenecks

Complexity grows if many product variations require many builder subclasses

Thread safety issues if builder instances are shared across threads

Excessive chaining can reduce readability if not designed well

Solutions

Use parameter objects or configuration classes to reduce number of builder subclasses

Ensure each thread uses its own builder instance or synchronize builder methods

Design fluent interfaces carefully to maintain clarity and avoid long chains

Interview Tips

Time: 10 minutes to explain the pattern and components, 15 minutes to design and draw the architecture, 10 minutes to discuss scaling and trade-offs, 10 minutes for Q&A

Explain separation of construction and representation

Highlight benefits of immutability and method chaining

Discuss optional Director role and when to use it

Show understanding of thread safety and extensibility

Relate pattern usage to real-world examples like building complex UI components or configuration objects

Practice

1. What is the main purpose of the Builder pattern in system design?

easy

A. To construct complex objects step by step, separating construction from representation

B. To enforce a single instance of a class throughout the system

C. To provide a way to access elements of a collection sequentially

D. To define a family of algorithms and make them interchangeable

Solution

1. Step 1: Understand Builder pattern purpose

   The Builder pattern is designed to create complex objects step by step, allowing different representations.

2. Step 2: Compare with other patterns

   Options A, C, and D describe Singleton, Iterator, and Strategy patterns respectively, not Builder.

3. Final Answer:

   To construct complex objects step by step, separating construction from representation -> Option A

4. Quick Check:

   Builder pattern = stepwise construction [OK]

Hint: Builder pattern builds complex objects stepwise [OK]

Common Mistakes:

• Confusing Builder with Singleton pattern
• Thinking Builder manages object access, not construction
• Mixing Builder with Strategy or Iterator patterns

2. Which of the following is the correct way to implement method chaining in a Builder class?

easy

A. Each setter method returns a new Builder instance every time

B. Each setter method returns void and does not return anything

C. Each setter method returns the final built object immediately

D. Each setter method returns this (the builder instance) to allow chaining

Solution

1. Step 1: Understand method chaining in Builder

   Method chaining requires each setter to return the builder instance (this) so calls can be chained.

2. Step 2: Analyze other options

   Returning void breaks chaining; returning new builder instances is inefficient; returning final object ends chain prematurely.

3. Final Answer:

   Each setter method returns this (the builder instance) to allow chaining -> Option D

4. Quick Check:

   Method chaining = return this [OK]

Hint: Return 'this' in setters for chaining [OK]

Common Mistakes:

• Returning void and expecting chaining
• Creating new builder instances in setters
• Returning final object too early

3. Given the following Builder usage code, what will be the output?

class House {
  constructor(walls, doors) {
    this.walls = walls;
    this.doors = doors;
  }
  describe() {
    return `House with ${this.walls} walls and ${this.doors} doors.`;
  }
}

class HouseBuilder {
  constructor() {
    this.walls = 0;
    this.doors = 0;
  }
  setWalls(count) {
    this.walls = count;
    return this;
  }
  setDoors(count) {
    this.doors = count;
    return this;
  }
  build() {
    return new House(this.walls, this.doors);
  }
}

const house = new HouseBuilder().setWalls(4).setDoors(2).build();
console.log(house.describe());

medium

A. House with 4 walls and 2 doors.

B. House with 0 walls and 0 doors.

C. House with 2 walls and 4 doors.

D. Error: setWalls and setDoors do not return builder

Solution

1. Step 1: Trace method calls and values

   The builder sets walls to 4 and doors to 2, then builds a House with these values.

2. Step 2: Check describe output

   The describe method returns a string with walls and doors values, so output is 'House with 4 walls and 2 doors.'

3. Final Answer:

   House with 4 walls and 2 doors. -> Option A

4. Quick Check:

   Builder sets walls=4, doors=2 [OK]

Hint: Follow method chain values stepwise [OK]

Common Mistakes:

• Mixing walls and doors values
• Assuming setters don't return builder
• Ignoring build() method output

4. Identify the error in this Builder pattern implementation:

class CarBuilder {
  constructor() {
    this.color = '';
  }
  setColor(color) {
    this.color = color;
  }
  build() {
    return { color: this.color };
  }
}

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

medium

A. build method returns wrong object type

B. setColor does not return the builder instance, so chaining fails

C. Constructor does not initialize color properly

D. No error, code works fine

Solution

1. Step 1: Check method chaining in setColor

   setColor does not return this, so chaining to build() fails.

2. Step 2: Analyze consequences

   Because setColor returns undefined, calling build() immediately after causes an error or unexpected behavior.

3. Final Answer:

   setColor does not return the builder instance, so chaining fails -> Option B

4. Quick Check:

   Missing 'return this' breaks chaining [OK]

Hint: Setters must return 'this' for chaining [OK]

Common Mistakes:

• Ignoring missing return in setter
• Thinking build returns wrong type
• Assuming constructor error

5. You need to design a system to build customizable computer configurations with optional components like GPU, RAM, and Storage. Which Builder pattern approach best supports this requirement?

hard

A. Build the computer object directly without a builder, setting all fields in constructor

B. Use multiple Builder classes, each building a fixed configuration without chaining

C. Create a single Builder class with methods for each optional component, returning the builder for chaining

D. Use a factory method that returns pre-built fixed configurations only

Solution

1. Step 1: Analyze requirement for optional components

   Optional components require flexible, stepwise construction with chaining for readability.

2. Step 2: Evaluate options

   Create a single Builder class with methods for each optional component, returning the builder for chaining supports chaining and optional parts; B lacks chaining and flexibility; C is inflexible; D only returns fixed configs.

3. Final Answer:

   Create a single Builder class with methods for each optional component, returning the builder for chaining -> Option C

4. Quick Check:

   Flexible builder with chaining fits optional parts [OK]

Hint: Use one builder with chaining for optional parts [OK]

Common Mistakes:

• Using multiple builders without chaining
• Setting all options in constructor (inflexible)
• Relying on fixed pre-built configurations only