Scaffolder.net is a deterministic code generation platform that produces complete, production-ready .NET solutions from a simple configuration interface. Instead of manually creating projects, folders, and boilerplate code, you define your domain model — Solutions, Bounded Contexts, Entities and their Properties — and Scaffolder.net generates the full Clean Architecture solution structure with all layers: Domain, Application, Infrastructure.Persistence, and optional Presentation projects (Blazor Server, Blazor WebAssembly, Minimal API).

No. Scaffolder.net does not use Artificial Intelligence. There are no tokens, no hallucinations, no syntax errors, and no waiting. The code generation is 100% deterministic, based strictly on your specified domain model. Every generated file is guaranteed to compile and follow best practices consistently across the entire solution.

No. The generated code is completely yours. You download a ZIP archive containing the full solution, extract it anywhere, and open the .slnx file in your preferred IDE. There is no runtime dependency on Scaffolder.net — your application runs entirely independently.

The generated solution uses modern .NET technologies with minimal, open-source dependencies: .NET 10, C# 14, Entity Framework Core for data access, Blazor Server and Blazor WebAssembly with MudBlazor components for the web UI, Minimal API with Scalar for API documentation, FluentValidation for input validation, and Serilog for structured logging.

The generated solution implements a cohesive set of industry-proven design patterns: Clean Architecture with Vertical Slices, Domain-Driven Design (DDD), CQRS (Command Query Responsibility Segregation), a custom Mediator pattern with compiled expression trees for optimal performance, the Result pattern for operation outcomes, the REPR pattern, the Repository pattern (Domain, Command, and Query repositories), the Unit of Work pattern for transaction management, the Proxy pattern for remote execution via HTTP, the Options pattern for strongly-typed configuration, EF Core Interceptors for domain event publishing, the Factory Method pattern on entities, the Template Method pattern on base repository classes, the Facade pattern with application services, and the Strategy pattern with per-entity EF Core configurations.

Each bounded context can independently configure one or more presentation types: Blazor Server with a full CRUD UI (list, details, create, edit, delete dialogs), Blazor WebAssembly with the same CRUD UI executing client-side via HTTP proxies, and Minimal API exposing REST endpoints with automatic Scalar documentation. You can combine multiple presentations within the same bounded context.

Yes. Each solution supports multiple bounded contexts, each representing a coherent domain boundary. Every bounded context generates its own Domain, Application, and Infrastructure.Persistence projects, and can independently configure its presentation types. Shared projects provide common abstractions and cross-cutting implementations reused across all bounded contexts.

Entity properties support the following types: Bool, Byte, DateTime, Decimal, Double, Enum (with custom enum type name), Float, Guid, Int, Long, Short, and String. Each type offers relevant constraints: minimum/maximum values for numerics, precision and scale for decimals, minimum/maximum date for DateTimes, minimum/maximum length and Unicode for strings, uniqueness, and nullability. Foreign key relationships (one-to-one and one-to-many) are also supported via the Foreign Entity field.

Yes. Domain events can be enabled per entity. When enabled, the generator creates Created, Edited, and Deleted domain event records. Events are raised by entities, collected by an EF Core SaveChangesInterceptor before persistence, and published via a DomainEventPublisher to all registered handlers after a successful SaveChangesAsync — ensuring no event is emitted for a failed transaction.

Validation is handled by FluentValidation at multiple levels. Entity validators validate business invariants before creation and edition. Command request validators validate incoming requests before handler execution. Validation rules are generated based on property types and constraints (min/max length for strings, range for numerics, min/max dates for DateTimes). All validation errors are returned as structured Result failures with localized messages, never as exceptions.

The generated code uses a custom Result pattern instead of exceptions for expected business errors. The Result class exposes Ok() and Fail() factory methods, and the generic Result<T> encapsulates a typed return value. Domain errors include uniqueness violations (e.g., "Name already exists"), and application errors include NotFound. The Minimal API maps errors to RFC-compliant ProblemDetails responses. Global error handling and structured logging with Serilog are configured in every presentation project.

Yes. The generated solution includes resource files (.resx) for multi-language management at every layer (Domain, Application, Presentation). Property display names, error messages, and UI labels are automatically humanized and localized. Default and supported cultures are configurable via the Options pattern in appsettings.json. The Minimal API respects the Accept-Language header for request localization.

The generated code uses Entity Framework Core and is configured for SQL Server (or SQL Server Express). The DbContext factory enables resilient operations with EnableRetryOnFailure for transient faults. A design-time DbContext factory is generated for migrations. Connection strings can be configured via appsettings.json or environment variables (recommended for production).

Absolutely. The generated code is 100% yours with no runtime dependency. You can modify, extend, and customize every file after download. The code follows standard .NET conventions and best practices, making it easy to understand and adapt. You can also regenerate the solution at any time by updating your domain model and downloading a new version.

You need the .NET 10 SDK installed on your development machine, an IDE such as Visual Studio, VS Code, or JetBrains Rider, and SQL Server or SQL Server Express installed and running. After downloading and extracting the ZIP, you configure the connection string, run EF Core migrations (dotnet ef migrations add and dotnet ef database update), and launch the presentation project as the startup project.

Scaffolder.net is ideal for development teams accelerating project kickoff, enterprise architects enforcing architectural standards across multiple projects, rapid prototyping with production-ready architecture, consultants delivering solutions faster while maintaining best practices, and learners exploring proper .NET solution structure, Clean Architecture, design patterns, and Domain-Driven Design.

Yes. Foreign key relationships are fully supported. You can define one-to-one relationships by setting a single property as the primary key with a foreign entity, or one-to-many relationships by selecting a foreign entity on a property. The generator produces navigation properties on both entities, configures cascade delete behavior, and generates EF Core entity configurations with proper relationship mapping. Composite primary keys (multiple properties) are also supported for many-to-many scenarios.

Each layer exposes an Add{Layer}Services extension method serving as a Composition Root. Service registration is automatic via marker interfaces and reflection: the generator scans assemblies for classes implementing IDomainRepository, ICommandRepository, IQueryRepository, ICommandService, IQueryService, and other marker interfaces, then registers them with their corresponding interfaces. All services, handlers, and repositories are registered as Scoped for transaction consistency per request.

Within each layer, code is organized by Vertical Slices: each entity has its own Features/{EntityName} folder grouping all related files. Commands (Create, Edit, Delete) include commands, handlers, requests, responses, validators, and proxies. Queries (GetList, GetDetails, GetEdit, GetDelete) include queries, handlers, requests, responses, and proxies. Each feature also has its own services (CommandService and QueryService as facades to the Mediator), domain event handlers, and localized resources.