LOW LEVEL DESIGN · FREE

Low level design, from OOP to machine coding

OOP, SOLID, all 23 design patterns, UML and thread safety, taught with animated lessons and Java you can run. Then practise the machine coding round on 42 full problems.

  • 48 lessons
  • 42 machine coding problems
  • 737 interview Q&As
1 / 15

The path

Four steps that build on each other. Every lesson is an animated walkthrough with a Java example, notes and interview questions.

  1. 1BasicsObject-oriented programming, the SOLID principles, design principles and UML.21 lessons
  2. 2Design patternsAll 23 classic patterns, each with a fresh example and where it shows up in interviews.23 lessons
  3. 3Concurrency and the interviewThread safety, producer-consumer, and how the machine coding round is run and scored.4 lessons
  4. 4Machine coding problemsParking lot to spreadsheet: requirements, class diagram, patterns, concurrency and full Java code.42 problems

Step 1 · Basics

Step 2 · Design patterns

All 23 patterns on one page →

Creational patterns

  • Singleton Exactly one shared instance, created once and reached from one place. Used in 2 problems
  • Factory method Let a method, often in a subclass, decide which concrete class to create. Used in 5 problems
  • Abstract factory Create whole families of related objects that are guaranteed to match.
  • Builder Assemble a complex object step by step, then validate it once in build(). Used in 1 problem
  • Prototype Make new objects by copying a configured one instead of building from scratch.

Structural patterns

  • Adapter Wrap a class so its interface fits the one your code expects.
  • Bridge Split two things that vary independently into two hierarchies joined by a reference.
  • Composite Treat a single item and a group of items through the same interface. Used in 4 problems
  • Decorator Add behaviour by wrapping an object in another object with the same interface. Used in 6 problems
  • Facade Give a complicated subsystem one simple front door. Used in 1 problem
  • Flyweight Share the heavy, unchanging part of many small objects to save memory.
  • Proxy Put a stand-in in front of an object to control access, cache or load lazily. Used in 2 problems

Behavioral patterns

  • Strategy Swap one algorithm for another at runtime behind one interface. Used in 32 problems
  • Observer Notify every subscriber automatically when something changes. Used in 30 problems
  • State Let an object change its behaviour by switching between state objects. Used in 14 problems
  • Command Turn a request into an object so it can be queued, logged or undone. Used in 6 problems
  • Chain of responsibility Pass a request along a chain of handlers until it is dealt with. Used in 2 problems
  • Template method Fix the steps of an algorithm in a base class and let subclasses fill in some. Used in 1 problem
  • Iterator Walk through a collection without knowing how it is stored. Used in 1 problem
  • Mediator Make objects talk through one coordinator instead of to each other.
  • Memento Save and restore an object's state without exposing its insides. Used in 1 problem
  • Visitor Add new operations over a fixed set of classes without editing them. Used in 1 problem
  • Interpreter Represent a small language as classes and evaluate sentences in it. Used in 2 problems

Step 3 · Concurrency and the interview

Step 4 · Machine coding problems

All 42 problems →

Classic object models

Entities, state machines and strategies: the questions asked in almost every machine coding round

Data structures and services

Business rules, algorithms and thread safety inside one process

Games and devices

Boards, turns, rules and controllers: state machines you can run in a console

Content and tools

Community sites and office tools: voting, reputation, formulas and dependencies

Games and sports

Cards, pieces and live scores: rules engines and state that must never go wrong

Companies with a low level design round

See which problems candidates report at each company, and the rest of the interview loop.

Questions

What is low level design?

Low level design (LLD) is turning a feature into classes, interfaces and methods: which objects exist, what each one is responsible for, how they talk, and how the code stays easy to change and safe when several threads use it. In interviews it is often called the machine coding round.

What should I learn first for LLD interviews?

Start with object-oriented programming (encapsulation, abstraction, inheritance, polymorphism), then the SOLID principles, then the common design patterns such as Strategy, Observer, State, Factory, Builder and Decorator. Then practise full problems like a parking lot, an elevator and a vending machine, writing working code each time.

How is LLD different from system design (HLD)?

High level design draws services, databases, caches and queues and reasons about scale. Low level design zooms into one service: the classes, their relationships, the design patterns and the code, including thread safety inside one process.

Do I need to know all 23 design patterns?

You should recognise all of them, but interviews lean on about ten: Strategy, Observer, State, Factory method, Builder, Singleton, Decorator, Adapter, Command and Chain of responsibility. Every pattern lesson here shows where it appears in real LLD problems.

Which language is used?

Every lesson and problem comes with Java 17 code that compiles and runs, with a small main() demo. The ideas carry over directly to C++, Python, C# and Kotlin.

Is it free?

Yes. All 48 lessons and 42 problems are free, with animated walkthroughs, notes, interview questions and code. Sign in to log each one and get two scheduled revisions.

Keep going

System Design covers the services, databases and queues around your classes. DSA keeps your coding sharp for the online test.