Blazor from Scratch: A New Series

I’ve been writing about Blazor for a while now — component lifecycles, isolated CSS, interactivity models, authentication. These posts have been useful on their own, but I’ve always felt they were missing a foundation. They assume you already know what Blazor is, why it exists, and how it fits into the broader .NET ecosystem. Not everyone does, and that’s completely fine.

So I’m starting something new: Blazor from Scratch. A proper series, built from the ground up, aimed at developers who want to actually understand what they’re building — not just copy-paste their way through it.

Who This Series Is For

This series is for you if:

• You’re a .NET developer who’s heard of Blazor but never had the time or right starting point to dig in.
• You’ve tried Blazor, got it working, but feel like you’re guessing at why things work.
• You come from a JavaScript/React/Angular background and want to understand what Microsoft’s answer to the modern frontend looks like.
• You want a single, coherent resource rather than scattered docs and blog posts.

You don’t need to be a senior developer. You do need to be comfortable with C# basics — classes, interfaces, async/await. If you can write a simple CRUD API in ASP.NET Core, you’re ready.

What We’ll Cover

Here’s a rough roadmap of what I have planned. Some of these will expand into multiple posts as needed:

1. What is Blazor? — Hosting models, history, how it compares to traditional web dev
2. Your first Blazor app — Scaffolding, project structure, running locally
3. Components — The building block of every Blazor UI
4. Data binding and events — Making your UI reactive
5. Component communication — Parameters, EventCallbacks, cascading values
6. Routing and navigation — How Blazor handles URLs and page transitions
7. Dependency injection — Services, scopes, and the DI container in Blazor
8. Forms and validation — EditForm, DataAnnotations, custom validators
9. HTTP and external data — Calling APIs from your Blazor app
10. Authentication and authorization — Securing your app the right way
11. JavaScript interop — When you need to reach into the browser
12. Performance and optimization — Virtualization, lazy loading, render strategies
13. Testing Blazor components — bUnit and what a solid test looks like
14. Deployment — Publishing to Azure, IIS, and static hosts

This list will evolve. Some topics will get split into multiple posts; others might merge. I’ll update this post as the series grows and add links to each entry as they publish.

Why a Series, Why Now

Blazor has matured a lot. With .NET 8 and 9, the rendering model was significantly overhauled — static SSR, streaming rendering, interactive Server, interactive WebAssembly, and Auto mode all live under the same roof now. It’s a genuinely interesting and capable framework, but the jump in complexity means the “getting started” experience can be disorienting.

I want to build a resource that meets you where you are and walks you through the whole thing systematically. Not a replacement for the official docs — those are good and you should read them — but a companion that explains the why behind the what.

How to Follow Along

Each post in the series will be self-contained enough to read on its own, but they’ll also build on each other. If you’re starting fresh, I recommend going in order. If you’re jumping in to fill a specific gap, that’s fine too — I’ll link to prerequisite posts where they matter.

The code for each post will be available on GitHub. I’ll share links as we go.

See you in the next one.