Best .NET and Blazor Boilerplates 2026

Q: When to Use Which?

Choose Clean Architecture Template when your team values architectural discipline and plans to add SaaS features (billing, tenancy) incrementally. The CQRS foundation scales well for complex domains. Strong fit for teams already familiar with MediatR and Clean Architecture patterns. Choose ABP Framework when you need multi-tenancy, audit logging, and enterprise module ecosystem from day one. The commercial tier is worth evaluating for B2B SaaS where the pre-built modules (identity, permissions,

TL;DR

The .NET and Blazor boilerplate ecosystem in 2026 is production-grade and enterprise-ready. Clean Architecture Template (Jason Taylor) is the strongest architectural foundation for CQRS-based applications. ABP Framework dominates enterprise multi-tenant SaaS. Blazor Hero delivers a full admin dashboard in C# with zero JavaScript. For teams that want official scaffolding without third-party opinions, the dotnet new templates remain the cleanest starting point, while fullstackhero and CodeDesignPlus fill the gap between minimal scaffolds and full-blown frameworks.

Quick Comparison

Starter	Price	Auth	Billing	UI Framework	Best For
Clean Architecture Template	Free	ASP.NET Identity	❌	Razor / Angular	CQRS architecture foundation
ABP Framework	Free / Commercial	Full (Identity + OAuth)	Module (paid)	Blazor / MVC / Angular	Enterprise multi-tenant SaaS
Blazor Hero	Free	ASP.NET Identity	❌	MudBlazor	Admin dashboards in C#
dotnet new templates	Free	Optional Identity	❌	Blazor / Razor	Official minimal scaffold
fullstackhero	Free	ASP.NET Identity + JWT	❌	Blazor (WASM)	Full-stack .NET starter
CodeDesignPlus Starter	Free	Identity + OAuth2	❌	Blazor / API-first	Microservices architecture

The Starters

Clean Architecture Template — Best Architectural Foundation

Price: Free | Creator: Jason Taylor | GitHub Stars: 16k+

Jason Taylor's Clean Architecture Template is the most-starred .NET project template for a reason: it translates Clean Architecture principles into an enforceable project structure with real tooling behind it. The template scaffolds four layers (Domain, Application, Infrastructure, Web) with CQRS via MediatR, validation via FluentValidation, persistence via Entity Framework Core, and API documentation via OpenAPI.

The separation is strict. Domain contains entities, value objects, and domain events with zero external dependencies. Application defines commands, queries, DTOs, and interfaces. Infrastructure implements those interfaces with EF Core, external service clients, and background jobs. Web exposes ASP.NET Core controllers and middleware. The dependency rule is enforced at the project reference level: inner layers never reference outer layers.

dotnet new install Clean.Architecture.Solution.Template
dotnet new ca-sln --name MyProject

The template includes ASP.NET Identity for authentication, but no billing integration, no multi-tenancy, and no admin UI. That is intentional. It gives you architectural guardrails and lets you build business features on a tested foundation. Teams that need multi-tenancy or Stripe billing add those to the Infrastructure layer without fighting the template's opinions.

Best for: Teams that value architectural discipline and want a CQRS foundation to build on. Particularly strong for complex domains where business logic justifies the command/query ceremony.

ABP Framework — Best Enterprise Multi-Tenant SaaS

Price: Free (open source) / Commercial (pro modules from $799/yr) | Creator: Volosoft | GitHub Stars: 13k+

ABP Framework is the most complete .NET SaaS framework available, and it is not close. Multi-tenancy with three database isolation strategies (database-per-tenant, schema-per-tenant, shared database), 40+ application modules (Identity, CMS, File Management, Chat, Payment, Audit Logging), DDD patterns baked into the architecture, and Blazor UI support alongside MVC and Angular frontends.

The open-source tier includes multi-tenancy, identity, permission management, audit logging, and the module system. The commercial tier (ABP Suite) adds a code generator, premium modules (SaaS billing, chat, file management), and a LeptonX theme with polished admin UI. For enterprise teams, the commercial tier pays for itself in the first sprint by eliminating weeks of plumbing work.

dotnet tool install -g Volo.Abp.Studio.Cli
abp new MySaas -t app -u blazor -d ef -dbms PostgreSQL

ABP's Blazor UI option generates a complete admin dashboard using Blazorise components with tenant switching, user management, role permissions, and audit log views. The framework handles tenant resolution from subdomain, header, or query string automatically — your application code reads ICurrentTenant and ABP's global query filters scope every EF Core query to the active tenant.

The tradeoff is complexity. ABP applications have more abstractions than standard ASP.NET Core projects — application services, DTOs, AutoMapper profiles, domain services, repository interfaces. Plan for 2-4 weeks of ABP-specific onboarding before a team is productive.

Best for: Enterprise B2B SaaS that needs multi-tenancy, audit logging, and modular architecture from day one. Organizations with compliance requirements (SOC 2, HIPAA) benefit from ABP's built-in audit trail.

Blazor Hero — Best Admin Dashboard Starter

Price: Free | Creator: Mukesh Murugan | GitHub Stars: 3.4k+

Blazor Hero is a Clean Architecture starter built specifically for admin dashboards using Blazor Server and MudBlazor components. It ships with ASP.NET Identity authentication, role-based authorization, user/role management UI, a document management module, entity audit trails, and dark/light theme switching — all in C# with no JavaScript.

The MudBlazor component library provides Material Design components (data tables, dialogs, forms, charts, navigation) that render server-side via SignalR. For teams building internal tools, B2B admin panels, or back-office applications, Blazor Hero eliminates the need for a separate frontend framework entirely.

@page "/dashboard"
@attribute [Authorize]
@inject IDashboardService DashboardService

<MudGrid>
    <MudItem xs="12" sm="6" md="3">
        <MudPaper Class="pa-4">
            <MudText Typo="Typo.h6">@stats.TotalUsers</MudText>
            <MudText Typo="Typo.body2">Total Users</MudText>
        </MudPaper>
    </MudItem>
</MudGrid>

Blazor Hero uses the same Clean Architecture layering as Jason Taylor's template but adds a complete Blazor UI layer on top. The codebase demonstrates how to structure a real Blazor application with shared state, SignalR communication, and component composition — patterns that are harder to learn from documentation alone.

Best for: Internal admin tools, B2B dashboards, and back-office apps where the team wants full-stack C# without maintaining a JavaScript frontend. Strong choice for .NET shops building internal tooling.

dotnet new Templates — Best Official Starting Point

Price: Free | Creator: Microsoft | Included with .NET SDK

The official dotnet new templates ship with every .NET SDK installation and provide the most minimal, unopinionated starting points for ASP.NET Core and Blazor applications. In .NET 9, the Blazor templates have been consolidated into a unified model that supports both Server and WebAssembly rendering from a single project.

# Blazor Web App (Server + WASM hybrid)
dotnet new blazor --name MyApp --interactivity Auto

# ASP.NET Core Web API (minimal APIs)
dotnet new webapi --name MyApi --use-minimal-apis

# ASP.NET Core with Identity
dotnet new webapp --name MyApp --auth Individual

The blazor template with --interactivity Auto creates a project that renders on the server initially (fast first paint) and switches to WebAssembly after the runtime downloads. This hybrid model gives you the best of both Blazor rendering modes without choosing upfront. The template includes a sample Weather page demonstrating streaming rendering and component interactivity.

The webapi template with --use-minimal-apis scaffolds the modern .NET minimal API pattern — endpoint definitions in Program.cs without controllers, closer to Express or Fastify in style than traditional ASP.NET MVC.

There is no authentication, no billing, no admin panel, and no architectural opinions beyond what Microsoft considers default. That is the point. The official templates are the correct starting point when you have strong opinions about architecture and want to compose your own stack without removing someone else's choices first.

Best for: Experienced .NET developers who want a clean slate. Teams evaluating Blazor's rendering models (Server, WASM, Auto) before committing to a more opinionated starter.

fullstackhero — Best Full-Stack .NET Starter

Price: Free | Creator: Mukesh Murugan (fullstackhero) | GitHub Stars: 4.5k+

fullstackhero's .NET Starter Kit is a production-oriented Clean Architecture template with a Blazor WebAssembly frontend, ASP.NET Core Web API backend, multi-tenancy, and JWT + ASP.NET Identity authentication. It bridges the gap between Jason Taylor's minimal architectural template and ABP's enterprise framework.

The kit includes: multi-tenant support with shared database (tenant ID filtering), JWT authentication with refresh tokens, role-based authorization with permission management, Entity Framework Core with PostgreSQL, Hangfire for background jobs, FluentValidation, Serilog structured logging, and Docker support. The Blazor WASM frontend provides a MudBlazor-based admin dashboard.

├── src/
│   ├── Core/              # Domain + Application layers
│   ├── Infrastructure/    # EF Core, Identity, Background Jobs
│   ├── Host/              # ASP.NET Core Web API host
│   └── Client/            # Blazor WebAssembly frontend

fullstackhero positions itself between "scaffold it yourself" and "buy a framework." You get multi-tenancy and auth without ABP's module system complexity. The codebase is readable enough to modify directly — unlike ABP where you work within the framework's extension points, fullstackhero's code is yours to change.

Best for: Teams that want Clean Architecture with multi-tenancy and a Blazor frontend but find ABP too heavy. Solo developers and small teams building B2B SaaS who want to ship fast without enterprise framework overhead.

CodeDesignPlus Starter Kit — Best Microservices Foundation

Price: Free | Creator: CodeDesignPlus | GitHub Stars: Growing

CodeDesignPlus provides a .NET starter kit oriented toward microservices and event-driven architecture. Built on ASP.NET Core with Clean Architecture principles, it emphasizes domain-driven design, CQRS with MediatR, and event bus integration for inter-service communication.

The kit scaffolds individual microservices with: ASP.NET Core Web API, Entity Framework Core, Identity Server / OAuth2 authentication, RabbitMQ or Kafka event bus, Docker and Docker Compose for local development, and Kubernetes deployment manifests. Each service follows the same Clean Architecture structure, making the codebase consistent across a microservices fleet.

# Scaffold a new microservice
dotnet new codedesignplus-microservice --name OrderService

The event-driven patterns distinguish CodeDesignPlus from other .NET starters. Domain events published within a service propagate to other services via the event bus, enabling eventual consistency patterns that ABP handles within a monolith but CodeDesignPlus distributes across service boundaries.

Best for: Teams building distributed .NET systems with multiple microservices. Organizations planning a microservices architecture from the start who want consistent service scaffolding and built-in event bus patterns.

Blazor Rendering Models in 2026

The Blazor rendering model choice affects which boilerplate fits your project. .NET 9 consolidates the three modes into a unified framework:

Blazor Server renders components on the server and sends UI updates over a persistent SignalR connection. Fast initial load, no WASM download, but every user interaction requires a server roundtrip. Best for internal tools and intranets where latency is low and concurrent user counts are manageable. Blazor Hero uses this model.

Blazor WebAssembly runs .NET code in the browser via WASM. No server connection needed after initial load, but the first load downloads the .NET runtime (~2-5MB). Best for public-facing apps where offline support or CDN-only hosting matters. fullstackhero uses this model.

Blazor Auto (new in .NET 8+, refined in .NET 9) starts with Server rendering for fast first paint and switches to WASM after the runtime downloads in the background. The official dotnet new blazor template defaults to this model. Best for applications that need both fast initial load and rich client-side interactivity.

For SaaS applications with authenticated dashboards, Blazor Server or Auto is typically the right choice — the SignalR connection is already established for an authenticated session, and server rendering avoids exposing API tokens to the browser.

When to Use Which

Choose Clean Architecture Template when your team values architectural discipline and plans to add SaaS features (billing, tenancy) incrementally. The CQRS foundation scales well for complex domains. Strong fit for teams already familiar with MediatR and Clean Architecture patterns.

Choose ABP Framework when you need multi-tenancy, audit logging, and enterprise module ecosystem from day one. The commercial tier is worth evaluating for B2B SaaS where the pre-built modules (identity, permissions, file management, payment) save weeks of development. Accept the learning curve as an investment.

Choose Blazor Hero when building admin dashboards, internal tools, or back-office applications where the entire team writes C#. The MudBlazor component library covers most admin UI patterns. Not the right choice for consumer-facing applications where bundle size and SEO matter.

Choose dotnet new templates when you want Microsoft's official scaffold with no third-party dependencies. Best for teams evaluating Blazor rendering modes, prototyping, or building on a clean foundation with strong opinions about what belongs in the stack.

Choose fullstackhero when you want Clean Architecture with multi-tenancy and Blazor WASM but find ABP too complex. The middle ground between minimal templates and full frameworks. Good for small teams and solo developers building B2B SaaS.

Choose CodeDesignPlus when your architecture is microservices-first. The event bus integration and per-service scaffolding differentiate it from monolith-oriented starters. Best for teams with experience running distributed systems.

For backend framework comparisons beyond .NET, see our guides on best Spring Boot boilerplates 2026 (the JVM equivalent), best Django boilerplates 2026 (Python's enterprise web framework), and best Laravel boilerplates 2026 (PHP's dominant SaaS ecosystem). If you are evaluating .NET against Go for high-throughput services, see best Go web boilerplates 2026.

Browse all .NET and Blazor starters in the StarterPick boilerplate directory.

Methodology

This comparison reflects evaluation of each template's source code, project structure, documentation, and community activity as of April 2026. ABP Framework evaluation covers the open-source tier and commercial module documentation. Performance claims reference TechEmpower Framework Benchmarks and Microsoft's published ASP.NET Core benchmarks. Blazor rendering model descriptions are based on .NET 9 GA documentation. All recommendations reflect the state of the .NET boilerplate ecosystem in early 2026.

The SaaS Boilerplate Matrix (Free PDF)