About Senior Frontend Engineer interviews
Senior Frontend Engineer interviews typically run across four to five stages and are designed to test depth, not just breadth. After a recruiter screen covering motivation, notice period and salary, you'll usually have a hiring manager conversation focused on ownership stories — how you've led frontend initiatives, influenced architecture decisions, and mentored juniors. The technical loop is where most candidates stand or fall: expect a live coding exercise (often a React component challenge with state management nuances), a frontend system design round (designing something like a Figma-style canvas, a feed, or a design system), and a deep-dive on a past project where interviewers will probe your JavaScript fundamentals, rendering performance, accessibility decisions and browser internals. A final round usually covers cross-functional collaboration with product, design and backend, plus values fit. The most common stumbles at senior level are: being fluent in a framework but shaky on the underlying platform (event loop, the DOM, CSS specificity, HTTP caching); designing UIs without considering accessibility or performance budgets; and failing the seniority bar in behavioural rounds by describing IC work rather than leadership, mentorship or technical direction. Interviewers at this level want to hear about trade-offs you owned, not features you shipped. Strong candidates demonstrate opinionated thinking about component architecture, testing strategy, and how the frontend fits into the wider system.
Typical stages
- Recruiter screen
- Hiring manager interview
- Live coding (React/JS)
- Frontend system design
- Past project deep-dive
- Final / values & cross-functional
Common formats
- Behavioral STAR
- Live coding
- Frontend system design
- Code review exercise
- Portfolio / project walkthrough
- Take-home assignment
What hiring managers screen for
- Depth in JavaScript, browser internals and the rendering pipeline — not just framework fluency
- Evidence of architectural ownership: component design systems, state management decisions, build tooling trade-offs
- Tangible impact on performance, accessibility and developer experience with measurable outcomes
- Mentorship and technical leadership signals — code review culture, raising the bar, unblocking peers
- Strong collaboration patterns with design and product, including pushing back constructively on specs
Red flags to avoid
- Reaches for libraries before understanding the underlying platform problem
- Cannot articulate trade-offs between rendering strategies (CSR, SSR, SSG, streaming) for a given context
- Treats accessibility and performance as afterthoughts or 'tickets for later'
- Describes solo IC work when asked about leadership — no evidence of multiplying others
- Vague metrics: 'made the app faster' with no Core Web Vitals, bundle size or user-impact numbers
Primary questions (15)
Behavioural
Tell me about a time you led a significant frontend architectural change — for example, migrating frameworks, introducing a design system, or rethinking state management.
Why this comes up: Senior FE hires are expected to drive architectural direction, not just implement features.
Prep pointers
- Pick an example where YOU framed the problem and built buy-in, not one handed to you fully scoped.
- STAR Situation: the technical debt or constraint that made the status quo untenable — quantify it (build times, bug rates, velocity).
- STAR Action: cover both the technical decision (why this approach over alternatives) and the change management (RFC, migration path, getting the team aligned).
- STAR Result: include adoption metrics and one thing you'd do differently — interviewers want self-awareness.
- Avoid describing this as a solo heroic effort; senior signal is multiplying the team.
Behavioural
Describe a time you mentored a more junior engineer through a difficult frontend problem.
Why this comes up: Seniority bar requires evidence of growing others, not just shipping yourself.
Prep pointers
- Choose a story where the mentee owned the outcome — your role was unblocking, not taking over.
- STAR Action should describe specific coaching moves: pairing cadence, code review patterns, questions you asked rather than answers you gave.
- Show you adapted your approach to that individual's learning style.
- Common failure: making the story about your own technical brilliance instead of their growth.
Behavioural
Tell me about a time you disagreed with a designer or product manager about a UI/UX decision. How did you handle it?
Why this comes up: FE engineers sit at the seam between design, product and engineering; collaboration friction is constant.
Prep pointers
- Pick a disagreement with real stakes — accessibility, performance budget, or feasibility — not a colour preference.
- STAR Action: show you brought data or user impact to the conversation, not just opinion.
- Demonstrate you were willing to be wrong; ideal stories include a compromise or a moment you updated your view.
- Avoid framing PMs or designers as adversaries — interviewers screen for partnership instinct.
Behavioural
Tell me about a time you owned a production frontend incident — how did you debug and resolve it?
Why this comes up: Production ownership and incident response are core senior expectations.
Prep pointers
- Choose an incident with diagnostic complexity (e.g. browser-specific, intermittent, only in production).
- STAR Action should walk through your hypothesis tree: what you ruled out, what tooling you used (source maps, RUM, error monitoring).
- Include the post-incident learning: what changed in tests, monitoring, or process to prevent recurrence.
- Avoid blaming tooling or other teams — show ownership of the full loop.
Technical
Walk me through what happens in the browser from the moment a user clicks a link to when the page is fully interactive.
Why this comes up: Tests whether the candidate understands the platform beneath the framework — a classic senior filter.
Prep pointers
- Cover DNS, TCP/TLS, HTTP request, server response, then critical rendering path: HTML parse, CSSOM, render tree, layout, paint, composite.
- Mention JS parsing/execution, hydration if SSR, and what blocks interactivity (long tasks, main-thread work).
- Tie it to user-facing metrics: TTFB, FCP, LCP, TTI, INP.
- Be ready for follow-ups on caching layers (HTTP cache, service worker, CDN) and how preloading/prefetching change the picture.
- Failure mode: jumping straight to React-specific lifecycle without grounding in the platform.
Technical
Design the component architecture and state management for a real-time collaborative editor (Google Docs style) for the frontend.
Why this comes up: Frontend system design is a near-universal senior round and collaborative editors surface every hard FE concern.
Prep pointers
- Start by clarifying scope: how many concurrent users, offline support, what document fidelity is required.
- Cover data model (CRDT vs OT trade-offs at a high level), local state vs server-synced state, optimistic updates.
- Address rendering performance: virtualisation, selective re-render, contenteditable pitfalls.
- Discuss presence, cursors, conflict resolution UX, and accessibility for screen readers in a live-updating document.
- Common miss: designing only the happy path — interviewers probe failure modes, reconnection, and offline.
Technical
You're told the app's Largest Contentful Paint is 4.2s on mid-tier mobile. Walk me through how you'd diagnose and improve it.
Why this comes up: Performance is a defining senior FE competency and interviewers want a structured diagnostic approach.
Prep pointers
- Open with measurement first — Lighthouse, WebPageTest, RUM data — and emphasise mid-tier device throttling.
- Distinguish between network-bound and render-bound LCP causes; cover server response, render-blocking resources, and the LCP element itself.
- Walk through concrete levers: image optimisation, preload hints, font loading strategy, code splitting, SSR/streaming.
- Mention how you'd validate the fix didn't regress other vitals (CLS, INP).
- Avoid generic answers like 'use lazy loading' — interviewers want specificity to the diagnostic findings.
Technical
How would you build an accessible, fully custom dropdown/combobox component? What are the non-obvious pitfalls?
Why this comes up: Tests both accessibility depth and the kind of low-level component work senior FEs are expected to lead on.
Prep pointers
- Reference WAI-ARIA Authoring Practices for combobox pattern — roles, aria-expanded, aria-activedescendant vs focus management.
- Cover keyboard interaction model: arrow keys, Home/End, type-ahead, Escape, Tab behaviour.
- Discuss why building from scratch is risky and when to reach for Radix/Headless UI/React Aria instead.
- Mention testing approach: axe, screen reader testing, keyboard-only testing.
- Common miss: relying on visual focus styles without managing actual focus correctly.
Situational
Your team is about to ship a feature when you discover the new bundle adds 180KB gzipped to the critical path. The PM wants to ship on time. What do you do?
Why this comes up: Tests how the candidate balances pragmatism, performance budgets and stakeholder pressure.
Prep pointers
- Don't answer with a binary 'ship' or 'don't ship' — show you'd quantify the user impact first.
- Walk through mitigations available before the deadline: code splitting, dynamic import, dependency audit, tree-shaking check.
- Show you'd surface the trade-off to the PM with data, not block unilaterally.
- Mention budgets and CI gates as the longer-term fix so this doesn't recur.
Situational
A backend team wants to ship a new API that requires the frontend to make 6 sequential requests to render the home page. How do you respond?
Why this comes up: Senior FEs are expected to push back constructively on cross-system designs that harm UX.
Prep pointers
- Frame the response around user impact (waterfall latency on mobile) rather than personal preference.
- Propose alternatives: BFF/aggregation layer, GraphQL, parallelisation, server-driven UI, or streaming.
- Show willingness to do the work to make the alternative easy for the backend team to adopt.
- Avoid coming across as territorial — frame as joint problem-solving.
Situational
You join the team and inherit a 4-year-old React codebase with class components, Redux boilerplate everywhere, and no tests. What's your first 90 days?
Why this comes up: Tests judgement around legacy systems — senior hires often inherit, not greenfield.
Prep pointers
- Resist the urge to rewrite — show you'd learn the domain and the why behind decisions first.
- Sequence: instrumentation and tests around critical paths before refactoring.
- Pick a thin vertical slice to demonstrate a new pattern, build consensus, then expand.
- Acknowledge the team and political dimension — earning trust before proposing change.
Competency
Walk me through the testing strategy you'd advocate for a medium-sized frontend application. Where do you draw the lines between unit, integration and E2E?
Why this comes up: Testing philosophy is a strong proxy for engineering maturity at senior level.
Prep pointers
- Anchor on the testing trophy/pyramid debate and where you actually land — and why.
- Be concrete about tools: Vitest/Jest, RTL, Playwright/Cypress, MSW for network mocking.
- Discuss what you DON'T test (implementation details) and how you've educated teams on that.
- Cover visual regression, accessibility testing in CI, and contract testing with backend.
- Avoid dogma — show you adapt strategy to team size, deployment risk and domain.
Competency
How do you approach component API design when building shared/library components? Walk me through a recent example.
Why this comes up: Component API design is where senior FEs either elevate or constrain a whole team's productivity.
Prep pointers
- Cover principles you apply: composition over configuration, controlled vs uncontrolled, polymorphic 'as' prop trade-offs.
- Talk about discoverability, TypeScript ergonomics, and how you handle escape hatches.
- Use a specific component as a worked example — show evolution and what you got wrong first time.
- Mention how you validate the API with consumers before locking it in.
Competency
How do you stay current with the frontend ecosystem without chasing every new framework?
Why this comes up: Senior FEs need a filter for hype vs signal; interviewers want to see disciplined learning habits.
Prep pointers
- Show a specific information diet: which sources, RFCs you follow, conferences, OSS you read.
- Give an example of a technology you evaluated and chose NOT to adopt — and why.
- Contrast with one you did adopt and what convinced you.
- Avoid sounding either dismissive of new tech or breathlessly enthusiastic about it.
Culture fit
What does great frontend engineering culture look like to you, and what would you push to change in your first six months here?
Why this comes up: Senior hires are expected to shape culture, not just adapt to it.
Prep pointers
- Have a clear point of view — vague answers read as lack of conviction at senior level.
- Tie your view to concrete practices: code review norms, design partnership, on-call, performance budgets.
- Show you've researched the company's current practices (from their blog, OSS, talks) before answering.
- Balance opinion with humility — frame changes as 'I'd want to understand context first, then advocate for...'
More practice questions (14)
Technical
Explain the difference between useMemo, useCallback and React.memo. When does each actually matter?
Why this comes up: Tests whether the candidate understands React's render model beyond surface usage.
Technical
What is the event loop, and how do microtasks and macrotasks differ? Give a practical example where this matters in a UI.
Why this comes up: JavaScript runtime fundamentals are a common senior screening question.
Technical
How does CSS specificity work, and how would you architect styles in a large app to avoid specificity wars?
Why this comes up: Senior FEs are expected to have an opinion on CSS architecture (CSS Modules, Tailwind, CSS-in-JS, cascade layers).
Technical
Implement a debounce function from scratch. Now adapt it so the trailing call always fires with the most recent arguments.
Why this comes up: Classic live coding warm-up to test vanilla JS fluency.
Technical
When would you choose SSR over CSR or SSG, and what are the operational trade-offs?
Why this comes up: Rendering strategy is a defining architectural decision for modern frontends.
Technical
How would you implement infinite scroll while preserving accessibility and avoiding memory bloat?
Why this comes up: Combines virtualisation, a11y and performance — common senior interview territory.
Technical
What's your approach to TypeScript generics in component libraries? Show how you'd type a generic Table component.
Why this comes up: TypeScript depth separates senior from mid-level FE candidates.
Behavioural
Tell me about a time you had to deprecate or sunset a frontend feature or library that internal teams depended on.
Why this comes up: Tests stakeholder management and migration planning skills.
Situational
Your analytics team wants to add a third tag manager script to the page. What questions do you ask before agreeing?
Why this comes up: Tests instinct around performance, privacy and the cost of third-party scripts.
Competency
How do you approach code reviews, especially for engineers more junior than you?
Why this comes up: Code review is the highest-leverage senior activity; interviewers probe for craft and tone.
Competency
Describe how you'd introduce a design system to a team that currently doesn't have one.
Why this comes up: Design systems work is a common senior FE remit and tests both technical and organisational skills.
Situational
A user reports the app is unusable on their device but you can't reproduce it. Walk me through your approach.
Why this comes up: Tests debugging discipline under ambiguity — a senior expectation.
Culture fit
What kind of product or domain do you find most motivating to work on, and why?
Why this comes up: Helps gauge retention risk and alignment with the company's mission.
Behavioural
Tell me about a technical decision you made that you later regretted. What did you learn?
Why this comes up: Tests self-awareness and growth mindset — both critical at senior level.
Get a prep pack tailored to your experience
describe.me matches these questions against your real work history,
flags your prep priorities, and gives you a STAR scaffold per question.
Start free →