Senior
Frontend architecture, build tooling, and component-level system design. The point where interviews stop being about syntax and start being about tradeoffs.
Performance Optimization
Core Web Vitals, bundle splitting, image strategy, caching layers, third-party scripts, and SSR/SSG/CSR tradeoffs measured end-to-end.
Recommended prerequisites: browser-rendering, networking, react-performance
Why interviewers ask
Senior loops test whether you can move a real metric. Naming techniques is the floor; knowing which one applies to *this* app on *this* metric is the bar.
Real-world relevance
Every 100ms of LCP costs measurable conversion. Performance work is one of the highest-leverage things a senior frontend engineer does, and it's measurable on dashboards leadership watches.
Common interview patterns
- Move work off the critical path with `defer`, dynamic imports, and route splitting
- Prioritize hero images with `fetchpriority` and preload
- Cache at every layer: CDN, service worker, HTTP, in-memory
- Pick SSR/SSG/CSR per route based on freshness, personalization, and SEO
Common mistakes
- Optimizing TTI without checking what's blocking it (often a third-party script)
- Lazy-loading above-the-fold content and tanking LCP
- Treating bundle size as the only perf metric (TBT and INP often matter more)
- Preloading more than the browser can use, starving real-priority requests
Follow-up questions
- How would you cut LCP by 30% on a page you've never seen?
- What does INP catch that FID didn't?
- How would you measure a perf regression in production, not just synthetics?
Build Tools
Webpack vs Vite vs Turbopack, tree shaking, code splitting, source maps, module formats, and the publishing story for shared packages.
Recommended prerequisites: javascript-core
Why interviewers ask
Senior engineers own the build. Slow CI, broken source maps, and accidental bundle bloat are owned by whoever understands the toolchain — usually the person who can explain it in interviews.
Real-world relevance
A 30-second slower build × every engineer × every push = real money. Shipping ESM/CJS dual exports correctly is the difference between a usable package and a support ticket queue.
Common interview patterns
- Split routes and big libraries with dynamic `import()`
- Use tree shaking + side-effect-free modules to drop unused exports
- Publish ESM + CJS + types for library consumers
- Generate stable source maps and ship only `.map` to error monitoring
Common mistakes
- Importing a whole library (`lodash`) when a named export would tree-shake
- Marking a side-effectful module as side-effect-free and losing CSS imports
- Shipping unminified bundles to production behind a misconfigured `NODE_ENV`
- Writing a webpack config that works in dev but breaks long-term caching in prod
Follow-up questions
- Why is Vite faster in dev than Webpack, and where does that advantage disappear?
- How would you debug a tree-shaking failure?
- What changes in the build when you support both Server and Client Components?
Frontend Architecture
Monorepos, micro-frontends, design systems, SDK publishing, module boundaries, and the org-shaped decisions interviews increasingly drill into.
Recommended prerequisites: build-tools, state-management
Why interviewers ask
Architecture answers test whether you can scope, version, and own a system. The interviewer is watching for tradeoff fluency, not for a memorized pattern.
Real-world relevance
Cross-team contracts, version skew, and dependency graphs are the dominant complexity at scale. Architecture choices determine whether a 50-engineer org ships weekly or quarterly.
Common interview patterns
- Pick monorepo vs polyrepo based on dependency velocity and release cadence
- Use module federation or build-time integration for micro-frontends, not iframes by default
- Version a design system with semver + changesets, ship migration codemods
- Expose an SDK with a stable, namespaced public API and internal-only escape hatches
Common mistakes
- Reaching for micro-frontends to solve a team-coordination problem that monorepo + codeowners would fix cheaper
- Publishing a design system without documenting the deprecation policy
- Letting internal-only utilities leak into a public SDK surface
- Coupling apps through shared global state instead of contracts
Follow-up questions
- When would you split a monorepo into multiple repos?
- How would you migrate a legacy app to a modern framework without a freeze?
- How do you handle cross-app routing in a micro-frontend setup?