Open-source SaaS foundation

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

Krafter combines Vertical Slice Architecture, Hybrid Blazor, Aspire orchestration, permission-based auth, and agent-friendly project structure so you can spend time on product features instead of startup plumbing.

Open Quick Start View on GitHub
Foundation includes
Krafter architecture preview with AppHost and migrator status
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 can spend time on business logic, product fit, and differentiated workflows instead of rebuilding the same infrastructure repeatedly.

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, validation, realtime capabilities, and explicit feature boundaries form the default delivery model.

Minimal APIsSignalRExplicit contracts

Hybrid UI stack

Blazor render modes, Radzen components, local state, and typed shared contracts keep the UI strongly connected to backend behavior.

Operational tooling

Aspire orchestration, OpenTelemetry, container support, and build automation are part of the default path rather than optional cleanup work.

Credible day-one security

JWT auth, refresh tokens, Google OAuth, and permission-based authorization 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.

Clone or Install the Template

Start from the GitHub repo or scaffold a renamed solution with the published dotnet new krafter template.

Run the Aspire AppHost

One command brings up the dashboard, database dependencies, migrator, API, and 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

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

You can inspect the hosted reference, scaffold a renamed solution from the template, or work directly from source when you want the full repo model.

Live Demo

Try now
  • Hosted reference deployment
  • Seeded admin credentials
  • Google login path available
  • Scalar API reference included
Open Demo
Fastest Setup

Template

CLI ready
  • Install from NuGet
  • Rename the full solution on creation
  • AppHost + migrator already wired
  • Good fit for greenfield products
  • Matches the published repo structure
See Quick Start

Source

MIT licensed
  • Full repository access
  • Agents.md guidance included
  • GitHub Actions and container publishing patterns
  • Contributing, issues, and discussions
Browse Source
Quick Start Options

Run the full stack locally or scaffold a renamed solution.

Use the AppHost when you want the repo as-is, or start from the template when you want the same baseline under your own product name.

Local app host dotnet run --project aspire/AditiKraft.Krafter.Aspire.AppHost/AditiKraft.Krafter.Aspire.AppHost.csproj
Renamed solution dotnet new krafter -n MyCompanyApp

Start From a Stronger Baseline

Explore the demo, read the source, and use Krafter as the foundation for the product you actually want to ship.

Open Quick StartView on GitHub

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