bitzorcas
中 EN
BitzOrcas.Modern · .NET 10 Enterprise Architecture
v1 in progress 15-phase roadmap

The shared .NET 10 enterprise architecture baseline, ready to reference, reuse, and trust.

BitzOrcas.Modern is the unified architecture baseline and reference for the team. Fifteen business modules — identity, tenancy, billing, cases, workflow, notifications, files, reporting, search, tickets, chat, webhooks, and more — organized through CQRS with Vertical Slice Architecture. Unified authorization (RBAC + ABAC + ReBAC), self-built workflow engine, Lucene global search, and CAP + RabbitMQ eventing. One architecture, shared across products.

Read the docs→ Explore the architecture
  • v1
  • ·
  • ·
  • .NET 10 / C# 14
  • ·
  • SQL Server · Redis · RabbitMQ
bitzorcas aspire session
$

Live preview · 6 services orchestrated by Aspire

Project overview
  • Modules

    15

    Identity · Tenancy · Billing · Cases · Workflow · +10 more

  • Phases

    15

    Architecture baseline → Golden Slice → SaaS platform

  • 15

    8 /

    Phases completed — CQRS · Auth · Pipeline · API · Infra

  • Building blocks

    12

    Auth · Cache · Events · Jobs · Observability · Idempotency · +6 more

The stack

A unified, production-ready stack, from day one.

The unglamorous infrastructure every product needs — already chosen, already connected. Sensible, production-grade defaults, and nothing you can't swap.

Backend

.NET 10

Minimal APIs, Mediator.SourceGenerator, and SqlSugar on the latest LTS — C# 14, source-generated, fast.

Database · default

SQL Server

SqlSugar default with tenant filter, soft-delete, audit, and optimistic concurrency. EF Core adapter optional.

Orchestration · ready

.NET Aspire

One command brings up SQL Server, Redis, RabbitMQ, and the API.

Deploy

Docker Compose

A production compose file in the box — ship it anywhere.

Storage · S3

S3-compatible

Local disk in dev; any S3 provider (or MinIO) in production.

Tenancy · built-in

Multitenancy

SqlSugar QueryFilter-powered tenant isolation across every module — SingleTenant and MultiTenant modes.

01·Modular monolith + vertical slice

A modular monolith, sliced vertically.

Each module is an isolated bounded context, talking to the others only through its contracts — never reaching into their internals. Inside a module, every feature is a vertical slice: endpoint, handler, validator, and tests in one folder.

Modular monolith

Ten modules, one process

Identity
Multitenancy
Auditing
Catalog
Files
Chat
Billing
Webhooks
Notifications
Tickets

Cross-module calls go through *.Contracts only — enforced by architecture tests.

Vertical slice

One feature, one folder

Modules.Billing / Features / v1 / Invoices / CreateInvoice

  • CreateInvoiceEndpoint.cs Minimal API endpoint
  • CreateInvoiceCommandHandler.cs Mediator command handler
  • CreateInvoiceCommandValidator.cs FluentValidation rules
  • CreateInvoiceTests.cs Unit + integration tests

No jumping between five projects to add a button — one folder, one PR, one merge.

02·Everything a production .NET 10 API needs

Infrastructure ready, start building features.

Authentication. Authorization. CQRS. Caching. Eventing. Background jobs. Structured logging. Distributed tracing. Idempotency. Webhooks. These cross-cutting capabilities are packaged as shared building blocks with consistent standards. New projects import and use them directly — no need to rebuild from scratch.

Browse the full building-blocks reference
03·Ten production modules ship in v10

Three pillars, seven more in the box.

Identity, multitenancy, and auditing are the architectural pillars — foundational capabilities every B2B product needs. Seven more modules ship alongside them, so new projects start building what makes your product yours right away.

Module

Identity

Auth that gets out of your way.

  • JWT bearer + refresh tokens
  • ASP.NET Identity with roles + permissions
  • Operator impersonation with audit trail
  • Rate-limited login, register & password reset
Explore Identity
Module

Multitenancy

Isolation by default. Cross-tenant by opt-in.

  • Finbuckle.MultiTenant 10 (claim, header, query)
  • SqlSugar global query filter for tenant scoping
  • IGlobalEntity opt-out for system-wide rows
  • Tenant-aware caching + jobs + outbox
Explore Multitenancy
Module

Auditing

A forensic record of every change.

  • SqlSugar interceptor captures all writes
  • Per-entity before/after snapshot
  • User, tenant, correlation ID, request path
  • Queryable via /audits with filters + redaction
Explore Auditing
And seven more in the box

  • Files

    Tenant-scoped object storage on MinIO / S3

  • Chat

    Realtime channels, DMs, @mentions, threads

  • Notifications

    User inbox with real-time SignalR push

  • Webhooks

    Tenant subscriptions, HMAC-signed payloads

  • Billing

    Subscription plans and usage metering

  • Catalog

    Products, categories, images

  • Tickets

    Support tickets and conversations

04·Under the hood

Unified stack, industry-standard choices.

No proprietary framework. No DSL. No magic. The same .NET 10, SqlSugar, CAP, and OSS libraries your team already knows — chosen carefully and wired together to minimize learning curve.

  • .NET 10

    C# latest · net10.0 LTS

  • Aspire

    latest · orchestration

  • SqlSugar

    Core · SQL Server default

  • EF Core

    optional · second adapter

  • CAP

    latest · RabbitMQ outbox

  • Mediator

    latest · source generator

  • Mapster

    latest · object mapping

  • FusionCache

    latest · Redis L2

  • Quartz

    latest · scheduled jobs

  • OpenTelemetry

    latest · OTLP exporter

  • Scalar

    latest · OpenAPI 3.1 browser

  • ArchUnitNET

    latest · architecture tests

05·Tested to production standard

Not a demo — a validated foundation.

Every Phase ships with automated tests at four levels. Unit tests for domain invariants, integration tests that run against a real SQL Server in Docker via Testcontainers — not mocks, not in-memory fakes — architecture tests that guard module boundaries, and E2E coverage of critical flows.

  • —

    Unit

    Domain rules, Result/Error contracts, value objects, and pipeline behaviors — pure, isolated, millisecond-fast.

  • —

    Integration

    The full HTTP stack against real SQL Server + Redis + RabbitMQ in Docker, via Testcontainers. No mocks, no fakes.

  • —

    Architecture

    Module boundaries, dependency direction, and contracts purity enforced by ArchUnitNET — they can't silently regress.

  • —

    End-to-end

    Full browser flows via Playwright, covering critical user paths across the platform.

BitzOrcas.Modern — tests CI Four test levels 
$ dotnet test
  ⟳  Testcontainers — sqlserver · redis · rabbitmq  ready
  ✓  unit ........................  passed
  ✓  integration (real SQL Server) .  passed
  ✓  architecture (ArchUnitNET) .   passed
  Passed!  all green  ·  0 failed

$ npx playwright test
  ✓  e2e — critical flows .........  passed
  all green ✓
Read the testing strategy
06·Who BitzOrcas is for

Know the scope, find what you need fast.

BitzOrcas.Modern has clear technical opinions and architectural constraints. Understanding its fit and non-fit scenarios helps you quickly identify which parts to reference in your current project.

A good fit

Consider this if you're…

  • New team members onboarding

    Quickly understand the overall architecture, module structure, technology choices, and coding standards through the docs site.

  • Teams starting new .NET 10 projects

    Reuse proven architecture patterns and building blocks without rebuilding infrastructure — jump straight into feature development.

  • Teams needing multitenancy reference

    Reference SqlSugar QueryFilter tenant isolation, Finbuckle multi-tenant resolver chain, and tenant-aware cache/jobs/audit implementation.

  • Developers exploring CQRS / Vertical Slice

    Reference the Mediator pipeline, vertical slice file structure, and domain event implementation — concrete architectural practices.

Not a fit

Note if any of these apply…

  • Frontend-only projects

    BitzOrcas.Modern is a backend architecture baseline. It doesn't include frontend frameworks or UI components — pair it with your frontend stack.

  • Teams that prefer classic Clean Architecture layering

    BitzOrcas organizes code by feature in vertical slices (endpoint, handler, validation, tests in one folder) rather than by technical concern in horizontal layers. If your team is used to the classic Domain\Services\Repositories layering, expect a shift to feature-based organization.

  • Microservices-from-day-one scenarios

    BitzOrcas is a modular monolith — modules can be extracted into services later, but it ships as one process. If you need independently deployed services on day one, plan accordingly.

  • Teams not using the .NET stack

    All architecture patterns and technology choices are based on the .NET 10 ecosystem. Non-.NET teams can reference the architectural ideas but cannot directly reuse the code.

07·Frequently asked

The questions team members actually ask.

Centralized answers to common questions. If your question isn't here, submit an Issue

  • Q.01

    What is the purpose of BitzOrcas.Modern?

    BitzOrcas.Modern is the unified enterprise architecture baseline and internal documentation hub. It provides consistent architecture patterns, technology choices, and coding standards for all .NET 10-based products — reducing cross-team friction and avoiding duplicated effort.

  • Q.02

    Can I start a new project based on this architecture?

    Yes. The architecture is being developed with a 15-phase roadmap. Phases 0–8 are complete: architecture baseline, domain seedwork, CQRS pipelines, unified authorization, cross-cutting concerns, infrastructure integration, and a golden slice. Every phase ships with four levels of automated tests, ready to serve as a starting point.

  • Q.03

    Do I have to use all building blocks and modules?

    No. Each module is its own project and registers through the IAppModule contract. Each building block can also be introduced or removed independently. New projects choose only what they need — remove the rest from the registry without affecting other modules.

  • Q.04

    How does multitenancy support work?

    Multitenancy is the default. Every entity is isolated through a SqlSugar query filter. Caching, background jobs, audit, and search are all tenant-aware. Both SingleTenant and MultiTenant modes are supported, switchable per project.

  • Q.05

    How do I deploy a new project?

    Two paths. For development, .NET Aspire orchestrates everything with `dotnet run --project BitzOrcas.AppHost`. For production, Docker Compose provides the full stack (SQL Server, Redis, RabbitMQ), deployable to a single host or Kubernetes.

  • Q.06

    Where do I go for help?

    Check the architecture decision records (ADR) in this docs site first. For module-specific questions, use the internal team communication channels. If you spot architectural improvements, submit an Issue or PR to the repository.

  • Q.07

    How do I contribute a new module or building block?

    Follow the module development guide and adapter development guide in this docs site. New modules must follow the IAppModule contract, vertical slice structure, and module boundary constraints. Ensure architecture tests and contract tests pass before submitting.

  • Q.08

    Can I swap technology choices?

    Yes. The architecture uses an adapter pattern for all key components. For example, SqlSugar can be swapped for EF Core, or the Redis cache for another implementation. Each component has a clear interface contract — swapping doesn't affect business code.

08·Ready to start

Start with the docs, get productive fast.

Complete architecture reference, module guides, building-block docs, and development guides. From quick start to deep understanding.

Read the docs→ View architecture overview
  • v1
  • ·
  • Internal project
  • ·
  • .NET 10 / C# 14
  • ·
  • Unified architecture