Course
Object-oriented design interview prep
Learn to design classes that stay correct and easy to change, then build complete multi-class projects, the way an object-oriented design (low-level design) interview asks you to.
- 9 topics
- 38 skills
- 152 lessons
- 446 practice questions
- 9 design projects
What you'll learn
Start with the core of object-oriented programming and the five SOLID principles, then the creational, structural and behavioral design patterns, UML class diagrams, and cache designs like LRU and LFU. Every pattern is taught through the problem it solves and the trade-off it brings.
Then build: 9 design projects, from a Parking Lot and Tic-Tac-Toe to a thread-safe Rate Limiter and Task Scheduler. You work in a real multi-file project. Run executes a sample test suite; Submit grades you with a hidden one, including concurrency tests for the multi-threaded systems. Debugging tasks, code reviews and test-writing tasks use the same projects, so you practice the whole job, not just the whiteboard.
The curriculum
Every skill has a lesson, a staff-level deep dive, a quick revise page and practice questions. Click a skill to read its lesson free.
OOP Fundamentals
The four pillars, and the composition-vs-inheritance call every class hierarchy eventually forces.
SOLID Principles
Five rules of thumb for keeping a class hierarchy changeable as requirements grow, instead of increasingly fragile.
Design Patterns: Creational
Controlling how and when objects get constructed, instead of scattering "new" calls (and their assumptions) everywhere.
Design Patterns: Structural
Composing objects and classes into larger structures - adapting, wrapping, and simplifying - without rewriting what they already do.
Structural Patterns
Design Patterns: Behavioral
Coordinating how objects interact and hand off responsibility, without hard-coding one object's logic into another's.
UML & Class Design Basics
Reading and drawing the class diagrams that communicate a design before any code gets written.
UML Basics
Data Structure Design
Combining a few data structures so that every required operation meets its own time and space budget - the "design an LRU cache" family of problems.
Caching Fundamentals
Design Projects: Classic Systems
Object-oriented design interviews, one project per module - the kind often run as a pair-programming or take-home exercise: clarify the scope, model the entities, build a working core in packages, and extend it when the interviewer pushes.
How to Approach an Object-Oriented Design Interview
Parking Lot
Tic-Tac-Toe
Splitwise
Elevator System
Movie Ticket Booking
Design Projects: Concurrent Systems
Design projects where correctness depends on time and threads: rate limiting, an in-memory store with expiry and transactions, a publish-subscribe queue and a task scheduler - each built against an injected clock and tested with many threads at once.
Rate Limiter
In-Memory Key-Value Store
Pub-Sub Message Queue
Task Scheduler
Projects, reviews and debugging tasks
Design projects
- Design a Parking Lot SystemFree
- Build a Splitwise Expense SharerPro
- Build a Tic-Tac-Toe Game EnginePro
- Build an Elevator ControllerPro
- Build a Movie Ticket Booking ServicePro
- Build a Pub-Sub Message BrokerPro
- Build a Thread-Safe Rate LimiterPro
- Build a Thread-Safe Task SchedulerPro
- Build an In-Memory Key-Value StorePro
Debugging tasks
- Debug: Parking Lot - Two Cars, One SpotFree
- Debug: Tic-Tac-Toe - The Stolen TurnPro
- Debug: Splitwise - The Missing CentPro
- Debug: Movie Booking - Double-Sold SeatsPro
Test-writing tasks
- Test the Shopping CartFree
- Test the Meeting Room CalendarPro
Code reviews
- Review: Parking Lot - The Exit Display PRFree
- Review: Splitwise - The Percent Split PRPro
- Review: Tic-Tac-Toe - An AI-Generated GamePro
- Review: Movie Booking - An AI-Suggested Speed-UpPro
Free warm-up problems
- A Bounded Stack Built by Composition
- Add Campaigns Without Touching Checkout
- Allow or Deny: A Sliding-Window Rate Limiter
- An Account That Protects Its Own Rules
- Good Night, Good Morning: A Smart-Home Facade
- Implement a Singleton Class
- Make HashSet Recognize Equal Values
- Payroll Without a Single Type Check
- Payslips: Calculate, Format, Archive
- Plug Two Legacy Sensors Into One Interface
- Price Shipping With Interchangeable Strategies
- Report Exporters From One Template Method
- Serve the Floors in LOOK Order
- Smart Home Capabilities
- Subscriptions on an Injected Clock
- Total Area via Polymorphism
Questions
What is a low-level design interview?
It's the round where you design the classes for a small system, like a parking lot or an expense splitter, and often write working code. US, UK and EU companies usually call it object-oriented design or a machine coding round. Interviewers look for clear responsibilities, sensible patterns and code that handles the edge cases.
Can I do the design projects in Python?
Yes. Every project, debugging task and code review comes in Java and Python, each with its own tests. The test-writing tasks are Java only for now.
How are concurrent designs like the rate limiter tested?
The hidden suites start many threads against your code at once and check that limits, counts and orderings still hold. A version with a race condition was checked to fail them before the project shipped.
What's free in the object-oriented design course?
All 152 lessons and 446 practice questions, the 16 easy warm-up problems, and one of each format: the Parking Lot project, its debugging task, its code review and the Shopping Cart test-writing task. Pro unlocks the rest.
More courses
Start the Object-oriented design course free
No card needed. Upgrade to Pro when you want the full problem bank.
Free plan, no card · 7-day Pro trial · Cancel anytime