Design Patterns in Lightning Web Components(LWC)

Design Patterns in Lightning Web Components(LWC) Salesforce Shastras

Table of Contents:

  1. Introduction: Design Patterns in Lightning Web Components(LWC)
  2. Singleton Pattern
  3. Observer Pattern
  4. Decorator Pattern
  5. Factory Pattern
  6. Making the Most of Design Patterns: Real-Life Examples
  7. Conclusion

Introduction: Design Patterns in LWC

If you’re seeking for a way to supercharge your Salesforce experience by using Design Patterns in Lightning Web Components (LWC), then you’ve landed on the right blog post. This in-depth guide will introduce you to design patterns, their significance in LWC, and practical examples of their application

Singleton Pattern

First up is the Singleton Pattern, a design pattern that restricts the instantiation of a class to a single instance. This ensures consistency, reduces system resources usage, and allows for global accessibility.

  • Purpose: Ensure that a class has only one instance and provides a global point of access to it.
  • Use Case: Use a singleton pattern for managing global state or resources that should have a single instance.
  • Example: You can use a singleton pattern to create a centralized service for managing application state.
   // Singleton.js
   export default class Singleton {
       static instance;

       constructor() {
           if (!Singleton.instance) {
               Singleton.instance = this;

           return Singleton.instance;

Here, the Singleton Pattern allows a single shared instance of a class to be used throughout your LWC, ensuring consistency and eliminating the need for multiple instants.

Observer Pattern

Next in line is the Observer Pattern. This pattern, widely known for its efficiency in handling complex dependencies, allows an object (the Subject) to notify other objects (the Observers) when a change in its state occurs.

  • Purpose: Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
  • Use Case: Use an observer pattern for handling component communication or event-driven architectures.
  • Example: You can use an observer pattern to create a custom event bus for inter-component communication.
   // EventBus.js
   import { LightningElement } from 'lwc';
   const listeners = new Set();

   export function addEventListener(callback) {

   export function removeEventListener(callback) {

   export function dispatchEvent(data) {
       listeners.forEach(listener => listener(data));

In the world of LWC, the Observer Pattern saves you a ton of work by automatically notifying relevant parts of your application when changes occur.

Decorator Pattern

The Decorator Pattern comes to the rescue when you need to add additional functionality to an object dynamically without altering its structure. This is particularly handy when you want to enhance your Salesforce experience with more features and customization.

  • Purpose: Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
  • Use Case: Use a decorator pattern for adding or modifying behavior of Lightning Web Components.
  • Example: You can use a decorator pattern to extend the behavior of a standard component.
   // Decorator.js
   import { LightningElement, api } from 'lwc';

   export default function decorate(Component) {
       return class extends Component {
           @api decoratedProperty;

           connectedCallback() {
               console.log('Decorated Component Connected');

By applying the Decorator Pattern in your LWC, you can easily tailor your Salesforce application to suit your specific needs.

Factory Pattern

Finally, there’s the Factory Pattern, a creational pattern that provides an interface for creating objects, allowing subclasses to determine the type of objects to create.

  • Purpose: Define an interface for creating an object, but let subclasses alter the type of objects that will be created.
  • Use Case: Use a factory pattern for creating instances of components with varying implementations.
  • Example: You can use a factory pattern to create different instances of a component based on certain conditions.
   // ComponentFactory.js
   import FirstComponent from 'c/FirstComponent';
   import SecondComponent from 'c/SecondComponent';

   export default class ComponentFactory {
       createComponent(type) {
           if (type === 'first') {
               return new FirstComponent();
           } else if (type === 'second') {
               return new SecondComponent();
           } else {
               throw new Error('Invalid component type');

In LWC, the Factory Pattern simplifies object creation, making your code cleaner and easier to manage.

Design Patterns: Real-Life Examples

Understanding the theory of design patterns is one thing, but seeing them in action within Lightning Web Components can bring a whole new level of comprehension. Here are some practical examples of how these patterns can be used in real-life applications:

  • Singleton Pattern: Used to manage global configuration in an LWC application.
  • Observer Pattern: Applied to sync price changes across multiple components in a salesforce app.
  • Decorator Pattern: Used to add additional functionality to standard Salesforce components.
  • Factory Pattern: Applied to streamline the creation of multiple, customized Salesforce objects.


Design patterns present an efficient way to solve common problems in software design, and their implementation in Lightning Web Components (LWC) can create a seamless Salesforce experience. Whether it’s the Singleton Pattern for consistency, the Observer Pattern for efficient communication, the Decorator Pattern for increased functionality, or the Factory Pattern for simplified object creation, these design patterns can greatly enhance your LWC.

Utilize these patterns to your advantage, witness the transformation they bring to your Salesforce applications, and don’t forget to share your experience with us in the comment section.

Reference: Introducing Lightning Web Components Recipes, Patterns and Best Practices

2 thoughts on “Design Patterns in Lightning Web Components(LWC)

  1. It was nice reading..
    & please keep updating posts like this, as most of us know how to use this patterns in apex.
    This post encourage as to implement these patterns in LWC as well, and make code cleaner.

Leave a Reply

Your email address will not be published. Required fields are marked *