Early Access: 87 spots left.

Claim

SOLID Principles

  • SOLID Principles in a Real Project
  • Single Responsibility Principle
  • Single Responsibility: Refactor UserService
  • Open/Closed Principle
  • Open/Closed: Refactor PaymentProcessor
  • Liskov Substitution Principle
  • Liskov Substitution: Refactor the Account Hierarchy
  • Interface Segregation Principle
  • Interface Segregation: Split the OfficeDevice Interface
  • Dependency Inversion Principle
  • Dependency Inversion: Inject the OrderRepository

Design Patterns

  • Singleton Pattern
  • Singleton: Make Logger a Single Shared Instance
  • Factory Method Pattern
  • Factory Method: Centralise Shape Creation
  • Builder Pattern
  • Builder: Refactor the EmailMessage Constructor
  • Adapter Pattern
  • Adapter: Wrap LegacyWeatherSdk in a WeatherProvider
  • Decorator Pattern
  • Decorator: Wrap a Notifier with Logging and Retries
  • Composite Pattern
  • Composite: Price a Catalog of Nested Product Bundles
  • Strategy Pattern
  • Strategy: Refactor the Checkout Discount Engine
  • Observer Pattern
  • Observer: Refactor OrderService Notifications
  • Chain of Responsibility Pattern
  • Chain of Responsibility: Build a Purchase Approval Chain

Interview Design Problems

  • Design a Parking Lot
  • Design an Elevator (FCFS)
  • Design an In-Memory Pub/Sub System
  • Design a Vending Machine
  • Design a Bounded Blocking Queue
  • Design an LRU Cache
  • Design an In-Memory File System
  • Design Tic-Tac-Toe
  • Design a Cron Job Scheduler (Virtual Clock)
  • Design Snakes and Ladders
Course · Object-oriented design·3 chapters · 63 lessons · Java · Python · C++

Design patterns,
drawn before they're coded.

A principles-first course for the low level design (LLD) and machine coding round: object-oriented design (OOD) with the five SOLID rules, the GoF patterns, and the design problems every interviewer reaches for. You sketch the class diagram first, then implement it in Java, Python, or C++ where hidden behaviour tests grade the design, not just the loops.

Level
Beginner
Study time
15h
Lessons
63
Designs
10
Languages
Java · Python · C++
Or scan the chapter list →

Package includes: Coding Interview Patterns + Low Level Design Course

PaymentStrategy.uml
Pattern · Strategy
«uses»CheckoutContext– strategy+ pay(amount: Money)«interface»PaymentStrategy+ charge(amount): ReceiptCardPayment– card: CardNumber– cvv: String+ charge(amount)UpiPayment– vpa: String– app: String+ charge(amount)open / closedadd an impl,don't touch context
Hidden tests · 8 / 8 passingJava · Python · C++
How it's taught

Diagram first.
Then prove it in code.

01

Pattern, in plain English

Every pattern opens with the problem it exists to solve, written like a colleague explaining it rather than a textbook quoting GoF.

02

Class diagrams that talk

Annotated UML for every pattern and every design problem. Arrows are labelled, stereotypes are explained, and no notation is left dangling.

03

Hidden behaviour tests

Implement Parking Lot or Pub/Sub in Java, Python, or C++, and a hidden harness grades the behaviour rather than the syntax. You find out fast whether the design holds.

What you'll learn

The skills that show up
in every LLD round.

The bar at most product companies for an LLD interview: name the pattern, draw the diagram, write the classes, defend the trade-offs. This course gets you to all four.

The five SOLID principles and how they support maintainable object-oriented code.
Creational design patterns, including Singleton and Factory, and when to use them.
Structural patterns such as Adapter and Decorator, with clear definitions and examples.
Behavioural patterns such as Observer and Strategy, and their typical roles in a system.
How to outline classes, interfaces, and relationships for interview-style problems.
How to select an appropriate pattern and keep the design straightforward.
Hands-on practice: design Tic-Tac-Toe, Parking Lot, Pub/Sub in Java, Python, or C++ with hidden behaviour tests.
Curriculum

Principles, patterns, practice.
Click any chapter to expand.

3 chapters·63 lessons
Structural9 lessons
Behavioural9 lessons
Capstone problems

The designs interviewers keep asking.

Each problem comes with a Java, Python, or C++ scaffold and a hidden test harness that grades the behaviour of your design.

01Medium
Design a Parking Lot
02Premium
Design an Elevator (FCFS)
03Premium
Design an In-Memory Pub/Sub System
04Premium
Design a Vending Machine
05Premium
Design a Bounded Blocking Queue
06Premium
Design an LRU Cache
07Premium
Design an In-Memory File System
08Premium
Design Tic-Tac-Toe
+ 2 more →
Unlock

Two courses, one unlock.
Coding plus Low Level Design, together.

The pack covers Coding Interview Patterns and the Low Level Design course end to end: every principle, every pattern, and every capstone with its hidden tests.