.NET Core Application Template Documentation
Reusable, production-oriented ASP.NET Core baseline
Start an ASP.NET Core application with authentication, authorization, structured logging, telemetry, security headers, rate limiting, health checks, and EF Core data access already implemented and tested.
The .NET Core Application Template (NCAT) exists so teams do not rebuild the same security and operational foundations for every application. Use it when you are starting a long-lived, team-maintained ASP.NET Core web application or API that needs those foundations from the first commit. NCAT is a baseline, not a finished, penetration-tested, or certified application: each generated application still needs its own configuration, threat analysis, deployment controls, testing, and security review.
This site is the implementation and operational reference for NCAT. It is authoritative for the template's generated behavior, template options, configuration, middleware order, authentication and authorization defaults, data-access implementation, public surface, ADRs, release compatibility, and runtime contracts.
Start here
dotnet new, choose template options, and validate the scaffold.
Build, test, and run it
Prerequisites, local build and test commands, first startup, and local documentation serving.
Secure sign-in and access
Cookie authentication with authenticated-by-default routed endpoints, and how to change it safely.
Observe the application
Structured Serilog logging, with telemetry and health checks documented alongside.
Work with data
EF Core with SQLite for local development or SQL Server, and audit records written on save.
Deploy and operate
The production checklist, reverse proxy and container notes, and runtime readiness.
Is the template a fit?
Use the template when
- you are starting a long-lived web application or API that a team will maintain and operate;
- you want secure defaults, structured logging, telemetry, health checks, and data access configured and tested from day one; and
- you want a documented public surface and middleware order to extend rather than reinvent.
If you choose the template, keep its secure defaults. Each reference article explains what a default protects before you change it.
When this may be unnecessary
- For a prototype, demo, or small single-purpose service, the built-in
dotnet new web,webapi, orwebapptemplates give a smaller starting point you can grow deliberately. - If your organization already has a platform template, adopt individual patterns instead, using articles such as Security Headers, Rate Limiting, and Forwarded Headers as references.
- If framework authorization and a simple service are enough, see When ASP.NET Core Authorization Is Enough and When a Simple Application Service Is Enough.
Not every application needs every feature the template provides.
At a glance
| Area | Current reference |
|---|---|
| Current release | 2.11.10 (release notes) |
| Supported platform | .NET 10.0 |
| Template package | NetCoreApplicationTemplate on NuGet |
| Template short name | netcoreapp-template |
| Default authentication | Cookie authentication with authenticated-by-default routed endpoints |
| Default data provider | SQLite for local development |
Understand the generated application
- Project Structure explains the generated projects and responsibilities.
- Configuration documents the application-owned configuration surface.
- Middleware Pipeline records the runtime ordering contract and extension points.
Generated application reference
Use these articles when you need the exact behavior of the scaffold rather than general ASP.NET Core guidance:
- Authentication
- Authorization
- Error Handling
- Logging
- Telemetry
- Security Headers
- Forwarded Headers
- Rate Limiting
- Health Checks
- API Versioning
- Data Access
The Public Surface and Compatibility Boundaries article records the generated configuration, routes, template symbols, middleware ordering, and other behavior consumers may rely on.
Extensibility
These references identify the intended growth points and the behavior that should remain stable when extending a generated application.
Deployment & operations
Architecture decisions and API reference
Repository-local design decisions remain first-class NCAT documentation because they explain why this implementation chose its concrete behavior.
Release & compatibility
Release and readiness evidence remains available after the core usage and implementation reference:
Historical archive
- v0.5.x to v1.0 Migration Guide — retained at its original URL for consumers of preview releases; it is not current upgrade guidance.
Learn the architecture
For organization-level software architecture education, ASP.NET Core teaching, terminology, tutorials, tradeoff analysis, architectural comparisons, labs, and general secure-by-default guidance, use AsiBackbone Learning.
Learning provides broader educational context; it does not define NCAT runtime behavior. See Documentation Ownership for the cross-repository ownership contract.
Related projects
Neither related project is a dependency of the template. Generated applications do not reference any AsiBackbone package. If a host later adopts AsiBackbone, Audit Accountability Integration describes the host-owned integration seams.
AsiBackbone Learning
Practical .NET architecture tutorials, labs, runnable samples, and reference patterns for governed execution, secure applications, AI integration, and policy-driven systems, including comparisons that show when these patterns are unnecessary.
AsiBackbone
A .NET governance and policy-control framework for auditable decision flows: policy evaluation, auditable decision records, acknowledgment workflows, capability-based authorization, host-owned execution boundaries, and ASP.NET Core integration.
.NET Core Application Template Current site
A secure-by-default ASP.NET Core application template with authentication and authorization, structured logging, security headers, rate limiting, EF Core data access, reverse proxy support, and Problem Details error handling.
AsiBackbone Reference Application
An NCAT-generated ASP.NET Core host that records the step-by-step integration of AsiBackbone, with host-specific API documentation and runnable governance examples added as the walkthrough progresses.
Design philosophy
We favor architectures where consequential operations are explicit, constrained, reviewable, and auditable.
We also document when these patterns are unnecessary: see When this may be unnecessary, When ASP.NET Core Authorization Is Enough, and When a Simple Application Service Is Enough.
The projects focus on practical .NET engineering. They do not claim regulatory certification or automatic compliance.