Loading...
System Design and AI Engineering, by Roni Das. 974 interactive lessons.
Start LearningIntermediate · Microservices Architecture
The family of design patterns about how objects get created: Singleton, Factory Method, Abstract Factory, Builder and Prototype. They hide the construction details from the code that uses the object.
In short
Creational design patterns are the family of design patterns that control how objects get created, so the code that uses an object does not decide which class to build or how. The Gang of Four list five: Singleton, Factory Method, Abstract Factory, Builder and Prototype.
In short
Creational design patterns are the family of design patterns that control how objects get created, so the code that uses an object does not decide which class to build or how. The Gang of Four list five: Singleton, Factory Method, Abstract Factory, Builder and Prototype.
This page is the free part.
₹499 in India$49 everywhere elseonce, for the whole course
The System Design course covers Creational Design Patterns across a run of lessons, not one page. These 4 alone are about 64 minutes of step-by-step reading, every one with a quiz.
Delegate object creation to a factory, decouple what you use from how it's built.
Ensure a class has only one instance, the most loved and hated design pattern in software.
Attaching permission lists directly to resources, who can do what to this specific object.
Control access to an object by placing a surrogate in front of it, caching, security, and lazy loading in one pattern.
all part of
System Design Masterclass
770 lessons · about 283 hours · 18 free to read
₹499in India, by UPI
$49everywhere else, by PayPal
Ive started this course by accident - LLM advised me this site. When I passed few free lessons, I had no doubt - this course should be bought. And I did it with special pleasent price and it was best decision of the month. Content is great, interesting to read and with a lot of practial cases (what makes it different from other souces and books) I hope to teach all the lessons, that will be my supergoal. Glad that I found this resource and speacial Thank You to Roni Das - Great Job!
You own this course
Continue with Factory Patternpay once,
yours for life
A design pattern is a named, reusable answer to a problem that keeps coming back in code. The 1994 Gang of Four book sorted its 23 patterns into three families. Creational patterns are about making objects. Structural patterns are about fitting objects together. Behavioral patterns are about how objects talk. The design patterns page maps all three.
Every creational pattern answers one question: who decides which object gets built, and how? Without a pattern, the answer is the calling code. It writes new followed by a concrete class name. A concrete class is a real class you can build, as opposed to an interface, which only lists the methods a class must have.
Creational patterns move that decision somewhere else. The caller asks for something it can use, and another piece of code decides what to build.
The Factory lesson opens with a startup in Bangalore. It had written new RazorpayClient() in 47 files. When it needed Stripe for international customers, every one of those files had to change. Not only the payment logic, but the code that created the client too.
The refactor took three months and brought dozens of bugs. The cause was simple. The code mixed two ideas: "I need a payment processor" and "give me a Razorpay instance".
A creational pattern separates them. The code asks for a payment processor. One place decides that, for this region, it means Razorpay or Stripe. The figure shows how the lesson does it with a factory.
Drawn from the lesson Factory Pattern.
Checkout Service passes a region. PaymentFactory reads config, builds the right client with its credentials, and returns it as a PaymentClient. Checkout Service never imports a Stripe or Razorpay type. Switching provider becomes a config change, not a code change.
The Gang of Four list five. This course teaches two of them in full lessons, covers two more briefly inside the Factory lesson, and does not teach the fifth.
These three get mixed up most often. The lesson separates them by what varies.
Singleton is the odd one out. It does not choose a class. It controls how many instances exist. That is why a factory and a singleton combine well: a factory can build an object once, cache it, and return the cached one after that. Go's sync.Once is exactly that factory-with-cache shape.
The lesson's decision chart starts with the simplest choice and adds a pattern only when the problem forces it. Every layer of indirection costs readability, so it has to earn its place.
Dependency injection, or DI, is worth a note here. In DI, a class lists what it needs in its constructor, and a framework builds those objects and passes them in. A DI container already does much of what factories and singletons do. The lesson says to skip a hand-written factory when your DI framework already handles creation.
The Factory lesson warns against overuse. A UserServiceFactory that only ever returns UserService, with no test double and no second implementation planned, adds a layer for zero benefit. The lesson calls that ceremony, not clean architecture.
The same goes for singletons. The Singleton lesson explains why many teams now treat the classic version as an anti-pattern. It hides dependencies and keeps state between tests. Most codebases get the one-instance behavior from a DI container instead.
Creational patterns pay off when creation really does vary: several providers, test fakes, regions, or feature flags. Outside those cases, plain construction is the better design.
Next, compare them with the patterns that wrap objects instead of building them, in structural design patterns. To walk through the payment factory one step at a time, the Factory Pattern lesson is the next step.
Multi-cloud client bundles
The Factory lesson uses a cloud bundle as its Abstract Factory example: an AWS factory that builds S3, SQS and DynamoDB clients together, and a Google Cloud factory that builds GCS, Pub/Sub and Firestore.
NestJS
Providers are singletons by default: the DI container builds one instance and shares it across the application, so code rarely writes a singleton by hand.
Creational, structural and behavioral, the three families from the 1994 Gang of Four book. Creational patterns control how objects are created. Structural patterns control how objects fit together. Behavioral patterns control how objects communicate and share work.
Anything that creates a second instance breaks it. Two threads racing through an unlocked getInstance() is the usual case. In Java, reflection, serialization and cloning can also produce copies. A Java enum with one value resists all of these, because the language forbids extra enum instances.
The same five as in any object-oriented language: Singleton, Factory Method, Abstract Factory, Builder and Prototype. The patterns do not depend on the language. In .NET code you often get the singleton behavior from the built-in container with AddSingleton instead of writing it by hand.
In backend and distributed systems work, Factory Method, according to the Factory lesson. Picking one implementation at runtime by region, config or feature flag comes up constantly. Abstract Factory appears in multi-cloud and cross-platform toolkits, and Builder in HTTP clients and query builders.
Design Patterns
Named, reusable solutions to problems that keep coming up in object-oriented code, such as creating objects, wrapping interfaces or reacting to events. The classic catalogue of 23 was published by the Gang of Four in 1994.
Factory Pattern
A creational design pattern where one method or class decides which concrete object to build, so the calling code asks for an object by type or config instead of calling a constructor directly.
Singleton Pattern
A creational design pattern that makes sure a class has exactly one instance and gives the whole program one shared way to reach it, used for things like a connection pool or a config object.
Structural Design Patterns
The family of design patterns about how classes and objects fit together: Adapter, Bridge, Composite, Decorator, Facade, Flyweight and Proxy. They change how pieces connect without changing what each piece does.
Microservices
An architecture where an application is split into small, independent services that communicate over the network. Each service owns its own data and can be deployed separately.
Monolith
A single, unified application where all features share the same codebase and deployment. Simpler to start with but harder to scale individual parts.
This page explains the idea. The "Factory Pattern" lesson builds it up step by step, with diagrams. It is part of the System Design Masterclass course, which has 770 lessons. 18 of them are free to read. You pay once and keep it for life, with no subscription.
Open the Factory Pattern lessoncourse 1
From absolute beginner to principal engineer, drawn step by step.