# Design Production-Ready .NET Backends

Complex .NET systems need clear architecture, reliable data access, and measurable performance. This skill guides production-ready C#, ASP.NET Core, testing, caching, and deployment decisions.

## Install

```bash
npx skillstore add sickn33/dotnet-architect
```

## Metadata

- Status: approved
- Slug: sickn33-dotnet-architect
- Skillstore revision: r2
- Version status: missing
- Tree hash: 4f71a4b235674e8e4629ba0cc2c394d32d5cbf5a8f1db984d567ce9546432580
- Author: sickn33
- GitHub username: sickn33
- License: MIT
- Repository: https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/dotnet-architect
- Ref: f9e2c34b4f19c7f3e6b0a1e93227b5f77cc12526
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: external\_commands
- Quality score: 78
- Quality tier: bronze
- Public page: https://skillstore.pages.dev/skills/sickn33-dotnet-architect
- Manifest: https://skillstore.pages.dev/api/skills/sickn33-dotnet-architect/manifest

## Capabilities

- Designs ASP.NET Core APIs, microservices, middleware pipelines, dependency injection, authentication, and health checks.
- Recommends EF Core and Dapper patterns for transactions, migrations, query performance, and connection management.
- Reviews async code, LINQ usage, memory allocation, caching, and database access for performance risks.
- Plans unit and integration testing with xUnit, mocking, WebApplicationFactory, containers, and coverage tools.
- Applies clean architecture, domain-driven design, CQRS, observability, containerization, and deployment patterns.

## Use Cases

- Modernize an ASP.NET Core API: Review an existing API and create a prioritized plan for structure, async behavior, data access, testing, security, and performance.
- Define Enterprise Service Boundaries: Compare modular monolith, vertical slice, and microservice options using scale, ownership, consistency, and operational constraints.
- Prepare a .NET Service for Production: Plan containers, health checks, telemetry, resilience, configuration, and deployment controls for a production service.

## Prompt Templates

### Structure a New API

```
Explain a suitable ASP.NET Core structure for [application]. Cover projects, dependency injection, configuration, validation, and testing.
```

### Review a Backend Design

```
Review this C# or ASP.NET Core design: [details]. Identify correctness, async, security, maintainability, and performance issues. Prioritize recommendations.
```

### Choose a Data Access Strategy

```
Design data access for [workload] using EF Core, Dapper, or both. Address transactions, query performance, migrations, testing, and failure handling.
```

### Create a Scalable Architecture Proposal

```
Create an architecture proposal for [system] at [scale]. Include service boundaries, caching, resilience, observability, security, deployment, tradeoffs, and validation steps.
```

## Limitations

- Provides guidance and examples but does not execute builds, tests, migrations, or deployments.
- Requires application code, constraints, and workload details for recommendations tailored to a specific system.
- A referenced implementation playbook is not included in the published skill package.
- Security, performance, and deployment advice still requires validation in the target environment.

## Best Practices

- Provide workload, latency, consistency, deployment, and team constraints before requesting an architecture.
- Share relevant code and observed metrics when asking for performance or reliability reviews.
- Request tradeoffs, validation steps, and test coverage with every recommended design.

## Anti Patterns

- Do not request a complete architecture without business boundaries, scale, or operational constraints.
- Do not apply microservices, repositories, CQRS, or caching without a demonstrated need.
- Do not treat generated examples as production-ready before testing security, failure behavior, and performance.

## Security Audit

- Audited at: 2026-07-23T22:55:02.798\+00:00
- Summary: Both static findings are false positives caused by Markdown backticks: a file reference on line 24 and a C\# fence beginning on line 150. The skill contains architectural guidance and example C\#; no executable shell command or malicious intent was found. No semantic security findings were identified.

## Stats

- Views: 113
- Downloads: 18
- Favorites: 0
- Popularity score: 0