Loading...
System Design and AI Engineering, by Roni Das. 974 interactive lessons.
Start LearningIntermediate · Microservices Architecture
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.
In short
Design patterns are named, reusable solutions to problems that keep coming up in object-oriented code, such as creating objects, wrapping an interface or reacting to an event. The classic catalogue of 23 comes from the 1994 Gang of Four book, sorted into creational, structural and behavioral patterns.
In short
Design patterns are named, reusable solutions to problems that keep coming up in object-oriented code, such as creating objects, wrapping an interface or reacting to an event. The classic catalogue of 23 comes from the 1994 Gang of Four book, sorted into creational, structural and behavioral patterns.
This page is the free part.
₹499 in India$49 everywhere elseonce, for the whole course
The System Design course covers Design Patterns across a run of lessons, not one page. These 4 alone are about 78 minutes of step-by-step reading, every one with a quiz.
Ensure a class has only one instance, the most loved and hated design pattern in software.
Two fundamental architecture patterns that shape how systems handle data, scale, and recover from failure.
Delegate object creation to a factory, decouple what you use from how it's built.
Let objects subscribe to events and react when something changes, the foundation of event-driven systems.
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 Singleton Patternpay once,
yours for life
Some problems show up in almost every codebase. You need exactly one connection pool. You need to swap Stripe for Razorpay without editing 47 files. You need several services to react when an order is placed. Each of these has been solved many times, and the good solutions look alike.
A design pattern is a name for one of those good solutions. It is not a library you install or code you copy. It is a shape: which objects exist, what each one is responsible for, and how they call each other. You adapt the shape to your own classes.
The name matters as much as the shape. When an engineer says "put a proxy in front of it" or "that is an observer", the team knows the whole design from two words. That shared vocabulary is a large part of why patterns are taught.
The standard catalogue is the 1994 book Design Patterns: Elements of Reusable Object-Oriented Software. Its four authors, Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, are known as the Gang of Four, or GoF. The book describes 23 patterns.
Two principles run through the book. Program to an interface, not an implementation. An interface is a list of methods a class promises to have, so code that depends on the interface works with any class that keeps the promise. And favor object composition over class inheritance. Composition means building behavior by holding other objects, instead of by extending a parent class.
You will see both ideas again and again below. The factory, strategy, adapter and decorator all rely on code that talks to an interface. The decorator exists mainly to replace deep inheritance with composition.
The Gang of Four sorted the 23 patterns by the kind of problem they solve.
Knowing the family is the first step to picking a pattern. If your problem is about building objects, look in the creational family. If it is about wrapping or connecting existing objects, look in the structural one. If it is about who reacts to what, look in the behavioral one.
The course teaches eleven of the 23 in full lessons, chosen for how often they appear in backend and distributed systems. The figure places each in its family, with its job in a few words taken from its lesson.
Drawn from the lesson Singleton Pattern.
One more has its own page. The State pattern gives an object a separate object for each state and swaps it when the state changes. The course has no lesson on the pattern itself, but it teaches the idea underneath, state machines, in the Finite State Machine lesson.
These patterns were written for classes inside one program. The lessons show the same shapes at the scale of services.
A pattern adds a layer of indirection, and every layer costs some readability. The lessons repeat one warning: add a pattern only when the problem forces it.
The Factory lesson's example is a UserServiceFactory that only ever returns UserService, with no test double and no second implementation planned. It adds a layer for zero benefit. The lesson calls that ceremony, not clean architecture.
The Singleton lesson goes further. Many engineers now treat the classic singleton as an anti-pattern, meaning a common answer that causes more problems than it solves. It hides what a class depends on, keeps state between tests, and ties code to one class. Most codebases get the same one-instance result from a dependency injection container instead. Dependency injection means a class receives what it needs through its constructor, and a framework builds and passes those objects in.
So learn the patterns as names for problems you already have, not as a checklist to apply. Start from the simplest code. Reach for a pattern when you see its problem appear.
The Singleton lesson is the simplest of the eleven and the best place to start, because it also shows how a pattern can go wrong. The Singleton Pattern lesson is the next step.
Express middleware
Each middleware wraps the next and adds one behavior, such as CORS, rate limiting, auth or logging. The Decorator lesson uses it as the everyday example of the pattern.
Redis append-only file
Redis logs each write command to the AOF and replays the log to recover after a crash. The Command lesson uses this as the command pattern enabling durability.
NestJS
Providers are singletons by default: the dependency injection container builds one instance and shares it, which is the modern replacement for a hand-written singleton.
It is a named, reusable solution to a problem that keeps coming up in software design. It describes which objects exist, what each is responsible for, and how they work together. It is a shape you adapt to your own code, not a library you install.
The Gang of Four sorted their 23 patterns into three kinds. Creational patterns control how objects are made, such as Singleton and Factory Method. Structural patterns control how objects fit together, such as Adapter and Proxy. Behavioral patterns control how objects communicate, such as Observer and Strategy.
Bridge is a structural pattern that splits a class into two separate hierarchies, an abstraction and an implementation, so the two can change independently. It is one of the seven structural patterns in the Gang of Four book. This course does not teach it in a lesson.
No. A handful cover most backend work: Singleton, Factory, Observer, Strategy, Adapter, Proxy, Decorator, Facade, Command and Chain of Responsibility. Learn to recognise the problem each one solves. The rest you can look up when you meet that problem.
Stateless vs Stateful Systems
Two fundamental architecture patterns that shape how systems handle data, scale, and recover from failure
Factory Pattern
Delegate object creation to a factory, decouple what you use from how it's built
Observer Pattern
Let objects subscribe to events and react when something changes, the foundation of event-driven systems
Strategy Pattern
Swap algorithms at runtime without touching the code that uses them, polymorphism done right
Adapter Pattern
Make incompatible interfaces work together, the universal translator of software architecture
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.
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.
Strategy Pattern
A behavioral design pattern that puts each version of an algorithm in its own class behind one interface, so code can swap the algorithm at runtime instead of growing an if-else chain.
Observer Pattern
A behavioral design pattern where an object keeps a list of subscribers and notifies each one when its state changes, so the object does not need to know what the subscribers do.
Adapter Pattern
A structural design pattern that wraps a class with an incompatible interface so it matches the interface your code expects, like a travel plug adapter for software.
Creational Design Patterns
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.
This page explains the idea. The "Singleton 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 Singleton Pattern lessoncourse 1
From absolute beginner to principal engineer, drawn step by step.