Stop rebuilding the same .NET plumbing. Ship your SaaS instead.

Who may do what, how they got in, and a record of everything they did.

app.slicekit.dev/admin/rolesOpen in the live demo ↗

• Granular permissions

  Endpoints and UI check the same permission catalog, in three tiers: self-service, assignable staff grants and superadmin operations.

• Role presets

  Named presets copy grants onto users or invitations. An explicit apply action pushes role edits to existing users.

• Invite-only onboarding

  Invite by email with a permission snapshot or preset. Resend, revoke or update pending invitations, and switch public sign-up off entirely.

• Accountable impersonation

  Support acts as a user only with a logged reason. The original admin stays in the token, and both identities land in the audit trail.

• Hash-chained audit trail

  Actor, resource, outcome and sequence number for every security action. Each entry carries the hash of the previous one, so tampering shows.

• Scoped API keys

  Users mint keys with a subset of their own permissions, an expiry and rotation. The plain key is shown once and never stored.

The parts an EU product needs before launch, enforced by the build instead of by memory.

app.slicekit.dev/settings/privacyOpen in the live demo ↗

• Self-service data export

  Users download everything held about them from the privacy settings, without a support ticket.

• Erasure with anonymization

  Deletion soft-deletes the user and anonymizes personal fields, so foreign keys and audit history stay intact.

• Export and erasure cannot drift

  An architecture test fails the build if a personal field is exported but not erased, or erased but not exported.

• Versioned consent

  Registration records which version of the terms and privacy policy was accepted, and when.

• PII encrypted and redacted

  Personal fields are encrypted at rest with ASP.NET Data Protection, and a Sensitive attribute keeps them out of logs and audit payloads.

• Your infrastructure

  Postgres, Redis, RabbitMQ, MinIO and the Grafana stack are open source and self-hosted. You pick the external providers.

Subscriptions that work against Stripe on day one, with Stripe as the source of truth.

app.slicekit.dev/billingOpen in the live demo ↗

• Subscriptions end to end

  Checkout, configurable trials and the Customer Portal, with confirmation and paid-invoice emails that attach the PDF.

• No parallel price table

  Products and prices live in your Stripe dashboard. A metadata marker keeps test and unrelated products out of the catalog.

• Feature-key entitlements

  Gate features with boolean flags and numeric limits, enforced in the API slice that acts and mirrored in the UI.

• Plan limits from the admin panel

  Map feature keys to products and tune limits, like 10 API keys on Starter and 100 on Pro, without a deploy.

• Webhooks that never double-process

  An idempotency ledger keyed on the Stripe event id, durable retries for transient faults, and PII payloads redacted on a schedule.

• Inside the GDPR flows

  Export includes subscription state. Deletion cancels live subscriptions while Stripe keeps the invoices tax law requires.

Your users work with your product from Claude, ChatGPT, Claude Code, Codex, Cursor or VS Code.

See it in the live demo ↗

• Server and setup guides

  Streamable HTTP at /mcp on the official C# SDK. Settings show the server URL and a setup guide per client.

• OAuth consent, wired

  PKCE, client discovery and registration. Users approve read-only, read-and-write or custom permissions.

• Sign up while connecting

  New users register with email, Google or GitHub mid-flow, and the pending request brings them back to consent.

• Access the user controls

  Connected apps are listed in settings with editable permissions, and disconnecting cuts off tokens already issued.

• Accountable tool calls

  Every call records the tool, client and outcome in the audit trail, under the same permission rules as the API.

• Your tools, same handlers

  Add product tools beside the account tools; they call the same handlers as the API. Scoped API keys for agents are opt-in.

Know what happens in your product as it happens, and tell the right people.

app.slicekit.dev/admin/notificationsOpen in the live demo ↗

• Know when someone signs up

  Twenty catalogued events, from a registration to a failed payment, fan out to Slack, Discord, Apprise or email.

• A message builder per event

  Choose which events reach which target and rewrite each message, with a preview of the real payload before saving.

• An admin inbox that misses nothing

  Every event is recorded in-app even with no target subscribed. Repeats collapse into one row and link to the user behind them.

• A personal inbox for users

  Live unread counts and localized messages. This part is the optional module; admin alerts always stay.

• Email, digests, quiet hours

  Users choose immediate email or a daily digest, set quiet hours and manage delivery preferences.

• Your own events

  A test event ships with the pattern for adding notifications for your product.

The account and admin UI, already built, in English and Dutch, light and dark.

app.slicekit.dev/Open in the live demo ↗

• Full settings area

  Profile and avatars, security, sessions, API keys and privacy.

• Finished admin panel

  Users, role presets, invitations, impersonation, the audit log and cache controls.

• English and Dutch

  i18next, with validation and API errors localized too. The pattern takes more languages.

• Light, dark and system

  OKLch design tokens and no flash of the wrong theme on load.

• One typed API client

  CSRF header and silent refresh-retry built in, with TanStack Query for server state.

• Forms that speak API

  React Hook Form and Zod. Server errors map to the field that caused them.

• Permission-gated UI

  The API permission catalog decides what renders, so the UI never shows what the API would refuse.

• Typed file-based routing

  TanStack Router with automatic code splitting.

A mainstream .NET 10 stack, organised by feature, with no framework of its own.

Browse every endpoint in the live API reference ↗

• Vertical slices and DDD

  Code grouped by feature. Aggregates guard their own rules and raise domain events.

• Wolverine CQRS

  Commands and queries are plain handler classes, discovered by convention and checked by tests.

• Transactional outbox

  Integration events leave through an outbox to RabbitMQ, so a crash between save and publish loses nothing.

• EF Core on PostgreSQL

  Migrations with bundles in the image, a readable .slnx and central package management.

• OpenAPI with Scalar

  Versioned endpoints, health checks and a live reference with request and response schemas.

• Caching, storage, jobs

  FusionCache with a Redis backplane, S3-compatible storage on MinIO and TickerQ background jobs.

You can see what it is doing in production from the first deploy.

• Three signals, one pipeline

  OpenTelemetry traces, metrics and logs through the collector to Tempo, Prometheus and Loki. One click is one span tree.

• Dashboards and alerts

  Four Grafana dashboards and six Prometheus alert rules ship provisioned, with Alertmanager routing.

• Local stack in one command

  docker compose up -d starts Postgres, Redis, RabbitMQ, MinIO, Mailpit and the observability stack.

• Migrations before rollout

  The API image includes EF migration bundles. Startup migrations are a configuration switch.

• CI from the first push

  Pull requests build both apps, run the tests and scan packages. Main pushes an image with SBOM and provenance to GHCR.

• Production compose file

  A production Docker Compose stack that builds and runs the API image beside its services.

Guardrails that keep the codebase honest, whether a person or an agent makes the change.

• Four test projects

  Unit, architecture, feature tests against real Postgres via Testcontainers, and API tests.

• Architecture tests

  Layer boundaries, encapsulation, endpoint access, handler discovery and personal-data completeness all fail the build when broken.

• AGENTS.md routers

  Per-side instructions point Claude Code, Codex, Copilot and Cursor at the right conventions first.

• One shape per feature

  Every slice has the same files in the same place, so an agent copies one and renames it.

• Docs as Markdown

  Every docs page is also served as raw Markdown, ready to paste into a model.

• Types end to end

  C# and TypeScript catch a wrong guess at compile time instead of in production.

Every library is mainstream, documented upstream and replaceable. Each name links to its own project.