Interview prep that respects your brain.

Whoever holds the phone owns the fingerprint.

A pre-pass that lifts declarations to the top of the stack.

A backpack of variables a function never puts down.

Rebuild Array.map on a factory line for an old browser.

The restaurant order queue that never blocks the kitchen.

Property lookup climbs a ladder of parent objects.

A ticket stub that resolves when your order is ready.

A function that can pause mid-execution and hand back control.

A bouncer who intercepts every property access.

Each function lives inside a set of nested rooms.

A magnifying glass gliding over a film strip.

Two fingers walking toward each other.

Russian dolls that remember how to close themselves.

Family trees and subway maps.

A dictionary where each letter branches the path.

A hotel that evicts the longest-idle guest when full.

Remember sub-answers so you never solve the same puzzle twice.

Ordering tasks when some must come before others.

A self-sorting pile that always surfaces the most urgent item.

Rate-limiters: wait for silence vs. pace the calls.

A bulletin board where subscribers hear only what they posted for.

Train cars connected by couplers — reverse the train by flipping one coupler at a time.

Five patterns that unlock 80% of string/array interview problems.

React redraws the blueprint; Signals flip one wire.

Render phase you can pause; commit phase you can't.

Redux vs Jotai vs Valtio — three shapes of truth.

LCP, CLS, INP — and the render path that produces them.

Cook-to-order, batch-bake, reheat-on-demand, or skip the oven.

Ship independently deployable UI slices into one shell.

Only ship the JavaScript the current page actually needs.

Static HTML comes alive tab-by-tab, not all at once.

One repo, many packages — cache the work you've already done.

<Select> and <Option> that share a private channel.

The four locks on the front door.

Walkie-talkie vs phone call vs checking the mailbox.

One source of truth that feeds every button in every theme.

A tailor-made API gateway that speaks exactly your UI's dialect.

stale-while-revalidate, surrogate keys, and the edge cache.

Ask for exactly what you need — and batch what the loader fetches.

The app keeps working when the wifi drops.

DOM → CSSOM → Layout → Paint → Composite in one breath.

V8 bets on your object's shape — break the shape, lose the bet.

Detached DOM nodes that haunt the heap forever.

Read-then-write loops that make the browser cry.

Move the heavy lift to a background thread the UI never blocks on.

Near-native speed in the browser sandbox.

Stamped passport vs. a name on the guest list.

Delegate the key to a trusted locksmith, never share the key.

An allowlist that tells the browser which scripts to trust.

The browser knocks before entering a cross-origin room.

One badge unlocks every door in the building.

A checksum that proves the CDN didn't swap your script.

Multiplexed lanes vs. UDP packets that don't block on loss.

Run code 50ms from the user, not 200ms away in Virginia.

A proxy that intercepts every fetch and decides where to look.

A real database that lives in the browser tab.

Preview deploys, bundle budgets, and lighthouse gates.

Measure real users, not just Lighthouse scores.

The document that builds alignment before a single line is written.

ARIA, focus management, and the four POUR principles.

Mirror the entire UI for a language that reads right to left.

Unit → Integration → E2E — know when each layer earns its cost.

Deprecate the old without breaking the team shipping on top of it.

Reviews that teach, not just gatekeep.

useState to useSyncExternalStore — what each hook solves and when to reach for it.

It's not a lifecycle hook — it's a synchronization primitive.

Memoization is an optimization, not a correctness fix — know when it helps.

useTransition lets you mark slow updates as non-urgent — the UI stays responsive.

Zero JS shipped to the client — the component lives entirely on the server.

Three ways to share logic — and why hooks replaced the first two.

Context re-renders every consumer — here's how to avoid the blast radius.

Each solves a different scale of problem — pick the right tool.

Wrong key = React destroys + remounts instead of updating. Subtle, deadly.

Test what the user sees, not the component's internals.

Folders are routes, files are slots — layout.tsx, page.tsx, loading.tsx explained.

Default to Server — add 'use client' only when you need interactivity or browser APIs.

fetch() in Next.js is extended — cache:'force-cache', revalidate:60, tags.

generateStaticParams → static. Dynamic headers → dynamic. Suspense → streaming.

API routes are gone — route.ts handles REST; middleware.ts runs at the edge.

next/image auto-sizes + lazy-loads; next/font eliminates layout shift from custom fonts.

Sessions, JWTs, OAuth providers, and protecting routes with middleware.

Node.js runtime vs Edge runtime — what you gain and lose at the edge.

error.tsx catches render errors per-segment — not-found.tsx handles 404s.

@Component is metadata — the decorator tells the framework how to compile your class.

Hierarchical injectors: platform → root → feature → component. Scope matters.

Default checks everything. OnPush checks only when inputs change or an Observable emits.

switchMap, mergeMap, concatMap, exhaustMap — four operators, four concurrency strategies.

Fine-grained reactivity that eliminates zone.js overhead — the future of Angular.

No NgModule required — import what you need directly in the component.

FormGroup + FormControl give you type-safe, testable forms without template magic.

Redux pattern for Angular — Actions flow in, Reducers compute state, Selectors slice it.

loadComponent() lazy-loads a standalone component on navigate — no NgModule wrapper.

@defer lets you lazy-render below-the-fold content without any router config.

AuthProvider wraps the app; ProtectedRoute checks the badge; silent refresh renews it before expiry.

HttpInterceptor attaches the token to every request and retries on 401 with a fresh one.

jwt.sign() stamps a hall pass; the middleware checks the signature on every request.

Short access tokens + long refresh tokens — rotate on use and detect theft via reuse.

PKCE replaces client_secret for SPAs — the browser proves it requested the code.