roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Walk into frontend interviews ready to build and reason about modern web UIs. Covers JavaScript and TypeScript, the browser platform, framework concepts, performance, testing and system design.
6795 of 6795 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 6795 new. 0 cut, outside your plan.
Frontend loops lean on the browser more than on the whiteboard. After a screen, the coding round as often builds a small interface live, a typeahead or a rating control with keyboard support, as it solves an algorithm problem, and a take-home frequently stands in for one round. A fundamentals conversation on JavaScript, CSS and the browser follows; from middle level up a frontend system design round is added, and a behavioral conversation closes. The fundamentals questions are short, and each right answer exposes a model. Why does a timeout inside a `var` loop log the final value on every iteration, and what does `let` change? Why does `z-index` do nothing on a statically positioned element in normal flow? Why does the browser send an `OPTIONS` request before your cross-origin `PUT` and not before your `GET`? Why does animating `top` stutter while the same motion on `transform` does not? What separates levels is the follow-up. For a junior the round stops at the correct prediction; for a senior it begins there, with what the fix costs, what measurement would show it worked and where the same mechanism bites elsewhere. A senior is also expected to say what good looks like before building it, an INP target and a ceiling on the route's bundle, and to give the reason a rendering or caching choice is worth what it costs the user on a mid-range phone and the team in complexity.
Everything in a frontend loop is written in JavaScript, so the plan begins there, from the runtime up: closures, prototypes and the [event loop](/topics/lang-javascript-event-loop) before the browser APIs, with [TypeScript](/topics/lang-typescript) as the layer that describes that code without changing what it does at runtime. [Algorithms](/topics/found-dsa) sit directly after, because even a coding round that builds a widget is graded on cost, and a typeahead over a long list is a data-structure question with a UI on it. The document comes next. [HTML](/topics/fe-html) and [CSS](/topics/fe-css) are the native layer, and accessibility sits inside HTML because most of it is what native elements already provide. The styling tools that follow are answers to one question, how to keep styles local: [CSS Modules](/topics/fe-css-modules) scope by file, while the utility approach lets [theme variables](/topics/fe-tailwind-config-theming) and source detection decide what reaches the stylesheet. The [browser platform](/topics/fe-browser-platform) closes this part, because its rendering pipeline and security model are what every framework abstraction later wraps. A tooling run sits before the frameworks on purpose: [Git](/topics/dev-git) and GitHub, the package manifest and its [lockfile](/topics/dev-npm-install-lockfile), and the [module graph](/topics/fe-build-tools-concepts-module-resolution) a bundler resolves, transforms and splits, because tree shaking and code splitting belong to that layer, not to a framework. Then the [framework concepts](/topics/fe-ui-frameworks-concepts) themselves, without a vendor, so that one answer about reactivity, the update cycle or remote data serves whichever framework the job names. Remote data turns the plan toward the wire: HTTP, TLS and the [browser's trust boundaries](/topics/proto-browser-security), then the API styles, with [GraphQL](/topics/proto-graphql) beside REST and the OpenAPI contract. [Meta-frameworks](/topics/fe-meta-frameworks-concepts) come after both, because render modes, hydration and execution placement are where a client framework meets HTTP and a server, and [performance](/topics/fe-performance) waits until here for the same reason: the critical path, bundle size and delivery caching can only be reasoned about once the pipeline, the bundler and the render modes are known. Quality follows: ESLint's [flat config](/topics/dev-eslint-config) and Prettier, then testing, where the general disciplines come first and the frontend modules open on [behavior over implementation](/topics/fe-testing-component-behavior-over-implementation), the rule the rest of them apply, from network mocking to visual regression, then [design systems](/topics/found-design-systems), tokens and the component library as the shared product a frontend team ships to the rest of the company. Security and auth sit late because the browser-side questions about an [OAuth2](/topics/proto-oauth2) token, where to keep it, why PKCE, what `SameSite` buys, presume the browser security model and HTTP already learned. [Frontend system design](/topics/fe-system-design), with general scalability on one side and [micro-frontend composition](/topics/found-microfrontends-composition-strategies) on the other, is built from everything before it and is where the senior round lives. The last stretch leaves the browser: how a change travels through a [pipeline](/topics/cloud-cicd-concepts) to production, how to hand work to an AI coding assistant and still own the review, and the [behavioral round](/topics/found-behavioral), with the anatomy of the loop itself.
The fundamentals conversation is where frontend loops are most often lost, so a short runway goes there first: narrow importance to must know and level to your own band, and study order can stay where it opens, on by frequency; expect JavaScript, CSS and the browser platform to take most of the resulting queue. With a season ahead, put study order on by topics and keep one small application growing beside the plan, so that the bundling, framework and performance questions are about code you have profiled. A backend engineer crossing over can move quickly through Git, HTTP, REST and general system design and should spend the saved hours on CSS layout, the rendering pipeline and accessibility, which backend loops rarely asked about. Someone who learned the trade through a framework should go the other way, underneath it: the event loop, the DOM and the [browser security model](/topics/fe-browser-platform-security) are what the framework was hiding. A senior's hours belong to frontend system design, performance and the meta-framework render modes; the design round there is graded on the trade-off you can defend, not on the pattern you can name. The framework itself is the deliberate gap: the plan teaches framework concepts without a vendor, so the hooks, signals or change detection of the framework in the job description belong to its own roadmap, [React](/roadmaps/react) being the one most postings name. The server half of the stack, Node.js and the database behind the API, is the [JS Full Stack Developer roadmap](/roadmaps/javascript-full-stack).
Frontend loops lean on the browser more than on the whiteboard. After a screen, the coding round as often builds a small interface live, a typeahead or a rating control with keyboard support, as it solves an algorithm problem, and a take-home frequently stands in for one round. A fundamentals conversation on JavaScript, CSS and the browser follows; from middle level up a frontend system design round is added, and a behavioral conversation closes.
The fundamentals questions are short, and each right answer exposes a model. Why does a timeout inside a var loop log the final value on every iteration, and what does let change? Why does z-index do nothing on a statically positioned element in normal flow? Why does the browser send an OPTIONS request before your cross-origin PUT and not before your GET? Why does animating top stutter while the same motion on transform does not?
What separates levels is the follow-up. For a junior the round stops at the correct prediction; for a senior it begins there, with what the fix costs, what measurement would show it worked and where the same mechanism bites elsewhere. A senior is also expected to say what good looks like before building it, an INP target and a ceiling on the route's bundle, and to give the reason a rendering or caching choice is worth what it costs the user on a mid-range phone and the team in complexity.
Everything in a frontend loop is written in JavaScript, so the plan begins there, from the runtime up: closures, prototypes and the event loop before the browser APIs, with TypeScript as the layer that describes that code without changing what it does at runtime. Algorithms sit directly after, because even a coding round that builds a widget is graded on cost, and a typeahead over a long list is a data-structure question with a UI on it.
The document comes next. HTML and CSS are the native layer, and accessibility sits inside HTML because most of it is what native elements already provide. The styling tools that follow are answers to one question, how to keep styles local: CSS Modules scope by file, while the utility approach lets theme variables and source detection decide what reaches the stylesheet. The browser platform closes this part, because its rendering pipeline and security model are what every framework abstraction later wraps.
A tooling run sits before the frameworks on purpose: Git and GitHub, the package manifest and its lockfile, and the module graph a bundler resolves, transforms and splits, because tree shaking and code splitting belong to that layer, not to a framework. Then the framework concepts themselves, without a vendor, so that one answer about reactivity, the update cycle or remote data serves whichever framework the job names.
Remote data turns the plan toward the wire: HTTP, TLS and the browser's trust boundaries, then the API styles, with GraphQL beside REST and the OpenAPI contract. Meta-frameworks come after both, because render modes, hydration and execution placement are where a client framework meets HTTP and a server, and performance waits until here for the same reason: the critical path, bundle size and delivery caching can only be reasoned about once the pipeline, the bundler and the render modes are known.
Quality follows: ESLint's flat config and Prettier, then testing, where the general disciplines come first and the frontend modules open on behavior over implementation, the rule the rest of them apply, from network mocking to visual regression, then design systems, tokens and the component library as the shared product a frontend team ships to the rest of the company.
Security and auth sit late because the browser-side questions about an OAuth2 token, where to keep it, why PKCE, what SameSite buys, presume the browser security model and HTTP already learned. Frontend system design, with general scalability on one side and micro-frontend composition on the other, is built from everything before it and is where the senior round lives. The last stretch leaves the browser: how a change travels through a pipeline to production, how to hand work to an AI coding assistant and still own the review, and the behavioral round, with the anatomy of the loop itself.
The fundamentals conversation is where frontend loops are most often lost, so a short runway goes there first: narrow importance to must know and level to your own band, and study order can stay where it opens, on by frequency; expect JavaScript, CSS and the browser platform to take most of the resulting queue. With a season ahead, put study order on by topics and keep one small application growing beside the plan, so that the bundling, framework and performance questions are about code you have profiled.
A backend engineer crossing over can move quickly through Git, HTTP, REST and general system design and should spend the saved hours on CSS layout, the rendering pipeline and accessibility, which backend loops rarely asked about. Someone who learned the trade through a framework should go the other way, underneath it: the event loop, the DOM and the browser security model are what the framework was hiding. A senior's hours belong to frontend system design, performance and the meta-framework render modes; the design round there is graded on the trade-off you can defend, not on the pattern you can name.
The framework itself is the deliberate gap: the plan teaches framework concepts without a vendor, so the hooks, signals or change detection of the framework in the job description belong to its own roadmap, React being the one most postings name. The server half of the stack, Node.js and the database behind the API, is the JS Full Stack Developer roadmap.