Home

MODULAR .NET DEVELOPMENT KIT

Empowering developers with modular components for modern application development, centered around Domain-Driven Design principles.

bITdevKit brings together domain modeling, requests, messaging, queueing, storage, scheduling, and presentation patterns into a practical toolkit for real-world systems built with clean architecture and DDD.

Get Started Use Templates Explore Docs View Source

Choose a start path

Learn the devkit

Start with the GettingStarted example, the DDD introduction, and the guided first-read path.

Scaffold a solution

Install the templates and create a new solution or module that already follows the expected structure.

Explore examples

Move from the focused GettingStarted example to broader scenarios like DoFiesta and EventSourcingDemo.

Read the docs

Browse the documentation map by capability area and feature-specific guide.

Capabilities for real-world application needs

Browse the full documentation overview

Domain

Aggregates, value objects, typed ids, specifications, policies and event-driven domain modeling.

Application

Commands, queries, handlers, mapping and explicit application orchestration with clear boundaries.

Requester & Notifier

In-process dispatching for request/response and publish/subscribe flows with reusable pipeline behaviors.

Messaging

Durable asynchronous messaging and outbox-backed delivery for decoupled application communication.

Queueing

Single-consumer work processing with operational visibility, retry/archive control and broker abstractions.

Pipelines

Structured, observable multi-step workflows for in-process execution with low-friction defaults.

Storage

Document and file storage abstractions, monitoring, behaviors and provider-based extensibility.

Scheduling

Startup tasks, background jobs and operational scheduling capabilities for hosted applications.

Presentation

Minimal API endpoints, console commands, CORS, exception handling and Blazor application state support.

Why not just plain ASP.NET Core + MediatR + EF Core?

More than a library stack

bITdevKit provides a coherent model for results, rules, request flow, modules, and operational infrastructure instead of leaving each project to compose its own conventions.

Developer guidance with reusable defaults

Examples, templates, and aligned documentation reduce the amount of architectural assembly work needed at project start.

Read the full why bITdevKit page

Designed for modular, maintainable .NET systems

ARCHITECTURE

Clean architecture, modular vertical slices and DDD by default.

bITdevKit is shaped around clear boundaries between domain, application, infrastructure and presentation. It supports modular systems where cross-cutting building blocks stay reusable while business logic remains explicit and testable.

See the architecture map

Presentation Infrastructure Application Domain

Request flow in practice

app.MapPost("/customers", async (CustomerCreateModel model, IRequester requester) =>
{
    var command = new CustomerCreateCommand(model);
    var result = await requester.SendAsync(command);

    return result.MapHttpCreated();
});

See the request flow and layer map

Example applications

GettingStarted

The canonical onboarding project for learning the devkit through a focused end-to-end example before building your own solution.

Open example

DoFiesta

A richer example application used throughout the repository to show operational, messaging, scheduling and UI integration scenarios.

Open example

EventSourcingDemo

A focused example for exploring how event-sourcing-oriented concepts fit into the broader development kit.

Open example

Explore the examples

Templates for new solutions and modules

SCAFFOLDING

Start from a working structure instead of assembling it by hand.

`bITdevKit` ships with .NET templates that can scaffold a full solution or add new modules using the kit's architectural conventions. That makes it easier to move from learning to a real project without rebuilding the same structure manually.

Explore the templates

Solution Module Tests Presentation

Common early decisions

Messaging vs Queueing

Choose between event fan-out and single-consumer work ownership based on runtime semantics.

Repository vs ActiveEntity

Pick between a richer DDD-oriented abstraction and a simpler persistence style for faster CRUD scenarios.

Package map

Understand the repository as grouped package families instead of a flat project list.

Why bITdevKit

See when the devkit pays off and when a simpler stack may be enough.