BlazorPlate is a comprehensive solution for .NET projects that utilizes .NET 10 and Blazor WASM. It offers pre-built boilerplate code with minimal customization required, catering to the needs of startups aiming to minimize development costs and efforts. By providing a well-structured and organized foundation, BlazorPlate enables startups to focus on building their business rather than the code. BlazorPlate's code ensures future modifications are more straightforward, reducing development time.
BlazorPlate's Clean Architecture is a developer-friendly solution that utilizes an organized and scalable project structure. The architecture is designed with various layers, including Presentation, Application, Domain, and Infrastructure, which promote modularity, maintainability, and separation of concerns.
Key features of BlazorPlate's Clean Architecture include:
BinaryPlate.Domain — Contains core domain entities representing business data and rules, independent of any external frameworks.BinaryPlate.Application — Contains commands, queries, validators, and custom exceptions, orchestrating data flow and operations between the domain and infrastructure layers.BinaryPlate.Shared — Contains shared classes, DTOs, and enums used across both frontend (Blazor) and backend (API) layers for consistent communication.BinaryPlate.Infrastructure — Includes implementations for external interfaces, including database access, file operations, and external services.BinaryPlate.Infrastructure.Razor — Contains Razor-based infrastructure services such as email template rendering using Razor views.BinaryPlate.AppResources — Provides static resources and shared assets including images, scripts, and styles.Aspire — The .NET Aspire AppHost project that orchestrates all infrastructure dependencies (SQL Server, Redis, mail server, etc.) for containerized development via Aspire Mode.BinaryPlate.Server — The host project that provides endpoints for communication via APIs or web services, hosting controllers, SignalR hubs, and static assets.BinaryPlate.BlazorPlate.Tdap — Encompasses the Tenant Dedicated Portal (TDP) accessible through custom sub-domains, and the Tenant Administration Portal (TAP) for host administrators at the primary domain.BinaryPlate.BlazorPlate.Top — The Tenant Onboarding Portal (TOP), a public-facing Blazor WebAssembly app for tenant registration, subscription, and initial onboarding.BlazorPlate supports two first-class development modes for different workflow needs:
Switching between modes is a single configuration change; the application code, database schema, and all feature implementations are identical in both modes.
BlazorPlate is fully operational from first launch:
BlazorPlate provides layer-appropriate HTTP context access patterns that preserve architectural boundaries:
BlazorPlate's API response wrapper and exception handling feature provide developers with a comprehensive solution for streamlining API consumption. This feature offers a unified API response structure, which simplifies development processes and eliminates inconsistencies in API responses.
BlazorPlate provides a testable, request-stable time abstraction throughout the application:
BlazorPlate's development team has completely redesigned ASP.NET Identity to offer an unparalleled user authentication experience. The revamped version utilizes Blazor-based components instead of traditional razor pages, simplifying the authentication process for businesses.
BlazorPlate's ASP.NET Identity includes crucial features such as Two-Factor Authentication, sign-in, sign-up, password reset, and account activation via email confirmation. These features ensure reliable and secure user authentication. With BlazorPlate's customized ASP.NET Identity, businesses can quickly create a secure and reliable user authentication system, allowing them to focus on developing their core business functionalities.
BlazorPlate introduces robust Two-Factor Authentication (2FA), an identity and access management security method that requires two forms of identification to access resources and data. With 2FA enabled, users are required to verify their identity using two distinct authentication methods:
By requiring both a username/password combination and a one-time passcode from an authenticator app, BlazorPlate significantly enhances protection against unauthorized access, strengthening overall account security and safeguarding sensitive resources and data.
BlazorPlate uses a two-token authentication strategy combining short-lived JWTs with secure HttpOnly refresh cookies:
BlazorPlate offers a robust Access Token Lifespan Management feature to ensure secure and reliable application access:
Experience the power of BlazorPlate with the capability to integrate with an extensive range of external OAuth authentication providers. From well-known platforms such as Outlook, Gmail, Twitter, and LinkedIn to many others, effortlessly empower your users with external login options. This feature enables users to sign in to your platform using their personal or work emails via secure OAuth 2.0 flows, ensuring a smooth and efficient authentication process.
BlazorPlate supports OAuth 2.0 social login with four providers, all sharing the same ASP.NET Core external login pipeline:
BlazorPlate offers a simple and streamlined way to manage user authentication and authorization. With BlazorPlate's built-in user management system, developers can easily manage users and roles, grant access to resources, and implement robust security measures. Developers can use BlazorPlate's permission-based authorization to control user access to application resources, preventing unauthorized access and data breaches.
BlazorPlate also allows for the customization of various user settings, including sign-in, password policy, and lockout settings, to meet specific security requirements.
Authorization is crucial for securing client requests for data access in Web APIs. However, the built-in authorization filter in .NET Web API projects can be challenging to manage, as it requires hardcoding which users or roles can access newly added APIs or actions.
BlazorPlate's innovative Dynamic API Authorization addresses this challenge by automatically scanning the system APIs and their actions for potential permissions during application startup. It saves the permissions in the database's permission table, and any new API or action changes are synced by restarting the application.
This approach combines Role-Based Access Control (RBAC) with Claims-Based Access Control (CBAC), allowing system administrators to grant or revoke fine-grained permissions from users or roles directly through the administration GUI panel. RBAC governs access through role assignments, while CBAC enables dynamic, claim-driven authorization policies for more granular control. This eliminates the need for hardcoding access rules using the built-in AuthorizeAttribute filter, providing a more flexible and maintainable approach.
BlazorPlate's latest enhancement introduces an advanced Identity Impersonation feature. This allows administrators to log in as other users, enabling them to experience and address user-specific issues more effectively. With this feature, admins can start and stop impersonation sessions with ease, providing a direct view of the user experience and facilitating more efficient support and troubleshooting.
The Identity Impersonation feature improves the ability to diagnose problems and deliver targeted assistance by allowing administrators to simulate user sessions. This capability ensures that administrators can accurately replicate and resolve issues while maintaining robust security measures.
By streamlining the management of user accounts and enhancing administrative efficiency, this feature contributes to better overall service quality. It allows for quicker issue resolution and improves the support experience for users.
BlazorPlate supports multiple deployment topologies to fit different business and infrastructure needs:
BlazorPlate organizes its multi-tenant portals into two complementary deployments, both running from a single shared codebase:
https://www.example.com). Host Admins manage the full tenant lifecycle from here.https://acmecorp.example.com). Each tenant's users and data remain fully isolated from all others.The Tenant Administration Portal (TAP) provides Host Admin Controls for centralized tenant account management. It efficiently handles the full tenant lifecycle from a single interface:
The Tenant Dedicated Portal (TDP) is the isolated environment provided by the Host for each tenant, served at the tenant's own subdomain (e.g., https://acmecorp.example.com). It is part of the TDAP deployment alongside TAP:
BlazorPlate's Tenant Onboarding Portal (TOP) serves as the crucial entry point for your SaaS customers. It enables self-service tenant registration and onboarding, ensuring a smooth transition to their dedicated portal:
my-business-name.saas.com.BlazorPlate automatically identifies and resolves the active tenant from each incoming request without any developer intervention:
tenant-name.saas.com; Kestrel wildcard binding is pre-configured for local development too.Tenant-aware data access control guarantees that users can only reach resources belonging to their own tenant. Multi-tenant CORS policy support ensures browser security across subdomain boundaries.
BlazorPlate provides enhanced security for tenant data privacy through robust data isolation, ensuring that each tenant can only access and manipulate their own data. Two isolation strategies are supported out of the box:
Per-tenant data isolation is enforced automatically via EF Core global query filters, with no manual scoping needed in application code. Dynamic database routing based on tenant context handles connection switching transparently.
BlazorPlate uses Entity Framework Core 10 with a strategy-based initialization pipeline:
With BlazorPlate, you can enjoy seamless management of database commands thanks to its atomic transaction processing. This feature allows for the efficient handling of multiple database commands in a single batch, eliminating any data inconsistencies.
BlazorPlate empowers you with the Concurrency Conflict Handler, an indispensable feature that expertly manages concurrent editing scenarios. When multiple users attempt to edit or delete the same record simultaneously, this powerful mechanism steps in to ensure data integrity and prevent any accidental data loss.
BlazorPlate ships a production-ready hybrid caching layer via IHybridCachingService, combining two levels of cache for optimal performance:
BlazorPlate uses Hangfire for reliable, durable background job processing:
IJobScheduler handles enqueueing and scheduling; IJobHandler handles execution. Clean separation keeps your application code decoupled from the job infrastructure.BlazorPlate is a comprehensive platform designed to streamline SaaS development processes, which includes an efficient and secure file storage management system. This feature stands out with its ability to switch seamlessly between On-Premise and Azure Storage options, providing the best of both worlds.
BlazorPlate ships a complete email delivery system with two delivery strategies:
IEmailStrategyFactory selects the delivery strategy at runtime based on application settings, with no code changes needed to switch modes.BlazorPlate includes a scaffolded SMS notification layer ready for provider integration:
BlazorPlate's SignalR integration is tenant-aware and permission-enforced from the ground up:
BlazorPlate ships a production-ready PDF generation pipeline:
Pending → InProgress → Completed | Failed states, persisted to SQL Server.BlazorPlate ships with SQL Server as the default database. Because the data access layer is built on Entity Framework Core, teams can migrate to other relational database engines without restructuring the application architecture:
Migration guidance for additional database providers can be made available upon request. Contact us at info@blazorplate.net.
BlazorPlate ships with OpenTelemetry 1.54.0+ fully pre-configured, providing end-to-end journey tracing out of the box. When a request enters the system, a distributed trace is created and propagated automatically across APIs, services, databases, and background workers. For example, when a user places an order:
Trace: Place Order Request
├─ Span: HTTP Request (Order API)
│ ├─ Span: SQL Query (EF Core)
│ └─ Span: Send Email (Notification)
├─ Span: Worker Processing (Hangfire)
└─ Span: Generate PDF ReportBlazorPlate eliminates the typical complexity of achieving fully connected traces by pre-configuring trace context propagation across all instrumented sources:
[Trace] to automatically tag its span with that value via MediatRTracingBehavior, with no manual span enrichment needed. Five trace modes control how values are captured: Primitive (scalars and enums, lowest cost), Summary (collections recorded as count only, avoids large payloads), Json (serializes small DTOs, configurable via MaxJsonLength), Redacted (PII-safe: value is transformed by a redaction strategy before the span tag is written), and StructuredLog (emits a full structured log entry alongside the span, highest cost, suited for audit events). Four redaction strategies are available: Full (replaces the entire value with [REDACTED]), Hash (SHA-256 fingerprint for correlation without exposure), Mask (preserves first and last characters, e.g. jo***om), and Partial (keeps a configurable number of leading characters). Example: [Trace(TraceMode.Redacted, RedactionStrategy.Mask, redactionReason: "PII-Email")] on an Email property writes argument.request.Email = "jo***om" to the span.[TraceMethod] to automatically create a child span, with no manual Activity creation needed. When traceArguments: true is set, method arguments are captured as span tags and any PII properties annotated with [TraceProperty(TraceMode.Redacted, ...)] are automatically redacted before the span tag is written.BlazorPlate's logging configuration adapts automatically to the deployment environment:
No manual configuration switching needed; the correct format is selected based on the ASPNETCORE_ENVIRONMENT value.
BlazorPlate exposes health check endpoints covering the full infrastructure dependency chain:
/health/live endpoint confirms the process is running and accepting traffic.BlazorPlate is built on MudBlazor, the top-rated Blazor Components UI Framework. MudBlazor is an open-source project that provides a wide range of versatile and responsive UI components designed with Material Design.
BlazorPlate's integration with MudBlazor allows developers to enhance their web application's appearance and user experience while streamlining their development process.
BlazorPlate uses a three-layer settings architecture that gives operators full runtime control without redeployment:
appsettings.json, serving as the base layer for static configuration.BlazorPlate enables dynamic localization of UI elements, ensuring a tailored experience based on user language preferences:
BlazorPlate proudly introduces LingoTextField, a groundbreaking component revolutionizing your app with dynamic, adaptive translations. Bid farewell to static data headaches and the complexity of managing multiple translation tables. LingoTextField simplifies your workflow by consolidating all translations into a single, streamlined table.