Learning tracks

The exact blind spots from your recent interviews — knock these out in the first 3–4 days for an instant confidence boost.

Compact an array in place with a read/write two-pointer — the pattern behind half of all easy/medium array problems.

Why a function remembers variables from where it was defined — and how scope, hoisting, and the TDZ actually work.

The four rules that decide what `this` is at call time — and why arrow functions ignore them.

How property lookup walks [[Prototype]] up to null, and why class is just sugar over it.

Why the output is A, D, C, B — how the call stack, microtask queue, and macrotask queue decide async ordering.

States, chaining, error handling, and the concurrency helpers — plus how await maps back to the event loop.

Why == is dangerous, how JS coerces types automatically, and the truthy/falsy rules that trip up even experienced devs.

Two patterns every frontend engineer must be able to implement cold: what they do, when each fits, and the code.

Pure functions, immutability, currying, partial application, and function composition — the functional toolkit asked at mid-senior interviews.

Symbol.iterator, the iterator protocol, generator functions, lazy sequences, and async generators — the machinery behind for...of and spread.

Static vs dynamic, live bindings vs copies, tree shaking, circular dependencies — what every senior JS dev must know about the module system.

The TS features that separate shallow knowledge from real depth: generics, the built-in utility types, type narrowing, and mapped/conditional types.

Error types, try/catch/finally semantics, async error propagation, custom error classes, and the patterns that prevent silent failures.

Observer, Module, Singleton, Factory, and Strategy — the classic patterns reframed for modern JS/TS, with real-world React/Node parallels.

Shallow vs deep clone, Object.freeze, structuredClone, WeakMap/WeakSet for memory-safe caching, and how the garbage collector works.

What triggers a re-render, how reconciliation and keys work, and where memoization actually helps.

The three threads, why the old bridge was slow, and what JSI, Fabric, and TurboModules changed.

useRef's dual role, useEffect vs useLayoutEffect timing, the rules of hooks, and custom hooks.

Expose a controlled set of imperative methods from a child to its parent via a ref — the right way.

The precise difference between the two hooks, what 'referential stability' means, and the honest truth about when memoization helps vs when it's just noise.

When to reach for each solution, how Redux Toolkit modernizes Redux, how Zustand works, and the real performance gotchas with Context API.

Why ScrollView kills long lists, how virtualization works, FlatList props that matter, and when to upgrade to FlashList.

Why the JS thread causes animation jank, how the Animated API works, and what Reanimated's worklets change — with practical patterns for both.

How React Navigation's navigator types work, how to pass params type-safely, nested navigators, and wiring up deep linking.

What concurrent rendering actually means, how useTransition and useDeferredValue let you keep UIs responsive, and where Suspense now fits.

AppState transitions, what happens when your app backgrounds, foreground/background detection, and handling tasks that must complete when the app isn't active.

AsyncStorage vs MMKV for persistence, React Query for server state, and offline-first patterns with optimistic updates.

What error boundaries catch (and don't), how to implement one, RN-specific crash reporting, and the React 18 updates to error handling.

The testing pyramid for RN apps — unit tests with Jest, component tests with React Native Testing Library, and E2E with Detox.

How to write platform-specific UI and logic, when and how to create a native module, and the Platform API patterns every RN dev must know.

Managed vs bare workflow, when to use Expo, EAS Build for production apps, and how CodePush/OTA updates work and what they can't update.

Frequency counting, seen-sets, and prefix products — the warm-up category that unlocks O(1) lookups and turns quadratic scans into linear.

Opposite-end and read/write pointers — clean, optimal, O(n)/O(1) solutions and a startup favorite. Your move-zeros gap lives here.

Fixed and variable windows over a sequence — turn O(n·k) substring/subarray scans into O(n).

The template that kills off-by-one bugs, plus 'search on the answer' — the variant that trips people up.

DFS (pre/in/post) as recursion, BFS as a queue, and the BST invariant — recursion fluency, tested constantly.

BFS/DFS on grids and adjacency lists, connected components, topological sort, and union-find — the startup staples.

Spot overlapping subproblems, define the state, write the recurrence — then memoize or tabulate. Templates for 1D, 2D, knapsack, LIS, and grids.

Top-K, streaming medians, and merge-k-sorted with a heap — O(log n) access to the smallest/largest, and the two-heap balance trick.

The dummy-head technique, fast/slow pointers for cycles and middles, and clean in-place reversal — pointer fluency under pressure.

LIFO/FIFO mechanics, the monotonic stack for next-greater problems, min-stack, and sliding-window-max via a deque.

The choose / explore / un-choose template, decision-tree thinking, and pruning — the engine behind subsets, permutations, combinations, and N-Queens.

The sort-by-start trick, merging overlaps, insert interval, non-overlapping removal, and meeting-rooms scheduling with a heap.

A repeatable 6-step structure, capacity math, latency numbers, CAP/PACELC, and consistency models so you never freeze on an open-ended design question.

Load balancers, gateways, caching, CDN, queues vs pub/sub vs streams, databases, object storage, search, rate limiters, service discovery — each with when to reach for it and the tradeoff.

The NoSQL families and when to use each, B-tree vs LSM indexing, ACID vs BASE and isolation levels, sharding & rebalancing, replication topologies, and access-patterns-drive-the-schema.

How Node stays fast on one thread — libuv loop phases, the thread pool, CPU vs IO-bound work, clustering & worker_threads, streams/backpressure, GC, and production pitfalls.

Two warm-up designs (URL shortener, rate limiter) plus the reusable patterns interviewers probe: fan-out, CQRS, event sourcing, idempotency, outbox, consistent hashing, replication, sharding, hot keys, backpressure.

A repeatable method for frontend design rounds: requirements → API/data → component architecture → state → rendering (CSR/SSR/SSG/ISR) → performance budget → network/caching → a11y → offline.

A deep concept walkthrough of the feed: fan-out on write vs read, the hybrid for celebrities, ranking, cursor pagination, caching, and the client-side concerns (virtualization, optimistic UI).

Caching layers, write strategies (aside/through/back), eviction, the three big failure modes (stampede, penetration, avalanche), invalidation & consistency, CDN internals, and Redis data structures.

API styles and when to choose each, REST done right (status codes, idempotency, pagination, versioning), real-time options, sync vs async, and resilience: retries, timeouts, circuit breakers, rate limiting.

Build 6–8 reusable stories with the STAR structure so any behavioral question has a crisp, specific answer.

A tight 90-second pitch that frames the whole interview in your favor.

How to run effective mocks, think out loud, simulate pressure, and structure the 45 minutes of a real round.

How to anchor, use leverage, and avoid the mistakes that leave money on the table — with exact scripts.

40+ common behavioral questions by theme, each with what it's really testing and a strong answer skeleton.

Decode the behavioral round — the signals they grade, the red flags that sink candidates, and how leveling works.

What an AI engineer actually does in 2026, the three rules that save months, and why your backend skills are an unfair advantage.

≈1 week. Reuse the production skills you already have; close the one real gap (enough Python to read notebooks).

Call LLM APIs correctly, treat tokens as money, implement streaming, and make structured outputs reliable with tool use.

Build a production RAG pipeline — chunking, embedding, pgvector retrieval, reranking, and the quality levers that actually matter.

Build production agents — tool use patterns, the ReAct loop, parallel tool calls, error recovery, and when to use deterministic workflows instead.

Ship AI to production — evaluation frameworks, LLM-as-judge, tracing, latency optimization, cost dashboards, and A/B testing prompts.

Know when fine-tuning beats RAG, implement LoRA with real code, pick a specialization depth, and ship one polished AI product publicly.

Your default pick per layer — and the alternatives worth knowing — for the current AI-engineering stack.

Predict the output — var/let/const hoisting, TDZ, function declaration vs expression, and block scope gotchas.

Predict the output — closure capture, stale closures, IIFE patterns, loop bugs, and memoization gotchas.

Predict execution order — setTimeout vs Promise vs queueMicrotask, async/await unwrapping, and nested async patterns.

Predict the output — implicit/explicit/new binding, arrow functions, prototype lookup, class inheritance, and the classic this-loss traps.

Predict the output — type coercion puzzles, == vs ===, + operator surprises, typeof edge cases, and bitwise/logical traps.

Predict the output — generators, class edge cases, Array methods, Object tricks, Symbol, and multi-concept combinations.

A repeatable 5-step process for frontend LLD interviews — requirements, API design, data model, class structure, and edge cases.

All five SOLID principles with real JS/TS examples — what each one means, how to violate it, and how to fix the violation.

Full implementation of a typed EventEmitter with on, off, emit, once, and removeAll — one of the most common LLD coding questions.

Design a production-quality Modal — focus trap, scroll lock, portal rendering, accessibility, animation, and composable API.

Design a production autocomplete — debounced remote search, keyboard navigation, accessibility, caching, and cancellation.

Design a global toast system — imperative API, auto-dismiss, stacking, progress bar, and the singleton pattern in React via context.

Design a composable, schema-based form validation library — validator functions, chaining, async validators, and a React hook integration.

A 6-step framework for frontend system design interviews — requirements, architecture, component tree, data flow, performance, and trade-offs.

Design the frontend of a social news feed — infinite scroll, virtualization, optimistic likes, real-time updates, and performance at scale.

Design a real-time chat widget — WebSocket architecture, message state, optimistic sending, read receipts, reconnection, and accessibility.

Design a Kanban board — column/card data model, drag-and-drop with optimistic reorder, virtualized columns, and undo/redo.

Design a custom video player — controls, buffering, adaptive streaming (HLS), keyboard shortcuts, accessibility, and performance.

A 6-step framework for backend system design interviews — requirements, estimation, API, data model, architecture, and deep-dives.

The core components of every scalable system — load balancers, caches, queues, CDN, databases, and how they connect.

Design bit.ly — hash generation, redirect performance, custom aliases, analytics, and storage at scale.

Design a distributed rate limiter — token bucket, sliding window counter, Redis implementation, and where to enforce limits.

Design the Twitter timeline — fanout-on-write vs fanout-on-read, hybrid strategy for celebrities, sharding, and real-time delivery.

Design a multi-channel notification system — push, email, SMS — with priority queues, fan-out, delivery guarantees, and user preferences.

Design Google-scale typeahead — trie vs prefix hash, top-K ranking, distributed storage, and < 100ms end-to-end latency.