This page reads each document’s lastUpdated frontmatter at build time and groups the results by date. When you edit a page, bump the date. Do not maintain a second list of “pages we touched.”
Capability changes that need impact, migration, and evidence still belong in the changelog. This page only answers which manual pages moved recently.
23 September 2026
- 5-Minute Quick Start: Aspire Orchestration, Data Persistence, and the First Authentication RequestMaster BitzOrcas.Modern onboarding: spin up complete microservice topologies with .NET Aspire AppHost, configure volume persistence and controlled resets, and authenticate via RSA-OAEP encrypted endpoints.
- Agent Governance & Multi-Tenant SecurityIn-depth architecture of MCP Agent governance in BitzOrcas.Modern: multi-tenant isolation, dynamic visibility filtering, concurrency rate limiting, and Human-in-the-Loop (HITL) approval.
- AI & Agentic DevelopmentComprehensive overview of BitzOrcas.Modern AI-Native architecture: turning enterprise vertical slices into Model Context Protocol (MCP) tools via compile-time source generation.
- Building Your First Vertical Slice: LegalTech Matter Intake Hands-on TutorialMaster BitzOrcas.Modern Vertical Slice Architecture through a real-world civil litigation matter intake use case: inheriting TenantAggregateRoot, [BitzTable] metadata, [GenerateEndpoint] route binding, IAuthorizedRequest policy declaration, and ICommandRepository persistence.
- Code Installation & Local Configuration: Container Infrastructure and Database SeedingMaster BitzOrcas.Modern local development onboarding: from spinning up digest-pinned Docker Compose infrastructure to zero-trust environment variable injection and idempotent --init-schema database provisioning.
- Configuring Your First Approval Workflow: High-Stakes Matter Countersigning Hands-onLeverage BitzOrcas.Modern's proprietary lightweight DAG state machine workflow engine to configure an approval workflow for major legal matters (claims exceeding 50M) with conditional gateways, partner countersigning, and immutable audit trails.
- Creating a Business Module from Scratch: Building High-Cohesion Domains Like LegoFollow BitzOrcas.Modern modular monolith standards to build a Legal Contract Management module from scratch: partitioning physical boundaries across Contracts/Domain/Application, declaring IAppModule governance metadata, inheriting TenantAggregateRoot, and guarding boundaries with ArchUnitNET fitness functions.
- Cursor & Claude Desktop Local IntegrationStep-by-step practical guide: configure Cursor and Claude Desktop to connect to the BitzOrcas.Modern local MCP endpoint for conversational business slice execution.
- Dapper Read-Side Performance & Connection PoolingPractical guide: leveraging Dapper and read-only connection pooling in BitzOrcas.Modern to maximize throughput for analytical dashboards, reporting, and high-concurrency pagination.
- Developer Guides: Practical Manuals from Slices to OperationsBitzOrcas.Modern developer guides: vertical slice construction, frontend hydration, feature and module extensions, hexagonal adapters, Aspire local infrastructure, and tenant impersonation.
- Development Environment & Prerequisites: Cross-Platform Toolchain Setup and ValidationStandardized cross-platform development environment setup: .NET 10 SDK, C# 14 and Native AOT toolchains, Node.js 22 LTS, Corepack (Yarn 4.17.0), Docker container engine, and IDE productivity suites.
- EF Core Isomorphic Integration & Interceptor GuidePractical guide: configuring and utilizing EF Core in BitzOrcas.Modern, exploring Audit interceptors, PII encryption, global query filters, and CAP outbox integration.
- GDPR & Data Privacy Compliance GovernanceIn-depth architecture of BitzOrcas.Platform.Gdpr: Subject Access Requests (SAR), the Right to be Forgotten, cryptographic shredding, and audit trail pseudonymization.
- Getting Started: BitzOrcas.Modern Developer Onboarding GuideBitzOrcas.Modern developer onboarding overview: from architectural mental models and prerequisites inspection to spinning up Docker containers and executing your first multi-tenant vertical slice.
- Guide: Dual-Track NuGet Distribution & Release Management for Bitz CLIComprehensive operational guide for Bitz CLI packaging and distribution: public NuGet.org vs. enterprise Yunxiao private feeds, packageSourceMapping supply chain defense, local offline validation, and CI/CD automation.
- Immutable Timekeeping & Billing Audit TrailsIn-depth architecture of BitzOrcas.Platform.Timekeeping: consultant time tracking, tiered hourly rate matrices, invoicing locks, and tamper-proof audit trails.
- Integrating Real-Time Notifications: Server-Sent Events (SSE) High-Performance StreamingAdhering to the architectural invariant 'Persistence First, Streaming Second,' leverage Server-Sent Events (SSE) to deliver high-performance streaming alerts for litigation approvals and conflict of interest warnings with automatic reconnection.
- Legal Connectors & Judicial Cloud IntegrationIn-depth architecture of BitzOrcas.Platform.LegalConnectors: court proceeding synchronization, litigation document retrieval, and circuit-breaker resilience.
- Legal Fee & Interest Calculation EngineIn-depth architecture of BitzOrcas.Platform.LegalCalculators: tiered court filing fees, asset preservation caps, and delayed performance compound interest.
- Matter Intake & Conflicts: Hands-on Multi-Tenant 4-Tier Dynamic ValidationMaster enterprise multi-tenant validation grounded in LegalTech: from universal base invariants and composite conflict strategies to tenant hot-configs and no-code field delivery rules.
- MCP Server Architecture & Source GeneratorsIn-depth analysis of the BitzOrcas.Mcp compile-time Roslyn Source Generator, [GenerateMcpTool] attribute contract, JSON Schema derivation, and /mcp endpoint registration.
- Module Lifecycle & Modularity EngineIn-depth breakdown of the BitzOrcas.Modularity engine: topological dependency graph resolution, ConfigureServices, and UseModule lifecycle hooks.
- Multi-ORM Dual-Engine Architecture & Selection MatrixIn-depth architecture of BitzOrcas.Modern persistence adapters: division of responsibilities, selection matrix, and dual-engine coexistence for SqlSugar, EF Core, Dapper, and MongoDB.
- Practical Guide: Add a Dashboard Management Page (React 19)Master building enterprise management dashboard pages in BitzOrcas.Modern React 19 + TanStack Query: route registration, OpenAPI SDK generation, metadata table hydration, and RBAC permission gates.
- Practical Guide: Add a Feature to an Existing ModuleMaster the 5-step feature delivery pipeline in BitzOrcas.Modern: extending domain aggregate invariants, single-file vertical slice, declarative RBAC endpoints, ICommandRepository persistence, and Testcontainers validation.
- Practical Guide: Add an Autonomous Business ModuleMaster creating autonomous modular monolith sub-domains in BitzOrcas.Modern: Contracts/Domain/Application project segregation, TenantAggregateRoot domain models, IAppModule governance metadata, and ArchUnit architecture guardrails.
- Practical Guide: Declarative Seed Data & Idempotent InitializationMaster seed data provisioning in BitzOrcas.Modern: implementing the ISeedStep contract, multi-tier environment gates (Global / Tenant / Demo / ProductionSafe), DAG topological dependency ordering, and automated idempotent seeding via --init-schema.
- Practical Guide: Framework Upgrades & Breaking Change MigrationSmooth upgrade guide for BitzOrcas.Modern: central package management version locking (CPM), Roslyn generator cache maintenance, database schema migrations, frontend dependency alignment, and quality gate validation.
- Practical Guide: Frontend Integration & Metadata HydrationMaster frontend integration in BitzOrcas.Modern: OpenAPI TypeScript SDK generation, IReadModelMetaMapped projection, 10-stage pipeline Stage 10 dictionary and entity hydration, and React 19 best practices.
- Practical Guide: How to Write a Command SliceBuild an enterprise command slice following the One Use Case One File standard: Minimal API route metadata, declarative RBAC permissions, IRequestRule pure validation, ICommandRepository persistence, and aggregate invariant enforcement.
- Practical Guide: Implement Hexagonal Infrastructure AdaptersMaster Hexagonal Ports and Adapters in BitzOrcas.Modern: define domain ports, implement production infrastructure adapters, encapsulate third-party network errors, configure Polly resilience, and register fallback mocks.
- Practical Guide: Local Infrastructure & .NET Aspire OrchestrationMaster local development orchestration in BitzOrcas.Modern: .NET Aspire AppHost, SQL Server 2022, Redis 7, MinIO containers, verified port matrices, volume persistence, and database schema reset.
- Practical Guide: Operator Impersonation & Security AuditMaster operator impersonation in BitzOrcas.Modern: short-lived dual-identity JWTs, DelegatedSessionRestrictionPipelineBehavior sensitive operation blocks, and immutable dual-identity audits.
- Pre-Seeded Demo Accounts and the Password Injection Contract: Zero-Trust Seeding and Multi-Tenant IsolationA deep dive into the BitzOrcas.Modern seeded account catalog: the Fail-Closed environment variable password injection contract, RSA-OAEP anti-replay transport encryption, and anti-probing 404 multi-tenant isolation.
- Profiles & Metapackage Tailoring ArchitectureIn-depth architecture of BitzOrcas Profiles: scenario-based dependency aggregation using Default.Business, Mini.Api, and Portal for commercial modular delivery.
- Sandbox Golden Sample Architecture BreakdownIn-depth architecture breakdown of src/Modules/Sandbox: three-tier physical boundaries, CQRS vertical slices, adapter-neutral aggregate roots, and narrow read stores.
- Structured Legal Document Templating & Streaming GenerationIn-depth architecture of BitzOrcas.Platform.Documents: structured contract templating, dynamic token replacement, PDF streaming generation, and anti-leak watermarking.
- Ten Architecture Anti-Patterns & Operational PitfallsSenior architect guide to avoiding production catastrophes: dissecting async deadlocks, module layer leaks, tenant isolation breaches, and unverified AI mutation loops.
- Troubleshooting Guide: Environment, Ports, Compilation, and Runtime DiagnosticsResolving common BitzOrcas.Modern onboarding failures: verified port matrices (6881, 6880, 6800, 1433), SQL Server connectivity, Roslyn source generator cache resets, and HTTPS developer certificate trust.
- Tutorial: Integrating a Module with Global Search and Index GovernanceComplete walkthrough for wiring a business module into BitzOrcas.Modern global search: same-transaction incremental index events, an authoritative rebuild source, host source-catalog configuration, authoritative hit re-checks, architecture-test locks, and end-to-end verification.
- Tutorials Overview: Mastering BitzOrcas.Modern from ScratchThe official hands-on learning roadmap for BitzOrcas.Modern. Master .NET 10 modular monolith development across 6 progressive legal-tech business scenarios.
- Understanding BitzOrcas.Modern: Design Philosophy, Architecture Topology, and Execution PipelineA deep dive into the BitzOrcas.Modern enterprise architecture: starting from the monolith-microservices trade-off, mastering vertical slices, the 10-tier application pipeline, dual ORM compile-time generation, and cross-module contract boundaries.
- WeChat Ecosystem & Enterprise WeChat IntegrationIn-depth architecture of BitzOrcas.Platform.WeChat.Mp: multi-tenant AppId isolation, parametric QR code login, event dispatching, and reliable template messaging.
- Writing Integration Tests and Behavior Parity: Testcontainers Hands-onLeverage Testcontainers to spin up real SQL Server 2022 and Redis containers, write end-to-end integration tests for litigation matter intake slices, and assert 100% behavioral parity between EF Core and SqlSugar dual ORM adapters.
12 September 2026
- bitz Developer Toolchain and Ecosystem OverviewIn-depth guide to the modernized Bitz CLI toolchain: Codeup default unified identity onboarding, anti-drift physical hardware locking, typed client proxies, CQRS vertical slice code generation, visual Suite studio, and automated environment self-healing.
- BitzOrcas Suite Visual Architecture StudioIn-depth guide to BitzOrcas Suite (bitz suite) visual workbench: from entity modeling and property grids, in-memory VFS slice diff review, to multi-dialect DDL preview, ER topology export, Git timeline, and double-column diff drawers.
8 September 2026
- CLI and controlled toolingSelect Consumer Solution templates, code generation, schema, seed, workflow, and database-maintenance entries while understanding write surface, privilege, and evidence boundaries.
- Create and Run a Consumer SolutionUse default-business-multi to install the template, generate a project, verify composition, restore commercial packages, run Aspire, and accept the starter slice.
- Generated Output, Profiles, and Composition EvidenceExamine native Consumer Solution output, Host composition, Business Starter, commercial package closure, manifests, plans, and ownership boundaries.
- Solution Template and Profile SelectionUnderstand the 15 coupled bitzorcas-host Profiles, two ORMs, three base topologies, optional Platform modules, and industry extensions.
- Solution Template TroubleshootingDiagnose bitzorcas-host by installation, generation, Feed, restore, build, schema, topology, Platform module, and License stage.
- Template Parameters and Profile ConstraintsPublic options, defaults, 15 Profiles, internal derivation, output selection, and verification boundaries for bitzorcas-host 1.0.0-alpha1.
3 September 2026
- Business Modules Architecture & Extension GuideIn-depth guide to BitzOrcas.Modern business module architecture, ADR 0203 physical isolation, ADR 0205 platform extension paradigms, and the Sandbox Golden Use Case.
- Platform CapabilitiesBitzOrcas.Modern platform-level specialized subsystems, cross-module core engines, and rule governance center.
- Standard List Query Kernel and QueryShapeA deep architectural dive into the BitzOrcas.Modern standard list query kernel, uncovering compile-time execution plan generation, multi-table alias decoupling, custom basePredicate injection, and dual-ORM projection pushdown.
2 September 2026
- External Standards Reference ListThe master list of external standards referenced by the platform and its manual: ProblemDetails (RFC 9457), HTTP QUERY (RFC 10008), the OAuth token family, TOTP, CSV and more — each with the authoritative link, source-code locations, and adoption mode.
- Sensitive Operation Re-authentication (Step-Up)Login MFA cannot answer “is it still you right now?”. Step-Up re-authentication verifies identity per sensitive operation: one global enforcement middleware, a three-layer policy model, and six factors reusing existing verification kernels.
- Step-Up Contract ReferenceEvery public surface of sensitive-operation re-authentication: ten endpoints, challenge and verification JSON contracts, three 403 ProblemDetails shapes, the full error table, and StepUpOptions keys — each verified against source.
- Step-Up Frontend IntegrationHow the first-party SPA implements the re-authentication protocol: the four interceptor replay rules, the verification dialog state machine, the memory-only credential red line, and SDK usage. Business code stays unaware.
- Step-Up QuickstartWire a business endpoint into sensitive-operation re-authentication through three paths: zero-code policy rows from the admin page, a [RequireStepUp] declared baseline, and one-shot tickets for money-moving operations — with staged verification points and expected failures.
- Step-Up Rollout and OperationsThe AuditOnly-first rollout order, threshold tuning guidance, runbook essentials, and three canonical troubleshooting paths: Redis unavailability, missing-version-key alerts, and rising GrantPurposeMismatch counts.
27 August 2026
- Alert runbookConcrete alert thresholds, per-signal diagnostic runbooks, and the monitoring-system integration matrix. The template defines thresholds; an external monitoring system scrapes OTel and fires the alerts.
- API startup sequenceGenerated defaults are registered before concrete adapters and readiness guards.
- Application Shell and WorkspaceDesign System 1.2 Side and Top shells, navigation ownership, sticky Local Tabs, global tools, and workspace semantics.
- Architecture Overview: BitzOrcas.Modern Design PhilosophyExplore the enterprise architecture of BitzOrcas.Modern: modular monolith boundaries, vertical slices, 10-stage execution pipeline, compile-time dual ORM, and Native AOT compilation.
- Audit categories, tables, and retentionSeven logical categories map to six base-table groups with distinct schedules.
- Authentication and authorizationCredential headers select one authentication scheme before policy authorization.
- Building Blocks Map and Architectural PhilosophyA comprehensive overview of BitzOrcas.Modern core building blocks, spanning Unified Aggregates, QueryShape read models, CAP Outbox, multi-level caching, and S3 storage.
- CAP outbox publish sequenceCommit first, dispatch afterward, then acknowledge or retry at the consumer boundary.
- CI/CD and Quality GatesUnderstand the current GitHub Actions pipeline, test layers, Consumer contracts, and commercial GA gate in BitzOrcas.
- Code generatorGenerate industry-neutral unified-aggregate slices through bitz-codegen's business-slice production entry, with atomic placement, the BOCG error-code families, manifest evidence fields, and fail-closed legacy audit inputs.
- Color and Legal ThemesDesign System 1.2 neutral surfaces, status colors, brand semantics, and the Navy, Amber, Burgundy, Jade, and Orange legal themes.
- Command and query responsibilitiesBoth message types enter the same generated Mediator chain, then use different state ports.
- Commercial Delivery OverviewUnderstand the BitzOrcas delivery boundary from product source and NuGet packages to Consumer Solutions and formal GA.
- Commercial GA GatePrepare the feed, signatures, provenance, SBOM, policy evidence, and external Consumer required for a formal BitzOrcas release.
- Consumer Contract TestsVerify package closure, template boundaries, Generator assets, and Release publish with an isolated feed and an external project.
- Database Initialization and MigrationsHow lock-safe --init-schema, /host/schema review scripts, and Host-Admin drift notifications work together.
- Database-Driven Background Jobs and Quartz Execution SafetySay goodbye to fragile Linux cron scripts! Learn how BitzOrcas.Modern implements scheduler-agnostic IJobExecutor, Quartz clustered persistence, and graceful execution shutdown.
- Defining and Designing WorkflowsCurrent JSON DSL guide to nodes, edges, expressions, business binding, form fields, participants, multi-instance, timers, listeners, validation, and simulation.
- Dependency Injection & Lifecycles: Compile-Time CompositionMaster Dependency Injection in BitzOrcas.Modern: phased composition order, service lifecycle rules (Scoped / Singleton / Transient), and Native AOT static registration.
- Dependency-injection compositionGenerated registrations, fail-closed defaults, and concrete adapters form one auditable tree.
- Deployment, Versioning, and RollbackImmutable snapshots, checksum reuse, office/tenant bindings, real grayscale semantics, cache invalidation, publish races, and release runbook.
- Distributed Locking and Deadlock Prevention: IDistributedLock Deep DiveExplore the BitzOrcas.Modern distributed locking core. Learn atomic acquisition, owner-checked Lua releases, lease renewals, and fallback strategies.
- Domain entities and persistence exceptionsUnified aggregate roots are the default; separate persistence models require explicit asymmetry.
- Embed Workflow Engine StandaloneCompose the engine outside BitzOrcas with correct persistence, query, permission, participant, service-task, notification, timer, cache, and operations boundaries.
- Eventing AbstractionsDistinguish domain events, integration events, and notification ports, including collection, topic resolution, and Null-adapter boundaries.
- Eventing Building BlockReference for CAP, RabbitMQ, SQL Server Outbox, topic contracts, consumer idempotency, and failed-message operations.
- Expected failures and unexpected exceptionsBusiness failures remain typed Result data; only unexpected faults reach the exception handler.
- Extension intakeThe productized intake contract for a new module, adapter, background job, or endpoint — capabilities EXT-1 through EXT-8, default semantics, mandatory Operations visibility, and the fixed verification block.
- Framework building-block mapSix responsibility groups help locate a concern before choosing a project or package.
- GA cutover runbookThe operator runbook for promoting a BitzOrcas release to GA — pre-cutover gate, configuration and secrets, migration sequences, health checks, Operations verification, Webhook drill, traffic cutover, rollback, and the post-cutover record.
- GovernanceThe quality gates, production-readiness ratchets, extension intake, module governance, readiness matrix, and industry-neutral rules that make a BitzOrcas release shippable.
- History, Archive, and AnalyticsActivity trail, instance and business timelines, archive transaction, report calculation, query-port fallback, precision limits, and operations evidence.
- Host Composition & Topology: API, Gateway, JobHost & AspireArchitectural breakdown of BitzOrcas.Modern host composition: API Host, YARP Gateway, JobHost, ServiceDefaults, and .NET Aspire orchestration.
- HTTP request lifecycleThe complete middleware order from trusted proxy data to endpoint dispatch.
- Identity frontendComplete usage and implementation reference for BitzOrcas Web Identity: encrypted credential sign-in, CAPTCHA, MFA, passwords, admissions, authorization, organizations, application credentials, and tenant governance.
- Industry-neutral surfacesThe ownership rules that keep Framework, generic Profiles, and Hosts vertical-free, the template adoption contract, and the AssignedLawyerId to AssignedOwnerId migration.
- Inside a bounded contextPublic contracts, domain rules, use cases, adapters, endpoints, and tests stay physically visible.
- Integration testsSeparate API Shell and Docker contracts while proving ORM parity, migrations, messaging, tenant isolation, and real-infrastructure semantics.
- Mediator behavior orderThe fourteen registered behaviors execute in this exact composition-root order.
- Migration, Start-at-Node, and Legacy ImportChoosing migration paths, mapping, preflight, current non-transactional/non-idempotent limits, batch recovery, applicant transfer, and acceptance runbook.
- Modern API Documentation with OpenAPI 3.1 and ScalarSay goodbye to heavy Swashbuckle reflection! Learn how BitzOrcas.Modern implements compile-time OpenAPI 3.1 metadata extraction and modern Scalar API references for Native AOT.
- Modular Monolith: Physical Isolation, Contract Boundaries & ArchUnitExplore the BitzOrcas.Modern modular monolith architecture: Contracts/Domain/Application project segregation, 5 inter-module collaboration rules, and ArchUnit architecture tests.
- Module dependency boundariesConsumers depend on owner Contracts; the host composes concrete adapters.
- Module dependency stackProtocol enters through the host; dependencies point inward to domain contracts.
- Module governanceThe compile-time AppModule system, the distinct current sets of 36 typed markers and 36 handbooks, the central legacy boundary, and the ledger ratchet governing module identity and dependencies.
- Module readiness matrixThe current 36 Platform roots, their Ready / Out-of-Scope status, ProductionDepth semantics, and repository-wide persistence closure.
- Module responsibility mapResponsibility belongs to bounded contexts; people and teams can change without moving the boundary.
- Multi-Brand, Dark Mode, and ProfilesDesign System 1.2 orthogonal Mode, Brand, Density, Shell, and Workspace axes, accessibility overrides, persistence, and tenant boundaries.
- Multi-Channel Message Delivery: From Facts to FanoutExplore the BitzOrcas.Modern message delivery engine. Learn how notification persistence, CAP transactional outbox, and email/SMS/IM connectors decouple external I/O.
- Multi-Level Caching and Stampede Protection with FusionCacheExplore the BitzOrcas.Modern caching architecture. Learn how FusionCache L1 in-memory and L2 Redis caching, CacheScope isolation, and tag invalidation prevent cache stampedes.
- Multitenancy Deep Dive: 8-Step Resolution Chain & Data IsolationDeep dive into BitzOrcas.Modern multitenancy: 8-step tenant resolution hierarchy, automated dual ORM global query filters, and operator impersonation sandboxes.
- Object Storage and S3 Integration: IFileStorage Deep DiveExplore the BitzOrcas.Modern object storage architecture. Learn how IFileStorage, MinIO/S3 adapters, presigned direct uploads, and tenant security eliminate server bandwidth bottlenecks.
- Performance baselines and regression decisionsBuild repeatable performance evidence for engineering gates, APIs, databases, messaging, and jobs while separating existing timing reports from runtime benchmarks still to be established.
- Persistence adapter compositionSqlSugar or EF Core owns writes; Dapper complements query-oriented reads.
- Persistence adapter responsibilitiesThe three adapters share application contracts but do not have identical runtime roles.
- Production readinessThe manifest-driven production-readiness model — the surface-to-manifest mapping, the legacy ledger ratchet, and the adapter readiness guard that fails closed in Production/Staging.
- Quality gatesThe verify-all flow, CI matrix, test layers, API status-code contract, data-consistency test matrix, AOT/reflection/T-SQL gates, and the template completion definition that gate a BitzOrcas merge.
- Quotas and Rate Limiting: Host Token Bucket & Billing QuotaTell apart the Host-level Redis token bucket limiter from the PlatformBilling quota check: where 429 belongs, how QuotaService.Check works, usage submission commands, and idempotent usage facts.
- Running testsSelect unit, architecture, container-free, Docker, template, package-consumption, and acceptance entries by risk while retaining reproducible evidence.
- Running Workflow InstancesStart, complete, reject, withdraw, resubmit, handoff, control, multi-instance, transactions, concurrency, callbacks, and timer failure semantics.
- Runtime host stackEdge routing, API composition, jobs, orchestration, defaults, and resources form distinct layers.
- Source Generator & Native AOT: Zero-Reflection CompilationExplore compile-time code generation in BitzOrcas.Modern: Minimal API EndpointGenerator, dual-ORM FluentMappingGenerator, and Native AOT sub-50ms cold starts.
- System overviewDeployment hosts, platform contexts, framework services, and runtime resources.
- Tenant resolution priorityEight ordered steps resolve a TenantId; SingleTenant mode still writes the tenant key.
- Testing StrategyUnderstand the five-layer BitzOrcas testing system, from unit tests to commercial release evidence, and choose the right verification set for each change.
- The platform contract layer@bitz/platform-sdk is the only sanctioned bridge between the web app and the .NET backend — it owns the request pipeline, auth session, ProblemDetails mapping, gates, Identity API, and generated OpenAPI contract.
- Tracker item lifecycleThe six TrackerItemStatus values and every transition TrackerItemTransitionRules allows.
- Transactional event deliveryBusiness state and CAP outbox data commit together before asynchronous delivery.
- Unified Aggregate and Persistence KernelA comprehensive architectural deep dive into why BitzOrcas.Modern eliminated the traditional Entity + Mapper + Aggregate boilerplate, and how the compile-time ORM Fluent Configuration Generator achieves zero-reflection dual-ORM parity.
- Vertical Slice Architecture: High Cohesion Use-Case CentricityMaster Vertical Slice Architecture in BitzOrcas.Modern: One Use Case One File, 10-stage pipeline governance, unified aggregate persistence, and retiring layered models.
- Visual workflow designerCurrent guide to the full-page designer, server schema, AOT business metadata, draft revisions, form-field policy, simulation paths, version scope, and permissions.
- Web admin app@bitz/app is the React 19 + Vite 8 admin SPA. It composes widgets, the platform-sdk context, Jotai and React Query, and reaches the backend same-origin through a Vite dev proxy.
- Web and API Infrastructure: Minimal API Generation and Middleware TopologyExplore the BitzOrcas.Modern Web API foundation. Learn [GenerateEndpoint] compile-time Minimal API bindings, ASP.NET Core middleware ordering, and RFC 9457 Problem Details.
- Workflow Architecture and Core ConceptsDeep guide to layers, focused ports, execution model, command/query stores, transactions, concurrency, cache, tenancy, and host composition.
- Workflow developer manualSource-verified navigation from the visual designer and JSON DSL through deployment, runtime, tasks, notifications, history, migration, embedding, and operations.
- Workflow HTTP API ReferenceCurrent Definition, Runtime, Task, History, Report, and Management routes with authorization, rate limits, timeouts, and error semantics.
- Workflow Notification PipelineEvent dispatch, recipients, default templates, preferences, platform adapter, JobHost wiring, transactional failure semantics, and external delivery reconciliation.
26 August 2026
- Auditing Module Architecture: Append-Only Trails & Tiered StorageExplore the BitzOrcas.Modern Auditing Subsystem. Learn immutable SysAuditRecord entities, automated pipeline interception, SQL/Mongo tiered storage, and GDPR retention.
- Billing Module Architecture: Subscriptions & Financial GuardrailsDeep dive into the BitzOrcas.Modern Billing Subsystem. Learn SubscriptionAggregate roots, atomic concurrency quota reservation, payment webhook idempotency, and invoice pipelines.
- Catalog Module Architecture: Multi-Tenant Offering ManagementExplore the BitzOrcas.Modern Catalog Subsystem. Learn OfferingAggregate roots, dynamic SKU variants, tiered pricing, and immutable version publishing.
- Chat Module Architecture: WebSockets, Redis Broadcasts & Message StreamsDeep dive into the BitzOrcas.Modern real-time chat architecture. Learn ChatSession aggregates, WebSocket connections, Redis Pub/Sub backplanes, and offline sequence sync.
- Data Masking and Privacy Compliance: IDataMasker GuideMaster BitzOrcas.Modern enterprise data masking. Learn [Masked] contract attributes, dynamic phone/email/card masking algorithms, and GDPR-compliant log redaction.
- Domain Error Modeling and ErrorCatalog StandardsSay goodbye to unhandled exceptions! Learn how BitzOrcas.Modern implements domain error modeling with ErrorType hierarchies, Error factories, and compile-time ErrorCatalog generators.
- End-to-End Observability and Structured Auditing with OpenTelemetryExplore the BitzOrcas.Modern observability engine. Learn OpenTelemetry distributed tracing, metrics export, and ActivityAudit pipeline audit trails.
- Fine-Grained Resource-Action Authorization: IAuthorizedRequest GuideSay goodbye to hardcoded role explosion! Master the BitzOrcas.Modern Resource-Action authorization model with IAuthorizedRequest contracts and dynamic evaluation.
- Functional Inbound Validation: IRequestRule and Anti-CorruptionSay goodbye to expensive validation exceptions! Master the BitzOrcas.Modern functional validation engine with IRequestRule declarative rules, pipeline guards, and typed error responses.
- Global Exception Handling and RFC 9457 Problem DetailsExplore the BitzOrcas.Modern error management architecture. Learn Result flow control, GlobalExceptionHandler catch-alls, and RFC 9457 Problem Details standards.
- Identity Module Architecture: Multi-Tenant Identity CoreDeep dive into the BitzOrcas.Modern Identity Subsystem. Learn multi-tenant user aggregates, Argon2id password hashing, TOTP two-factor authentication, and enterprise SSO/OIDC.
- Interface Idempotency and Replay: Idempotency-Key in ActionMaster BitzOrcas.Modern interface idempotency. Learn Idempotency-Key contracts, Redis/DB deduplication stores, concurrency mutexes, and historical response replays.
- Modern Multi-Tenant Authentication: JWT, API Keys, and Context InjectionExplore the BitzOrcas.Modern authentication core. Learn ClaimsPrincipal resolution, high-throughput API Key validation, and immutable ICurrentUser / ICurrentTenant scoped injection.
- Multi-Tenant Rate Limiting and Anti-Scraping ProtectionMaster BitzOrcas.Modern enterprise rate limiting. Learn ASP.NET Core RateLimiter partition strategies (Sliding Window / Token Bucket), tenant quota isolation, and 429 guards.
- Ticketing Module Architecture: Collaboration, SLA & EventsExplore the BitzOrcas.Modern Ticketing Subsystem. Learn Ticket aggregate roots, SLA escalation state machines, optimistic concurrency assignments, and read model projections.
- Webhooks Architecture: Subscriptions, HMAC Signing & Exponential RetriesExplore the BitzOrcas.Modern Webhooks Subsystem. Learn WebhookSubscription aggregates, HMAC-SHA256 payload signing, SSRF defense, and exponential backoff retry schedules.
- Workflow Engine Architecture: DAG State Machines & SchedulingDeep dive into the BitzOrcas.Modern self-hosted workflow engine. Learn WorkflowDefinition topologies, WorkflowInstance state machines, Activity execution, and human approvals.
Dated pages outside the window
- 1Panel Linux Development PreviewDeploy a BitzOrcas Development preview on Linux with 1Panel, OpenResty, SQL Server, Redis, RabbitMQ, MinIO, and AgileConfig—including pack, deploy, seed flags, and login troubleshooting.
- BitzSaury migration MCP serversBuild and configure three BitzSaury migration MCP servers for foundation contracts, legacy code, and migration PRDs.
- ChangelogMajor capability and documentation changes that affect developers, adapter authors, and commercial delivery.
- Deployment Method SelectionChoose between systemd single-host, docker-compose, and Kubernetes release paths, and understand migration, startup, and rollback ordering across the three Hosts.
- Documentation maintenance and fact calibrationMaintain the bilingual developer manual from source, tests, and delivery evidence so paths, modules, behavior, and release semantics do not drift.
- Local Aspire OrchestrationUse BitzOrcas.AppHost to orchestrate SQL Server, RabbitMQ, Redis, MinIO, schema initializers, LicenseSigner, API, JobHost, and the Vite frontend.
- Online License Issuance and DistributionConfigure the vendor control plane, isolated signer, and Azure KMS/HSM; operate four-eyes approval, asynchronous issuance, download, distribution, and revocation from the UI.
- Project governance and version informationFind contribution rules, documentation maintenance, release notes, and future investment areas.
- Schema MaintenanceDetect drift between declared metadata and SQL Server schema, generate or apply safety-tiered migrations, and validate owner-local Seed CSV offline.
- Single-host blue-green on 1Panel OpenRestySwitch a single-host BitzOrcas pair through a named OpenResty upstream so 1Panel reverse-proxy sites do not pin port 8082 or reject upstream blocks.
Maintenance
- update matching Chinese and English paths together and set the same
lastUpdatedday; - bump the date even for typo or link fixes, or the calibration will not show here;
- do not add handwritten entries to this page; the window is fixed at 30 days in build logic.
How this differs from the changelog
| Reader question | Where to look |
|---|---|
| Which manual pages moved recently? | This page, generated from lastUpdated at build time |
| What changed in behavior, config keys, or migration steps? | The changelog |
| What is still an unmerged proposal? | The roadmap |
Omitting the date hides the calibration from readers. When you add a capability note to the changelog, still bump the related pages so both surfaces stay aligned.