Open-source SaaS foundation

Ship multi-tenant SaaS faster with a production-ready .NET 10 template

Krafter is a dotnet new template pack combining Vertical Slice Architecture, hybrid Blazor, Aspire, permission-based auth, and an agent-friendly project structure. Pick Split Host for separate API + UI, or Single Host for one combined process — both ship the same feature foundation.

Try the Live Demo View on GitHub Open the quick start
Runtime .NET 10 baseline Blazor Web App, Aspire, EF Core, auth, background jobs, and realtime hooks are already wired.
Hosting Split host or single host Choose separate API and UI projects, or one combined host when deployment needs to stay simple.
License MIT-licensed Use it for client work, internal products, or commercial SaaS without vendor lock-in.
Production starter topology
Krafter architecture preview with AppHost and migrator status
Foundation includes
  • .NET 10
  • Blazor
  • Aspire
  • PostgreSQL / MySQL
  • Refit
  • SignalR
  • TickerQ
  • OpenTelemetry
Platform Value

Krafter starts where serious product work usually gets delayed.

Instead of asking teams to assemble architecture, auth, tenancy, and developer workflow from scratch, it gives them a credible baseline that behaves like a real product.

Vertical slice structure

Feature work is organized by business capability so handlers, routes, validation, and contracts stay easier to trace as the system expands.

Minimal APIsFluentValidationRefit contracts

Tenancy already modeled

Start from a multi-tenant baseline with room to support single-tenant products, isolated behavior, and tenant-aware APIs.

Security baseline included

JWT auth, refresh tokens, Google login, and permission-aware authorization are part of the starter instead of postponed into riskier later work.

Human and agent clarity

Scoped guidance and explicit project boundaries reduce ambiguity for teams using AI-assisted workflows alongside conventional engineering.

Production Backbone

Build faster without starting fragile.

Krafter handles the platform foundation so your team spends time on business logic, product fit, and differentiated workflows instead of rebuilding the same infrastructure on every project.

Delivery Workflow

Start from a system that already behaves like a real product, not a demo shell.

Krafter combines structured backend slices, authentication, and dependable local orchestration so new features land on a foundation that stays understandable as the codebase expands.

Feature Structure

Backend slices that stay readable

Routes, handlers, validation, and contracts follow a consistent VSA flow that keeps review and extension work predictable.

Security Baseline

Authentication already wired

JWT, refresh tokens, Google OAuth, and permission-aware checks are built in instead of pushed into a risky later phase.

Local Startup

Persistence and migrations in flow

AppHost boots the migrator before the API so schema changes and startup sequencing are part of the normal developer path.

startup-flow.krafter
Boot sequence dotnet run --project aspire/AditiKraft.Krafter.Aspire.AppHost/AditiKraft.Krafter.Aspire.AppHost.csproj
krafter-migrator

checked-in migrations applied cleanly

00:02
krafter-api

auth, endpoints, and contracts available

00:04
blazor-ui

serving on https://localhost:7291

00:05
Migration safety Automated
Auth coverage Pre-wired
Startup path Repeatable
System Design

Use a full-stack starter that stays inspectable for humans and reliable for AI-assisted workflows.

Krafter is opinionated enough to accelerate delivery, but explicit enough that teams can still reason about structure, trace behavior, and extend the system without losing confidence.

Typed Flow

Hybrid UI with typed backend access

Blazor UI modes, Refit clients, and shared contracts create a strongly typed path from browser interaction to API behavior.

Observability

Cloud-native defaults included

Aspire and OpenTelemetry are part of the architecture from the start, reducing the need for a later operations rewrite.

Team Clarity

Conventions that help humans and agents

Scoped guidance, explicit feature boundaries, and predictable project structure make AI-assisted work more dependable instead of more chaotic.

system-blueprint.json
Experience
Blazor WASM + Server

Hybrid rendering with typed shared contracts.

Application
Minimal APIs + Refit

Strongly typed boundaries between UI and backend slices.

Platform
Aspire + OpenTelemetry

Operational defaults that scale past localhost.

.NET 10 Minimal APIs Blazor WASM Refit SignalR Redis PostgreSQL Docker NUKE OpenTelemetry
Tech & Operations

A practical modern stack with the operational pieces teams normally add too late.

Krafter is opinionated where it prevents drift and flexible where product teams still need room to adapt domain behavior, infrastructure choices, and delivery pace.

Backend foundation

ASP.NET Core Minimal APIs, EF Core 10 with PostgreSQL or MySQL, FluentValidation, soft delete, and dedicated DbContexts for app data, tenants, and background jobs.

Minimal APIsEF Core 10PostgreSQL / MySQLMulti-context

Hybrid UI stack

Blazor Web App render modes, Radzen components, Refit-based typed HTTP clients, and shared contracts keep the UI strongly connected to backend behavior.

Realtime & background jobs

SignalR for live updates with typed method contracts, plus TickerQ for scheduled and recurring background processing — wired in from day one through their own context.

Operational tooling

Aspire orchestration, OpenTelemetry, health checks, structured logging, Docker support, NUKE build automation, and GitHub Actions workflows are part of the default delivery path.

Credible day-one security

ASP.NET Core Identity, JWT access tokens with refresh, Google OAuth, and a permission-based authorization model give teams a baseline they can extend with less rework.

Delivery Path

From clone to real feature work in five deliberate steps.

The startup path is intentionally short, but still opinionated enough to keep local setup, migrations, and the first extension work aligned with the repo model.

Install the Template Pack

Run dotnet new install AditiKraft.Krafter.Templates once, then scaffold a renamed solution with dotnet new krafter -n MyApp (Split Host) or dotnet new krafter-single -n MyApp (Single Host).

Run the Aspire AppHost

A single dotnet run on the generated AppHost brings up the dashboard, PostgreSQL or MySQL, the migrator, the API, and the Blazor UI in the expected order.

Let the Migrator Finish

Checked-in migrations are applied automatically before the main API starts, so local setup stays aligned with the repo.

Explore the Demo or Log In Locally

Use the seeded admin account or Google login, then inspect the existing flows before shaping the product around your own domain.

Add the Next Feature Using the Guides

Follow the scoped Agents.md instructions to extend contracts, backend slices, UI features, and infrastructure with minimal drift.

Adoption Paths

Pick the starting path that matches how your team evaluates new platforms.

Try the hosted reference, scaffold a renamed solution from the published template pack with the hosting model that fits your team, or work directly from source when you want the full repo model.

Live Demo

Try now
  • Hosted reference at krafter.getkrafter.dev
  • Seeded admin: admin@getkrafter.dev
  • Google login path available
  • Scalar API reference included
Open Demo
Most Flexible

Split Host

dotnet new krafter
  • Separate Backend API + Blazor UI
  • Independent scaling of API and UI
  • Clearer service boundaries
  • Room for additional clients (mobile, CLI)
  • Best when teams own backend and frontend separately
See Quick Start

Single Host

dotnet new krafter-single
  • Combined API + UI in one process
  • Single Aspire resource, simpler deployment
  • Lower operational overhead
  • Same Vertical Slice feature structure
  • Best when one team owns the full stack
See Quick Start

Source

MIT licensed
  • Full repository on GitHub
  • Agents.md guidance included
  • GitHub Actions and container publishing patterns
  • Contribute to the template itself
Browse Source
Quick Start Commands

Install the template pack once, then scaffold the hosting model you want.

Krafter ships as a NuGet template pack. You install it once with dotnet new install, then create as many renamed apps as you need — each with its own namespace, folders, and project files.

Install the template pack dotnet new install AditiKraft.Krafter.Templates
Create a Split Host app dotnet new krafter -n MyApp
Create a Single Host app dotnet new krafter-single -n MyApp
Run the generated AppHost dotnet run --project aspire/MyApp.Aspire.AppHost/MyApp.Aspire.AppHost.csproj
Frequently Asked

Questions teams ask before they commit

Quick answers to the things prospects need clear before they sign up or talk to sales.

How do I start a new app with Krafter?

Krafter is consumed via dotnet new. Install the template pack once with dotnet new install AditiKraft.Krafter.Templates, then scaffold a renamed solution with dotnet new krafter -n MyApp or dotnet new krafter-single -n MyApp. You only clone the GitHub repo if you want to contribute to the template itself.

What is the difference between Split Host and Single Host?

Split Host (dotnet new krafter) keeps the Backend API and Blazor UI as separate processes — clearer service boundaries and independent scaling. Single Host (dotnet new krafter-single) combines API and UI in one process for the simplest deployment and a single Aspire resource. Both share the same Vertical Slice structure and feature code.

Is Krafter free to use?
Yes. Krafter is MIT-licensed and free for commercial and personal use. The source lives on GitHub and the templates ship on NuGet as AditiKraft.Krafter.Templates.
What versions of .NET and Blazor does Krafter target?

Krafter targets .NET 10 and uses Blazor Web App with hybrid render modes (Server + WebAssembly + Auto). It expects modern Aspire-compatible tooling and EF Core 10 with PostgreSQL or MySQL.

Does Krafter support multi-tenancy out of the box?
Yes. Multi-tenancy is modeled at the persistence and API layers from day one through a dedicated TenantDbContext, with hooks for both isolated-database and shared-database tenancy strategies.
How is authentication wired?

JWT access tokens with refresh tokens, Google OAuth, ASP.NET Core Identity, and a permission-aware authorization model are part of the starter. You can swap providers without re-architecting the UI layer.

How are background jobs and realtime handled?

SignalR is wired in for live updates with typed method contracts in the shared Contracts project. TickerQ handles background processing through its own BackgroundJobsContext, so scheduled and recurring work is part of the baseline rather than an afterthought.

Can I try a hosted demo before scaffolding?

Yes. The reference deployment is live at krafter.getkrafter.dev. Sign in with admin@getkrafter.dev / 123Pa$$word! or use Google login to create a fresh account.

Can I use Krafter as a baseline for client work?
Absolutely. The MIT license allows commercial and derivative use. Many teams use Krafter as their internal platform baseline.

Start From a Stronger Baseline

Try the live demo, read the source on GitHub, or jump straight into the quick start.

Try the Live DemoView on GitHubOpen Quick Start

Discuss Your Starter Strategy

Need to evaluate Krafter for a new SaaS product, internal platform baseline, or team adoption path? Reach out and we can help frame the fit.

Location

Kathmandu, Nepal