roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for Blazor interviews on where a component runs under each render mode, and how it renders, binds and keeps state. Covers routing, forms, JavaScript interop, circuits and auth.
239 of 239 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 239 new. 0 cut, outside your plan.
Blazor rarely gets an interview loop of its own. It comes up on .NET teams, in the frontend half of a full-stack interview or in a technical conversation that also covers ASP.NET Core, and the first question is usually where the code runs. The same Razor component can render statically on the server, run interactively on the server over a live connection, or run in the browser on WebAssembly, and most follow-ups test whether you keep track of which one you are in: why `HttpContext` is there for a statically rendered page and gone in an interactive one, why `OnInitializedAsync` can run twice for a single visit, why a scoped service under the server model lives as long as the browser tab. Stronger answers go from symptom to mechanism. A list whose inputs keep the wrong values after an item is removed points to a missing `@key`. A component that never refreshes after a timer fires points to work done outside the renderer's synchronization context, fixed with `InvokeAsync` and `StateHasChanged`. From middle level up the questions turn to cost: the memory every server circuit holds, what a dropped connection does to unsaved state, the download a WebAssembly client pays before its first click, and why one `DbContext` shared by a circuit fails when two events overlap.
The plan opens on what a component is written in rather than on Blazor itself: [Razor syntax](/topics/fe-razor), where markup ends and C# begins, and two parts of C# the framework leans on constantly, [async and await](/topics/lang-csharp-async-tasks) behind every lifecycle method and JavaScript call, with the synchronization context a component's updates return to and the cancellation a disposed component owes its pending work, and delegates and events behind each handler and each subscription a component has to release. Render modes come next, and early, because the answer to nearly every later question depends on them. The framework-neutral ideas of [hydration](/topics/fe-meta-frameworks-concepts-rendering-hydration) and streamed HTML supply the vocabulary, and [Blazor's render modes](/topics/fe-blazor-render-modes) apply it. From there most groups pair a general idea with Blazor's version of it, theory first. The [component model](/topics/fe-ui-frameworks-concepts-components) precedes [parameters, callbacks and cascading values](/topics/fe-blazor-components). Keys and [diffing](/topics/fe-ui-frameworks-concepts-rendering-diffing-bailouts) precede the [lifecycle methods](/topics/fe-blazor-lifecycle) that schedule a rerender, and [error boundaries](/topics/fe-ui-frameworks-concepts-rendering-error-boundaries) close that group. Routing moves from route tables and client navigation to [`@page` routes and enhanced navigation](/topics/fe-blazor-routing). Forms carry two pieces of ASP.NET Core, DataAnnotations validation and the [antiforgery check](/topics/be-aspnet-core-security-antiforgery) a statically rendered form posts through, before [`EditForm`](/topics/fe-blazor-forms) itself. [JavaScript interop](/topics/fe-blazor-js-interop) follows, for whatever the framework does not reach. In the later groups the render mode stops being a setting and becomes an operating concern. A shared store and [DI lifetimes](/topics/be-aspnet-core-di-lifetimes) take on a new meaning when a scope is a circuit, and keeping [circuits and persisted state](/topics/fe-blazor-state) alive across several servers leads to [SignalR scale-out](/topics/be-signalr-core-scaling). Identity runs from the server's cookie scheme, [policies](/topics/be-aspnet-core-auth-authorization) and OpenID Connect through route guards to the [auth state](/topics/fe-blazor-auth) a component reads, because hiding a button with `AuthorizeView` protects nothing the server does not also check. [Component testing](/topics/fe-ui-frameworks-concepts-testing) comes last, once there is a tree worth mounting.
Most of the preparation time belongs to render modes, components and state, where questions about prerendering and circuits cluster; on a short run-up, narrow level to the seniority on the posting and raise importance to must know. Coming from React, Angular or Vue, you can move fast through the neutral concept topics and slow down on what has no counterpart there: a component instance that lives on the server, a scope that lasts as long as a tab, and a form that posts without any interactivity at all. Coming from MVC or Razor Pages, expect the opposite: the syntax is familiar, and the rerender model is the new part. The plan takes from ASP.NET Core only what a component touches directly. Hosting, middleware, configuration, endpoints and the data layer behind a Blazor app are in the [ASP.NET Core roadmap](/roadmaps/aspnet-core), and the language beyond async code and delegates is in the [C# roadmap](/roadmaps/csharp). Blazor Hybrid, which runs components inside a native .NET MAUI app, is outside this plan.
Blazor rarely gets an interview loop of its own. It comes up on .NET teams, in the frontend half of a full-stack interview or in a technical conversation that also covers ASP.NET Core, and the first question is usually where the code runs. The same Razor component can render statically on the server, run interactively on the server over a live connection, or run in the browser on WebAssembly, and most follow-ups test whether you keep track of which one you are in: why HttpContext is there for a statically rendered page and gone in an interactive one, why OnInitializedAsync can run twice for a single visit, why a scoped service under the server model lives as long as the browser tab.
Stronger answers go from symptom to mechanism. A list whose inputs keep the wrong values after an item is removed points to a missing @key. A component that never refreshes after a timer fires points to work done outside the renderer's synchronization context, fixed with InvokeAsync and StateHasChanged. From middle level up the questions turn to cost: the memory every server circuit holds, what a dropped connection does to unsaved state, the download a WebAssembly client pays before its first click, and why one DbContext shared by a circuit fails when two events overlap.
The plan opens on what a component is written in rather than on Blazor itself: Razor syntax, where markup ends and C# begins, and two parts of C# the framework leans on constantly, async and await behind every lifecycle method and JavaScript call, with the synchronization context a component's updates return to and the cancellation a disposed component owes its pending work, and delegates and events behind each handler and each subscription a component has to release.
Render modes come next, and early, because the answer to nearly every later question depends on them. The framework-neutral ideas of hydration and streamed HTML supply the vocabulary, and Blazor's render modes apply it.
From there most groups pair a general idea with Blazor's version of it, theory first. The component model precedes parameters, callbacks and cascading values. Keys and diffing precede the lifecycle methods that schedule a rerender, and error boundaries close that group. Routing moves from route tables and client navigation to @page routes and enhanced navigation. Forms carry two pieces of ASP.NET Core, DataAnnotations validation and the antiforgery check a statically rendered form posts through, before EditForm itself. JavaScript interop follows, for whatever the framework does not reach.
In the later groups the render mode stops being a setting and becomes an operating concern. A shared store and DI lifetimes take on a new meaning when a scope is a circuit, and keeping circuits and persisted state alive across several servers leads to SignalR scale-out. Identity runs from the server's cookie scheme, policies and OpenID Connect through route guards to the auth state a component reads, because hiding a button with AuthorizeView protects nothing the server does not also check. Component testing comes last, once there is a tree worth mounting.
Most of the preparation time belongs to render modes, components and state, where questions about prerendering and circuits cluster; on a short run-up, narrow level to the seniority on the posting and raise importance to must know. Coming from React, Angular or Vue, you can move fast through the neutral concept topics and slow down on what has no counterpart there: a component instance that lives on the server, a scope that lasts as long as a tab, and a form that posts without any interactivity at all. Coming from MVC or Razor Pages, expect the opposite: the syntax is familiar, and the rerender model is the new part.
The plan takes from ASP.NET Core only what a component touches directly. Hosting, middleware, configuration, endpoints and the data layer behind a Blazor app are in the ASP.NET Core roadmap, and the language beyond async code and delegates is in the C# roadmap. Blazor Hybrid, which runs components inside a native .NET MAUI app, is outside this plan.