FAQ | BlazorPlate - A Multi-Tenant SaaS Starting Point Template

Common Questions

Feel like your questions are playing hide and seek? No worries! Dive into the excitement by exploring our FAQ list or feel free to shoot us an email at info@blazorplate.net for all the answers you hunt! Let's unravel the enigmas together!

General Questions

  • BlazorPlate is a project template for startups that utilizes .NET 10 and Blazor WASM to provide developers with commonly used boilerplate code in many .NET projects with minimal customization.
  • Features like authentication, multi-tenancy, authorization, logging, localization, and others frequently appear in almost every .NET project, requiring considerable time and resources.
  • BlazorPlate's primary goal is to aggregate all repetitive code and standard UI pages associated with the aforementioned features into a single, standardized template that developers can use repeatedly in their future projects, significantly reducing development effort and cost.

Yes, BlazorPlate includes the full source code. Upon payment acceptance, BlazorPlate will be available for immediate download. Customers can access the latest releases at any time by logging into our website and navigating to My Orders in their account.

However, it's important to note that the solution incorporates three external free and open-source libraries, referenced as NuGet packages. To maintain efficiency and avoid unnecessary complexities, the complete source code for these libraries is not included in the main solution. Instead, you can obtain the source code of these packages directly from their respective repositories, if needed.

No. BlazorPlate is only available for purchase along with its source code, and there is no trial version available.

If you have any further questions, please don't hesitate to email us at info@blazorplate.net.

Yes, you can! We have several code samples available here. These samples demonstrate the best practices for writing clean code for CRUD functionality for a sample entity, and they can serve as a guide for your own implementation of various entities. These samples will provide you with a thorough and accurate understanding of how BlazorPlate was implemented.

Each module in BlazorPlate's source code ships with multiple dedicated Markdown files — covering an Overview, Configuration Guide, Developer Onboarding, Troubleshooting, and more — providing structured, human-readable documentation right alongside the code. This is complemented by thorough XML and inline comments throughout every class and method, ensuring a deep understanding of each line of code.

Additionally, the source code is self-explanatory and written in a clear and concise style. The code's documentation is fully integrated into the codebase, providing a transparent explanation of the logic behind it.

Once you've completed your purchase, refer to the README.md file in the root directory of your BlazorPlate package for a seamless setup of your local development environment. This document includes detailed instructions on getting started, covering:

  • Configuring Startup Projects: Guidance on setting up the appropriate startup projects.
  • Database Preparation: Steps to create and configure the necessary databases for development and production environments.
  • Managing App Settings: Guidelines for setting up application options and configuring tenant modes and settings in appsettings.json.
  • Performing Migrations: Instructions for handling database migrations in single and multi-tenant environments, including setting up connections for each tenant.
  • Technical FAQs: Answers to key topics such as architectural design, tenant management, data isolation strategies, storage options, access vs. refresh tokens, and tenant modes.

Technical Questions

BinaryPlate uses Clean Architecture, emphasizing separation of concerns and layer independence within the application. This architecture promotes a scalable, organized project structure that is easy to modify. In Clean Architecture, the application is divided into layers, including the Presentation, Application, Domain, and Infrastructure layers.

BlazorPlate's design allows clear separation of concerns, enabling easy modification and testing. Each layer functions independently, allowing changes without affecting other layers. This pattern is especially beneficial for large projects requiring frequent updates.

Additionally, BinaryPlate incorporates architectural features like interfaces and dependency injection, enhancing the application's modularity and maintainability.

Learn more →

Core Layers

Domain Layer

BinaryPlate.Domain

This project contains the core domain logic, including entities, value objects, enumerations, and custom exceptions. It encapsulates business rules and domain-specific behavior.

Application Layer

BinaryPlate.Application

This layer contains commands, queries, validators, and custom exceptions, orchestrating data flow and operations between the domain and infrastructure layers.

BinaryPlate.Shared

This project contains shared classes, DTOs, and enums used across both frontend (Blazor) and backend (API) layers for consistent communication.

Infrastructure Layer

BinaryPlate.Infrastructure

This project includes implementations for external interfaces, including database access, file operations, and external services.

BinaryPlate.Infrastructure.Razor

This project contains Razor-based infrastructure services such as email template rendering using Razor views.

BinaryPlate.AppResources

This project provides static resources and shared assets including images, scripts, and styles.

Presentation Layer

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

This is the host project that provides endpoints for communication via APIs or web services, hosting controllers, SignalR hubs, and static assets.

BinaryPlate.BlazorPlate.Tdap

This project encompasses the Tenant Dedicated/Administration Portals:

  • Tenant Dedicated Portal (TDP): A dedicated platform for tenant subscribers, accessible through a custom sub-domain like tenant01.example.com.
  • Tenant Administration Portal (TAP): A centralized platform managed by Host Administrators for tenant management, accessible at the primary domain, such as example.com.
BinaryPlate.BlazorPlate.Top

This project serves as the Tenant Onboarding Portal (TOP), streamlining the onboarding process through a personalized subdomain URL for easy access to the Tenant Dedicated Portal (TDP).

BlazorPlate supports two development modes targeting different workflows:

  • Aspire Mode: Uses .NET Aspire and Docker to automatically orchestrate all infrastructure dependencies (SQL Server, Redis, mail server, etc.) from a single AppHost project. Best for team consistency and onboarding — no manual infrastructure setup required.
  • Native Mode: Connects directly to locally installed services (e.g., SQL Server on your machine). Offers faster application startup times since infrastructure is already running locally. Best for experienced developers who prefer working with pre-installed services.

You can switch between modes with a single configuration change — the application code is identical in both modes.

Learn more →

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 such as PostgreSQL, MySQL, SQLite, and Oracle. A dedicated PostgreSQL migration guide is available. For a full list of EF Core providers, refer to the official EF Core documentation here. For migration guidance for other providers, reach out to us at info@blazorplate.net.

Learn more →

BlazorPlate implements an L1+L2 hybrid caching strategy via IHybridCachingService. L1 is in-process memory cache (fastest, zero network overhead); L2 is a distributed Redis cache (shared across app instances).

Three named cache profiles are pre-configured for common TTL patterns, so you don't write cache expiry logic from scratch. When Redis is unavailable, the system automatically falls back to the in-memory L1 cache — your application keeps running with no manual intervention or code changes.

Learn more →

BlazorPlate uses Hangfire with SQL Server persistence for durable background job execution. Jobs survive application restarts and are retried automatically on failure.

A two-interface design separates job scheduling (IJobScheduler) from job execution (IJobHandler), keeping concerns clean. Distributed trace context is propagated into every job, so Hangfire jobs appear as child spans in your traces — you get end-to-end visibility from the originating HTTP request through to the background job completion.

Learn more →

BlazorPlate's SignalR integration is tenant-aware from the ground up. Every hub connection is automatically scoped to the tenant resolved from the connection request — clients from different tenants are placed into separate SignalR groups and can never receive each other's messages.

Hub methods use the same permission enforcement system as REST API endpoints: the HubClientBase enforces hub-level and method-level permission checks before dispatching. On the client side, an exponential backoff reconnection strategy ensures graceful recovery from transient network failures.

Learn more →

BlazorPlate ships with OpenTelemetry 1.54.0+ fully wired. Auto-instrumented sources include ASP.NET Core requests, EF Core queries, HttpClient calls, and Hangfire jobs — with zero boilerplate required from your team.

A three-layer filter pipeline strips noise, and a [TraceMethod] attribute enables AOP-style tracing of any service method. PII redaction is applied before spans are exported. Six business metrics (logins, registrations, tenant provisioning, job completions, file uploads, and API error rates) are pre-wired and visible in the Aspire Dashboard or any OTLP-compatible backend.

Learn more →

BlazorPlate's Concurrency Conflict Detection feature handles situations where multiple users attempt to edit or delete the same record concurrently. This ensures data integrity and supports various database systems, offering a smooth experience across different database engines.

BlazorPlate supports OAuth 2.0 social login with four providers: personal Microsoft accounts (@outlook.com / @hotmail.com), Google, LinkedIn, and Twitter/X. Incoming OAuth identities are automatically linked to existing accounts by verified email, so users keep their full history and permissions regardless of which login method they choose.

BinaryPlate uses the following URL configurations:

  • TOP (Tenant Onboarding Portal): https://signup.example.com
  • TDAP (Tenant Dedicated/Administration Portal): https://www.example.com (base domain for TAP) and https://*.example.com (wildcard subdomains for TDP)
  • API Documentation: https://www.example.com/scalar/v1

For TDP wildcard subdomains, replace the wildcard with specific tenant identifiers (e.g., https://xyzcorp.example.com or https://acmecorp.example.com).

Absolutely! BlazorPlate's flexible architecture allows replacing the default MudBlazor component library with alternatives like Infragistics, Syncfusion, or Telerik, as needed. The Blazor framework is versatile, enabling customization to fit specific requirements.

Certainly! The BlazorPlateplatform allows replacing the Blazor client-side project with a JavaScript framework like Angular or React, while still using the existing Web APIs.

BlazorPlate's architecture supports various client-side frameworks, letting developers create applications with their preferred tech stack, while benefiting from BlazorPlate's robust Web APIs provided by the BinaryPlate.Server layer.

No. BlazorPlate is infrastructure agnostic. While it includes Azure Blob Storage as a file storage option, it runs on any environment that supports .NET 10 — AWS, DigitalOcean, on-premise servers, or any container platform. Teams are not locked into a specific cloud provider or hosting platform.

Learn more →

Yes. SQL Server is the default configuration, and a dedicated PostgreSQL migration guide is available, as PostgreSQL is the most commonly requested alternative to SQL Server. Because the data access layer is built on Entity Framework Core, migrating to PostgreSQL is a well-defined workflow involving changing the EF Core provider package, updating the connection string, and running database migrations. For migration guidance for other providers, reach out to us at info@blazorplate.net.

Yes. As a standard .NET 10 application, BlazorPlate is fully compatible with containerized deployment. It can be containerized using standard .NET container publishing workflows and deployed to Docker, Docker Compose, or Kubernetes environments. BlazorPlate already uses .NET Aspire for development orchestration, which runs infrastructure dependencies (SQL Server, Redis, Azure Storage emulator) in containers.

Learn more →

Multitenancy Questions

The Host is the company that owns and manages the SaaS platform, including infrastructure, billing, and customer support. A Tenant is a customer organization that subscribes to the service, with isolated access to their own data, settings, and users.

Real-world example: In TaskSync, TaskSync Inc. is the Host. Companies like Acme Corp and TechStart Inc are Tenants, each managing their own data without seeing the other Tenant's information.

BlazorPlate supports single-tenant and multi-tenant models.

In the single-tenant model, each Tenant operates within its own instance of the software application and database, completely separate from other tenants. This provides each Tenant full control over their instance, but with higher costs and maintenance requirements. Real-world example: A large enterprise like Boeing may use a single-tenant deployment for strict security and extensive customizations.

In the multi-tenant model, multiple Tenants share a single instance of the SaaS application managed by the Host. This reduces costs and simplifies maintenance. Depending on configuration, this could use a shared database for all Tenants or a dedicated database per Tenant. Real-world example: Zendesk serves thousands of organizations (Tenants) through one platform, with each Tenant managing its own support tickets, agents, and knowledge base in isolation.

BlazorPlate ensures each Tenant can access and manipulate only their own data through two strategies: a shared database for all Tenants or a separate database per Tenant. The shared database separates data logically via tenant IDs, while the separate database provides full physical isolation.

Real-world example: In TaskSync, using the shared database, Acme Corp and TechStart Inc store their data in one database but see only their own Tenant data. Using separate databases, each Tenant's data resides in a distinct database, ensuring stronger isolation.

The Tenant Administration Portal (TAP) is managed by the Host to handle tenant account lifecycle, usage metrics, billing, and system monitoring. TAP allows the Host to create, modify, or suspend tenant accounts as needed.

Real-world example: Support agents from TaskSync Inc. (the Host) access TAP to resolve billing issues for Acme Corp, adjust subscriptions, or temporarily suspend accounts for investigation.

The Tenant Dedicated Portal (TDP) is the isolated environment provided by the Host for each Tenant. Tenant Admins manage their organization's users, roles, and data within their TDP, while regular users access features relevant to their roles.

Real-world example: Acme Corp accesses their TDP at https://acmecorp.tasksync.com. Tenant Admin Sarah manages users and project templates, while project manager Tom creates tasks and generates reports. Other Tenants, like TechStart Inc, have their own isolated TDP at https://techstart.tasksync.com.

The Tenant Dedicated/Administration Portal (TDAP) unifies TAP and TDP in one deployment. The same instance serves:

  • The Host interface (TAP) at https://www.example.com
  • Tenant interfaces (TDP) at subdomains https://*.example.com

This ensures cost-efficient infrastructure while maintaining role-based access and data isolation.

The Tenant Onboarding Portal (TOP) allows prospective Tenants to register and receive access to their isolated Tenant Dedicated Portal (TDP). The Host configures TOP to handle tenant account provisioning and subdomain allocation.

Real-world example: Acme Corp signs up at https://signup.tasksync.com, selects a plan, and receives access to https://acmecorp.tasksync.com, their isolated TDP environment.

The Hybrid Multitenancy Model allows each Tenant to select their preferred data isolation strategy during onboarding — either a shared database or a separate database — while the Host manages both options seamlessly.

BlazorPlate achieves hybrid multi-tenancy by deploying two TDP instances with different data isolation strategies and using TOP to let Tenants select their preferred strategy during onboarding, directing them automatically to the appropriate TDP instance.

BlazorPlate uses three complementary tenant resolution mechanisms, applied in order:

  • Header-based: The X-Tenant-Id HTTP header — useful for API clients and inter-service calls.
  • Query string-based: A tenantId query parameter — convenient for link-based access flows.
  • Subdomain-based: DNS label matching (e.g., acmecorp.example.com resolves to the acmecorp tenant) — the primary mechanism for browser-based portals.

During local development, subdomain resolution can be emulated using the system hosts file — no DNS changes required. Once resolved, the tenant identity is placed into the request's DI scope and is available everywhere via injection — you never need to pass a tenant ID manually through your service layer.

Purchasing Questions

Our website accepts PayPal as a payment method. With PayPal, you can make payments in over 200 countries using Visa, MasterCard, or American Express.

We also accept Bank Wire, MoneyGram, and Western Union. For these options, the payment information will be provided on the checkout page.

Upon successful payment, you can download BlazorPlate immediately through your browser.

You will also receive an Order Confirmation email, and the source code will remain accessible in the Downloads section of your BlazorPlate account for future reference.

Yes, with each BlazorPlate purchase, a detailed tax invoice is sent automatically to the email you provided during checkout. The invoice includes essential purchase details, such as Billing Information

Our Employer Identification Number (EIN), 810747219, is also listed on the invoice as our U.S. tax identifier.

Your Tax ID: For businesses registered for tax purposes, please provide your Tax ID during checkout. This enables us to include it on your invoice, which is essential for tax exemptions or tax-related documentation. If no Tax ID is provided, the invoice will not include a tax reference.

You can also access a copy of your invoice in the My Orders section of your BlazorPlate account for future reference or to download and print as needed.

Yes, you can upgrade from the Professional Edition to the SaaS Edition at any time. Simply go to your account, select the Upgrade option for your current license, and complete the process. The system will handle the upgrade, and any cost adjustments will be applied during checkout.

The upgrade cost from BlazorPlate Professional Edition to BlazorPlate SaaS Edition is the difference between the current price of BlazorPlate SaaS Edition and the original purchase price of BlazorPlate Professional Edition. This will be calculated automatically at checkout.

Licensing Questions

BlazorPlate is offered under two primary license categories: the Individual License and the Organization License.
  • The Individual License is designed for a single developer, allowing personal and commercial use with a combined annual gross revenue limit of $250,000 for all projects created with BlazorPlate.
  • The Organization License is designed for businesses and allows multiple developers to use BlazorPlate for internal projects without any revenue restrictions, making it suitable for larger teams and commercial endeavors.
Both licenses allow you to build and deploy an unlimited number of BlazorPlate projects, ensuring flexibility and scalability for any size of operation.
The Individual License is tailored for individual developers, providing full access to BlazorPlate for personal and commercial use, subject to a revenue cap. Developers are permitted to generate up to $250,000 in annual gross revenue from all projects combined. If this revenue cap is exceeded, an upgrade to the Organization License is required to continue development under the same terms.
  • The Individual License grants the ability to develop and deploy unlimited projects using BlazorPlate.
  • The license is designed for individual use, with a revenue threshold that ensures scalability without compromising the developer's ability to generate revenue.
  • If the total revenue from all projects exceeds the set limit, an upgrade to the Organization License is necessary for continued commercial use without restrictions.
The Organization License is ideal for teams and businesses, granting unlimited developer seats within the organization. This license covers internal business operations and allows for unlimited deployments of projects developed with BlazorPlate. There are no revenue restrictions for commercial projects, making it suitable for enterprises pursuing expansive growth or working with multiple clients.
  • Unlimited developers within the organization can access and utilize BlazorPlate for internal and client-facing projects.
  • There are no restrictions on revenue generation from projects developed under the Organization License.
  • The license also allows for unlimited deployments of any number of projects built using BlazorPlate.

Yes. You can switch between license types at any time. There is no additional cost to switch license Editions.

Switching is handled from our end. Please contact us at info@blazorplate.net to initiate the process.

See available license Editions →

Maintenance & Technical Support Plans

The Annual Maintenance Plan provides annual access to the latest updates and releases, ensuring your software stays current with new features and security patches. The Ongoing Technical Support Plan provides lifetime support for technical issues, even after the Maintenance Plan expires. These plans ensure that Licensees have continuous access to both software improvements and dedicated support.

Maintenance Plan

Under BlazorPlate's SLA-based maintenance plan, Licensees receive one year of updates and releases. This plan provides access to the latest features, security patches, and enhancements. Updates are available through the User Account Portal, and major releases are communicated by email.

After your Maintenance Plan expires, you will retain access to the latest version released during your subscription period, but you will no longer receive new updates or features. Technical support remains available for issues with the last version obtained.

You can renew your Annual Maintenance Plan directly through your account portal at any time — no need to contact us. The renewal is processed automatically through the same checkout flow used for your original purchase.

The renewal cost is 50% of the current license price, with any active discounts applied.

Technical Support Plan

The SLA-based Ongoing Technical Support Plan includes lifetime technical support via email, Discord, and WhatsApp. Licensees can submit unlimited support requests without additional charges, covering inquiries, installation help, configuration, and troubleshooting.

Technical support requests can be submitted via:

Our support team provides assistance during business hours for live chat and 24/7 for email inquiries.

Response times are based on the severity of the issue:

  • Critical Issues: Response within 1 hour
  • High Priority Issues: Response within 4 hours
  • Medium Priority Issues: Response within 1 business day
  • Low Priority Issues: Response within 2 business days