Challenges

Design Patterns

22 challenges22 playable now

Difficulty

Showing 22 of 22

Cache Eviction (Strategy Pattern)

One cache, three eviction policies, swappable at runtime — the Strategy pattern made real. Build FIFO, LRU, and LFU policies (each a small data-structure exercise), plug them into a single capacity-bound cache, and hot-swap the algorithm without touching the cache code.

Unified Payments (Adapter Pattern)

Two payment gateways, two incompatible SDKs, one checkout button. The Adapter pattern wraps each mismatched provider API in a common interface so the rest of your system never has to care which gateway it is talking to. Build a Stripe adapter and a PayPal adapter behind a single charge() contract, write a client that works with either, map declines to a uniform result, and finish with a factory that hands you the right adapter by name.

One-Call Checkout (Facade Pattern)

Checking out an order really means three separate jobs — reserving stock, charging a card, and booking a shipment — each with its own failure mode. The Facade pattern hides that messy orchestration behind one friendly call. Build a CheckoutFacade over in-memory Inventory, Payment, and Shipping subsystems, add rollback when a step fails, return a tracking id on success, keep an order log, and finish with a one-argument quick_buy convenience method.

Notification Dispatcher (Factory Pattern)

Callers should say send this on email and never touch a class name. The Factory pattern puts that decision in one place. Build concrete notifiers, a simple factory function, a registry-driven factory you can extend without editing, then a service that dispatches and fans messages out across many channels at once.

Config Registry (Singleton Pattern)

Build the one shared configuration registry that every real app relies on. You will implement the Singleton pattern by hand with a classmethod accessor, give it read and write access, add safe lookups, then generalize the whole idea into a reusable decorator you apply to a second class. This is the exact machinery behind global config, connection pools, and loggers.

Undo/Redo (Command Pattern)

See how design patterns and data structures build a real feature: undo/redo. You will implement the Command pattern over a document, drive it with two stacks, extend it with a new command type, and batch actions with the Composite pattern — the exact machinery behind every editor.

Reactive Store (Observer Pattern)

Build the machinery behind signals, RxJS, and Vue/MobX reactivity from the Observer pattern up: a Subject that notifies observers, subscriptions you can cancel, an observable value that only fires on real change, derived computed values, and effects that re-run when their state changes.

Order State Machine (State Pattern)

Model an order's lifecycle the way real systems do — as a state machine. Drive transitions from a table, expose what each state allows, record history, run entry actions on arrival (charge, email), and gate transitions with guards. The State pattern behind checkout flows and TCP.

Middleware Pipeline (Chain of Responsibility Pattern)

Every web framework runs each request through a pipeline of middleware: authenticate, rate-limit, then dispatch to the app. That pipeline is the Chain of Responsibility pattern. You will build a handler base that passes requests down a chain, add auth and rate-limit stages that can short-circuit the pipeline, write a terminal app handler, and finish with a builder that wires any list of handlers into a chain — the exact machinery behind Express and Django middleware.

Stream Wrappers (Decorator Pattern)

Build the machinery behind I/O stream wrappers like gzip, base64 and text codecs from the Decorator pattern up. You will define a source with a read() method, a Decorator base that wraps another stream and keeps the exact same interface, then stack transformers (uppercase, reverse, repeat, call counting) that add behavior without either the source or the caller knowing the difference.

Caching Proxy (Proxy Pattern)

A slow service, and a stand-in that speaks its exact language. The Proxy pattern puts an object in front of the real one, sharing its interface so callers never know the difference — while it quietly adds superpowers. Build a proxy that delegates, then caches results, then defers construction until first use, then guards access, then invalidates stale entries. Same fetch(key) throughout; the real service never changes.

SQL Query Builder (Builder Pattern)

Learn the Builder pattern by constructing a fluent SQL SELECT query builder. Each method records one clause and returns the builder itself, so calls chain into a readable pipeline. You will add SELECT and FROM, then WHERE, ORDER BY and LIMIT, prove the whole chain and a reset flow, and finish with a count_all preset - the exact machinery ORMs use to assemble SQL.

Paginated Cursor (Iterator Pattern)

Learn the Iterator pattern by building a lazy paginated cursor. You will write a custom iterator over a list, make it work in for-loops, walk a page-serving backend fetching pages only on demand, prove the laziness by counting fetches, and finish with a generator that paginates in a few lines of code.

ETL Pipeline (Template Method Pattern)

Build an ETL pipeline the way frameworks do — as a fixed skeleton. One run() method fixes the order of extract, transform, and load, while subclasses override individual steps to change behaviour without ever rewriting the algorithm. Add an overridable hook, then record the execution order to see the template in action. The Template Method pattern behind Django views, test frameworks, and data pipelines.

Themed UI Kit (Abstract Factory Pattern)

Build a themed UI kit -- Light and Dark -- using the Abstract Factory pattern. You will define matching families of Button and Checkbox products, hide them behind interchangeable factories, and write a single client plus a registry that produce a consistent widget family for whichever theme you pick.

Cloning Entities (Prototype Pattern)

Learn the Prototype design pattern by cloning game entities from a registry of prototypes. Build deep-copy cloning, a prototype registry, override-aware spawning, and unique id stamping from an injected counter.

Shapes and Renderers (Bridge Pattern)

Learn the Bridge pattern by decoupling shapes from the backends that render them. You build a Renderer implementation hierarchy (vector and raster) and a Shape abstraction (circle and square) that talks to a renderer through a reference. Because the two hierarchies vary independently, two shapes times two renderers reuse just four classes instead of exploding into a class per combination, and you can even swap the backend at runtime.

Shared Glyphs (Flyweight Pattern)

Build a text renderer with the Flyweight pattern: share one immutable Glyph object per character across every position it appears, and pass position (extrinsic state) in per render call. You will grow a GlyphFactory cache, prove object identity is reused, keep extrinsic state out of the shared object, lay out a whole document with shared glyphs, and finally key the cache by (char, style) so styled variants stay separate.

Chat Room (Mediator Pattern)

Build a chat room step by step to learn the Mediator pattern. Instead of users holding references to each other, every message flows through a central ChatRoom that coordinates delivery. You will add broadcasting, user-driven sends, private messages, leaving, and a centralized banned-words policy.

Editor Snapshots (Memento Pattern)

Build a text editor with undo, redo, and bounded history by learning the Memento pattern. Across five steps you will capture and restore an editor's state through opaque snapshot objects, so the history keeper can save and roll back without ever peeking inside the editor. Unlike a command-based undo that replays individual actions, this approach photographs the whole state at each save point and restores it wholesale.

Expression Evaluator (Visitor Pattern)

Build an arithmetic expression tree and learn the Visitor pattern by adding operations to it. You will give nodes an accept method for double dispatch, write an evaluator, add a new node type, then add printing and node-counting visitors — each a new operation with zero changes to the node classes.

Rule Engine (Interpreter Pattern)

Build a boolean rule / feature-flag engine using the Interpreter pattern: represent a small grammar as a tree of expression objects, each with an interpret(context) method that evaluates the rule against a context dict.