Master distributed systems
& client-side engineering.

Design a local-first notes / to-do app like Google Keep - the note saves to Room the instant you type it, the UI renders from disk, and a background outbox syncs it to the cloud whenever the network is up.

The directory-scale follow-up to Image Processing Pipeline. Walk a tree of images (Large/ and Small/ subfolders), load transform lists from a folder of JSON files, and apply every transform to every image in parallel - preserving the source subdirectory layout in the output and isolating per-combination failures. The fan-out the interview actually scales to millions of combinations.

Apply ordered image operations (resize, rotate, crop, blur, grayscale) with Pillow - one image, then every image-by-pipeline combination, then a thread pool, then partial-failure isolation, then directory discovery. A throughput and fault-tolerance problem dressed as image manipulation.

The durability follow-up to the in-memory key-value store. Snapshot the store to disk and restore it, then make the write crash-safe with an atomic temp-file rename, then add an append-only write-ahead log so writes made since the last snapshot survive a crash. Length-prefix encoding keeps arbitrary key/value bytes intact across disk.

The concurrency follow-up to the in-memory key-value store. Many threads call put / get / erase on one shared store at once; make it correct under contention, then refine from a single global lock to a reader-writer lock and finally to atomic compound operations (get_and_set, compare_and_swap).

Build a web crawler on top of an injected get_links helper - breadth-first crawl with deduplication, then same-domain and fragment handling, then a concurrent version with a thread pool and a shared visited set, and finally depth and global rate limits. A concurrency problem disguised as a graph traversal.

Design a Google Photos-style gallery - one timeline over the device and cloud libraries, background backup, full-resolution viewing, fresh-device restore.

A mutable social graph that has to do three hard things at once - answer point-in-time history without copying the world on every snapshot, and rank friends-of-friends recommendations both live and as-of a past snapshot.

The chunked-persistence follow-up to KV Store Serialize/Deserialize. Serialize a key-value store with a fixed-width binary (TLV) format, then split the blob into 1 KB chunks and checkpoint it to an S3-style object store - with the chunk count carried in a chunk header, no separate metadata object.

Single-account GPU credit grants with time windows; FIFO partial spending and windowed balance queries.

Count nodes in an n-ary tree using async fan-out. The recursion is trivial; the real test is fanning out child queries concurrently so wall-clock time scales with tree depth, not node count.

Session-based auth with register, login, logout, session TTL, and salted password hashing. Paired with the TTL token variant in OpenAI loops.

LeetCode 1797. Tokens issued with a fixed TTL; renew before expiry to extend; count live tokens at time t. Later phases push the count to amortized O(1) and add thread safety.

A cell becomes infected on step t+1 only if it has at least K infected neighbors right now. Looks like rotting oranges but the K threshold turns it into a wave simulation with stall detection.

Serialize a list of arbitrary strings into a single string and parse it back. Any character is allowed in the strings, including the delimiters - length-prefix framing is the only safe answer.

Group identical files by content. Stream-hash to keep memory bounded, then add size pre-filtering and an opt-in symlink/min-size policy.

Same starting point as the basic duplicate-finder, then six layers: streaming hash, size + symlink filters, recursive directory walking, two-pass hashing, per-file error handling, and a persistent hash cache.

Two shapes that often combine in the same interview. Historical-balance lookup (add/deduct stamped at a time, query balance as of t) and FIFO consumption with per-batch expiration.

A single-table in-memory database supporting INSERT and SELECT with WHERE (AND-only equality) and multi-column ORDER BY. The stable-sort trick is the trade tool.

Build a key-value store as a single class. Layer on prefix-scan, TTL, then gzip persistence - each phase is its own surface area on top of the previous one.

Convert dotted-quad to 32-bit integers and back, iterate forward and reverse over a range, parse CIDR notation, and decompose an arbitrary range into the minimum CIDR cover.

The most-reported OpenAI coding problem. An in-memory key-value store where both keys and values are arbitrary strings - delimiters, newlines, unicode, anything. The on-the-wire format must round-trip them all.

Given a list of half-open meeting intervals, find the minimum number of conference rooms; later phases assign specific room IDs and add capped capacity with priority eviction.

Auto-simulate a turn-based team fight enforcing round order, dying-strike counterattacks, draw detection, and a full time-ordered event log.

An iterator whose state can be captured and replayed - stop iterating, save the state, hand it to a fresh iterator, and continue from exactly where you left off. Layer composition over flat and nested data.

A typed variant of the stack-samples problem - Sample and Event are dataclasses, comparisons are by value, and the contract is exposed via the imports the test file requires.

Parse and compare semver-style version strings, then layer on range constraints (>=, <, ^, ~, x-wildcards). The lexicographic-vs-numeric comparison trap is the centerpiece.

Cells hold literals or formulas that reference other cells. set_cell evaluates and caches each cell so get_cell is O(1); later levels propagate changes to dependents and reject updates that would form a cycle.

A key-value store with timestamped writes. Read at time t returns the latest value written at or before t; later phases add arbitrary-order inserts and range queries.

A stateful shell that supports POSIX cd semantics - absolute and relative paths, `.`/`..`, symlink resolution, and cycle detection. Looks simple, hides a stack-and-recursion problem.

Design a Firebase-Analytics-lite / Amplitude-lite Android SDK - microsecond-budget `track()` on the main thread, a durable on-device queue that survives OOM kill, and batched uploads that respect battery and consent.

Design a Google Docs-style collaborative editor on Android - local-first keystrokes, conflict-free merge across hours-long offline gaps, reconnect catch-up, and 100k-character documents at 60 fps.

Design a LaunchDarkly-lite / Firebase Remote Config-lite Android SDK - typed flag evaluation that never throws, deterministic bucketing on user attributes, SSE push refresh with polling fallback, and a global kill switch that outranks targeting.

Design an OkHttp-lite Android HTTP client - the shared layer every network call flows through. Reuse warm connections, cache and retry safely, pin TLS certificates, and keep any one call from running forever.

Design a Coil / Glide-lite Android image loader - memory + disk + network cache ladder, in-flight request dedup, downsampled decode, cancel-on-rebind, and bitmap pooling that keeps a 100-cell `LazyVerticalGrid` at 60 FPS without OOM.

Design an Android messenger - a durable outbox so a tapped message survives a kill, a server-assigned per-chat seq so order is a property of the data, reconnect catch-up, and FCM wakeup for offline recipients.

Design a Spotify-lite Android player - adaptive HLS/DASH streaming, gapless playback via the Media3 playlist API, background playback as a MediaSessionService that lights up Auto / Wear / lockscreen, offline downloads with Widevine DRM, audio focus, and resume-position persistence.

Design an Android social feed - opaque cursor pagination over Paging 3 + RemoteMediator, optimistic engagement with idempotent retries, 60 FPS mixed-media scrolling with autoplay video, and pull-to-refresh that surfaces new posts without losing the reading position.

Design an Uber / Lyft-lite Android rider app - a server-authoritative ride state machine, an idempotent ride request that survives a process kill, a 1-2 Hz driver-location stream interpolated to 60 FPS, FCM (Firebase Cloud Messaging) wakeup when the WebSocket is closed, and reconnect-and-reconcile under cellular drops.