Skip to content
DevFlash

Technical interview

Front-end technical interview: what to study and demonstrate

Interface and browser skills organized into a study plan with practical evidence.

  • 6 min read
  • 6 sections
  • Updated November 2, 2026

This guide is under editorial review.

In 1 minute

  • Prepare around the role’s responsibilities and confirm the assessment format.
  • Explain interactions through initial state, action and result, including keyboard use and errors.
  • Derive calculable values, separate responsibilities and prioritize conceptual gaps in practice.

A front-end technical interview asks you to connect code with interface behavior. Naming hooks or CSS properties does not replace explaining how someone completes an action, understands an error or uses a page with a keyboard. Preparation becomes clearer when you organize study around observable behavior as well as the technologies named in the role.

This roadmap covers browser fundamentals, data, components and quality checks. It does not try to predict every stack question. For an overview of the whole process, use the technical interview guide. Here, choose a small screen you know and use each section to check whether you can explain your decisions without relying on a rehearsed presentation or a long tool list.

How to prepare for a front-end technical interview

Start with the role's responsibilities. For product interfaces, practice requirements, visual states and data integration. If maintenance is emphasized, spend time reading existing code and explaining a small change. Confirm the assessment format before choosing an exercise. A take-home needs delivery planning; a live session also requires communication while you work.

  1. Run a diagnostic

    Run a short diagnostic: build an interaction, try it with a keyboard and explain an error case.

  2. Record the gaps

    Record where you needed documentation and where you did not understand behavior. Looking up a signature and missing a concept are different gaps.

  3. Prioritize and repeat

    Address the conceptual gap before adding more topics, then repeat the task and compare the clarity of your explanation.

  • Choose one responsibility and an interaction that represents it.
  • Describe the initial state, the user's action and the expected result.
  • Review one gap per session with an example you can run.
A radar chart with six unlabeled axes and a balanced amber shape.
Use an interaction diagnostic to locate gaps and choose the next area to study.

Semantic HTML, CSS and browser behavior

Explain structure versus appearance through a concrete decision. A button performs an action; a link with a destination provides navigation. Replacing them with a clickable div means rebuilding behavior the browser already provides. Instead of listing tags, show how your element choice affects focus, activation and understanding. Its visible name should also communicate what the action does.

For CSS, use realistic situations: long text breaking a layout, a column refusing to shrink or an error message increasing a form's height. Check a narrower viewport and zoom. Explain flexbox or grid through the relationship between elements. Avoid using a fixed height merely to hide a problem that returns when content changes or another language needs more space.

JavaScript, events and interface data

Review arrays, objects and functions through interface tasks. Explain whether a transformation changes its original collection and what happens with empty input. Use the JavaScript interview questions for deeper language behavior. When preparing an interface, focus on the data contract and how a failure becomes visible to the person using the product.

For asynchronous operations, describe loading, success and failure. Ask whether another action can happen before the previous one finishes. That opens a discussion about stale responses, disabled controls and recovery. Do not assume requests finish in the order they started. A short rehearsal need not implement every strategy, but identify any unprotected behavior and explain how you would check it.

Components, state and an interaction example

Choose the smallest data set needed to represent an interaction. Imagine a reading screen that switches between summary and detail views. The example below models only that transition, independently of a framework. The function does not know how the control will be rendered. Explain the rule first, then discuss which component receives the event and which part of the interface needs the state.

Do

  • When using React, derive calculable values from available data during rendering.
  • Split components around responsibilities you can name. Ask how many places would need to know if a rule changed. That gives you a practical way to assess the structure.

Avoid

  • Keeping two copies of the same information: they require synchronization and can diverge.
  • Turning every line into a separate file.
type ReadingMode = "summary" | "details";
export function nextReadingMode(mode: ReadingMode): ReadingMode {
return mode === "summary" ? "details" : "summary";
}

Review accessibility, tests and performance

Perform a short manual review before claiming quality. Move through the screen with Tab, check visible focus and confirm that controls have understandable names. Read error messages independently of the code: do they explain what the user can do? The front-end interview accessibility guide covers semantics, keyboards and forms. Automated tools complement this inspection but do not observe the entire experience.

Choose tests based on interaction risks. A check for recovery after a failure may explain your judgment better than several checks of internals. For performance, name the symptom before optimizing: slow input, shifting content or a delay before data appears. Explain how you would observe it. Avoid adding memoization without knowing what work it would save and whether that work is costly.

How to present a front-end project

Start with the main workflow and show a condition beyond the happy path. Then explain one state decision, one structural decision and one validation choice. This connects the demonstration to the code. For a take-home assignment, the front-end take-home delivery guide helps with scope and documentation. Do not spend the whole presentation on the folder tree before the interviewer understands the problem.

Close with specific limitations. State what content size you checked, which states you simulated and what depends on an external service. If work remains, describe a completion sequence based on user impact. Clear boundaries demonstrate understanding; you do not need to promise an application ready for every possible scenario. Keep one decision available for deeper discussion if time allows.

Frequently asked questions

What should I study for a front-end technical interview?

Prioritize semantic HTML, CSS, JavaScript, events, asynchronous data and interface states. Add the stack required by the role. Use a small screen to connect these topics and check accessibility, testing and decision explanations.

Do I need React for a front-end role?

It depends on the stated requirements. Confirm whether the exercise requires React or allows alternatives. Even when React is mandatory, browser and language fundamentals remain necessary to explain behavior and investigate problems.

How should I prepare for a junior front-end interview?

Choose a small project you understand. Explain its structure, an interaction and a bug you fixed. Review the fundamentals it uses and practice asking questions. Do not present study experience as responsibilities you never held.

How should I present my portfolio in an interview?

Select a relevant project and show its problem, your contribution and a decision worth discussing. Prepare the environment and a backup if the demo fails. Explain limitations and evidence rather than relying on appearance alone.

Practice with real tests

Solve front-end exercises in the browser, with the same tests a reviewer would run.

See the exercises