roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for ASP.NET Core 10 interviews: hosting and middleware, Minimal APIs and MVC, binding, DI and config, auth, EF Core, caching, SignalR, Blazor, testing and Aspire.
1190 of 1190 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 1190 new. 0 cut, outside your plan.
ASP.NET Core questions usually arrive as the framework part of a .NET backend or full-stack loop, after a round of C# questions, with a system design round added for senior roles. A take-home or live exercise often asks for a small Web API with validation, persistence and a test or two. The conversation is built on the request pipeline and the container. Why does `UseAuthorization` have to sit after `UseRouting`? What happens when a singleton takes a scoped `DbContext` in its constructor, and why does that fail loudly only in Development? Why does an `HttpClient` created per call exhaust sockets, while one held for the life of the process stops seeing DNS changes? What moves a candidate up the level range is where the answer starts. Early in a career, the expectation is to place a feature correctly: a filter or a middleware, `IOptions` or `IOptionsMonitor`, a tracked query or `AsNoTracking`. From senior up, the question arrives as an incident: requests queue while the CPU sits idle, users are signed out whenever the load balancer moves them to another instance, a list endpoint issues one query per row. The answer then has to name the mechanism behind it: blocking on async code until the thread pool starves, Data Protection keys that each instance generated for itself, a navigation property loaded inside a loop.
The plan opens beneath the framework, on [C#](/topics/lang-csharp) and the [.NET runtime](/topics/be-dotnet): the async state machine, the thread pool and the garbage collector come back in nearly every later module, from middleware that must not block to a `DbContext` that lives for one request. Still before any request arrives, the plan then sets up the toolchain: the [startup file](/topics/be-aspnet-core-foundations-program) where services and middleware are registered, the CLI that builds and publishes it, and NuGet for the packages later modules pull in. Hosting & the Pipeline then follows a request from the socket to your code: the server and the proxy in front of it, the [middleware](/topics/be-aspnet-core-middleware) chain whose order decides what each component can see, and [endpoint routing](/topics/be-aspnet-core-routing), which selects the endpoint early so that later middleware, authorization above all, can read its metadata. Handlers arrive in the fourth module. [Minimal APIs](/topics/be-aspnet-core-minimal-apis) and [controllers with Razor Pages](/topics/be-aspnet-core-mvc) come side by side, followed by the [Razor syntax](/topics/fe-razor) their views and pages are written in, where an `@` switches from HTML to C# and output is HTML-encoded unless you opt out. [Binding and validation](/topics/be-aspnet-core-modelbinding) follow both handler styles, because the two bind parameters differently: inference from a handler's signature on one side, model binders and `ModelState` on the other. Error responses and the published API contract finish the endpoint. App Wiring turns back to what the handlers took for granted: where settings come from, and which [lifetime](/topics/be-aspnet-core-di-lifetimes) each injected service lives by. Identity and protection build on both. [Sign-in and permissions](/topics/be-aspnet-core-auth) are middleware plus handlers resolved from the container, and the built-in defenses end with [Data Protection](/topics/be-aspnet-core-security-data-protection), the key ring that authentication cookies and antiforgery tokens depend on. Data starts from the request scope a `DbContext` lives in, gives [EF Core](/topics/be-ef-core) a module of its own, and then puts caches in front of it, [HybridCache](/topics/be-aspnet-core-caching-hybrid) among them, which keeps many requests from rebuilding the same expired entry at once. Then the plan leaves the single request: [downstream calls](/topics/be-aspnet-core-http-clients) with resilience handlers, raw WebSockets and Server-Sent Events ahead of [SignalR](/topics/be-signalr-core) so the abstraction comes after what it abstracts, and work done off the request, from hosted services to Hangfire, with MediatR's in-process dispatch at the module's end. [Blazor](/topics/fe-blazor) follows the real-time work for a reason: its interactive server mode keeps each user's UI state on the server and talks to the browser over a SignalR circuit. Quality & Troubleshooting tests and watches what was built, with [WebApplicationFactory](/topics/be-aspnet-core-testing-integration) booting the real pipeline in memory and [logs, traces and health checks](/topics/be-aspnet-core-logging) beside it. The plan ends in production: Native AOT and the thread pool, the layout of a solution, and [Aspire](/topics/be-dotnet-aspire), which describes the app and everything it depends on as one resource model for local runs and deployment.
Where you come from changes what this plan asks of you. A developer arriving from .NET Framework has the most to unlearn: no `System.Web`, no `Global.asax`, no `web.config` driving the app. For that reader the plan's own sequence is the lesson: pick by topics as the study order, open at Hosting & the Pipeline and keep going through App Wiring. A developer from Spring or Express already knows middleware or dependency injection under other names; the transfer most often breaks at scoped lifetimes, where .NET puts no proxy between a singleton and the scoped service it captured. With the interview this week, let level span only the band the job ad hires at and raise importance until only must know is left; study order can stay on by frequency, where it opens. Of the test frameworks the plan carries, one is enough, the one the team uses, and Blazor, Hangfire and MediatR earn hours only when the posting names them. The language and runtime open this plan because the framework questions stand on them. When the loop also holds a round on C# itself, the [C# roadmap](/roadmaps/csharp) takes the same language in its own order, from the type system to source generators, with the runtime beside each part it explains. A loop with a whiteboard design round needs the [System Design roadmap](/roadmaps/system-design) as well: this plan's architecture module lays out one solution, not a fleet of services.
ASP.NET Core questions usually arrive as the framework part of a .NET backend or full-stack loop, after a round of C# questions, with a system design round added for senior roles. A take-home or live exercise often asks for a small Web API with validation, persistence and a test or two. The conversation is built on the request pipeline and the container. Why does UseAuthorization have to sit after UseRouting? What happens when a singleton takes a scoped DbContext in its constructor, and why does that fail loudly only in Development? Why does an HttpClient created per call exhaust sockets, while one held for the life of the process stops seeing DNS changes?
What moves a candidate up the level range is where the answer starts. Early in a career, the expectation is to place a feature correctly: a filter or a middleware, IOptions or IOptionsMonitor, a tracked query or AsNoTracking. From senior up, the question arrives as an incident: requests queue while the CPU sits idle, users are signed out whenever the load balancer moves them to another instance, a list endpoint issues one query per row. The answer then has to name the mechanism behind it: blocking on async code until the thread pool starves, Data Protection keys that each instance generated for itself, a navigation property loaded inside a loop.
The plan opens beneath the framework, on C# and the .NET runtime: the async state machine, the thread pool and the garbage collector come back in nearly every later module, from middleware that must not block to a DbContext that lives for one request. Still before any request arrives, the plan then sets up the toolchain: the startup file where services and middleware are registered, the CLI that builds and publishes it, and NuGet for the packages later modules pull in. Hosting & the Pipeline then follows a request from the socket to your code: the server and the proxy in front of it, the middleware chain whose order decides what each component can see, and endpoint routing, which selects the endpoint early so that later middleware, authorization above all, can read its metadata.
Handlers arrive in the fourth module. Minimal APIs and controllers with Razor Pages come side by side, followed by the Razor syntax their views and pages are written in, where an @ switches from HTML to C# and output is HTML-encoded unless you opt out. Binding and validation follow both handler styles, because the two bind parameters differently: inference from a handler's signature on one side, model binders and ModelState on the other. Error responses and the published API contract finish the endpoint.
App Wiring turns back to what the handlers took for granted: where settings come from, and which lifetime each injected service lives by. Identity and protection build on both. Sign-in and permissions are middleware plus handlers resolved from the container, and the built-in defenses end with Data Protection, the key ring that authentication cookies and antiforgery tokens depend on.
Data starts from the request scope a DbContext lives in, gives EF Core a module of its own, and then puts caches in front of it, HybridCache among them, which keeps many requests from rebuilding the same expired entry at once. Then the plan leaves the single request: downstream calls with resilience handlers, raw WebSockets and Server-Sent Events ahead of SignalR so the abstraction comes after what it abstracts, and work done off the request, from hosted services to Hangfire, with MediatR's in-process dispatch at the module's end.
Blazor follows the real-time work for a reason: its interactive server mode keeps each user's UI state on the server and talks to the browser over a SignalR circuit. Quality & Troubleshooting tests and watches what was built, with WebApplicationFactory booting the real pipeline in memory and logs, traces and health checks beside it. The plan ends in production: Native AOT and the thread pool, the layout of a solution, and Aspire, which describes the app and everything it depends on as one resource model for local runs and deployment.
Where you come from changes what this plan asks of you. A developer arriving from .NET Framework has the most to unlearn: no System.Web, no Global.asax, no web.config driving the app. For that reader the plan's own sequence is the lesson: pick by topics as the study order, open at Hosting & the Pipeline and keep going through App Wiring. A developer from Spring or Express already knows middleware or dependency injection under other names; the transfer most often breaks at scoped lifetimes, where .NET puts no proxy between a singleton and the scoped service it captured.
With the interview this week, let level span only the band the job ad hires at and raise importance until only must know is left; study order can stay on by frequency, where it opens. Of the test frameworks the plan carries, one is enough, the one the team uses, and Blazor, Hangfire and MediatR earn hours only when the posting names them.
The language and runtime open this plan because the framework questions stand on them. When the loop also holds a round on C# itself, the C# roadmap takes the same language in its own order, from the type system to source generators, with the runtime beside each part it explains. A loop with a whiteboard design round needs the System Design roadmap as well: this plan's architecture module lays out one solution, not a fleet of services.