AI Coding Assistants 1
▼
Uses Copilot for generating C# code: LINQ queries, ASP.NET endpoints, unit tests. Validates type correctness and null safety.
Productively works with Copilot: generates tests, migrations, configurations. Uses Copilot Chat for legacy analysis. Critically evaluates for thread-safety and security.
Maximizes productivity: generates SQL, K8s manifests, NBomber performance tests. Builds workflow where AI accelerates routine.
Introduces Copilot to team: policies, boundaries, training. Evaluates ROI. Security aspects: secret leaks, licenses.
Algorithms & Data Structures 2
▼
Understands basic algorithmic concepts in C#: simple LINQ operations, basic sorting and searching in collections, loop-based algorithms for data processing. Follows team guidance on algorithm selection and applies standard .NET collection operations.
Independently applies algorithmic thinking in C#: selects efficient LINQ operations for data processing, understands parallel algorithm patterns with TPL, evaluates collection algorithm trade-offs. Analyzes computational complexity of hot code paths in .NET services.
Applies algorithmic expertise in .NET development: LINQ query optimization for efficient data processing, parallel algorithm design with TPL, lock-free concurrent algorithms using Interlocked operations. Evaluates algorithmic complexity in hot paths and designs efficient caching strategies with proper eviction algorithms.
Sets performance budgets for .NET services. Conducts reviews focused on algorithmic complexity and allocations. Implements BenchmarkDotNet in CI for performance regression testing.
Understands basic .NET collection types: List, Dictionary, HashSet for common operations. Follows team conventions for data model classes and entity structures. Applies simple data structures for CRUD operations and API request/response handling.
Independently selects appropriate data structures in C#: Dictionary vs SortedDictionary for different access patterns, List vs LinkedList for collection operations, ConcurrentBag for thread-safe scenarios. Understands trade-offs between value types and reference types for memory allocation.
Selects optimal data structures for .NET applications: ConcurrentDictionary for thread-safe caching, ReadOnlySpan for zero-allocation parsing, ImmutableList for functional patterns. Optimizes collection usage considering GC pressure and memory layout. Designs custom data structures using C# generics and struct constraints.
Defines data handling standards: record types, immutable collections, value objects. Reviews collection choices for performance (Span<T>, ArrayPool). Implements source generators for optimization.
API Management 2
▼
Documents API via XML comments and Swagger annotations: summary, remarks, response types. Maintains Swagger UI. Describes parameters and examples.
Designs API documentation: OpenAPI spec generation via Swashbuckle, XML docs, Swagger examples. Automates freshness checks. Documents auth flows and error codes.
Builds documentation pipeline: auto-generation + manual guides, versioned docs. Uses NSwag for client SDK generation. Integrates with developer portal.
Defines documentation standards: mandatory sections, examples, changelog format. Implements docs-as-code. Ensures developer experience.
Understands API versioning. Uses Asp.Versioning: URL segment, query string, header-based. Maintains backward compatibility. Knows semantic versioning.
Implements versioning: multiple API versions simultaneously via ApiVersion, deprecation via Sunset header. Automates compatibility checks. Plans migration path.
Designs versioning strategy: consumer-driven contracts, schema evolution via Protobuf. Automates breaking change detection in CI. Manages migration between versions.
Defines versioning policy: deprecation strategy, minimum support window, communication plan. Implements automated compatibility testing.
API Protocols 1
▼
Understands gRPC fundamentals in .NET: proto file definitions, code generation with protobuf-net/Grpc.Tools, and basic unary RPC calls. Follows team patterns for implementing gRPC services and clients with ASP.NET Core gRPC.
Develops gRPC services on ASP.NET Core: implements all RPC types including bidirectional streaming via IAsyncStreamReader/IAsyncStreamWriter, configures Interceptor for logging and auth, integrates with DI container. Uses Grpc.Net.ClientFactory for typed gRPC clients.
Designs gRPC architecture for .NET microservices: configures gRPC-JSON transcoding for REST compatibility, implements health checks via Grpc.HealthCheck, optimizes through HTTP/2 connection management. Integrates with OpenTelemetry.Instrumentation.GrpcNetClient for distributed tracing.
Standardizes gRPC in .NET ecosystem: creates NuGet packages with base interceptors and configuration, implements source generators to reduce boilerplate, designs gRPC integration with MassTransit/NServiceBus for hybrid communication. Defines gRPC service testing strategy.
Application Security 2
▼
Knows OWASP Top 10. Prevents SQL injection via EF Core parameterization. Uses anti-forgery tokens. Applies [Authorize] and ASP.NET Core Identity.
Applies OWASP in .NET: security headers via middleware, rate limiting, input validation via FluentValidation. SAST through Roslyn Security analyzers. Masking in logs.
Designs security architecture: threat modeling (STRIDE), SAST/DAST in CI, dependency scanning (Snyk/Dependabot). Implements security-as-code via ASP.NET Core middleware pipeline.
Defines security standards: OWASP compliance checklist, security review process, incident response. Trains on secure coding.
Follows secure coding: doesn't hardcode secrets (User Secrets, Azure Key Vault), validates input, uses parameterized queries. Stores passwords via ASP.NET Core Identity (bcrypt).
Applies advanced practices: Data Protection API for encryption, SecureString, certificate-based auth. Configures CORS and CSP. Conducts security reviews.
Designs secure-by-default: zero-trust (mTLS), secrets management via Azure Key Vault/HashiCorp Vault, audit logging via Serilog enrichers. Automates security checks in CI.
Establishes secure coding standards: security checks in PRs, approved crypto libraries, data classification. Implements security training.
Architecture Patterns 1
▼
Follows layered architecture: Controller doesn't contain business logic, services via interfaces. Understands DI through IServiceCollection. Separates Entity and DTO.
Applies Clean Architecture: Use Cases via MediatR handlers, Domain and Infrastructure through Ports & Adapters. Inverts dependencies. Domain code without ASP.NET/EF coupling.
Designs with Hexagonal Architecture: ports for business logic, adapters for EF/Kafka/REST. Refactors legacy. Anti-corruption layers between bounded contexts.
Defines architectural standards: solution structure, dependency rules, ArchUnitNET tests. Balances cleanliness and speed.
Authentication & Authorization 1
▼
Understands JWT and OAuth2. Configures ASP.NET Core Authentication: AddJwtBearer, [Authorize] with policies. Works with Identity Server/Auth0/Azure AD as IdP.
Implements full auth flow: OAuth2 Authorization Code + PKCE, token refresh, policy-based authorization. Configures multiple auth schemes. Implements RBAC and claims-based access.
Designs auth architecture: centralized IdP (Duende IdentityServer), token exchange, fine-grained authorization (OPA/Cedar). Multi-tenancy via claims. Token security: rotation, revocation.
Defines auth strategy: SSO, MFA, session management. Implements identity governance. Conducts security review of auth solutions.
Caching 2
▼
Uses caching in .NET at a basic level: IMemoryCache, IDistributedCache with Redis. Follows team patterns for cache-aside implementation and TTL configuration. Understands basic cache invalidation concepts and cache key naming conventions.
Independently implements caching strategies in .NET: distributed caching with StackExchange.Redis, output caching, response caching middleware. Understands cache stampede prevention, write-through vs write-behind patterns, and cache warming.
Designs multi-level caching: MemoryCache + HybridCache (.NET 9) + Redis. Implements write-behind for batch persistence, pre-warming on deployments. Optimizes serialization via System.Text.Json source generators.
Defines caching standards: what data to cache, TTL policies, invalidation strategies. Implements metrics and alerting. Balances data freshness and latency.
Uses Redis via StackExchange.Redis/IDistributedCache. Caches frequently requested data with TTL. Understands basic structures: strings, hashes, sets. Configures connection via appsettings.json.
Designs caching in .NET: IMemoryCache (L1) + IDistributedCache/Redis (L2), cache-aside pattern. Implements cache stampede protection via SemaphoreSlim. Configures Redis Sentinel for HA. Monitors hit ratio.
Designs distributed caching: Redis Cluster, Lua scripts for atomic operations, Redis Streams for event-driven invalidation. Uses StackExchange.Redis pipelining for batch operations.
Defines product caching strategy: multi-level cache, warming, invalidation policies. Establishes metrics and SLA for cache performance. Chooses between Redis and Garnet.
Clean Code & Refactoring 1
▼
Understands basic code quality principles for C#/.NET development. Follows team coding standards and Roslyn analyzer recommendations. Writes simple, clean methods following C# naming conventions. Accepts code review feedback and learns from established design patterns.
Independently applies code quality practices in C#/.NET development. Writes clean code using modern C# features with proper LINQ usage and async patterns. Understands trade-offs between abstraction layers and performance in .NET applications. Reviews code for proper disposal patterns, null safety, and architectural boundary adherence.
Designs code quality standards for .NET projects: C# coding conventions, analyzer configurations (Roslyn, SonarAnalyzer), architectural fitness functions. Refactors legacy codebases using modern C# patterns (records, pattern matching, minimal APIs). Establishes code review culture with focus on SOLID and clean architecture.
Establishes .NET code quality standards: .editorconfig, Roslyn analyzers, SonarQube quality gates. Implements Architecture Decision Records. Balances speed and quality through continuous refactoring.
Concurrency & Parallelism 2
▼
Understands basic async programming in C#: async/await syntax, Task-based patterns, basic CancellationToken usage. Follows team conventions for async method signatures and avoids common pitfalls like async void and deadlocks.
Independently applies async programming in C#/.NET: proper async/await with ConfigureAwait, ValueTask for hot paths, IAsyncEnumerable for streaming data. Understands trade-offs between Task and ValueTask, async state machine overhead.
Designs async architectures in C#/.NET: async pipeline patterns with System.IO.Pipelines, Channel-based producer/consumer, custom async state machines for performance. Mentors team on async best practices and diagnosing async deadlocks.
Defines async strategy in .NET: async/await best practices, Channel<T> for producer-consumer, IAsyncEnumerable for streaming. Implements CancellationToken and ValueTask standards.
Understands basic multithreading in C#/.NET: Task and async/await fundamentals, basic understanding of thread safety and lock keyword, ConcurrentDictionary and thread-safe collections. Follows team conventions for async patterns in ASP.NET Core.
Independently applies multithreading in C#/.NET: Task Parallel Library for complex async workflows, Channels and pipelines for producer-consumer patterns, ConcurrentBag/Queue for thread-safe collections, understanding of SynchronizationContext and ConfigureAwait. Solves typical concurrency tasks independently.
Has deep expertise in C#/.NET multithreading: designs high-performance concurrent systems with System.Threading.Channels, implements lock-free algorithms for hot paths, optimizes thread pool usage for ASP.NET Core scalability. Mentors team on advanced concurrent programming patterns in .NET.
Defines .NET team concurrency standards: SemaphoreSlim vs lock, ConcurrentDictionary, Interlocked operations. Implements concurrent code testing practices. Conducts thread safety reviews.
Containerization 1
▼
Writes Dockerfile for ASP.NET Core: multi-stage build (sdk → runtime), HEALTHCHECK endpoint. Runs via docker-compose: app + PostgreSQL + Redis. Understands volumes, networks.
Optimizes Docker for .NET: trim self-contained, Alpine-based images, chiseled Ubuntu. Configures DOTNET_SYSTEM_GLOBALIZATION_INVARIANT for smaller images. Docker-compose for full dev environment.
Designs Docker strategy: base images, AOT compilation for minimal containers, security scanning via Trivy. Optimizes startup via ReadyToRun. Configures Buildpacks.
Defines Docker standards: base image policy, layer caching, size budgets. Implements automated scanning. Standardizes docker-compose.
Data Modeling 2
▼
Designs schemas via EF Core: Entity classes, relationship Navigation Properties, owned types for value objects. Understands normalization. Uses Fluent API for configuration.
Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Designs domain models: DDD Aggregates via EF Core, Value Objects via Owned Types, soft deletes via query filters. Chooses between EF Core and document DB based on context.
Defines modeling standards: EF Core conventions, naming strategy, documentation. Reviews models for DDD compliance and performance.
Writes migrations via EF Core: Add-Migration, Update-Database. Creates tables, columns, indexes. Understands migration idempotency. Tests on dev environment before production.
Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Designs safe migrations: zero-downtime via expand-contract pattern, data backfill via raw SQL in migrations, idempotent scripts for CI/CD. Automates via dotnet ef migrations bundle.
Defines migration standards: EF Core vs DbUp vs FluentMigrator, review process for schema changes, rollback strategies. Tests migrations on production data copies.
Database Optimization 3
▼
Creates indexes via EF Core Fluent API and migrations. Understands B-tree and hash indexes. Uses EXPLAIN for verification. Knows about index impact on INSERT/UPDATE.
Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Designs indexing strategy: partial indexes, covering indexes, GIN for JSONB. Analyzes index bloat. Configures monitoring via DMV (SQL Server) or pg_stat_user_indexes.
Defines indexing standards: mandatory query plan review in PRs, index naming conventions, automatic missing index detection.
Understands N+1 problem in EF Core and solves via Include/ThenInclude. Uses AsNoTracking for read-only queries. Analyzes generated SQL through logging.
Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Optimizes data access in .NET: compiled queries, split queries, raw SQL/Dapper for analytics. Profiles via MiniProfiler and EF Core interceptors. Uses query tags for monitoring.
Defines query performance standards: execution time budgets, mandatory profiling. Implements automatic slow query monitoring.
Understands ACID properties and isolation levels. Uses DbContext SaveChanges as unit of work. Handles concurrency via RowVersion/Timestamp. Knows the difference between optimistic and pessimistic locking.
Independently designs schemas and optimizes queries with transactions and concurrency. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Designs transaction model: distributed transactions via Saga (MassTransit), eventual consistency, compensating transactions. Optimizes transaction scope. Uses TransactionScope for cross-DbContext.
Defines transaction standards: DbContext lifetime rules, isolation levels, conflict handling strategies. Conducts transaction boundary reviews.
Domain-Driven Design 1
▼
Understands DDD tactical patterns in C#/.NET: Entity, Value Object, Repository with EF Core. Applies Ubiquitous Language in code using domain-specific naming. Implements Repository pattern with IRepository interfaces and specification pattern.
Applies DDD tactical patterns in C#/.NET: Aggregates with invariant enforcement, Domain Events via MediatR/MassTransit, Specification pattern. Designs aggregate boundaries aligned with transaction consistency. Implements rich domain models with EF Core value conversions.
Designs DDD architecture for the domain. Defines Bounded Contexts and Context Maps. Implements Anti-corruption Layer for legacy integration. Trains team on DDD. Balances DDD complexity with pragmatism.
Event-Driven Architecture 1
▼
Understands CQRS in .NET ecosystem: knows MediatR for command/query separation, distinguishes IRequest and INotification. Can add a new query handler using existing project patterns.
Implements CQRS in .NET projects: uses MediatR with FluentValidation for command validation, creates separate Dapper-based read repositories from EF Core write repositories, configures pipeline behaviors for cross-cutting concerns. Applies Clean Architecture with CQRS.
Designs CQRS architecture for .NET microservices: integrates with Marten or EventStoreDB for event sourcing, implements projections via subscription processors, configures different read stores (SQL Server for reports, Redis for real-time). Ensures testability via ArchUnit tests for CQRS boundaries.
Standardizes CQRS in .NET organization: chooses between MediatR, Wolverine and custom implementations, creates NuGet packages for standard CQRS setup, designs distributed CQRS via MassTransit. Defines architectural guidelines and trains teams on DDD + CQRS + ES.
Git & Workflows 1
▼
Confidently works with Git in .NET projects: commit, push, branch, merge. Follows branching model. Writes conventional commits. Resolves conflicts in .csproj and .sln.
Uses Git advanced: interactive rebase, cherry-pick, bisect. Configures .gitattributes for .NET. Manages conflicts in solution files. Reviews PRs.
Defines branching strategy: trunk-based with feature flags, release branches. Git hooks for quality gates (dotnet format, analyzers). Semantic versioning via GitVersion.
Shapes Git workflow: branching model, PR process, CODEOWNERS, required checks. Mono vs multi-repo. Automates dependabot.
GraphQL 1
▼
Creates GraphQL schemas via Hot Chocolate: types, queries, mutations. Implements resolvers. Understands differences with REST. Tests via Banana Cake Pop.
Designs GraphQL API: custom scalars, DataLoader for N+1, pagination via Relay. Configures filtering/sorting via Hot Chocolate conventions. Handles errors through error filter middleware.
Designs GraphQL architecture: Schema Stitching/Federation for microservices, subscriptions via WebSocket, persisted queries. Optimizes execution engine and complexity analysis.
Defines GraphQL strategy: schema conventions, federation architecture, performance budgets. Implements schema registry and breaking change detection.
Infrastructure as Code 1
▼
Understands Infrastructure as Code concept and Terraform basics. Can run terraform plan/apply for .NET application infrastructure. Understands state file purpose and remote backends. Makes changes to existing .tf files for Azure/AWS resources used by C# services.
Writes Terraform configurations for .NET service infrastructure: Azure App Services, SQL databases, Service Bus, Key Vault. Uses modules for environment replication (dev/staging/prod). Works with remote state (Azure Storage backend). Uses workspaces for multi-environment management. Imports existing Azure resources into Terraform.
Designs modular Terraform architecture for .NET microservices platform. Creates reusable Azure modules with comprehensive documentation. Configures Terragrunt for DRY multi-environment configurations. Implements policy as code (Azure Policy + OPA) for compliance. Designs state management strategy across multiple state files. Automates drift detection for production infrastructure.
Designs IaC strategy for organization. Evaluates Terraform vs Pulumi vs Crossplane. Implements self-service infrastructure via Terraform modules + Backstage. Designs multi-account/multi-project landing zones. FinOps via Terraform (tagging, cost estimation). Manages Terraform at scale (1000+ resources).
Integration Testing 1
▼
Writes integration tests via WebApplicationFactory: HTTP requests to API, response validation. Tests with in-memory database. Validates controller → service → repository flow.
Writes integration tests: Testcontainers for PostgreSQL/Redis/Kafka, WireMock.Net for HTTP dependencies. Tests transactions, auth, error handling. Manages test data via Respawn.
Designs integration testing strategy: slice tests vs full integration, contract testing via Pact-Net, load testing via NBomber. Optimizes CI time.
Defines standards: mandatory scenarios for endpoints, test environment management, test data strategy. Implements contract testing.
Kubernetes & Orchestration 1
▼
Understands basic K8s objects: Pod, Deployment, Service, ConfigMap, Secret. Deploys ASP.NET Core via kubectl. Configures health checks (/health, /ready). Reads pod logs.
Configures K8s for .NET: resource limits considering GC, HPA, graceful shutdown via IHostApplicationLifetime. Uses Helm. Configures Ingress and network policies.
Designs K8s architecture: namespace-per-team, service mesh, GitOps via ArgoCD/Flux. Optimizes .NET in K8s: ServerGC vs WorkstationGC, container-aware GC settings.
Defines K8s standards: deployment strategies, resource quotas, pod security. Implements GitOps and IaC. Conducts capacity planning.
Logging 1
▼
Uses Serilog for structured logging: levels, enrichers (RequestId, UserId), JSON format. Understands structured logging vs string interpolation. Doesn't log sensitive data.
Configures Serilog: enrichers for traceId, sinks (Console, File, Seq, ElasticSearch), log context via LogContext.PushProperty. Organizes logging pipeline in Program.cs.
Designs logging for .NET platform: correlation via Activity/DiagnosticSource, distributed tracing via OpenTelemetry. Log sampling for high-throughput. Integration with Grafana Loki.
Defines logging standards: mandatory enrichers, log levels, retention. Implements log-based alerting. Compliance requirements.
Message Queues & Event Streaming 3
▼
Understands Kafka basics for .NET services: Confluent.Kafka client setup, basic producer/consumer patterns, and topic/partition concepts. Follows team practices for message serialization and consumer group configuration in C# applications.
Implements Kafka integration for .NET microservices: event-driven communication patterns, Avro schema registry integration, and exactly-once semantics with transactions. Configures consumer groups for parallel processing with proper offset management. Implements dead letter queues and retry policies for fault-tolerant message processing.
Designs event-driven architecture on Kafka via Confluent.Kafka/.NET: consumer groups, exactly-once via transactions, Schema Registry with Avro. Optimizes throughput: batching, compression. Configures Dead Letter Topics.
Defines Kafka strategy: topic naming, schema evolution policy, MassTransit vs raw Confluent.Kafka. Implements event-driven communication standards and consumer lag monitoring.
Understands message broker patterns in .NET: publish-subscribe, request-reply, and competing consumers with MassTransit/NServiceBus. Follows team conventions for producing and consuming messages via RabbitMQ or Azure Service Bus.
Works with messaging in .NET: configures MassTransit with consumer/saga, uses NServiceBus for enterprise messaging, applies Azure Service Bus with sessions for ordered processing. Implements retry policies via Polly and configures dead letter handling.
Designs messaging architecture for .NET microservices: implements outbox pattern via EF Core with Debezium/polling publisher, configures MassTransit courier for routing slip pattern, integrates Kafka via Confluent .NET Client. Designs event-driven architecture with MediatR for internal events.
Standardizes messaging in .NET ecosystem: chooses between MassTransit, NServiceBus and Wolverine, designs event sourcing with EventStoreDB/Marten, implements saga orchestration for distributed transactions. Creates internal NuGet packages for standardizing messaging patterns.
Uses RabbitMQ with MassTransit/EasyNetQ in .NET applications at a basic level. Publishes and consumes simple messages following established patterns. Understands exchange types, queues, and basic routing concepts.
Independently implements RabbitMQ messaging with MassTransit in .NET: sagas, consumers, retry policies. Configures dead-letter exchanges and priority queues. Writes integration tests with TestHarness for message-driven workflows.
Designs RabbitMQ-based messaging architecture for .NET microservices with MassTransit. Implements saga orchestration, outbox pattern for reliable messaging, and federation for multi-datacenter setups. Optimizes throughput with batch publishing and consumer scaling.
Defines RabbitMQ architectural standards for .NET platform. Establishes messaging conventions, topology management practices, and monitoring dashboards. Conducts design reviews for event-driven architecture with MassTransit patterns.
Microservices Patterns 1
▼
Decomposes .NET monolith into microservices: extracts bounded contexts into separate ASP.NET Core services, implements anti-corruption layer with MediatR. Uses Ocelot or YARP as API gateway for Strangler Fig migration. Manages distributed transactions with MassTransit Saga orchestration.
Architects .NET microservices decomposition at scale: designs domain-driven service boundaries with CQRS and event sourcing (EventStoreDB, Marten). Implements service mesh integration (Istio sidecar with Kestrel). Designs database-per-service strategy with eventual consistency patterns. Leads Strangler Fig migrations preserving zero-downtime SLAs.
Defines .NET microservices decomposition standards across the organization: establishes reference architectures with CQRS, event sourcing, and Saga patterns. Drives service mesh adoption (Istio/Linkerd) with .NET-specific tuning. Designs cross-team service contract governance with AsyncAPI and OpenAPI specs. Reviews decomposition proposals for distributed monolith risks. Mentors senior engineers on DDD strategic design and context mapping.
OOP & Design Patterns 2
▼
Understands basic design patterns in C#/.NET: Singleton, Factory, Repository pattern in ASP.NET Core, dependency injection fundamentals with built-in DI container. Follows team conventions for pattern usage in .NET solution architecture.
Independently applies design patterns in C#/.NET: mediator with MediatR for CQRS, decorator for cross-cutting concerns, repository and unit of work for data access, specification pattern for query building. Understands trade-offs between patterns and YAGNI in .NET applications.
Has deep expertise in design patterns for .NET: designs domain-driven architectures with aggregate roots and bounded contexts, implements CQRS/ES patterns for complex business domains, optimizes pattern usage for .NET runtime performance. Mentors team on enterprise patterns for high-load .NET systems.
Establishes .NET team architectural standards: MediatR for CQRS, FluentValidation, Options pattern. Defines Dependency Injection conventions. Conducts architectural reviews.
Understands basic OOP concepts in C#: classes, interfaces, inheritance, encapsulation. Applies simple SOLID principles following .NET project conventions. Follows team patterns for service/repository class design and dependency injection setup.
Independently applies OOP/SOLID in C#/.NET: proper interface contracts for services, abstract base classes for shared behavior, dependency injection via built-in DI container. Understands trade-offs between inheritance and interface-based polymorphism in .NET architecture patterns.
Applies OOP/SOLID in .NET architecture: clean layer separation with dependency inversion, interface segregation for service contracts, proper use of C# abstractions (abstract classes, interfaces, generics). Designs Domain-Driven Design implementations using C# records, value objects, and aggregate roots.
Defines OOP standards for .NET team: records for immutability, interfaces for DI, sealed classes for performance. Trains on SOLID and DDD modeling. Conducts design reviews.
Relational Databases 2
▼
Writes SQL queries for CRUD via Entity Framework Core / Dapper. Creates tables, indexes, foreign keys. Understands normalization to 3NF. Uses MySQL Workbench for analysis.
Independently designs schemas and optimizes queries with MySQL / MariaDB. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Designs MySQL architecture for .NET services: read replicas via DbContext routing, connection pooling via Pomelo.EntityFrameworkCore.MySql. Optimizes EF Core: compiled queries, bulk operations via EFCore.BulkExtensions.
Defines MySQL standards for team: naming conventions, migration workflow via EF Core Migrations, performance budgets. Conducts schema and query reviews.
Works with PostgreSQL via EF Core (Npgsql): entity mapping, LINQ queries, raw SQL via FromSqlRaw. Understands PostgreSQL types: UUID, JSONB, arrays. Uses pgAdmin.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Entity Framework Core effectively.
Uses advanced PostgreSQL features in .NET: Npgsql bulk copy, JSONB via EF Core value converters, full-text search. Configures connection pooling (PgBouncer). Optimizes EF Core batch operations.
Defines PostgreSQL standards: extension policy, schema review, monitoring via pg_stat_statements. Chooses between EF Core, Dapper and raw Npgsql for different scenarios.
REST API 1
▼
Creates REST endpoints via ASP.NET Core Minimal API or Controllers: MapGet/MapPost, [HttpGet]/[HttpPost], model binding. Returns correct HTTP statuses via Results/IActionResult. Validates via FluentValidation.
Designs RESTful API: versioning via Asp.Versioning, content negotiation, pagination via cursor/offset. Documents via Swashbuckle/NSwag. Handles errors through ProblemDetails (RFC 7807). Implements HATEOAS.
Designs API architecture: API Gateway (YARP/Ocelot), rate limiting via RateLimiter middleware, circuit breaker via Polly. Defines contracts through OpenAPI spec-first. Optimizes via output caching and response compression.
Defines product API standards: naming conventions, error format (ProblemDetails), pagination, versioning policy. Implements contract-first approach. Conducts API design reviews.
Search Engines 1
▼
Uses Elasticsearch / OpenSearch at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.
Independently implements Elasticsearch integration in .NET with NEST/Elastic.Clients.Elasticsearch. Designs index mappings, builds complex queries with bool/nested filters, and implements bulk indexing pipelines for searchable content.
Designs search solutions: Elastic.Clients.Elasticsearch for .NET, custom analyzers, nested documents, aggregations. Optimizes mapping and bulk indexing pipeline. Integrates with CQRS read model.
Defines full-text search strategy: Elasticsearch for search vs SQL for filtering, ILM, capacity planning. Implements monitoring via Kibana.
Type Systems 2
▼
Understands C# generics syntax: declares generic classes, methods, and interfaces with type parameters (List<T>, Dictionary<TKey,TValue>). Applies basic constraints (where T : class, where T : struct, where T : new()). Correctly uses built-in generic collections and avoids boxing by choosing generic over non-generic APIs.
Designs advanced C# generic abstractions: applies covariance/contravariance on interfaces (IEnumerable<out T>, IComparer<in T>), implements generic repository and specification patterns. Uses constraints combinations (where T : class, IComparable<T>, new()) for precise API contracts. Understands generic type caching (typeof(T)), reflection over generic types, and builds fluent generic builders with method chaining.
Architects generic type systems in C# codebases: designs generic middleware pipelines (IMiddleware<TRequest, TResponse>), implements compile-time metaprogramming with source generators over generic types. Applies Curiously Recurring Template Pattern (class Base<T> where T : Base<T>) for static polymorphism. Optimizes hot paths with generic specialization techniques, profiles JIT behavior for value-type vs reference-type generic instantiations to minimize allocations.
Defines generics usage standards: constraints, covariance/contravariance, generic host builders. Reviews API design focused on type safety and ergonomics.
Understands basics of C# type system — value types vs reference types, nullable reference types, and generic constraints. Follows team conventions for type annotations, interface-based abstractions, and strongly-typed configuration patterns.
Independently applies C# type system features — nullable reference type analysis, generic variance in interfaces, and source generators for type-safe boilerplate. Understands trade-offs between record types and classes for domain modeling. Applies type-safe patterns with System.Text.Json and strongly-typed options in code reviews.
Has deep expertise in C# type system — designs domain models leveraging discriminated unions (OneOf/custom), generic math interfaces, and Span<T>/Memory<T> for high-performance type-safe code. Architects type-safe middleware pipelines and API contracts. Mentors team on advanced generics, covariance/contravariance patterns, and compile-time type validation with analyzers.
Defines typing strategy: nullable reference types, required members, init-only properties. Implements strict null checks via <Nullable>enable</Nullable>. Controls warning-as-error in CI.
Web Frameworks 1
▼
Uses ASP.NET Core at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.
Independently implements tasks with ASP.NET Core. Understands internals and optimizes performance. Writes tests.
Designs solutions based on ASP.NET Core for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines ASP.NET Core architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.