Post

Tech Education

Best Resources for Object-Oriented Design Interviews

The best books, courses, websites, GitHub repositories and practice platforms for object-oriented design (low-level design) interviews, what each one is good for, and how to combine them into a study plan.
By Codemia • November 14, 2026

6 min read

Object-oriented design interviews, also called low-level design (LLD) rounds, ask you to model a system as classes: a parking lot, an elevator, a chess game. Preparing for them needs three different things: an understanding of the principles and patterns, worked examples of classic problems, and practice designing problems yourself.

No single resource covers all three well. This guide lists the best options in each category, what each is good for, and how to combine them.

The short answer

Learn patterns from Head First Design Patterns or Refactoring.Guru. Study worked solutions from a problem collection such as Grokking the Object Oriented Design Interview or the awesome-low-level-design repository. Then practise designing problems yourself with feedback, on a platform like Codemia, until you can do one in 45 minutes.

Quick comparison

ResourceTypeBest forCost
Head First Design PatternsBookLearning patterns for the first timePaid
Design Patterns (Gang of Four)BookThe original referencePaid
Refactoring.GuruWebsiteQuick pattern lookups with diagrams and codeFree (book paid)
Grokking the Object Oriented Design InterviewCourseWorked solutions to classic interview problemsPaid
awesome-low-level-designGitHub repoProblem list with solutions in several languagesFree
Codemia OOD Fundamentals courseCoursePrinciples and patterns with coding exercisesPaid
Codemia OOD practice problemsPractice platformDesigning problems yourself and getting gradedFree and paid
Mock interviewsPracticeExplaining a design out loud under time pressureVaries

Learning the principles and patterns

Head First Design Patterns

Eric Freeman and Elisabeth Robson's book is the friendliest introduction to design patterns. It teaches each pattern through a concrete problem and builds up why the pattern exists before showing its structure. The second edition uses modern Java. If you have never studied patterns properly, start here.

Good for: understanding Strategy, Observer, Decorator, Factory, State and Command well enough to use them, not just name them.

Design Patterns: Elements of Reusable Object-Oriented Software

The 1994 "Gang of Four" book by Gamma, Helm, Johnson and Vlissides defined the 23 classic patterns. It is dense and its examples are dated, so it is a poor first read, but it is the reference everyone else draws on.

Good for: precise definitions and the trade-offs of each pattern, once you already know the basics.

Refactoring.Guru

Refactoring.Guru explains every classic pattern with an illustration, a structure diagram, pros and cons, and code in a dozen languages. It also covers code smells and refactoring techniques.

Good for: a quick refresher on one pattern the night before an interview, or seeing a pattern in your own interview language.

SOLID principles

Interviewers often judge a design by the SOLID principles even when they do not name them. Robert C. Martin's writing is the original source; most OOD courses, including the ones below, cover the principles with examples. Make sure you can explain each one with a short example, such as why a new pricing rule should be a new class rather than another if branch.

Studying worked examples

Grokking the Object Oriented Design Interview

The Grokking course from DesignGurus is one of the best known OOD interview resources. It walks through classic problems, including a library management system, parking lot, Amazon, Stack Overflow, a movie ticket booking system and an ATM, with use case diagrams, class diagrams, activity diagrams and code.

Good for: seeing how a complete answer to a classic problem is structured, especially the requirements and diagramming steps.

awesome-low-level-design (GitHub)

The awesome-low-level-design repository is the most popular free LLD collection on GitHub, with tens of thousands of stars. It lists OOP concepts, design principles, patterns and a long set of interview problems, with solutions in several languages.

Good for: a free, broad problem list and reference solutions to compare against your own.

YouTube

Many engineers learn LLD from YouTube playlists that design a problem from scratch on a whiteboard or in an IDE. Watching someone reason through requirements and refactor a design as it grows is useful in a way that finished solutions are not. Use videos for problems you have already attempted, so you can compare your reasoning with theirs.

Practising with feedback

Reading solutions builds recognition. Interviews test production: designing a system yourself, from a blank page, while explaining your choices. This is the step most candidates skip, and the one that matters most.

Codemia OOD Fundamentals course

The OOD Fundamentals course on Codemia goes from OOP foundations through SOLID, creational, structural and behavioural patterns, to classic interview problems and advanced OOD. Every lesson includes coding exercises where you design classes and implement methods, then run them against test sequences in the browser.

Good for: learning the patterns by writing them, rather than reading about them.

Codemia object-oriented design practice problems

The Codemia OOD catalogue has interview problems from easy (parking lot, vending machine, tic-tac-toe) to advanced (LRU cache, permission systems, code editors). You write your own design and it is graded against the key points for that problem, so you find out what you missed. The object-oriented design topic in the Codemia Knowledge Hub has short explanations of individual concepts.

Good for: turning knowledge into the ability to design a problem yourself under a timer.

Mock interviews

An OOD round is also a communication test: clarifying requirements, explaining responsibilities and handling "what if we add a new vehicle type?" in real time. Practise with a friend, a colleague who interviews, or a paid mock interview service. Even two or three mocks show you where your explanation breaks down.

How to combine them

  1. Week 1: principles and patterns. Read the core chapters of Head First Design Patterns, or work through the pattern sections of an OOD course. Write a small example of Strategy, State, Observer and Factory in your interview language.
  2. Week 2: worked examples. Study three or four classic problems from Grokking or the awesome-low-level-design repo. Pay attention to how each answer finds the classes and where it puts the extension points.
  3. Weeks 3 and 4: practise yourself. Do one problem a day under a 45 minute timer, starting easy. Get each one graded, then compare with a reference solution.
  4. Final days: mocks and refreshers. Do one or two mock interviews, and use Refactoring.Guru to refresh any pattern you are unsure of.

For a step-by-step method for answering, the patterns that come up most, and a full list of problems from easy to advanced, see object-oriented design interview: practice problems and how to prepare. If your loop also includes a system design round, see how to prepare for a system design interview at big tech.