# Design Patterns in Technical Interviews: 10 Essential Patterns Every Candidate Should Know > Master design patterns for technical interviews. Understand their role in architectural thinking and communication. Learn 10 essential patterns to solve complex OO design problems efficiently. - Repository: [John Washam/coding-interview-university](https://github.com/jwasham/coding-interview-university) - Tags: deep-dive - Published: 2026-02-24 --- **Design patterns demonstrate architectural thinking, facilitate clear communication with interviewers, and provide reusable building blocks for solving complex object-oriented design problems efficiently.** Design patterns play a critical role in technical interviews by providing a shared vocabulary for discussing software architecture and scalable solutions. According to the Coding Interview University repository (`jwasham/coding-interview-university`), candidates who master fundamental patterns gain a significant advantage in both coding and system-design rounds. Understanding design patterns in technical interviews signals to hiring managers that you can reason about maintainability, extensibility, and clean code architecture beyond basic algorithmic implementation. ## Why Design Patterns Matter in Technical Interviews Design patterns serve three strategic purposes during the interview process: - **Demonstrate architectural thinking** – Discussing patterns shows that you view problems at a higher level than just writing code. It signals an ability to reason about scalability, maintainability, and extensibility from the outset. - **Facilitate clear communication** – Referring to a well-known pattern (e.g., "Factory Method") gives the interviewer a shared vocabulary, reducing ambiguity and allowing you to focus on core logic rather than explaining basic structural concepts. - **Provide ready-made building blocks** – Many interview problems, especially object-oriented design questions, can be solved more cleanly by applying a pattern, which reduces the chance of bugs and makes your solution easier to extend. ## Recommended Study Resources The Coding Interview University roadmap explicitly recommends learning design-pattern fundamentals. In [`README.md`](https://github.com/jwasham/coding-interview-university/blob/main/README.md) at lines 1359–1363, the repository lists two canonical resources: - **Head First Design Patterns** – A gentle introduction for beginners - **Design Patterns: Elements of Reusable Object-Oriented Software** (the "Gang-of-Four" book) – The definitive reference for software architects These recommendations also appear in translation files such as [`translations/README-ur.md`](https://github.com/jwasham/coding-interview-university/blob/main/translations/README-ur.md) at lines 1290–1293, confirming their importance across the global preparation community. ## The 10 Must-Know Design Patterns for Technical Interviews Candidates should be comfortable with the most frequently asked patterns. Below are the **core 10** that appear most often in interview discussions and system-design questions, organized by category. ### Creational Patterns These patterns handle object creation mechanisms, optimizing for flexibility and reuse. #### Singleton Ensures a single shared instance throughout the application (e.g., logger, database connection). ```python class Logger: _instance = None def __new__(cls): if cls._instance is None: cls._instance = super().__new__(cls) return cls._instance def log(self, msg): print(f"[LOG] {msg}") ``` *Why it matters:* Guarantees a single logger instance—a classic interview topic for resource management. #### Factory Method / Abstract Factory Hides object creation when the concrete class depends on runtime data, decoupling client code from concrete classes. ```python from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def draw(self): pass class Circle(Shape): def draw(self): print("Circle") class Square(Shape): def draw(self): print("Square") class ShapeFactory: @staticmethod def create(shape_type: str) -> Shape: return {"circle": Circle, "square": Square}[shape_type.lower()]() ``` *Why it matters:* Essential for "create objects without specifying exact classes" scenarios. #### Builder Constructs complex objects step-by-step (e.g., building an immutable request or configuration object). ```python class Pizza: def __init__(self, dough, sauce, toppings): self.dough = dough self.sauce = sauce self.toppings = toppings class PizzaBuilder: def __init__(self): self.dough = "regular" self.sauce = "tomato" self.toppings = [] def set_dough(self, dough): self.dough = dough; return self def set_sauce(self, sauce): self.sauce = sauce; return self def add_topping(self, topping): self.toppings.append(topping); return self def build(self): return Pizza(self.dough, self.sauce, self.toppings) ``` *Why it matters:* Demonstrates step-wise construction when constructor arguments explode. ### Structural Patterns These patterns focus on composing classes and objects into larger structures. #### Adapter Converts one interface to another—useful when integrating legacy code or incompatible APIs. ```python class EuropeanPlug: def voltage(self): return 230 class USASocket: def voltage(self): return 120 class PlugAdapter: def __init__(self, plug): self.plug = plug def voltage(self): # Convert EU voltage to USA voltage return self.plug.voltage() / 2 ``` *Why it matters:* Shows how to make incompatible interfaces work together without modifying existing code. #### Decorator Adds responsibilities to objects dynamically (e.g., streaming data with compression or encryption layers). ```python def bold(fn): def wrapper(*args, **kwargs): return f"{fn(*args, **kwargs)}" return wrapper @bold def greet(name): return f"Hello, {name}" ``` *Why it matters:* Adds behavior without modifying the original function or class. #### Facade Provides a simple unified interface to a set of subsystems—common in system-design sketches. ```python class Database: def query(self, sql): pass class Cache: def get(self, key): pass def set(self, key, val): pass class ServiceFacade: def __init__(self): self.db = Database() self.cache = Cache() def get_user(self, uid): user = self.cache.get(uid) if not user: user = self.db.query(f"SELECT * FROM users WHERE id={uid}") self.cache.set(uid, user) return user ``` *Why it matters:* Provides a simple entry point to a complex subsystem. #### Proxy Controls access or adds lazy loading (e.g., virtual proxy for heavy objects or protection proxy for access control). ```python class RealImage: def display(self): print("Displaying high‑res image") class ImageProxy: def __init__(self, filename): self.filename = filename self._real = None def display(self): if not self._real: self._real = RealImage() self._real.display() ``` *Why it matters:* Demonstrates lazy loading of heavy resources—a frequent design question. ### Behavioral Patterns These patterns focus on communication between objects and assignment of responsibilities between them. #### Observer Implements publish-subscribe—frequently appears in event-driven design questions and UI callback systems. ```python class Subject: def __init__(self): self._observers = [] def attach(self, obs): self._observers.append(obs) def notify(self, data): for obs in self._observers: obs.update(data) class ConcreteObserver: def update(self, data): print(f"Received {data}") ``` *Why it matters:* Models event-driven systems such as notification services or UI updates. #### Strategy Swaps algorithms at runtime—perfect for "choose sorting algorithm" or "payment method" scenarios. ```python from abc import ABC, abstractmethod class SortStrategy(ABC): @abstractmethod def sort(self, data): pass class QuickSort(SortStrategy): def sort(self, data): data.sort() # placeholder class BubbleSort(SortStrategy): def sort(self, data): pass # naive implementation class Context: def __init__(self, strategy: SortStrategy): self.strategy = strategy def execute(self, data): self.strategy.sort(data) ``` *Why it matters:* Enables runtime algorithm selection and encapsulates varying behavior. #### Command Encapsulates actions as objects—useful for undo/redo functionality or request queues. ```python from abc import ABC, abstractmethod class Command(ABC): @abstractmethod def execute(self): pass class LightOnCommand(Command): def __init__(self, light): self.light = light def execute(self): self.light.on() class RemoteControl: def __init__(self): self.commands = [] def set_command(self, cmd): self.commands.append(cmd) def press_all(self): for cmd in self.commands: cmd.execute() ``` *Why it matters:* Encapsulates actions, enabling undo/redo or batch execution queues. ## Summary - Mastering design patterns in technical interviews demonstrates **architectural thinking** and the ability to discuss scalability and maintainability. - The Coding Interview University repository specifically recommends studying *Head First Design Patterns* and the Gang-of-Four book, referenced in [`README.md`](https://github.com/jwasham/coding-interview-university/blob/main/README.md) at lines 1359–1363. - Focus on the **core 10 patterns**: Singleton, Factory Method, Builder (Creational); Adapter, Decorator, Facade, Proxy (Structural); Observer, Strategy, Command (Behavioral). - Use these patterns to structure solutions in **coding interviews** and to sketch components in **system-design interviews**. - Practice implementing these patterns in your preferred language to ensure you can code them confidently on a whiteboard or shared screen. ## Frequently Asked Questions ### Do I need to memorize all 23 Gang-of-Four patterns for technical interviews? No. While the Gang-of-Four book documents 23 patterns, technical interviews typically focus on the 10 core patterns listed above. Prioritize understanding the intent, structure, and trade-offs of these high-frequency patterns rather than memorizing every implementation detail. ### Should I implement design patterns from scratch during a coding interview? Only if the problem explicitly requires it or if the pattern significantly clarifies your solution. In timed coding rounds, mentioning a pattern by name ("I'll use the Observer pattern here") often suffices, though you should be prepared to implement the core logic if asked. For object-oriented design interviews, full implementation is usually expected. ### How do design patterns differ between coding interviews and system design interviews? In **coding interviews**, patterns help structure clean, testable code (e.g., using Strategy to swap algorithms). In **system design interviews**, patterns describe architectural relationships between services (e.g., using Observer for event-driven microservices or Proxy for load balancing). The vocabulary remains the same, but the scope shifts from class-level to component-level design. ### Which programming language should I use to demonstrate design patterns? Use the language specified in the job description or the one you listed on your resume. Python, Java, C++, and TypeScript are all acceptable, though statically typed languages (Java/C++) often make pattern structure more explicit. The Coding Interview University resources are language-agnostic, focusing on concepts that translate across ecosystems.