90-Day Programme · Java · System Design · React · DSA

Software Engineer Prep Ledger

Four questions a day, every day, across the four tracks a Software Engineer loop actually tests — with the exact problems named and a reference link on every question. Semi-basic on day one, specialist by week ten.

0/360Closed
0/90Days done
Review queue

Quiz yourself on the syllabus notes. Anything you miss comes back here on a schedule.

The daily protocol

  1. Answer out loud, from memory, before reading the hint or opening the link. Reading feels like learning; recall is learning.
  2. Then read the hint and note the gap between what you said and what it lists.
  3. Only then open Answer and compare. What you missed is the day's real lesson; the study link is for repairing it.
  4. Write code for anything code-shaped. Never accept a conceptual answer to a mechanical question.
  5. For system design, draw it on paper — you will be drawing under pressure, so practise drawing.
  6. Do the named DSA problems yourself before looking at any solution. A read solution teaches nothing.
  7. Log every fumble to a weak-spots list. Days 78 and 84 exist to clear that list.

If you cannot explain it out loud, at speed, without notes, you do not know it yet.

Daily budget

TrackWhy it is hereTime
JavaYour primary language. Software Engineer loops go to internals, not syntax.45m
System DesignThe largest single gap between the Junior Engineer and Software Engineer hiring bars.45m
ReactIt is on your resume, so it is fair game — and it unlocks full-stack roles.30m
DSAThe screening gate. 232 named problems, grouped by pattern.45m

Roughly 2.5–3 hours a day. On a heavy work day, drop to the Java question plus one DSA problem and leave the day part-closed. Never skip a whole day — the streak is the mechanism, not the hours.

A handful of the named problems are LeetCode Premium. Every one of them has a free equivalent on NeetCode — substitute rather than skip the pattern.

Phase map

WkDaysPhaseFocusProgress
011–7 Language & Object ModelJava syntax to the object contracts - system design fundamentals - React's render model 0%
028–14 Core Libraries & CollectionsStrings, collections internals, caching strategy - and the hooks that mirror them 0%
0315–21 Streams, Generics & the EdgeFunctional Java, CDN and HTTP caching, object storage - and hooks in depth 0%
0422–28 Concurrency I & the Data LayerLocks and the memory model - indexes, query plans, transactions - state architecture 0%
0529–35 Concurrency II & Distributed DataThread pools, CAS, Loom - replication, sharding, isolation - async React 0%
0636–42 JVM, Performance & ReliabilityGC, leaks, JIT, profiling - resilience patterns - frontend performance 0%
0743–49 Spring, Persistence & Design CasesIoC, transactions, Hibernate, security - the first block of full design cases 0%
0850–56 Spring Depth & ArchitectureSpring MVC, Spring Data, Actuator, WebFlux - crawlers, caches, contended inventory 0%
0957–63 Distributed Systems & Advanced JavaPatterns, consensus, testing, security - streaming pipelines - advanced React 0%
1064–70 Fintech SpecializationLedgers, payments, exchanges, KYC - plus low-level design and frontend system design 0%
1171–77 Low-Level Design & Resume DefenseLLD rounds, metering, moderation - then every number on your resume attacked 0%
1278–84 Mock Loops & RepairSix full mock loops, rapid fire, behavioural depth, and a full dress rehearsal 0%
1385–90 Final SprintConsolidation to three pages, company targeting, and rest 0%

Week 01  ·  Days 1–7Language & Object Model

Java syntax to the object contracts - system design fundamentals - React's render model

You cannot bluff depth at Software Engineer. This week rebuilds the base every later week is interrogated against.

0/28
010/4

Object identity and the hash contract

Explain == vs equals() vs hashCode(). What exactly breaks in a HashMap when you override equals but not hashCode?

Must coverReflexive/symmetric/transitive/consistent contract; unequal hashCodes send equal objects to different buckets so get() returns null; mutable key fields after insert strand the entry permanently.

StudyHashMap API + implementation notes →

Do a back-of-envelope capacity estimate for a service with 1M DAU, 20 requests/user/day, 500-byte records, 3-year retention. Derive QPS, peak QPS, storage, bandwidth.

Must coverKnow the latency ladder cold: L1 ~1ns, RAM ~100ns, SSD random ~100us, same-DC RTT ~0.5ms, cross-continent ~150ms. Peak = 2-3x average. Always state read:write ratio before choosing storage.

StudySystem Design Primer →

What actually happens between calling setState and the DOM updating? Walk through render phase vs commit phase and automatic batching.

Must coversetState enqueues an update and schedules work; render phase is pure and interruptible, produces a new element tree, diffs it; commit phase applies mutations synchronously then runs layout effects, then paints, then passive effects. React 18 batches across promises/timeouts too.

Studyreact.dev — Render and commit →
Arrays & Hashing I
020/4

Strings, pools, and stateless scale

Why is String immutable? Explain the string pool, intern(), and why immutability makes String a safe HashMap key and safe to share across threads.

Must coverFinal char/byte array, cached hash, no defensive copy needed; pool lives in heap since Java 7; compact strings since Java 9. Contrast StringBuilder (unsynchronized) vs StringBuffer, and why + in a loop is O(n^2).

StudyJDK API docs →

Vertical vs horizontal scaling. What has to be true about your service before you can add a second instance? Explain stateless services, sticky sessions, and where session state should actually live.

Must coverExternalize session to Redis/JWT; sticky sessions break rebalancing and deploys; call out the single points of failure that horizontal scaling does not fix (the DB, the cache, the LB itself).

StudySystem Design Primer →

Why do list keys matter? Explain React reconciliation and what concretely goes wrong when you use array index as key.

Must coverSame-position/same-type elements are reused, state is keyed by position+key; index keys on a reordering or filtering list bind stale state (input values, animation) to the wrong row. Keys are scoped to siblings, not global.

Studyreact.dev — Preserving and resetting state →
Arrays & Hashing II
030/4

Immutability by design

Design a fully immutable Money class (amount + currency). What are all the rules for immutability, and where do defensive copies matter?

Must coverfinal class, private final fields, no setters, defensive copy in constructor AND getters for mutable types, BigDecimal not double for money, currency-mismatch guard, equals/hashCode/compareTo consistency. Then show it as a record and say what a record does not give you.

StudyBigDecimal API docs →

Load balancers: L4 vs L7. Compare round-robin, least-connections, consistent-hash, and weighted routing. How do health checks and connection draining work during a deploy?

Must coverL4 is fast, opaque, connection-level; L7 sees paths/headers so it enables routing, retries, TLS termination. Draining prevents dropped in-flight requests. Mention that the LB itself needs HA (DNS/anycast/failover pair).

StudyAWS — Implementing health checks →

useState vs useRef vs useReducer: give a decision rule and one case where each is the only correct choice.

Must coverState = triggers render; ref = mutable value that must NOT trigger render (timers, DOM nodes, previous values, latest-callback pattern); reducer = several fields transitioning together as one atomic action, or logic you want testable outside the component.

Studyreact.dev — Referencing values with refs →
Arrays & Hashing III
040/4

Type hierarchies and consistency models

Abstract class vs interface after Java 8 default methods. How does Java resolve a diamond when two interfaces provide the same default method? When do you actually prefer composition over inheritance?

Must coverClass wins over interface, most-specific interface wins, otherwise compile error forcing explicit Iface.super.m(). Inheritance couples you to a superclass invariant you do not control; favour composition + delegation. Cite the Liskov violation classic (Square extends Rectangle).

StudyJava Language Specification →

CAP theorem, and why PACELC is the more useful framing in practice. Explain strong, eventual, read-your-writes, and monotonic-read consistency with a real example each.

Must coverCAP only applies during a partition; PACELC adds the latency-vs-consistency tradeoff in normal operation. Payments need strong/linearizable; a feed can be eventual; a user reading their own just-posted comment needs read-your-writes (sticky routing to primary or version tokens).

StudyJepsen — consistency models →

Explain useEffect precisely: when it runs, when cleanup runs, and the two classic bugs (stale closure, missing/lying dependency array). When should you NOT use an effect at all?

Must coverCleanup runs before the next effect and on unmount. Stale closure = the effect captured an old render value. Do not use effects to derive state (compute during render), to transform props, or to handle user events - only for external synchronization.

Studyreact.dev — Synchronizing with effects →
Two Pointers I
050/4

Failure modes and the request path

Checked vs unchecked exceptions and how you would design the exception contract for a public service API. Explain try-with-resources and suppressed exceptions.

Must coverChecked for recoverable caller-actionable conditions, unchecked for programming errors; never swallow, never catch Exception broadly, never use exceptions for flow control. Wrap-and-rethrow preserving cause. AutoCloseable closes in reverse order and suppression preserves the primary failure.

StudyRFC 9110 — HTTP Semantics →

Trace exactly what happens from typing a URL to the response rendering, then map each hop to a failure mode and a mitigation.

Must coverDNS (TTL, GeoDNS) - anycast/CDN edge - TLS handshake - LB - API gateway (authN, rate limit) - service - cache - DB. Name the timeout and retry policy at each hop and where you would put a circuit breaker.

StudyAWS Builders' Library →

Controlled vs uncontrolled components. Design a 40-field form: which do you pick and why, and how do you keep typing from re-rendering the whole form?

Must coverControlled gives validation and derived UI but re-renders on every keystroke; uncontrolled + refs (or react-hook-form) isolates re-renders to the field. Discuss subscription-based form state as the scaling answer.

Studyreact.dev — Reacting to input with state →
Two Pointers II
060/4

Generics and the storage decision

Explain type erasure and its consequences. What do List<?>, List<? extends T>, List<? super T> each allow, and what is PECS?

Must coverNo generic type at runtime: no new T[], no instanceof List<String>, bridge methods, heap pollution/@SafeVarargs. Producer Extends (read-only), Consumer Super (write-only). Show why Collections.copy has both.

StudyOracle tutorial — Generics →

Give a decision framework for SQL vs NoSQL. For each of: user profiles, an audit log, a session store, a social graph, transaction ledger - pick a store and defend it.

Must coverDrive it from access patterns, consistency needs, and cardinality of relationships, not hype. Postgres is the correct default; justify moving off it. Mention that NoSQL means you model the query, not the entity.

StudyDesigning Data-Intensive Applications (Kleppmann) →

How does Context actually propagate? Why does a context update re-render every consumer, and what are the three standard fixes?

Must coverProviders bypass memoization - any consumer re-renders on value identity change. Fixes: split into multiple contexts (state vs dispatch), memoize the value object, or use a subscription store (useSyncExternalStore/Zustand) so consumers select slices.

Studyreact.dev — Passing data deeply with context →
Prefix Sum
070/4

Week 1 checkpoint - first full mock

Design a type-safe generic Cache<K,V> API with TTL, max size, and a loader function. Implement get-or-load without a race that loads twice.

Must coverInterface design first, then computeIfAbsent semantics, then why computeIfAbsent on ConcurrentHashMap can deadlock on recursive updates. Discuss eviction policy pluggability.

StudyOracle tutorial — Generics →

Design a URL shortener end to end. Cover ID generation, storage, redirect path, and analytics.

Must coverBase62 over a counter vs hash-and-check vs pre-generated key pool; 301 vs 302 (302 keeps analytics); read-heavy so cache aggressively; custom aliases need uniqueness under concurrency; async analytics via a queue.

StudySystem Design Primer →

Build an autocomplete: debounced input, request cancellation, keyboard navigation, accessible listbox.

Must coverDebounce 250-300ms, AbortController on each new request, ignore out-of-order responses, aria-activedescendant + role=combobox/listbox, arrow/enter/escape handling, and cache results by query.

StudyARIA Authoring Practices Guide — patterns →
MOCK - 45 min, timed, narrate throughout

Two mediums in 45 minutes. State brute force before optimizing, state complexity before coding.

Week 02  ·  Days 8–14Core Libraries & Collections

Strings, collections internals, caching strategy - and the hooks that mirror them

Your 1s-to-40ms caching win lives here. By the end of the week you should be able to defend it under attack.

0/28
080/4

Class internals and availability maths

Nested vs inner vs anonymous vs local classes - what does each capture, and where does the implicit outer reference cause a leak? Then explain enums with behaviour and the enum singleton idiom.

Must coverA non-static inner class holds a reference to its enclosing instance - a long-lived inner class pins the outer object in memory. Enums are the correct singleton: serialization-safe, reflection-safe, lazily initialized by the class-init lock. Cover enum with abstract methods and EnumMap/EnumSet.

StudyJava Language Specification →

Availability maths: derive the availability of a system with three serial dependencies at 99.9% each, then with a redundant pair. Define SLA, SLO, SLI and the error budget policy that follows.

Must coverSerial dependencies multiply (0.999^3 = 99.7%); redundancy adds a nine or more. An error budget converts reliability into a release-velocity decision: burn it and you freeze features. Know how many minutes/month each nine buys.

StudyGoogle SRE Workbook — SLOs →

What is StrictMode actually doing, why does it double-invoke your components and effects, and what class of bug is it designed to surface?

Must coverDevelopment-only double render and double effect mount/unmount surfaces impure render logic and missing effect cleanup - exactly the bugs that break under concurrent rendering. Map each old class lifecycle method to its function-component equivalent.

Studyreact.dev — StrictMode →
Sliding Window I
090/4

Arrays, varargs and queueing theory

Explain array covariance and ArrayStoreException, why generics are invariant instead, and the varargs/generics interaction that produces heap pollution.

Must coverObject[] a = new String[1] compiles but throws at runtime on a bad store - arrays are covariant and reified, generics are invariant and erased. Varargs of a generic type creates an unchecked array, hence @SafeVarargs. Cover Arrays.asList pitfalls and List.of immutability.

StudyOracle tutorial — Collections →

Explain Little's law and apply it: a service handles 200 req/s with 50ms average service time - how many concurrent requests are in flight? Why does latency explode past ~70-80% utilization?

Must coverL = lambda x W. Queueing delay grows non-linearly with utilization, so a system sized at 95% CPU has no headroom for a traffic spike or a GC pause. This is why you size on p99, add headroom, and why averages hide the problem.

StudyAWS Builders' Library →

How does React's synthetic event system work? Where are listeners actually attached, and how do events behave with portals?

Must coverReact 17+ attaches listeners at the root container, not document. Events bubble through the React tree, not the DOM tree - so a portal rendered into document.body still bubbles to its React parent, which surprises people building modals. Cover capture phase and stopPropagation caveats.

Studyreact.dev — Render and commit →
Sliding Window II
100/4

HashMap internals and cache strategy

Walk through HashMap internals: bucket array, hash spreading, resize, and the Java 8 treeify change. Why 0.75 load factor and why threshold 8?

Must coverhash ^ (hash >>> 16) spreads high bits; resize doubles and splits each bucket into lo/hi lists preserving order; treeify at 8 with capacity >= 64, untreeify at 6 - hysteresis. Java 7 had a resize race causing infinite loops.

StudyHashMap API + implementation notes →

Compare cache-aside, read-through, write-through, write-behind, and refresh-ahead. Which did you use for your 1s to 40ms win and what are its failure modes?

Must coverCache-aside is the default but has a stale-write race (read miss + concurrent update). Write-behind risks data loss. Eviction: LRU vs LFU vs TTL vs ARC. Always name what happens on a cache node failure.

StudyAWS — Caching challenges and strategies →

When do useMemo and useCallback actually help, and when are they pure cost? Explain referential equality as the real motivation.

Must coverThey help when (a) the computation is genuinely expensive, or (b) the value is a dependency of a memoized child/effect. They cost an allocation + comparison otherwise. Note the React Compiler changes the calculus.

Studyreact.dev — useMemo reference →
Sliding Window III
110/4

Concurrent maps and cache pathologies

ConcurrentHashMap vs Hashtable vs Collections.synchronizedMap. How does CHM achieve concurrency in Java 8, and are size() and iteration accurate?

Must coverJava 8 dropped segments for per-bin CAS + synchronized on the first node; size() is an estimate via CounterCells; iterators are weakly consistent, never throw ConcurrentModificationException. Compound operations still need putIfAbsent/compute.

StudyConcurrentHashMap API docs →

Explain cache stampede, thundering herd, and hot keys. Give three concrete mitigations for each.

Must coverStampede: request coalescing/single-flight, probabilistic early expiry, stale-while-revalidate. Hot keys: key splitting with random suffix, local L1 cache in front of Redis, dedicated replicas. Never let all keys share one TTL - add jitter.

StudyAWS — Caching challenges and strategies →

React.memo: exactly what does it compare, and name three situations where it silently does nothing.

Must coverShallow prop compare only. Defeated by: inline object/array/function props, children as JSX (new element each render), and context updates. Show the fix for each.

Studyreact.dev — memo reference →
Stack I
120/4

List internals and edge delivery

ArrayList vs LinkedList vs ArrayDeque - real performance, not textbook Big-O. Explain fail-fast vs fail-safe iterators and when CopyOnWriteArrayList is right.

Must coverLinkedList loses on cache locality almost always; ArrayDeque beats both for queue/stack. modCount drives fail-fast (best-effort, not a guarantee). COW is for read-dominant listener lists - writes copy the whole array.

StudyOracle tutorial — Collections →

Design the static asset and CDN strategy for a global app. Explain cache-control, ETag, immutable, and cache busting.

Must coverHashed filenames + max-age=31536000, immutable for assets; short/no-cache for HTML. Push vs pull CDN, origin shield, purge lag. Mention that a bad Cache-Control on HTML is the classic outage-you-cannot-roll-back.

StudyMDN — HTTP caching →

Explain list virtualization. Implement the core math for a windowed list with fixed row height, then say what changes for variable heights.

Must coverstartIndex = floor(scrollTop/rowH), visible = ceil(viewportH/rowH), overscan buffer, absolutely positioned rows inside a spacer of total height. Variable heights need measurement caching and estimated total height.

StudyTanStack Virtual — virtualization →
Stack II
130/4

Ordering: in memory and across the wire

TreeMap/TreeSet internals. Comparable vs Comparator, and what breaks when a comparator is inconsistent with equals or is not transitive.

Must coverRed-black tree, O(log n), navigable methods (floor/ceiling/headMap). Inconsistent-with-equals breaks Set/Map semantics (TreeSet uses compare, not equals). Non-transitive comparators throw IllegalArgumentException from TimSort.

StudyOracle tutorial — Collections →

Message queue vs pub/sub vs distributed log. Explain at-most-once, at-least-once, and what exactly-once really means in practice.

Must coverQueue = competing consumers, message deleted; log = retained, offset-based, replayable, multiple independent consumer groups. Exactly-once end-to-end is idempotent processing + transactional offset commit, not a delivery guarantee.

StudyKafka — design and delivery semantics →

Name the three classic data-fetching bugs: request waterfalls, race conditions, and fetch-on-render. Show the fix for each.

Must coverWaterfall: hoist/parallelize or prefetch on route. Race: AbortController or an ignore flag in cleanup. Fetch-on-render: render-as-you-fetch with Suspense or route loaders.

StudyMDN — AbortController →
Monotonic Stack
140/4

Streams and Kafka - your resume core

How do Streams actually execute? Explain laziness, the terminal-op trigger, short-circuiting, stateful vs stateless ops, and when parallel streams make things worse.

Must coverPipeline is fused into one pass; sorted/distinct are stateful barriers. Parallel uses the common ForkJoinPool - dangerous with blocking IO, bad for small N or non-splittable sources (LinkedList, IO streams), and never inside a request thread pool.

StudyStream package overview →

Kafka deep dive: partitions, keys, consumer groups, offset commits, rebalancing. How do you guarantee ordering, and what does your 1000s-of-events/minute pipeline do when a consumer falls behind?

Must coverOrdering is per-partition only, so the partition key is the design decision. Cover manual vs auto commit and the duplicate/loss window, rebalance stop-the-world vs cooperative sticky, consumer lag as the key SLI, and DLQ + retry topics.

StudyApache Kafka documentation →

What makes a good custom hook? Give the extraction rules, and explain why the rules of hooks exist at the implementation level.

Must coverExtract when logic is stateful AND reused, or when it isolates an external system. Hooks are stored in a linked list per fiber, resolved by call order - conditional calls misalign the list. A hook returning JSX should have been a component.

Studyreact.dev — Reusing logic with custom hooks →
Binary Search I

Week 03  ·  Days 15–21Streams, Generics & the Edge

Functional Java, CDN and HTTP caching, object storage - and hooks in depth

The week that turns Java-the-syntax into Java-the-toolkit. Do not rush the Collectors day.

0/28
150/4

Nullability and exactly-once semantics

Where does Optional belong and where is it an anti-pattern? Then explain functional interfaces, method references, and the effectively-final rule for lambda capture.

Must coverOptional is a return type, not a field/parameter/collection element - it is not Serializable and adds allocation. Never call get() without isPresent. Lambdas capture values not variables, which is why the compiler demands effectively-final.

StudyJDK API docs →

Design idempotent event processing. Explain idempotency keys, the transactional outbox, and deduplication windows.

Must coverOutbox: write the domain row and the event row in one local transaction, then a relay publishes - this removes the dual-write problem. Dedup needs a bounded store (Redis SETNX with TTL, or a processed_events table with a unique key).

Studymicroservices.io — Transactional outbox →

Design the loading/error/empty architecture for a data-heavy page. Explain error boundaries, what they do not catch, and how Suspense composes with them.

Must coverBoundaries catch render/lifecycle errors only - not event handlers, async code, or SSR. Pair each Suspense boundary with an error boundary; design skeletons per region so one slow call does not blank the page.

Studyreact.dev — Error boundaries →
Binary Search II
160/4

Week 2 checkpoint

Implement an LRU cache with O(1) get/put twice: once with LinkedHashMap, once from scratch with a HashMap plus doubly linked list. Then make it thread-safe.

Must coverLinkedHashMap(cap, 0.75f, true) + removeEldestEntry. From scratch: sentinel head/tail nodes to avoid null checks. Thread-safe version: discuss why a single lock is fine before reaching for striping.

StudyHashMap API + implementation notes →

Design a distributed rate limiter for an API gateway. 1000 req/min per API key, 10k keys, multiple gateway nodes.

Must coverCompare fixed window (boundary burst), sliding log (memory), sliding counter (the practical answer), token bucket (allows burst). Redis Lua for atomic check-and-increment; discuss local-first with async sync as the low-latency variant, and fail-open vs fail-closed.

StudyRedis documentation →

Design a toast/notification system: an imperative API callable from anywhere, a queue, auto-dismiss, and stacking.

Must coverStore outside React (module store + useSyncExternalStore) so non-component code can trigger it; portal for rendering; pause timer on hover/focus; aria-live=polite; cap the visible queue.

Studyreact.dev — useSyncExternalStore →
MOCK - 45 min, 1 medium + 1 hard

If the hard stalls past 25 minutes, say your partial approach out loud - a stated approach scores; silence does not.

170/4

Generic API design and HTTP caching

Design a fluent generic builder that supports subclassing. Explain recursive generic bounds (the self-type idiom) and when a bounded wildcard belongs in a public signature.

Must coverabstract class Builder<T extends Builder<T>> with a self() hook. Rule for public APIs: accept the widest type you can consume (? super), return the narrowest useful type. Never put a wildcard in a return type - it leaks into every caller.

StudyOracle tutorial — Generics →

Design the HTTP caching layer for an app with static assets, an HTML shell, and a JSON API. Explain Cache-Control directives, ETag validation, and stale-while-revalidate.

Must coverHashed assets get max-age=31536000, immutable; HTML gets no-cache (revalidate every time); API responses get private with a short max-age or ETag. A wrong Cache-Control on HTML is the outage you cannot roll back - clients hold it until TTL expiry.

StudyMDN — HTTP caching →

useLayoutEffect vs useEffect: what is the timing difference, what breaks if you pick wrong, and why does useLayoutEffect warn during SSR?

Must coveruseLayoutEffect runs synchronously after DOM mutation, before paint - use it only for measuring and mutating layout to avoid a visible flicker. It blocks paint, so misuse costs you INP. It cannot run on the server because there is no layout.

Studyreact.dev — useLayoutEffect →
Binary Search on the Answer
180/4

Collectors in depth and object storage

Write these from scratch: groupingBy with a downstream collector, toMap with a merge function, partitioningBy, and teeing. What happens when toMap hits a duplicate key, and what does it do with null values?

Must covertoMap throws IllegalStateException on duplicate keys and NPEs on a null value (unlike HashMap) - the classic production surprise. groupingBy with counting/mapping/summingInt downstream is the highest-value collector idiom. Then write a custom Collector and explain the combiner.

StudyCollectors API docs →

Design an object storage service. Cover the metadata/blob split, presigned URLs, multipart and resumable uploads, dedup, and durability via replication vs erasure coding.

Must coverBytes must never traverse your API servers - issue presigned URLs. Content-addressed storage (hash of content) gives dedup for free. Erasure coding gives the same durability as 3x replication at ~1.5x storage, at the cost of reconstruction CPU on read.

StudyAWS Builders' Library →

What problem does useSyncExternalStore solve? Explain tearing and why external stores needed a dedicated hook in concurrent React.

Must coverConcurrent rendering can interrupt and resume, so two components reading the same mutable external store mid-render can see different values - that is tearing. The hook subscribes and forces a consistent snapshot. This is how Redux and Zustand stay correct under React 18.

Studyreact.dev — useSyncExternalStore →
Linked List I
190/4

Text, encoding and unique IDs

Explain Charset handling end to end: why new String(bytes) is a bug, what UTF-8 vs UTF-16 means for String internals, and how compact strings changed things. Then cover regex catastrophic backtracking.

Must coverNever use platform-default charset - always specify StandardCharsets.UTF_8. Java 9 compact strings store Latin-1 in a byte[] when possible. Nested quantifiers like (a+)+ on a non-matching input backtrack exponentially - a real DoS vector in log parsing.

StudyJDK API docs →

Design distributed unique ID generation. Compare UUIDv4, UUIDv7, Snowflake, ULID, and a database sequence. Which do you pick for a primary key and why?

Must coverUUIDv4 is random so it destroys B-tree insert locality and index cache hit rate - UUIDv7 and ULID are time-ordered and fix that. Snowflake needs coordinated machine IDs and is clock-sensitive. Sortability, size, and leak-of-information are the three axes.

StudySystem Design Primer →

Type a component properly in TypeScript: generic props, discriminated unions for state, and typing a polymorphic component. What are the common typing mistakes?

Must coverModel state as a discriminated union ({status:'loading'} | {status:'error', error} | {status:'ok', data}) so illegal combinations do not compile. Avoid React.FC, avoid any in event handlers, prefer ComponentPropsWithoutRef for wrapper components.

StudyTypeScript — React cheatsheet →
Linked List II
200/4

Locks and indexes

synchronized vs ReentrantLock. Explain reentrancy, monitor entry, and what ReentrantLock gives you that synchronized does not.

Must covertryLock with timeout, interruptibility, fairness, multiple Conditions, lock-in-one-method-unlock-in-another. synchronized got biased/lightweight locking optimizations and works with virtual threads well post-JDK21 pinning fixes. Always unlock in finally.

StudyJenkov — Java Concurrency tutorial →

Explain B-tree indexes, composite index column order, covering indexes, and selectivity. Take a slow query and show your full diagnosis process.

Must coverLeftmost-prefix rule for composite indexes; index-only scans; low-cardinality columns are poor leading columns. Diagnosis: EXPLAIN ANALYZE, look for seq scans and bad row estimates, check statistics, then consider the index. This is your 30-40% claim - own it.

StudyPostgreSQL — Indexes →

Give a rule for where state should live: local, lifted, context, or external store. What is the cost of getting it wrong in each direction?

Must coverColocate by default; lift to the lowest common ancestor; context for low-frequency wide values (theme, auth); external store for high-frequency or cross-tree state. Too high = needless re-renders; too low = prop drilling and desync.

Studyreact.dev — State as a snapshot →
Linked List III
210/4

Memory model and query plans

Explain the Java Memory Model: happens-before, reachability, and what volatile guarantees. Why is volatile insufficient for i++ but sufficient for a flag?

Must covervolatile gives visibility + ordering (no reordering across it) but not atomicity of compound actions. Cover the double-checked-locking bug and why the field must be volatile, plus final field freeze semantics for safe publication.

StudyJLS ch.17 — Threads and Locks →

How do you read an EXPLAIN plan? Fix an N+1, and compare offset pagination vs keyset/cursor pagination at page 10,000.

Must coverOFFSET 100000 still scans and discards 100k rows and is unstable under concurrent inserts; keyset uses WHERE (created_at, id) < (?, ?) with a matching index - O(1) per page. N+1 fix: join fetch / batch size / IN-clause batching.

StudyPostgreSQL — Using EXPLAIN →

Redux Toolkit vs Zustand vs Context+useReducer vs a server-cache library. Give the selection criteria and explain state normalization.

Must coverDistinguish server state (cache, needs invalidation/staleness - use TanStack Query) from client state (needs a store). Normalize by id to avoid duplicate sources of truth. Selector granularity is what determines re-render cost.

StudyRedux Toolkit — usage guide →
Linked List IV - hard

Week 04  ·  Days 22–28Concurrency I & the Data Layer

Locks and the memory model - indexes, query plans, transactions - state architecture

The single highest-yield week for a backend Software Engineer loop. Slow down here if you need to.

0/28
220/4

Thread pools and replication

How do you size a thread pool for CPU-bound vs IO-bound work? Explain the ThreadPoolExecutor parameters, queue choice, and rejection policies - and the classic newFixedThreadPool trap.

Must coverCPU-bound: cores+1. IO-bound: cores * (1 + wait/service). Unbounded LinkedBlockingQueue means maxPoolSize is never reached and you OOM instead of rejecting. Always bound the queue and pick a rejection policy deliberately (CallerRuns as backpressure).

StudyThreadPoolExecutor API docs →

Leader-follower replication: sync vs async vs semi-sync. Explain replication lag and three ways it breaks user experience.

Must coverRead-your-writes, monotonic reads, and consistent-prefix violations. Fixes: read-from-primary after write for N seconds, version/LSN tokens, sticky routing. Cover failover, split-brain, and fencing tokens.

StudyPostgreSQL — Replication and high availability →

Explain TanStack Query mentally: query keys, stale vs cached, background refetch, invalidation. How would you model a paginated + filtered table with it?

Must coverKey encodes every input (page, filters, sort) so caching is automatic; staleTime vs gcTime; keepPreviousData for smooth pagination; invalidateQueries after a mutation vs setQueryData for instant updates.

StudyTanStack Query — important defaults →
Heaps I
230/4

Deadlock and sharding

Produce a two-lock deadlock, then fix it three different ways. How do you detect a deadlock in a running production JVM?

Must coverFixes: global lock ordering, tryLock with timeout and backoff, or removing the need for two locks. Detection: jstack/jcmd shows Found one Java-level deadlock; ThreadMXBean.findDeadlockedThreads programmatically.

StudyJenkov — Java Concurrency tutorial →

Design sharding for a 5TB transactions table. Choose a shard key, explain consistent hashing with virtual nodes, and describe a resharding plan with zero downtime.

Must coverRange vs hash vs directory-based. A bad shard key = hotspots and cross-shard joins/transactions. Resharding: dual-write, backfill, verify, cut over reads, then stop old writes. Say what queries become expensive after sharding.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Implement optimistic updates with rollback for a like button and for a reorderable list. What are the correctness hazards?

Must coverSnapshot previous state, apply optimistic change, roll back on error, always refetch/invalidate on settle. Hazards: concurrent mutations to the same entity, and the server returning a different canonical value than you guessed.

StudyTkDodo — Practical React Query →
Heaps II
240/4

Lock-free and isolation levels

Explain CAS and how AtomicInteger works. What is the ABA problem, when does LongAdder beat AtomicLong, and what is the cost of contended CAS?

Must coverCAS spins under contention wasting CPU; LongAdder uses per-thread cells and sums on read - great for write-heavy counters, worse for read-heavy. ABA solved with AtomicStampedReference. Mention false sharing and @Contended.

StudyJLS ch.17 — Threads and Locks →

Explain ACID and each isolation level with the anomaly it prevents. What is MVCC and how does Postgres implement snapshot isolation?

Must coverDirty read / non-repeatable read / phantom / lost update / write skew. Read Committed is the Postgres default - write skew is still possible, needs SERIALIZABLE or SELECT FOR UPDATE. Explain why long transactions cause table bloat.

StudyPostgreSQL — Concurrency control / MVCC →

Design form architecture for a multi-step wizard with cross-step validation, autosave, and resumability.

Must coverSchema-driven validation (Zod) shared with the backend, per-step submit with a draft resource, debounced autosave with conflict detection, and URL-driven step state so refresh and back button work.

StudyReact Hook Form documentation →
Heaps III - two heaps
250/4

Virtual threads and sagas

ThreadLocal: legitimate uses, and the leak it causes in a thread pool. Then explain virtual threads - what changed, what pins a carrier thread, and when platform threads are still right.

Must coverThreadLocal must be removed in a finally or it leaks across pooled tasks; use ScopedValue on modern JDKs. Virtual threads make thread-per-request cheap for IO-bound work; they do not help CPU-bound work; pooling them is an anti-pattern.

StudyJEP 444 — Virtual Threads →

Distributed transactions: 2PC vs saga. Design an order flow across payment, inventory, and shipping with compensating transactions.

Must cover2PC blocks on coordinator failure and does not scale. Choreography (events, loose, hard to trace) vs orchestration (a state machine, easier to reason about). Compensations are not rollbacks - they are semantic reversals, and some are impossible.

Studymicroservices.io — Saga pattern →

Design routing and code splitting for a large app. Where do you split, how do you prefetch, and how do you avoid a loading spinner on every navigation?

Must coverSplit at route boundaries plus heavy leaf components (editor, charts); prefetch on link hover/viewport; keep the shell persistent; use transitions so the old page stays visible during load instead of flashing a fallback.

Studyreact.dev — Suspense →
Intervals I
260/4

Week 3 checkpoint - fintech mock

Implement a bounded blocking queue with wait/notify, then with ReentrantLock+Condition. Then implement a thread-safe token-bucket rate limiter.

Must coverAlways wait in a while loop (spurious wakeups), use notifyAll or two Conditions (notFull/notEmpty). For the limiter, compute tokens lazily from elapsed time rather than running a refill thread.

StudyThreadPoolExecutor API docs →

Design a payments ledger service. Requirements: double-entry, idempotent charge API, eventual reconciliation with a PSP, full auditability.

Must coverImmutable append-only entries, every transaction balances to zero, balance as a materialized projection with periodic snapshots. Idempotency-Key header with a stored request-hash+response. Never DELETE or UPDATE a ledger row. This is your strongest domain - be crisp.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Build a live operations dashboard: WebSocket updates at 50 msgs/sec, 8 widgets, must stay responsive.

Must coverBuffer and flush on an animation frame instead of setState per message; keep the socket in a store outside React; useDeferredValue for expensive charts; virtualize the event log; handle reconnect with backoff and a resync snapshot.

StudyMDN — WebSockets API →
MOCK - 45 min, 1 medium + 1 hard

Design-flavoured hard. Ask clarifying questions about the API before writing anything.

270/4

Advanced locking and layered caching

Compare ReentrantLock, ReadWriteLock, and StampedLock. When does a read-write lock perform worse than a plain mutex, and what is optimistic reading?

Must coverReadWriteLock has higher acquisition overhead and risks writer starvation - it only pays off with long reads and rare writes. StampedLock adds optimistic reads (no lock at all, validate afterwards) but is not reentrant and misuse deadlocks. Also cover lock striping.

StudyJenkov — Java Concurrency tutorial →

Design a two-tier cache: an in-process L1 in front of a shared Redis L2. How do you invalidate L1 across 20 instances, and what is cache penetration?

Must coverL1 gives nanosecond reads but goes stale independently on every node - invalidate via a pub/sub channel or accept a short TTL. Penetration = repeated misses for keys that do not exist; fix with negative caching or a Bloom filter in front.

StudyAWS — Caching challenges and strategies →

Effects that race: a component fetches on prop change and the responses arrive out of order. Show three fixes and say which you would ship.

Must coverIgnore-flag in cleanup (simplest, always correct), AbortController (also cancels the network work), or a query library that handles it structurally. Also cover the latest-callback ref pattern for handlers that must not re-subscribe.

StudyMDN — AbortController →
Intervals II
280/4

Fork/Join and backpressure

Explain the Fork/Join framework and work stealing. Write a RecursiveTask, and explain why the common pool is dangerous for blocking work.

Must coverWork stealing keeps threads busy by taking from the tail of other deques. The common pool is sized to cores-1 and is shared by every parallel stream in the JVM - one blocking task in it starves everything else. Use ManagedBlocker or a dedicated pool.

StudyOracle tutorial — Concurrency →

Design backpressure across a chain of three services plus a queue. What are the mechanisms at each boundary, and what happens when you have none?

Must coverBounded queues, rejection with 429/503, concurrency limits, and consumer-driven pull (Kafka, Reactive Streams request(n)). Without backpressure the failure mode is unbounded memory growth then a cascading collapse - the queue absorbs load until it does not.

StudyAWS — Using load shedding to avoid overload →

Build accessible drag-and-drop reordering. Cover pointer events, keyboard alternative, live-region announcements, and optimistic persistence.

Must coverMouse-only DnD is an accessibility failure - every drag needs a keyboard path (grab, arrow, drop) and an aria-live announcement of the new position. Persist optimistically with rollback, and handle the drop-outside and mid-drag-unmount cases.

StudyARIA Authoring Practices Guide — patterns →
Trees I - traversal basics

Week 05  ·  Days 29–35Concurrency II & Distributed Data

Thread pools, CAS, Loom - replication, sharding, isolation - async React

Concurrency and data both get their second, harder pass. Expect this week to be uncomfortable.

0/28
290/4

Async error handling and consistency models

How do exceptions propagate through a CompletableFuture chain? Contrast exceptionally, handle, and whenComplete, and explain what happens to an exception you never join on.

Must coverAn exception completes the future exceptionally and short-circuits the dependent chain; thenApply is skipped, handle is not. An unobserved failed future fails silently - always terminate a chain with an exception-aware stage. Also cover CompletionException unwrapping.

StudyCompletableFuture API docs →

Walk the consistency model catalogue: linearizable, sequential, causal, read-your-writes, monotonic reads, eventual. Give a real system for each and say what a user notices when it is violated.

Must coverAnchor each to an observable symptom: your own comment vanishing on refresh (read-your-writes), a reply appearing before the message it answers (causal), a counter going backwards (monotonic). Interviewers reward symptoms over vocabulary.

StudyJepsen — consistency models →

Build infinite scroll with IntersectionObserver: loading sentinel, deduplication, error retry, and scroll restoration on back-navigation.

Must coverObserve a sentinel element rather than listening to scroll. The hard parts are: not double-firing while a request is in flight, preserving scroll position when returning to the list, and providing a keyboard-accessible load-more button as a fallback.

StudyMDN — Intersection Observer API →
Trees II
300/4

JVM memory layout and hashing at scale

Describe JVM memory: heap generations, metaspace, thread stacks, code cache, direct buffers. What is escape analysis and scalar replacement?

Must coverMetaspace is native memory and grows unbounded by default - a classloader leak shows up here, not in the heap. Escape analysis can eliminate allocation entirely or remove locks. Know -Xmx vs container memory limits (the classic OOMKilled).

StudyHotSpot GC Tuning Guide (JDK 21) →

Explain consistent hashing from first principles, including virtual nodes. What problem does it solve that modulo hashing does not?

Must coverWith mod N, changing N remaps nearly every key. Consistent hashing remaps only K/N. Virtual nodes fix load imbalance and let you weight heterogeneous nodes. Mention bounded-load consistent hashing and rendezvous hashing as alternatives.

StudyConsistent hashing with bounded loads (Google) →

What is your testing strategy for a React app? What do you test, what do you never test, and how do you handle the network?

Must coverTest behaviour through the accessible tree (getByRole), not implementation. MSW for network so tests survive refactors. Never snapshot-test large trees. Integration tests over unit tests for components; keep pure logic in plain functions and unit-test that.

StudyReact Testing Library — guiding principles →
Trees III - BFS
310/4

Garbage collection and rate limiting math

Compare Serial, Parallel, G1, and ZGC. Explain the generational hypothesis, why G1 is region-based, and how you would read a GC log to diagnose a latency problem.

Must coverG1 targets a pause goal by choosing how many regions to collect; ZGC/Shenandoah are concurrent with sub-ms pauses at some throughput cost. Look for: promotion rate, humongous allocations, full GCs, and whether pauses correlate with your p99 spikes.

StudyHotSpot GC Tuning Guide (JDK 21) →

Compare token bucket, leaky bucket, fixed window, sliding window log, and sliding window counter. Derive the memory cost and the burst behaviour of each.

Must coverFixed window allows 2x burst at the boundary; sliding log is exact but O(requests) memory; sliding counter approximates with two counters and is the industry default. Token bucket is the right model when bursts are legitimate.

StudyRedis documentation →

Make a modal fully accessible: focus trap, restore focus, escape, scroll lock, screen reader semantics. What is the inert attribute for?

Must coverrole=dialog + aria-modal, aria-labelledby, focus first meaningful element (not always the first focusable), return focus to the trigger on close, trap Tab cycling, inert or aria-hidden the background.

StudyARIA Authoring Practices Guide — patterns →
Binary Search Trees
320/4

Leaks and resilience patterns

Name five classic Java memory leaks and how you would confirm each from a heap dump. Distinguish the OutOfMemoryError variants.

Must coverStatic collections, unremoved listeners, ThreadLocal in pools, classloader leaks on redeploy, unbounded caches. Heap dump: dominator tree, retained size, GC roots path. OOM variants: Java heap space, GC overhead limit, Metaspace, unable to create native thread, Direct buffer memory.

StudyJDK Troubleshooting Guide →

Design the resilience layer for a service calling three flaky downstreams. Cover timeouts, retries with jitter, circuit breakers, bulkheads, and graceful degradation.

Must coverTimeout budget must shrink down the call chain. Retries without jitter synchronize into a retry storm; only retry idempotent operations; cap total attempts. Circuit breaker states closed/open/half-open. Bulkhead = separate pools so one slow dependency cannot exhaust all threads.

StudyAWS — Timeouts, retries and backoff with jitter →

How do you profile a slow React page? Walk through the Profiler flamegraph and the Core Web Vitals that matter for interactivity.

Must coverIdentify whether the cost is render count, render duration, or a long task blocking the main thread. INP replaced FID; LCP is usually an image or font issue; CLS from unsized media. Fix render count with memo/selectors, render duration with virtualization or moving work off the main thread.

Studyweb.dev — Interaction to Next Paint (INP) →
Trees - hard
330/4

Class loading and observability

Explain the classloader hierarchy and delegation model. What is the order of static initialization, and why is reflection slow?

Must coverBootstrap - platform - application, parent-first delegation; child-first breaks it for app servers. Static init runs on first active use, is thread-safe via the class init lock (basis of the holder idiom). Reflection skips JIT inlining and does access checks - use MethodHandles/LambdaMetafactory when hot.

StudyJava Language Specification →

Design observability for a microservice fleet: metrics, logs, traces. Define SLI/SLO/error budget and pick the right dashboard signals.

Must coverRED for request services (rate, errors, duration), USE for resources (utilization, saturation, errors). Trace context propagation across Kafka needs headers. Alert on symptoms (SLO burn rate), not causes. Cardinality is the metric-system killer.

StudyOpenTelemetry documentation →

How do you diagnose and reduce a 3MB JS bundle? Explain tree shaking, side effects, and dynamic import boundaries.

Must coverAnalyze first (source-map-explorer / rollup-visualizer). Common wins: moment to date-fns, deep-import icon libraries, accidental barrel-file imports pulling everything, duplicate React from mismatched deps, polyfills for browsers you do not support. sideEffects:false in package.json.

Studyweb.dev — Core Web Vitals →
Tries
340/4

Serialization and safe deploys

Why is Java serialization discouraged? Explain serialVersionUID, transient, and the deserialization attack surface. What are the pitfalls of JSON mapping in Spring?

Must coverDeserialization constructs objects without constructors, bypassing invariants - the source of many RCE CVEs. Prefer JSON/protobuf. Jackson pitfalls: missing no-arg constructor, LocalDateTime without JavaTimeModule, unknown-property failures, and Lombok breaking builder deserialization.

StudyJDK API docs →

Design a zero-downtime deploy for a service and a schema change. Cover blue/green, canary, feature flags, and expand-contract migrations.

Must coverExpand-contract: add nullable column, dual-write, backfill, switch reads, then drop - never rename in one step. Flyway/Liquibase migrations must be forward-only and backward-compatible for one release. Canary on error rate + latency with automatic rollback.

StudyFlyway documentation →

CSR vs SSR vs SSG vs ISR vs streaming SSR. What is hydration, why is it expensive, and what are React Server Components solving?

Must coverHydration re-runs the whole component tree to attach handlers - it is O(tree), not O(interactive). Hydration mismatch causes silent client re-render. RSC removes component code from the bundle and moves data access to the server.

StudyNext.js — rendering strategies →
Backtracking I
350/4

Contracts, records, and search

State the contracts for equals, hashCode, compareTo, clone, and toString. Then explain records and sealed classes - what do they buy and what do they not?

Must covercompareTo should be consistent with equals or sorted collections misbehave. clone is broken - prefer copy constructors. Records: final, auto equals/hashCode/toString, but shallow - a record holding a List is still mutable. Sealed + records + pattern matching gives you exhaustive switches.

StudyJEP 395 — Records →

Design search/typeahead over 100M documents. Explain the inverted index, tokenization, ranking, and how Elasticsearch shards and replicates.

Must coverInverted index: term to posting list; TF-IDF/BM25 for ranking. Typeahead often uses a trie or completion suggester, not full search. Index is near-real-time (refresh interval); discuss the write path and why search clusters are not the source of truth.

StudyElasticsearch guide →

Design a micro-frontend architecture. When is it worth it, and what breaks - shared state, routing, duplicate deps, design consistency?

Must coverWorth it for independent team deploy cadence at scale; almost never worth it below ~5 teams. Module Federation for shared runtime deps; a shared design system package; a host-owned router contract; version skew is the real operational cost.

StudyModule Federation documentation →
Backtracking II - dedupe

Week 06  ·  Days 36–42JVM, Performance & Reliability

GC, leaks, JIT, profiling - resilience patterns - frontend performance

Where a senior answer separates from a mid-level one: you stop describing systems and start operating them.

0/28
360/4

Week 4 checkpoint - production debugging

Production incident: a Spring Boot service shows 100% CPU on two pods and p99 latency at 8s. Walk the entire diagnostic toolchain to root cause.

Must covertop -H to find hot threads, convert TID to hex, jstack and match; jcmd Thread.print repeatedly to spot a stuck thread; GC log for a GC death spiral; async-profiler flamegraph; check connection pool exhaustion (HikariCP metrics) which looks like CPU but is queueing.

Studyasync-profiler →

Design a multi-channel notification system: push, email, SMS, in-app. 10M users, user preferences, dedupe, rate caps, and delivery tracking.

Must coverTemplate service + preference service + per-channel senders behind a queue; fan-out via Kafka topic per channel; idempotency by (user, event_id, channel); retry with DLQ; digest/batching to respect rate caps; provider failover.

StudyAWS Builders' Library →

Design the public API for a design-system Table component: sorting, selection, pagination, expandable rows, sticky columns. Make it flexible without becoming a god component.

Must coverPrefer a headless core hook + composable subcomponents over 40 props. Controlled/uncontrolled dual support for each feature. Render props or slots for cells. Discuss how you keep it accessible and how you version breaking changes.

StudyARIA Authoring Practices Guide — patterns →
MOCK - 45 min, 1 medium + 1 hard

Trie + backtracking together. If you cannot finish, get the trie built and state the search plan.

370/4

JIT, warmup and capacity planning

Explain tiered compilation, inlining, and deoptimization. Why is the first minute after deploy slower, and what does that mean for load balancing and benchmarking?

Must coverC1 compiles fast with profiling, C2 compiles slow and optimizes hard using that profile; a changed type profile triggers deopt back to the interpreter. Practical consequences: slow-start on new pods, warmup requests before joining the LB, and why a naive microbenchmark measures the interpreter.

StudyJMH — Java Microbenchmark Harness →

Do capacity planning for a service: peak QPS, headroom, instance sizing, and autoscaling signals. Why is CPU usually the wrong autoscaling metric?

Must coverCPU lags for IO-bound services and hides queueing - scale on concurrency, queue depth, or request latency instead. Account for scale-up lag (image pull, JVM warmup) which is often longer than your traffic spike. Always leave headroom for one AZ failing.

StudyAWS Builders' Library →

Optimize LCP on a content page: fonts, images, and critical CSS. What are the specific levers and their order of impact?

Must coverPreload the LCP image, use fetchpriority=high, avoid lazy-loading above the fold, use font-display:swap plus preloaded woff2 to kill FOIT, inline critical CSS, and remove render-blocking scripts. Measure with field data (CrUX/RUM), not just lab.

Studyweb.dev — Largest Contentful Paint →
Backtracking III
380/4

Off-heap memory and log pipelines

Explain direct ByteBuffers, memory-mapped files, and zero-copy transfer. Where does off-heap memory show up in your monitoring, and how does it cause an OOM the heap graph does not explain?

Must coverDirect buffers live in native memory freed only when the referencing object is collected - a slow GC means unbounded native growth. Track -XX:MaxDirectMemorySize and Native Memory Tracking. FileChannel.transferTo is how Kafka avoids copying through user space.

StudyJDK Troubleshooting Guide →

Design a log aggregation and search platform: 10TB/day ingest, 7-day hot retention, sub-second search on recent data.

Must coverAgent, buffer (Kafka), index tier, cold object storage. Index only what you search on and store the rest as blobs. Time-based indices so retention is a drop, not a delete. Sampling and cardinality control are what keep this affordable.

StudyElasticsearch guide →

Find and fix memory leaks in a long-lived SPA. What leaks, how do you detect it, and what is the heap-snapshot workflow?

Must coverUncleaned listeners, timers, subscriptions, observers, detached DOM held by closures, and caches that never evict. Workflow: take a snapshot, interact, snapshot again, compare retained size and look for detached nodes. Every subscribe in an effect needs its unsubscribe.

Studyreact.dev — Profiler →
Graphs I - grid DFS/BFS
390/4

Packaging, startup and analytics offload

Explain JPMS modules, jlink, and GraalVM native image at a high level. What do you gain and what do you give up on a Spring Boot service?

Must coverNative image gives ~50ms startup and low memory but a long build, closed-world assumptions, and reflection needing explicit hints - painful with dynamic frameworks. Modules give strong encapsulation but break reflective libraries. Know when the tradeoff is worth it (serverless, CLI) and when it is not.

StudyJDK API docs →

Keep analytics off your OLTP database. Explain change data capture, the log-based approach, and the OLTP/OLAP split.

Must coverCDC reads the write-ahead log (Debezium) rather than polling, so it does not add query load and it captures deletes. Feed a warehouse or lakehouse; never let analysts query the primary. Discuss schema drift and the exactly-once question on the CDC pipeline.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Put performance budgets in CI. What do you measure, what fails a build, and how do you stop slow regression over months?

Must coverBundle-size budget per route chunk, Lighthouse CI on key pages, and RUM alerts on INP/LCP percentiles. Fail on a delta against the base branch, not an absolute number, so the budget stays honest. Track it as a chart owned by the team.

Studyweb.dev — Core Web Vitals →
Graphs II - multi-source BFS
400/4

Spring container and feed fan-out

Explain Spring IoC: bean lifecycle, scopes, and how @Configuration proxying (CGLIB) makes inter-bean calls return singletons. How does Spring resolve a circular dependency, and why does constructor injection fail?

Must coverThree-level cache of singletons enables setter/field circular refs; constructor injection cannot because the object does not exist yet - and that is a feature, it surfaces a design smell. Know @Primary/@Qualifier, @Lazy, and why field injection hurts testability.

StudySpring Framework — Core / IoC container →

Design a news feed for 200M users. Compare fan-out on write vs fan-out on read, and design the hybrid that handles celebrity accounts.

Must coverFan-out on write is fast reads but explodes for high-follower accounts; hybrid = precompute for normal accounts, pull-and-merge for celebrities at read time. Discuss feed ranking, pagination stability with a cursor, and cache warming.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Explain compound components and headless components. Refactor a 25-prop Select into a composable API.

Must coverContext inside the parent shares state with children (Select.Trigger, Select.Option); headless separates behaviour/a11y from markup so consumers own styling. Trade-off: more flexible, but the API surface is implicit and harder to type/document.

Studyreact.dev — Passing data deeply with context →
Topological Sort
410/4

Transactions in Spring and realtime chat

How does @Transactional work internally? Explain the proxy, the self-invocation trap, propagation levels, rollback rules, and why it silently does nothing on a private method.

Must coverAOP proxy intercepts external calls only - this.method() bypasses it. Default rollback is on RuntimeException only, not checked exceptions. REQUIRES_NEW uses a separate connection (deadlock risk). Never do a remote call inside a transaction.

StudySpring Framework — Transaction management →

Design a chat system: 1-1 and group, online presence, delivery/read receipts, message ordering, and offline sync.

Must coverWebSocket with a connection registry (which server holds which user) in Redis; messages persisted before ack; ordering via per-conversation sequence numbers, not timestamps; presence via heartbeat with TTL; offline devices sync by last-seen sequence.

StudyMDN — WebSockets API →

HOCs vs render props vs hooks: what problem did each solve and why did hooks win? When is a HOC still the right tool?

Must coverHOCs cause wrapper hell and prop collisions; render props cause callback nesting; hooks compose linearly. HOCs still fit cross-cutting concerns applied at the boundary (withErrorBoundary, route guards, instrumentation).

Studyreact.dev — Escape hatches →
Union-Find
420/4

Hibernate internals and blob storage

Explain the Hibernate persistence context: dirty checking, flush timing, the 1st-level cache, and lazy loading. Diagnose and fix an N+1, and explain LazyInitializationException.

Must coverFlush happens before query execution and on commit, not on every setter. N+1 fixes: JOIN FETCH, @EntityGraph, @BatchSize, or a projection DTO. LazyInitializationException = touching a proxy after the session closed - fix with a fetch plan, not OSIV.

StudyHibernate ORM user guide →

Design a file storage service (S3-like) with 1GB uploads, deduplication, and resumable uploads.

Must coverChunked/multipart upload with per-chunk checksums; content-addressed storage (hash) for dedupe; metadata DB separate from blob store; presigned URLs so bytes never traverse your API; erasure coding vs replication for durability.

StudyAWS Builders' Library →

Model a complex UI flow (checkout with payment retry) as a state machine. Why is a state machine better than a pile of booleans?

Must coverN booleans = 2^N states, most of them illegal. Explicit states + transitions make impossible states unrepresentable, make the flow testable and diagrammable, and make the loading/error/retry paths obvious. Show the state chart before the code.

StudyXState — state machines documentation →
Shortest Path

Week 07  ·  Days 43–49Spring, Persistence & Design Cases

IoC, transactions, Hibernate, security - the first block of full design cases

Framework depth plus real design problems. Every Spring question this week has a trap in it.

0/28
430/4

Auth end to end - your Unsent project

Explain Spring Security's filter chain, then the OAuth2 authorization-code flow with PKCE. Where do you validate a JWT, how do you handle refresh, and how do you revoke?

Must coverFilter chain order matters (auth before authorization). JWTs are not revocable by design - use short access tokens + a refresh token with rotation and reuse detection, plus a denylist by jti for emergencies. Validate signature, iss, aud, exp, and alg (never accept none).

StudySpring Security reference →

Design an authentication service for a multi-product company: SSO, sessions vs JWT, RBAC vs ABAC, and token lifetimes.

Must coverSessions are revocable and simple but need a shared store; JWTs scale statelessly but leak the revocation problem. SSO via OIDC. RBAC scales badly past ~50 roles - ABAC/policy engine (OPA) for fine-grained. Discuss the blast radius of a signing-key compromise and key rotation via JWKS.

StudyRFC 6749 — OAuth 2.0 →

Implement auth in React: where do you store the token, how do you do silent refresh, and how do route guards avoid flashing protected content?

Must coverhttpOnly cookie beats localStorage (XSS-proof) but needs CSRF protection (SameSite=Lax/Strict + token). Refresh via a single-flight interceptor that queues concurrent 401s. Guard with a loading state during the initial auth check, never render-then-redirect.

StudyRFC 8725 — JWT Best Current Practices →
Advanced Graphs
440/4

API design and gateways

Design a REST API you would defend in review: versioning strategy, pagination, filtering, error contract, idempotency, and partial updates.

Must coverURI vs header versioning (URI wins for pragmatism); RFC 7807 problem+json for errors; cursor pagination; PATCH with JSON Merge Patch semantics; Idempotency-Key on POST; never leak internal exceptions or stack traces. Discuss when gRPC or GraphQL beats REST.

StudyRFC 9457 — Problem Details for HTTP APIs →

What belongs in an API gateway vs a BFF vs a service mesh? Design the edge for a system with web, mobile, and partner API clients.

Must coverGateway: authN, rate limiting, routing, TLS. BFF: per-client aggregation and shaping (mobile needs fewer round trips). Mesh: service-to-service mTLS, retries, observability - a sidecar concern, not an edge concern. Avoid the gateway becoming a business-logic monolith.

StudygRPC documentation →

Design the API layer of a React app: typed clients, error normalization, retries, auth injection, and cancellation. How do you keep components ignorant of transport?

Must coverOne fetch wrapper - interceptors for auth/tracing, a normalized error type, typed responses generated from OpenAPI. Components use hooks that speak domain language (useInvoice), never fetch directly. This makes swapping REST for GraphQL a non-event.

StudyTanStack Query — important defaults →
1-D DP I
450/4

Caching layer - defend your 96% win

Explain Spring's caching abstraction: @Cacheable, @CachePut, @CacheEvict, key generation, and the self-invocation trap again. What are the pitfalls with a Redis cache manager?

Must coverSame proxy limitation as @Transactional. Pitfalls: default key generator collisions, caching null, serialization format lock-in (avoid JDK serialization), no per-entry TTL without config, and cache stampede on eviction. sync=true for single-flight.

StudySpring Framework — Cache abstraction →

Redis deep dive: data structures and their real uses, persistence (RDB vs AOF), cluster mode, and distributed locking. Why is Redlock controversial?

Must coverSorted sets for leaderboards/rate limits/delayed queues, hashes for objects, streams for lightweight queues. Redlock relies on bounded clock drift and GC pauses - use fencing tokens if correctness matters. Cluster mode breaks multi-key ops across slots.

StudyRedis — distributed locks and Redlock →

Design client-side persistence: what goes in memory, localStorage, IndexedDB, or the service worker cache? Build an offline-capable read path.

Must coverlocalStorage is synchronous and blocks the main thread - small values only. IndexedDB for structured data and large sets. Service worker for network-level caching with stale-while-revalidate. Discuss the sync-conflict problem on reconnect.

StudyMDN — IndexedDB API →
1-D DP II - strings
460/4

Week 5 checkpoint - full mock round

Live coding: design and implement an in-memory transactional key-value store supporting begin/commit/rollback with nested transactions.

Must coverStack of change-sets; commit merges down one level; rollback pops. Get walks the stack top-down. Then discuss making it thread-safe and what isolation level you have actually implemented.

StudyJDK API docs →

Design the end-to-end Kafka event pipeline you built at FIS, as if from scratch. Producers, topic design, consumers, error handling, monitoring, and scaling to 100x.

Must coverJustify partition count and key choice, acks and idempotent producer settings, consumer concurrency, retry topic + DLQ, schema registry and compatibility rules, and lag alerting. Then answer: what breaks first at 100x?

StudyApache Kafka documentation →

You inherit a 2000-line component with 30 useState calls and 8 effects. Give your refactoring plan, in order, with how you avoid regressions.

Must coverCharacterization tests first, then extract pure logic, then collapse related state into a reducer, then split by responsibility, then extract custom hooks, then memoize only where profiling proves it. Never refactor and change behaviour in the same commit.

Studyreact.dev — You might not need an effect →
MOCK - 45 min, two mediums

Graph round. Say which traversal you are choosing and why before you write it.

470/4

Spring MVC internals and audit history

Trace a request through Spring MVC: DispatcherServlet, handler mapping, argument resolvers, message converters, and the response path. Where do filters differ from interceptors, and how do you design a global error handler?

Must coverFilters are servlet-level (see every request including static and security), interceptors are Spring-level (have the handler). @ControllerAdvice + @ExceptionHandler with RFC 9457 problem details. Bean validation groups for conditional rules. Never leak stack traces.

StudySpring Framework — Web MVC →

Design an audit history service for a regulated fintech system: who changed what, when, immutable, queryable, and retained for seven years.

Must coverAppend-only store, hash-chained records or WORM storage for tamper evidence, actor/subject/action/before/after schema, and async ingestion so audit never blocks the business path - but with a durability guarantee. Retention tiering to cold storage after 90 days.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Design route-level data loading with nested layouts: parallel fetching, pending UI, and error isolation per segment.

Must coverLoaders per route segment fetch in parallel instead of waterfalling through component mounts. Each segment gets its own pending and error boundary so a slow sidebar does not blank the page. Cover deferred data and streaming the slow parts.

Studyreact.dev — Suspense →
1-D DP III
480/4

Spring Data depth and distributed caching

Spring Data JPA: derived queries, @Query, projections (interface vs DTO vs class-based), Specifications, and pagination. Why is a projection often the correct fix for a slow endpoint?

Must coverFetching whole entities to return three fields wastes IO and fills the persistence context. Interface projections generate a narrow select; DTO projections avoid dirty-checking overhead entirely. Pageable with a count query is expensive - know when to use Slice instead.

StudySpring Data JPA reference →

Design a distributed cache service: partitioning, replication, eviction, consistency with the source of truth, and the cold-start problem after a deploy.

Must coverConsistent hashing for placement, replicas for read availability, and a clear answer for what happens on a node loss (rehydrate from DB - which can stampede the DB). Warm the cache before taking traffic, and never let a cache outage become a database outage.

StudyRedis documentation →

Extend the table design: column virtualization, sticky headers and columns, resize and reorder persistence, and keyboard grid navigation.

Must coverTwo-axis virtualization needs careful measurement caching. Sticky columns fight with virtualization - usually rendered in a separate pinned layer. Grid keyboard nav follows the ARIA grid pattern: roving tabindex, arrow keys, not 400 tab stops.

StudyTanStack Virtual — virtualization →
1-D DP IV
490/4

Operational Spring and crawling at scale

Spring Boot in production: Actuator endpoints, liveness vs readiness probes, graceful shutdown, and configuration refresh. What does a bad readiness probe do during a rolling deploy?

Must coverLiveness restarts the pod; readiness removes it from the LB. Conflating them causes restart loops during a dependency blip. Graceful shutdown must drain in-flight requests and stop Kafka consumers cleanly, or you get duplicate processing and 502s on every deploy.

StudySpring Boot reference →

Design a web crawler: politeness, URL frontier, deduplication, freshness scheduling, and trap avoidance at a billion pages.

Must coverFrontier as a priority queue partitioned by host for politeness (per-host rate limits, robots.txt with caching), content dedup by shingle/simhash rather than exact URL, and recrawl scheduling driven by observed change rate. Traps: infinite calendars, session IDs in URLs.

StudySystem Design Primer →

Design a page with React Server Components: what runs where, what crosses the boundary, and where do you place client components?

Must coverServer components can access data directly and ship zero JS; client components need serializable props. Push the boundary as deep as possible - a client component high in the tree makes everything below it client. Cover the serialization constraint and interleaving.

Studyreact.dev — Server Components →
2-D DP I - grids

Week 08  ·  Days 50–56Spring Depth & Architecture

Spring MVC, Spring Data, Actuator, WebFlux - crawlers, caches, contended inventory

Operational Spring - the parts that only show up when your service is actually in production.

0/28
500/4

Reactive Java and contended inventory

Spring WebFlux: Mono/Flux, operators, schedulers, and backpressure. How do you detect a blocking call in a reactive chain, and when is WebFlux genuinely the right choice post-Loom?

Must coverBlockHound detects blocking on event-loop threads. WebFlux still wins for streaming, SSE, huge fan-out with few threads, and explicit backpressure. Post-Loom, thread-per-request with virtual threads gets most of the throughput with far simpler debugging and stack traces.

StudySpring Framework — WebFlux →

Design ticket booking for a 50,000-seat venue with 500,000 people arriving at once. Handle seat locking, overselling, payment timeouts, and the queue.

Must coverA virtual waiting room caps concurrency into the real system. Seat holds with a short TTL (Redis with a fencing token or a DB row lock), not optimistic-only. Payment timeout must release the hold idempotently. Overselling is a correctness bug - state exactly where the invariant is enforced.

StudyPostgreSQL — Concurrency control / MVCC →

Concurrent rendering pitfalls: what breaks under interruption, and how do you make a third-party or external-store integration safe?

Must coverAnything that mutates during render, reads mutable module state, or assumes a render always commits. Fixes: useSyncExternalStore for external state, keep render pure, move side effects to effects or event handlers. Cover why derived state during render must be deterministic.

Studyreact.dev — useSyncExternalStore →
2-D DP II - state machines
510/4

Patterns and service boundaries

Show Strategy, Builder, Factory, Observer, and Decorator in code you would actually ship. Where does each appear inside Spring or the JDK itself?

Must coverDecorator in java.io and Spring's BeanPostProcessor; Strategy in Comparator and Spring's PlatformTransactionManager; Template Method in JdbcTemplate; Proxy in @Transactional. Naming real occurrences is what separates memorized from understood.

StudyRefactoring Guru — design patterns catalogue →

How do you decide service boundaries? Explain bounded contexts, and give three concrete signs a service should NOT have been split.

Must coverSigns: every feature needs changes in three services, distributed transactions everywhere, chatty synchronous call chains, shared database. Start modular-monolith and split along the seams that actually differ in scaling or deploy cadence.

StudyMartin Fowler — Bounded Context →

When do you reach for portals, refs, and useImperativeHandle? Give the rules that keep escape hatches from becoming architecture.

Must coverPortals for overlays that must escape overflow/stacking contexts (keep React event bubbling in mind - it follows the tree, not the DOM). Imperative handles for focus/scroll/play - never for state. Anything imperative should be a small, named, documented surface.

Studyreact.dev — createPortal →
2-D DP III - hard
520/4

SOLID and event sourcing

Take a service class doing validation, persistence, and notification, and refactor it against SOLID. Which principle earns its keep most often, and which is most over-applied?

Must coverSRP and DIP earn their keep; ISP and OCP are the most over-applied - premature interfaces with one implementation add indirection without value. Be able to argue when NOT to apply a principle; that is the senior signal.

StudySOLID principles reference →

Explain CQRS and event sourcing. Design an audit-critical system with them, and name three costs you take on.

Must coverCosts: eventual consistency between write and read models, schema evolution of stored events (they are forever), and replay time as the log grows (fix with snapshots). CQRS without event sourcing is often the right dose.

StudyMartin Fowler — CQRS →

Explain concurrent React: startTransition, useDeferredValue, and streaming SSR with Suspense. Give a case where each visibly improves UX.

Must coverTransitions mark updates as interruptible so typing stays responsive while a heavy list re-renders. useDeferredValue when you do not own the update site. Streaming SSR sends the shell first so LCP does not wait on the slowest query.

Studyreact.dev — useTransition →
Greedy I
530/4

Coordination primitives and consensus

CountDownLatch vs CyclicBarrier vs Semaphore vs Phaser vs CompletableFuture.allOf - given four concurrency scenarios, pick the right primitive and justify it.

Must coverLatch is one-shot, barrier is reusable and runs an action, semaphore bounds concurrent access (also a permit-based rate limiter). For async composition prefer CompletableFuture with an explicit executor - the default common pool is a shared resource.

StudyOracle tutorial — Concurrency →

Explain leader election and the intuition behind Raft. What are ZooKeeper/etcd actually used for in a real architecture?

Must coverRaft: leader, terms, log replication, commit on majority. Uses: config, service discovery, distributed locks, leader election for singleton jobs. Emphasize that you should use a consensus system, never implement one, and that quorum needs odd node counts.

StudyThe Raft Consensus Algorithm →

Move expensive work off the main thread. When is a Web Worker worth it, and what are the data-transfer costs?

Must coverStructured clone cost can exceed the compute saved for small payloads; use transferable objects or SharedArrayBuffer for large ones. Good candidates: parsing large JSON/CSV, crypto, image processing, diffing large datasets. Comlink to keep the ergonomics sane.

Studyweb.dev — Use web workers to run JavaScript off the main thread →
Greedy II
540/4

Testing rigor and multi-region

Describe your testing pyramid for a Spring Boot service. Mocks vs stubs vs fakes, testing async/Kafka code, and where Testcontainers changes the calculus.

Must cover@SpringBootTest is slow - use slices (@DataJpaTest, @WebMvcTest). Do not mock what you do not own; wrap it. Async tests need Awaitility, never Thread.sleep. Testcontainers gives real Postgres/Kafka so you catch dialect and serialization bugs H2 hides.

StudyTestcontainers for Java →

Design multi-region deployment. Active-active vs active-passive, conflict resolution, and data residency (GDPR). What is your RTO/RPO?

Must coverActive-active needs conflict resolution (LWW loses data, CRDTs or app-level merge). Cross-region writes cost 100ms+. Often the right answer is region-pinned users with async replication for DR. Define RTO/RPO before choosing architecture.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Design CI for a frontend: unit, integration, E2E, visual regression, and bundle-size budgets. What runs on every PR vs nightly?

Must coverPR: typecheck, lint, unit/integration, affected E2E, bundle budget check. Nightly: full E2E matrix, visual regression, Lighthouse. Flaky E2E is the main failure mode - quarantine, do not retry blindly.

StudyPlaywright documentation →
Greedy III
550/4

Storage engines and collaboration

Maven vs Gradle, transitive dependency resolution, and how you resolve a version conflict. What is shading and when do you need it?

Must coverMaven nearest-wins vs Gradle highest-wins - this difference causes real bugs. dependencyManagement/BOM for alignment; mvn dependency:tree to diagnose. Shading relocates packages to avoid classpath collisions in libraries.

StudyJDK API docs →

LSM tree vs B-tree: write path, read path, compaction, and write/read amplification. When would you pick Cassandra over Postgres, honestly?

Must coverLSM: fast sequential writes, reads may touch several SSTables (bloom filters help), compaction costs IO. B-tree: in-place, read-optimized, WAL for durability. Cassandra when you need multi-region writes and can model every query up front - not for ad-hoc queries or transactions.

StudyApache Cassandra documentation →

Explain the intuition behind OT and CRDTs. Design collaborative editing for the diary pages in your Unsent project.

Must coverOT transforms operations against concurrent ones (needs a central server); CRDTs converge without coordination but carry metadata overhead. For your approval workflow, the simpler correct answer may be document-level locking or explicit diffs - argue that tradeoff.

StudyCRDT.tech — conflict-free replicated data types →
Bit Manipulation I
560/4

Security on both sides

Walk the OWASP Top 10 as it applies to a Spring Boot service. Show SQL injection via string concatenation and three ways it is prevented. How do you handle secrets?

Must coverPreparedStatement/JPA parameter binding; validate and allowlist for dynamic ORDER BY. Secrets in a vault or env, never in application.yml or git. Also cover mass assignment (@RequestBody binding to entities), SSRF, and dependency CVEs.

StudyOWASP Top 10 →

Design a real-time fraud/risk detection pipeline for card transactions. Sub-200ms decision, feature lookups, rules plus model scoring, and a feedback loop.

Must coverStreaming feature computation (windowed aggregates in Kafka Streams/Flink) into a low-latency feature store; rules engine for hard blocks, model for scoring; shadow mode before enforcement; label lag from chargebacks means the feedback loop is weeks long. Fail-open vs fail-closed is a business decision.

StudyApache Kafka documentation →

Frontend security: XSS vectors in React, when dangerouslySetInnerHTML is defensible, CSP, and CSRF with cookie auth.

Must coverReact escapes by default but href={userInput} allows javascript: URLs, and dangerouslySetInnerHTML needs DOMPurify. CSP with nonces kills inline-script XSS. CSRF matters only with cookie auth - SameSite plus a double-submit token.

StudyMDN — Content Security Policy →
Bit Manipulation II

Week 09  ·  Days 57–63Distributed Systems & Advanced Java

Patterns, consensus, testing, security - streaming pipelines - advanced React

Breadth week. You will not master every topic; you need a defensible position on each.

0/28
570/4

Week 6 checkpoint

Implement a job scheduler: submit jobs with a delay, retry with exponential backoff and jitter, max attempts, and a dead-letter path. Make it thread-safe.

Must coverDelayQueue or ScheduledExecutorService plus a PriorityQueue by next-run time; backoff = base * 2^attempt with full jitter, capped. Discuss what changes when this must survive a restart (persistence) and run on many nodes (leases).

StudyThreadPoolExecutor API docs →

Design a ride-hailing matching service. Geospatial indexing, driver location updates at scale, matching, and surge.

Must coverGeohash/S2/H3 cells for proximity queries; location updates are high-write low-value so keep them in Redis, not Postgres; matching as a dispatch loop per cell; handle the double-assignment race with an atomic claim.

StudyH3 — hexagonal geospatial indexing →

Design a data grid: 100k rows, inline editing, multi-column sort, column resize/reorder, and CSV export - all responsive.

Must coverVirtualize both axes; keep row data outside React state; edit state per-cell not per-grid; sorting/filtering server-side past a threshold; export streamed via a worker. Explain your re-render isolation strategy per cell.

StudyTanStack Virtual — virtualization →
MOCK - 45 min, 1 medium + 1 hard

DP round. Write the recurrence on the board before writing any code - that is what is being scored.

580/4

Data-oriented Java and click aggregation

Model a domain with sealed interfaces plus records and exhaustive switch pattern matching. What does this replace, and where does it beat a class hierarchy with polymorphism?

Must coverData-oriented programming: when the data shapes are fixed and the operations vary, sealed + records + switch gives compile-time exhaustiveness and keeps operations together. Classic polymorphism wins when the operations are fixed and the types vary. Cover record patterns and deconstruction.

StudyJEP 409 — Sealed Classes →

Design ad-click aggregation: 1M events/sec, per-minute and per-hour counts, deduplicated, queryable within seconds, and reconcilable to an exact number for billing.

Must coverTwo paths: a fast approximate streaming path for dashboards and a slow exact batch path for billing (lambda architecture). Windowed aggregation with watermarks for late events, dedup by event id in a bounded window, and pre-aggregation before storage.

StudyApache Kafka documentation →

Design animation architecture: enter/exit transitions, the FLIP technique, layout animation, and honouring prefers-reduced-motion.

Must coverFLIP: measure First and Last positions, Invert with a transform, then Play - it animates layout changes on the compositor instead of triggering layout every frame. Animate only transform and opacity. Reduced motion is a hard requirement, not an option.

Studyweb.dev — Core Web Vitals →
Math & Geometry I
590/4

Immutable structures and recommendation serving

Explain persistent (immutable) data structures and structural sharing. Where would you use one in a Java service, and what does Java give you out of the box?

Must coverList.of/Map.of are immutable but copy on change; true persistent structures share structure so a copy is O(log n) not O(n). Useful for config snapshots, undo stacks, and lock-free publishing of a versioned state. Contrast with CopyOnWriteArrayList's O(n) writes.

StudyJDK API docs →

Design the serving path for a recommendation system: candidate generation, feature lookup, ranking, and a 100ms budget. Ignore model training.

Must coverRetrieve hundreds of candidates cheaply (ANN index, co-occurrence), then rank with an expensive model on that small set. Feature store with low-latency reads; precompute what you can offline. Discuss fallbacks when the model service is slow - a stale or popularity-based list beats a spinner.

StudyDesigning Data-Intensive Applications (Kleppmann) →

You own a design-system component used by 40 teams. Design your API versioning, deprecation, and migration story.

Must coverSemver with a written breaking-change policy, deprecation warnings in dev with a migration link, codemods for mechanical changes, and a support window. Additive changes with sensible defaults over new major versions. Track adoption so you know when you can actually delete the old path.

StudyModule Federation documentation →
Math & Geometry II
600/4

Bytecode, lambdas and video pipelines

What does the compiler actually generate? Use javap to explain how a lambda compiles (invokedynamic + LambdaMetafactory), how string concatenation compiles now, and what an anonymous class costs by comparison.

Must coverLambdas are not anonymous classes - invokedynamic defers the implementation to runtime, so no class file per lambda and the JIT can inline it. Java 9+ compiles string concat with invokedynamic (StringConcatFactory) rather than StringBuilder chains.

StudyJava Language Specification →

Design a video upload, transcoding, and streaming pipeline: multiple renditions, adaptive bitrate, CDN delivery, and progress feedback to the uploader.

Must coverChunked upload to object storage, a job per rendition fanned out through a queue, segment-based output (HLS/DASH) with a manifest, CDN in front. Transcoding is the expensive part - prioritize the lowest rendition first so playback can start. Cover idempotent job retries.

StudyAWS Builders' Library →

Design undo/redo with autosave for a document editor. How do you coalesce operations, and what happens when autosave conflicts with a concurrent edit?

Must coverCommand stack of invertible operations, coalescing keystrokes within a time window so undo is not per-character. Autosave debounced with a version/etag; on conflict either merge, or surface it explicitly - never silently overwrite. Persist the undo stack per session, not per keystroke.

StudyProseMirror — document model guide →
Design I - basic structures
610/4

Interop and regulated workflows

When do you leave the JVM? Compare JNI and the Foreign Function and Memory API (Panama), and explain the cost model of crossing the boundary.

Must coverCrossing the boundary blocks JIT inlining and complicates GC (pinned memory). Panama gives safer, faster interop with no C glue code and structured off-heap memory access. Legitimate cases: native crypto, hardware access, an existing C library you cannot reimplement.

StudyJDK API docs →

Design a KYC and document verification workflow: async third-party checks, manual review queue, state machine, SLAs, and full auditability.

Must coverAn explicit state machine per application (submitted, screening, manual_review, approved, rejected) with every transition audited and reversible only forward. External vendor calls are async with webhooks plus polling fallback. PII encryption, access logging, and data retention rules are part of the design, not an afterthought.

StudyOWASP Cheat Sheet Series →

Design a resumable file upload UI: chunking, progress, pause/resume, retry, and multi-file queueing with concurrency limits.

Must coverChunk client-side, track uploaded chunks so resume skips them, limit concurrent uploads (3-4) to avoid saturating the connection, exponential backoff per chunk. Show real per-file and aggregate progress, and handle the tab-close case honestly.

StudyMDN — navigator.sendBeacon →
Design II - caches
620/4

Async models and matching engines

Virtual threads vs reactive (WebFlux). When is reactive still justified, and what is backpressure? Why can reactive code be harder to operate?

Must coverLoom gives you async throughput with synchronous code and readable stack traces - it removes most of the reason to go reactive. Reactive still wins for streaming and when you need explicit backpressure (Flow/Reactive Streams request(n)). Debugging, ThreadLocal/MDC, and blocking-call leaks are the operational costs.

StudyJEP 444 — Virtual Threads →

Design an order matching engine for an exchange. Order book structure, price-time priority, matching latency, durability, and market data fan-out.

Must coverSingle-threaded matching per instrument for determinism (LMAX pattern), in-memory book with price levels as a sorted structure and FIFO queues per level, sequenced input journal for replay/durability, and a separate fan-out path for market data. Determinism is the whole design constraint.

StudyLMAX Disruptor — mechanical sympathy →

Give your framework for a frontend system design interview. Take a 45-minute prompt (design a photo feed) through it end to end.

Must coverRequirements and scope - API contract and data model - component architecture - rendering strategy - state and caching - performance budget - accessibility - error and offline states - observability. Frontend interviews reward API design and perf tradeoffs, not component trivia.

Studyweb.dev — Core Web Vitals →
Design III - randomized
630/4

Streams internals and the ledger at scale

How do Collectors work? Write a custom collector, and explain Spliterator, characteristics, and how the framework splits work.

Must coverCollector = supplier, accumulator, combiner, finisher, characteristics (CONCURRENT, UNORDERED, IDENTITY_FINISH). The combiner is only used in parallel - a wrong combiner is a silent bug. Spliterator.trySplit determines parallel efficiency.

StudyCollectors API docs →

Design a double-entry ledger at 50k writes/sec with strict balance guarantees and full audit history. How do you shard something that must balance?

Must coverShard by account, keep each transfer within a shard where possible, use a saga or 2PC-lite for cross-shard transfers with a pending state. Balances as periodic snapshots plus a delta log so you never scan history. Idempotency and monotonic sequence per account are non-negotiable.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Design a rich text editor: document model, selection, undo/redo, plugins, and paste sanitization.

Must coverNever store HTML as the model - use a structured document (like Slate/ProseMirror node trees) so operations are well-defined. Undo as an inverse-operation stack with coalescing. contentEditable is a minefield: IME composition, paste normalization, and browser divergence are the real work.

StudyProseMirror — document model guide →
Design IV - counters & rate limits

Week 10  ·  Days 64–70Fintech Specialization

Ledgers, payments, exchanges, KYC - plus low-level design and frontend system design

Your differentiator. Most candidates cannot design a ledger or a payment retry path. You can.

0/28
640/4

Probabilistic structures and payment reliability

How does a Bloom filter work, what are the tradeoffs, and where would you use one in a Java service? Contrast with HyperLogLog and Count-Min Sketch.

Must coverFalse positives never false negatives; size from expected n and target FPR; cannot delete (counting Bloom can). Uses: cache-miss avoidance, dedupe pre-check before an expensive lookup, LSM SSTable probing. HLL for cardinality, CMS for frequency - both sublinear memory.

StudyCP-Algorithms — algorithm reference →

Design integration with an external payment provider: retries, timeouts, webhook handling, and daily reconciliation. What happens when you time out but the charge succeeded?

Must coverThis is the core fintech question. Answer: idempotency key on every attempt, a local pending state, status polling as a fallback to webhooks, webhook signature verification and replay tolerance, and a reconciliation job that diffs your ledger against their settlement file. Never assume a timeout means failure.

StudyStripe — idempotent requests →

Design a media player UI: buffering states, adaptive quality, keyboard shortcuts, captions, and resumable playback.

Must coverMap every player state explicitly (idle, loading, buffering, playing, paused, ended, error) - the classic bug is treating buffering as paused. Persist playback position debounced; handle autoplay policy rejection; captions and keyboard control are accessibility requirements, not extras.

StudyMDN — WebSockets API →
Design V - feeds & history
650/4

Time, money, and scheduled work

Instant vs LocalDateTime vs ZonedDateTime vs OffsetDateTime - pick correctly for: a DB timestamp, a user-facing meeting time, a birthday, an event log. Then explain BigDecimal for money.

Must coverStore instants in UTC; store future meetings as local time plus zone id (because zone rules change); birthdays are LocalDate. BigDecimal: never use double for money, always specify scale and RoundingMode, and never use the double constructor - use valueOf or the String constructor.

Studyjava.time package overview →

Design a distributed scheduler that fires millions of delayed jobs with at-least-once semantics and second-level accuracy.

Must coverTime-bucketed partitions (a table or Redis sorted set per minute) so the poll query is bounded; leases with expiry so a crashed worker's jobs are retried; idempotent handlers because at-least-once means duplicates; clock skew and DST are real hazards.

StudyRedis documentation →

Implement i18n and timezone-correct rendering: message formatting, pluralization, RTL, and date display. What breaks when you get this wrong?

Must coverUse Intl APIs, never manual string concat for plurals or dates. RTL needs logical CSS properties (margin-inline-start), not directional ones. Render times in the user's zone but keep the instant in state; never trust the browser zone for business logic.

StudyMDN — Intl API →
Design VI - stores & search
660/4

Library design and telemetry

You are designing a library other teams depend on. Rules for nulls, overloading, builders, defaults, and backward compatibility. What counts as a breaking change in Java?

Must coverAdding a method to an interface is breaking (unless default); changing a return type, widening a checked exception, or reordering enum constants used in serialization all break. Prefer static factories with names over overloaded constructors. Make the common case one line and the complex case possible.

StudyJDK API docs →

Design a metrics/observability backend: high-cardinality ingestion, time-series storage, rollups, and fast dashboard queries.

Must coverTime-series storage with delta-of-delta and XOR compression (Gorilla); downsample old data with retention tiers; cardinality explosion from unbounded label values is the #1 operational failure; separate the write path (append-optimized) from the query path.

StudyOpenTelemetry documentation →

Design a browser analytics SDK: event batching, delivery on page unload, sampling, and a tiny bundle footprint.

Must covernavigator.sendBeacon or fetch with keepalive for unload (unload handlers are unreliable on mobile); batch with a size and time trigger; queue in localStorage for offline; sample at the session level not the event level so funnels stay intact; must never throw into the host app.

StudyMDN — navigator.sendBeacon →
Design VII - calendars & intervals
670/4

Code review round and multi-tenancy

Code review round: given a snippet with a non-thread-safe SimpleDateFormat field, a @Transactional self-invocation, a leaked ExecutorService, and an N+1 - find every bug and propose fixes.

Must coverPractice narrating in severity order: correctness, then concurrency, then performance, then style. Interviewers score how you prioritize and whether you ask about context before rewriting.

StudyVlad Mihalcea — Hibernate performance →

Design a multi-tenant SaaS platform. Compare silo, bridge, and pool isolation models. How do you stop one tenant from degrading everyone?

Must coverShared DB with a tenant_id and row-level security (cheap, risky), schema-per-tenant (middle), DB-per-tenant (expensive, compliant). Noisy neighbor: per-tenant rate limits and query cost budgets, separate pools for large tenants. Every query must be tenant-scoped by construction, not by convention.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Design theming and design tokens: light/dark, per-tenant brands, and runtime switching without a flash of wrong theme.

Must coverCSS custom properties at the root, semantic tokens (surface, on-surface) not literal ones (grey-200). Prevent FOUC with an inline script that sets the attribute before first paint. Respect prefers-color-scheme as the default with an explicit override.

StudyWCAG quick reference →
Design VIII - leaderboards
680/4

Week 7 checkpoint - full interview loop simulation

Simulate a 45-minute coding round under time pressure. Pick an unseen medium-hard problem, narrate constantly, and write compiling code with tests.

Must coverScore yourself on: clarifying questions asked, brute force stated before optimizing, complexity stated correctly, edge cases enumerated before coding, and whether you tested by hand.

StudyNeetCode — pattern-organized practice roadmap →

Simulate a 45-minute system design round on an unseen prompt. Time-box: 5 min requirements, 5 min estimates, 10 min high level, 20 min deep dive, 5 min tradeoffs.

Must coverThe failure mode is jumping to boxes-and-arrows before pinning functional/non-functional requirements. Always end by naming your top three risks and what you would build first.

StudySystem Design Primer →

Simulate a 45-minute frontend round: build a working component with real states from a vague prompt.

Must coverConfirm scope, sketch the API, build the happy path, then add loading/error/empty, then accessibility, then perf. Talk about what you would do with more time.

StudyARIA Authoring Practices Guide — patterns →
MOCK - 45 min, design round

Design-heavy coding round. Sketch the data structures and their invariants before writing a single method.

690/4

Low-level design: parking lot and job queues

LLD round: design a parking lot system. Vehicle types, spot allocation, pricing strategy, ticketing, and multi-floor. Produce class diagrams and working core classes in 45 minutes.

Must coverInterviewers score extensibility: adding an EV-charging spot type or a new pricing rule must not touch existing classes. Use Strategy for pricing, Factory for spots, and keep the allocation policy pluggable. State your assumptions and the invariants you enforce.

StudyRefactoring Guru — design patterns catalogue →

Design a distributed job queue with competing consumers: visibility timeouts, at-least-once delivery, priority, and dead-lettering.

Must coverLease-based claim with a visibility timeout so a crashed worker's job is redelivered; the handler must therefore be idempotent. Priority via separate queues rather than an in-queue sort. Cover long-running jobs (heartbeat to extend the lease) and poison-message detection.

Studymicroservices.io — pattern catalogue →

Build a command palette: fuzzy search over hundreds of commands, keyboard-first, grouped results, recent commands, and full accessibility.

Must coverDebounced fuzzy match with score ranking, virtualized results, aria combobox pattern with aria-activedescendant, Cmd+K to open with focus trap and restore. Recent commands from localStorage. Must be usable with zero mouse input.

StudyARIA Authoring Practices Guide — patterns →
Concurrency I (Java-specific)
700/4

Low-level design: elevators and feature flags

LLD round: design an elevator control system for a 20-floor building with 4 cars. Model requests, car state, and the scheduling policy - and make the policy swappable.

Must coverState machine per car (idle, moving_up, moving_down, doors_open), a dispatcher that assigns requests, and a Strategy for scheduling (nearest car, look/scan algorithm). Discuss concurrency: requests arrive from many threads. Interviewers probe how you would test this.

StudyRefactoring Guru — design patterns catalogue →

Design a feature flag service: low-latency evaluation, targeting rules, gradual rollout, kill switches, and consistency for a single user.

Must coverEvaluate in-process from a locally cached ruleset (never a network call per flag), pushed via streaming updates. Deterministic bucketing by hash(userId + flagKey) so a user's assignment is stable and consistent across services. Kill switches must propagate in seconds, and flags need an expiry policy or they become permanent tech debt.

StudyGoogle SRE Book →

Design a schema-driven form builder: JSON schema in, validated form out, conditional fields, custom widgets, and array/nested sections.

Must coverA registry mapping field type to component, a resolver for conditional visibility, and validation derived from the same schema the backend uses. The hard parts are conditional field state (clear or preserve hidden values?) and keeping re-renders local as the schema grows.

StudyReact Hook Form documentation →
Concurrency II (Java-specific)

Week 11  ·  Days 71–77Low-Level Design & Resume Defense

LLD rounds, metering, moderation - then every number on your resume attacked

LLD is the round candidates prepare for least and Software Engineer loops increasingly include. Then the interrogation starts.

0/28
710/4

Low-level design: booking and metering

LLD round: design a movie ticket booking system. Seat selection under concurrency, hold expiry, payment integration, and cancellation - with the concurrency control made explicit.

Must coverThe whole interview is the double-booking race. Answer with a DB unique constraint or SELECT FOR UPDATE on the seat rows plus a short-lived hold with expiry - not application-level checks. Model Show, Seat, Booking, Hold, Payment and state the transaction boundaries.

StudyPostgreSQL — Concurrency control / MVCC →

Design an API metering, quota, and billing service: accurate usage counts, per-plan quotas, overage handling, and invoices that must reconcile exactly.

Must coverMetering is at-least-once, so dedup by request id before counting. Approximate counters at the edge for enforcement, exact aggregation asynchronously for billing - and reconcile the two daily. Billing disputes mean you need the raw events retained, not just the aggregate.

StudyStripe — idempotent requests →

Design an accessible chart component: what does a screen reader get, how does keyboard navigation work, and how do you handle 50,000 points?

Must coverProvide a data table alternative or aria description - an SVG of paths is invisible to assistive tech. Keyboard: arrow through series and points with a live region announcing values. For 50k points, downsample for display (LTTB) and render to canvas rather than DOM nodes.

StudyWCAG quick reference →
Simulation & matrices
720/4

Low-level design: engines and moderation

LLD round, two problems: design a chess game engine (pieces, moves, validation, check detection) and an in-memory database with secondary indexes and transactions.

Must coverChess tests polymorphism and rule encapsulation - avoid a giant switch on piece type. The in-memory DB tests data structure choice: hash index for equality, sorted structure for ranges, and a copy-on-write or undo-log approach for transaction rollback.

StudyRefactoring Guru — design patterns catalogue →

Design a content moderation pipeline: automated classification, human review queues, appeals, and latency requirements that differ per content type.

Must coverTiered: cheap classifiers first, expensive models on the uncertain band, humans on the rest. Pre-publish blocking for high-risk categories, post-publish async for the rest. Reviewer queues need prioritization, sampling for quality control, and an audited appeal path.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Design an offline-first notes app: local-first writes, background sync, conflict resolution, and honest UI about sync state.

Must coverWrite to IndexedDB first and treat the server as a replica. Each note carries a version or vector clock; on conflict either last-writer-wins with a visible history or a merge. Show sync state explicitly - users forgive conflicts, not silent data loss.

Studyweb.dev — Offline cookbook / caching strategies →
Parsing & stacks
730/4

Resume defense I - Kafka and throughput

Rapid fire, 25 questions, 60 seconds each: core Java, collections, concurrency, JVM. Any hesitation is a topic to revisit tomorrow.

Must coverCover: string pool, autoboxing cache range, finally vs finalize, static vs instance init order, interface private methods, var limitations, pass-by-value semantics, hashCode of null keys, fail-fast internals, volatile vs atomic, and JMM ordering.

StudyJDK API docs →

Defend the resume line: processed 1000s of events/minute via Kafka. Expect: how many partitions, what key, what was consumer lag, what happened on a poison message, what was the throughput ceiling.

Must coverHave real numbers ready: topic count, partition count, consumer instances, average and p99 processing time, lag alert threshold, DLQ volume. If you do not know a number, say what you would measure. Vague answers on your own resume are the fastest way to fail a Software Engineer loop.

StudyApache Kafka documentation →

Walk through the Unsent architecture as an interviewer would attack it: OAuth2 flow, the edit-approval workflow's concurrency, AI generation cost/latency, and what you would redesign.

Must coverPrepare the honest critique: what does the approval workflow do if two people request edits to the same page simultaneously? What is your AI call timeout and fallback? Self-critique is a senior signal.

Studyreact.dev — Render and commit →
SPEED SET - 30 min total, three problems

Pure speed. Under 10 minutes each including narration, or your fundamentals are still slow.

740/4

Resume defense II - latency wins

Rapid fire round 2: Spring, JPA, testing, build, and design patterns. 25 questions.

Must coverCover: bean scopes, proxy modes, @Transactional edge cases, JPA cascade types, orphanRemoval, optimistic vs pessimistic locking, @MockBean vs @Mock, slice tests, and the Spring Boot auto-configuration mechanism.

StudyUse The Index, Luke — SQL indexing →

Defend: reduced query latency 30-40%. What did you measure, what was the baseline, what was the actual change, and how did you verify it in production?

Must coverStructure it as: symptom, measurement, hypothesis, change, verification, guardrail. Name the tool (EXPLAIN ANALYZE, pg_stat_statements, APM). Say what you rejected and why. The story matters more than the percentage.

StudySpring Data JPA reference →

Defend: reduced API latency 96% via caching. What was cached, what was the TTL, what was the invalidation strategy, and what is the worst stale-data outcome?

Must coverBe precise about correctness: what data could a user see that is wrong, for how long, and was that acceptable? A Software Engineer answer names the risk it accepted, not just the speedup.

StudyAWS — Caching challenges and strategies →
SPEED SET - 60 min, two hards

Both are pattern-recognizable. If either takes more than 30 minutes, re-drill that pattern tomorrow.

750/4

Behavioral and leadership signal

Explain a technical decision you made that you later regretted, in full technical detail, including what you would do now.

Must coverInterviewers probe depth here. Have the actual code/design in mind. Own the mistake without self-flagellation, and show the general principle you extracted.

StudyPramp — free peer mock interviews →

Design a system you would pitch to your own team, from a real pain point at FIS. Requirements, design, rollout plan, and success metrics.

Must coverSoftware Engineer loops test whether you can identify problems, not just solve assigned ones. Prepare one genuine proposal with a cost/benefit argument.

StudyExcalidraw — for drawing system designs →

Build one small feature live in 30 minutes from a vague spec, narrating tradeoffs the whole way.

Must coverPractice speaking while coding - most candidates go silent under pressure. Record yourself once and watch it back.

Studyreact.dev — You might not need an effect →
TEMPLATES - write from memory, no IDE

Write the code template for all 20 patterns from memory on paper: sliding window, two pointers, binary search on answer, monotonic stack, fast/slow pointers, BFS, DFS, topological sort, union-find, Dijkstra, trie, backtracking, 1-D DP, 2-D DP, heap top-K, merge intervals, prefix sum, bit tricks, matrix traversal, and cyclic sort.

760/4

Mock loop 1

Full mock: 45-min coding round with a peer or an AI interviewer. No pauses, no notes.

Must coverAsk for written feedback on: communication, structure, correctness, and speed. Log every gap.

StudyNeetCode — practice list →

Full mock: 45-min system design on an unseen prompt.

Must coverRecord it. Watch for: did you drive, or did the interviewer drive? Did you quantify anything?

StudySystem Design Primer →

Full mock: 45-min frontend round.

Must coverWatch for accessibility and error states - these are the most commonly skipped and most easily scored.

StudyReact Testing Library — guiding principles →
MOCK 1 - full 45 min, no notes

Get written feedback on communication, structure, correctness, and speed. Log every gap.

770/4

Mock loop 2

Full mock 2: coding round, different problem class than mock 1 (graphs or DP if you did arrays).

Must coverTarget: correct, compiling, tested solution within 35 minutes, leaving 10 for follow-ups.

StudyNeetCode — practice list →

Full mock 2: pick a design in your weakest area from the past 7 weeks.

Must coverDeliberately choose discomfort. The point of a mock is to fail cheaply.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Full mock 2: a component design + API design prompt.

Must coverFocus on the public API and the state model before any markup.

StudyPlaywright documentation →
MOCK 2 - full 45 min, harder pair

Different problem classes from mock 1 on purpose. Deliberately pick discomfort.

Week 12  ·  Days 78–84Mock Loops & Repair

Six full mock loops, rapid fire, behavioural depth, and a full dress rehearsal

Performance week. Stop learning, start rehearsing. Fail cheaply here so you do not fail expensively later.

0/28
780/4

Weak-spot repair day

No new material. Take your three weakest Java topics from the last 8 weeks and rebuild them from first principles, out loud, with code.

Must coverTeaching it out loud to an imaginary junior is the fastest way to find the gap you have been hiding.

StudyNeetCode — pattern-organized practice roadmap →

Rebuild your three weakest system design topics. Redraw each diagram from memory on a blank page.

Must coverIf you cannot draw it from memory, you cannot draw it under pressure.

StudyExcalidraw — for drawing system designs →

Rebuild your three weakest React topics with a small working example each.

Must coverWorking code you wrote yourself beats notes you read.

Studyreact.dev — Escape hatches →
REPAIR - re-solve failures from scratch

Re-solve every problem you failed or needed a hint on, from a blank file, with no reference. If you cannot, that pattern is not learned - go back to its template.

790/4

Mock loop 3 - final calibration

Final mock: coding round at full interview intensity.

Must coverYou should now be consistently landing a working optimal solution with narration. If not, that is the priority for the last 4 days.

StudyPramp — free peer mock interviews →

Final mock: a full 45-min design, ideally with a real Senior Engineer.

Must coverAsk specifically: would you hire me at Software Engineer based on this round? Get the honest answer.

StudyByteByteGo — system design newsletter →

Final mock: frontend round at full intensity.

Must coverConfirm you handle vague specs by asking, not assuming.

StudyARIA Authoring Practices Guide — patterns →
MOCK 3 - final calibration

You should now consistently land a working optimal solution with narration. If not, that is the priority for the last two weeks.

800/4

Mock loop 4 - system design intensive

Warm-up only: 15 minutes of rapid-fire recall on your three weakest Java levels. No new material today.

Must coverToday is about the design round. Keep the Java light so you arrive fresh.

StudyJenkov — Java Concurrency tutorial →

Two back-to-back 45-minute design rounds on unseen prompts, with a 10-minute break. Record both.

Must coverTwo in a day simulates a real onsite, where the second round is the one candidates fade in. Watch the recording for: did you quantify, did you drive, did you name risks unprompted?

StudyByteByteGo — system design newsletter →

Review only: re-draw your frontend system design framework from memory and apply it to one prompt in 15 minutes.

Must coverCompression practice - the full framework in a quarter of the time forces you to identify what actually matters.

Studyweb.dev — Core Web Vitals →
Warm-up pair - keep it light

Today is design-round intensive. Keep the coding light so you arrive fresh.

810/4

Low-level design mock round

Full 60-minute LLD mock: an unseen prompt (vending machine, ATM, or splitwise). Class diagram, working core code, and extension discussion.

Must coverLLD rounds are increasingly common at Software Engineer and candidates prepare for them least. Score yourself on: did you clarify requirements, did you name your patterns, is your design open to the extension they asked about at minute 45?

StudyRefactoring Guru — design patterns catalogue →

Take your LLD design and scale it: what changes when it is distributed across 50 servers with a shared database?

Must coverThis is the classic follow-up. Single-process invariants (a synchronized block, an in-memory map) become distributed problems (a lock service, a database constraint). Name every assumption that breaks.

Studymicroservices.io — pattern catalogue →

Design the UI for the same system. What state lives where, and what is the API contract between them?

Must coverPractising all three views of one system is how you stop treating frontend, backend, and design as separate vocabularies.

StudyXState — state machines documentation →
LLD CODING - build it, do not solve it

From a blank file in 60 minutes: an LRU cache with per-entry TTL, thread-safe, with a pluggable eviction policy and unit tests. This is what an LLD round actually feels like.

820/4

Rapid fire III - design and frontend

Rapid fire: 25 questions across Spring, JPA, and testing at 60 seconds each.

Must coverThird pass. Anything still slow after three passes goes on a physical card you carry.

StudyJDK API docs →

Rapid fire: 30 system design questions at 60 seconds each - definitions, tradeoffs, and 'when would you not do this'.

Must coverCover: CAP, consistency models, sharding keys, cache patterns, queue semantics, circuit breaker states, isolation levels, consistent hashing, saga vs 2PC, idempotency, CDC, SLO maths.

StudySystem Design Primer →

Rapid fire: 25 React questions at 60 seconds each.

Must coverCover: render vs commit, keys, effect timing, stale closures, memo defeats, context cost, hydration, Suspense, transitions, INP, XSS, focus management.

Studyreact.dev — Rules of hooks →
SPEED SET - five easies, 40 min

Fluency check. Every one of these should be reflexive by now.

830/4

Mock loop 5 - coding intensive

Two 45-minute coding rounds, hard difficulty, back to back. Different problem classes.

Must coverTarget: state the brute force in 2 minutes, the optimal approach in 5, working code by 30, tested by 40. If you are silent for more than 20 seconds, you are failing the communication axis.

StudyNeetCode — practice list →

45-minute design round immediately after the coding rounds, with no break.

Must coverDeliberate fatigue training. Real onsites are four to five hours and the last round decides ties.

StudyDesigning Data-Intensive Applications (Kleppmann) →

Skip today. Rest the track.

Must coverRecovery is part of the schedule. Overtraining before the loop is a real failure mode.

Studyreact.dev — You might not need an effect →
MOCK 5 - two hards, back to back

Deliberate fatigue training. The second problem is the one that matters.

840/4

Weak-spot repair II

Take every Java gap logged during mocks 4 and 5 and rebuild those topics from first principles, out loud, with working code.

Must coverBy now the list should be short and specific. If it is still broad, that is the signal to extend the timeline rather than interview.

StudyJenkov — Java Concurrency tutorial →

Redraw from memory every design you fumbled. Blank page, no notes, then compare against your original.

Must coverThe gap between what you can recognize and what you can produce from memory is exactly the gap that shows up in an interview.

StudyExcalidraw — for drawing system designs →

Rebuild your weakest React topics with a small working example each.

Must coverCode you wrote beats notes you read - and the examples become your revision material for week 13.

Studyreact.dev — Escape hatches →
REPAIR II - clear the list

Re-solve every problem logged during mocks 4 and 5. The list should now be short and specific; if it is still broad, extend the timeline rather than interview.

Week 13  ·  Days 85–90Final Sprint

Consolidation to three pages, company targeting, and rest

Compress everything. Do not learn anything new. Sleep.

0/24
850/4

Behavioural depth and leadership signal

Prepare the technical depth behind each STAR story: for every story, be ready for three levels of 'and then what happened' follow-up.

Must coverBehavioural rounds at Software Engineer probe until they hit the limit of your involvement. Know the actual code, the actual numbers, and what you would do differently - vagueness at depth three reads as someone else's work.

StudyPramp — free peer mock interviews →

Prepare your 'design a system you proposed at work' story, plus your questions for the interviewer about architecture, on-call, and tech debt.

Must coverSoftware Engineer hiring tests whether you identify problems, not just solve assigned ones. Bring one genuine proposal with a cost/benefit argument.

StudyMartin Fowler — Microservices →

Record your 90-second introduction and your 4-minute project walkthrough. Watch them back and cut 20%.

Must coverAlmost every candidate's opening is too long and too chronological. Lead with what you own and what it is worth, not with when you joined.

Studyreact.dev — Render and commit →
TEMPLATES - second pass from memory

All 20 pattern templates again, on paper, timed. Anything you cannot write in 3 minutes goes on a physical card you carry to the interview.

860/4

Full dress rehearsal

Complete loop in one day, in order, with no notes: 45-min coding, 45-min LLD, 45-min system design, 45-min frontend, 45-min behavioural.

Must coverFour to five hours with short breaks, exactly as scheduled onsite. The point is stamina and consistency, not any single round.

StudyPramp — free peer mock interviews →

The design round of the dress rehearsal, on a prompt you have never seen.

Must coverAsk your mock partner for a hire/no-hire call at Software Engineer level, with reasons. That answer is the input to your final week.

StudyByteByteGo — system design newsletter →

The frontend round of the dress rehearsal.

Must coverAfter today, stop adding material. Week 13 is consolidation only.

StudyARIA Authoring Practices Guide — patterns →
DRESS REHEARSAL - unseen pair

One medium and one hard you have never attempted - pick blind from the NeetCode 150. Full interview conditions: no notes, narrate throughout, 45 minutes.

870/4

Final sprint - consolidation

Build a one-page Java cheat sheet from memory: collections complexity, concurrency primitives, JVM flags, and the five contracts.

Must coverWritten from memory, not copied. What you cannot recall today is what you must review tomorrow.

StudyJDK API docs →

Build a one-page system design cheat sheet: latency numbers, capacity estimation formulas, the 12 building blocks, and your standard interview framework.

Must coverOne page. If it does not fit, you have not compressed it enough.

StudySystem Design Primer →

Build a one-page React cheat sheet: render model, hook rules, perf levers, and the frontend design framework.

Must coverSame rule - from memory, one page.

Studyreact.dev — Render and commit →
Light - stay warm
880/4

Final sprint - company targeting

Research your target companies' actual interview formats and rehearse the Java style they use (LLD-heavy vs algorithm-heavy).

Must coverProduct companies lean LLD/design; service companies lean core Java trivia; startups lean build-something-real. Prepare accordingly.

StudyNeetCode — pattern-organized practice roadmap →

Prepare two design prompts specific to each target company's domain.

Must coverDesigning something adjacent to their actual product signals genuine interest and gives you home-field advantage.

StudyByteByteGo — system design newsletter →

Prepare your project walkthrough as a tight 4-minute story with a diagram you can draw live.

Must coverProblem, constraints, your design, one hard tradeoff, the outcome with a number, what you would change.

StudyTypeScript — React cheatsheet →
Light - two mediums
890/4

Final sprint - questions and negotiation

Review your cheat sheets only. No new topics.

Must coverCramming new material within 48 hours of an interview lowers performance. Consolidate.

StudyGoogle SRE Book →

Prepare your questions for the interviewer: architecture, on-call, tech debt, deploy cadence, and how Software Engineer to Senior Engineer is evaluated.

Must coverGood questions are a scored signal. Ask about how decisions get made, not just what stack they use.

StudyMartin Fowler — Microservices →

Do a full dry run of your introduction and resume walkthrough, timed at 90 seconds.

Must coverThe opening sets the interviewer's prior for the whole loop. Rehearse it until it is effortless, not memorized.

Studyreact.dev — Render and commit →
Rest or one easy

Sleep matters more than one more problem. Review your STAR stories instead.

900/4

Interview ready

Skim cheat sheet only. Confirm you can explain: hashCode contract, JMM, thread pool sizing, and @Transactional proxying in under 2 minutes each.

Must coverThese four come up in nearly every Java Software Engineer loop.

StudyJLS ch.17 — Threads and Locks →

Skim cheat sheet only. Confirm you can drive the framework end to end without prompting.

Must coverRequirements, estimates, high level, deep dive, tradeoffs, risks.

StudySystem Design Primer →

Skim cheat sheet only. Confirm you can explain the render model and your perf toolkit cleanly.

Must coverThen stop. You are prepared.

Studyreact.dev — Render and commit →
Rest completely

No problems. Skim your cheat sheets once, review your stories, sleep eight hours.

Resume defence

Every number on your resume is an invitation. Week 11 attacks each one — but find the real figures before you get there. If a figure is unrecoverable, prepare what you would measure. That is an acceptable answer; vagueness is not.

Progress is stored in this browser only. 90 days · 270 questions · 232 named problems · 4 tracks.