Post

Tech Education

Object-Oriented Design Interview: Practice Problems and How to Prepare

How the object-oriented design (low-level design) interview works, a step-by-step approach to answering, the principles and patterns that come up, and practice problems ordered from easy to advanced.
By Codemia • November 14, 2026

6 min read

The object-oriented design interview, often called the low-level design (LLD) round, asks you to model a system as classes: "design a parking lot", "design an elevator system", "design a chess game". Where a system design round is about servers, databases and scale, an OOD round is about the code inside one service: which classes exist, what each one is responsible for, how they talk to each other, and how easy the design is to extend.

It is common at Amazon, Microsoft, Uber and many mid-size companies, and increasingly part of senior loops alongside the system design round. This guide covers how the round works, how to structure an answer, and which problems to practise.

OOD is not system design

The same problem name can mean different rounds. 'Design a parking lot' in a system design round is about services, storage and scale. In an OOD round it is about classes like ParkingLot, Level, Spot, Ticket and a pricing strategy. Ask the interviewer which they want.

How the round works

A typical OOD round is 45 to 60 minutes. You get a short prompt and are expected to:

  1. Clarify the requirements and the scope.
  2. Identify the main objects and their responsibilities.
  3. Define the relationships between them (has-a, is-a, uses).
  4. Write class definitions, method signatures and sometimes working code for the core flow.
  5. Explain how the design handles change: a new vehicle type, a new pricing rule, a new piece in a game.

Interviewers are looking for clean responsibilities, sensible use of interfaces and composition, awareness of design patterns where they genuinely help, and code that would be easy to extend and test.

A step-by-step approach

StepTimeWhat to produce
Requirements5 minThe core use cases, and what is explicitly out of scope
Core objects5 minThe nouns in the requirements: a short list of candidate classes
Responsibilities and relationships10 minWhat each class owns and does; a simple class diagram
Key flows10 minWalk through the main use cases as method calls between objects
Code15 minInterfaces, classes and the core methods in your language
Extension5 minHow the design handles one or two likely changes

Find the nouns and verbs. "A driver parks a vehicle in a spot and receives a ticket; on exit, they pay a fee based on duration." Nouns: driver, vehicle, spot, ticket, fee. Verbs: park, pay, exit. That is most of your first class list.

Pick the extension points. Ask where the requirements are likely to change and put an interface there: vehicle types, pricing rules, payment methods, notification channels.

Principles that come up

  • Single responsibility: each class has one reason to change. A ParkingLot should not calculate fees.
  • Open/closed: add new behaviour by adding classes, not editing existing ones. A new pricing rule is a new PricingStrategy, not another if branch.
  • Liskov substitution: subclasses must work anywhere the parent does. If Penguin extends Bird breaks fly(), the hierarchy is wrong.
  • Interface segregation: small, focused interfaces beat one large one.
  • Dependency inversion: depend on interfaces, so you can swap implementations and test in isolation.
  • Composition over inheritance: prefer "has a" to "is a" when behaviour varies independently.

Patterns worth knowing

You do not need all 23 Gang of Four patterns. These come up most:

PatternTypical use in interviews
StrategyPricing rules, payment methods, move validation
StateVending machines, elevators, order lifecycles, traffic lights
ObserverNotifications, event subscriptions, UI updates
FactoryCreating vehicles, pieces, accounts by type
SingletonA single parking lot or logger instance (use sparingly, and say why)
CommandUndo and redo in a text editor; queued operations
DecoratorAdding toppings to a coffee order; layering features
CompositeFile systems, nested menus, shape groups

Use a pattern when it solves a problem you can name. Naming patterns without a reason reads as memorised.

Practice problems, easy to advanced

Every problem below links to a page in the Codemia object-oriented design catalogue, where you can write your design and get it graded against that problem's key points.

Easy: one or two central ideas

Medium: several interacting objects

Hard: extensibility and tricky behaviour

Advanced: data structures and access control

A four-step study plan

  1. Review the principles and patterns above in a day or two. Write a tiny example of Strategy, State and Observer in your interview language.
  2. Do the easy problems under a 45 minute timer, one per day. Focus on clean responsibilities.
  3. Move to medium and hard problems. For each, write down the two likely changes and check your design handles them without edits to existing classes.
  4. Write real code for the core flow on at least half the problems. Many OOD rounds expect compilable code, not just a diagram.

Common mistakes

  • Starting with code before agreeing the requirements.
  • God classes: one System or Manager class that does everything.
  • Inheritance everywhere: deep hierarchies where composition would be simpler.
  • Patterns for their own sake.
  • Ignoring concurrency in booking problems: two users booking the last seat at once.

Start practising

Begin with the parking lot, then work down the list. If you also have a system design round, see system design practice problems, from easy to hard; for ML roles, see the ML system design interview prep guide.