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.

Independently implements tasks with ASP.NET Core. Understands internals and optimizes performance. Writes tests.

Optimizes connection pooling in .NET: configures Npgsql connection pool for PostgreSQL, implements connection string building via NpgsqlConnectionStringBuilder, monitors pool via NpgsqlConnection.GlobalStatistics. Configures EF Core pooling via AddDbContextPool.

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.

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 GraphQL API: custom scalars, DataLoader for N+1, pagination via Relay. Configures filtering/sorting via Hot Chocolate conventions. Handles errors through error filter middleware.

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.

Independently designs schemas and optimizes queries with MySQL / MariaDB. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

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.

Implements rate limiting in .NET services: uses System.Threading.RateLimiting with Redis partitioned limiter for distributed scenarios, configures Polly rate limiting policy, implements custom RateLimiterPolicy for complex business rules. Integrates with ASP.NET Core output caching.

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 RESTful API: versioning via Asp.Versioning, content negotiation, pagination via cursor/offset. Documents via Swashbuckle/NSwag. Handles errors through ProblemDetails (RFC 7807). Implements HATEOAS.

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.

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.

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 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.

Designs API documentation: OpenAPI spec generation via Swashbuckle, XML docs, Swagger examples. Automates freshness checks. Documents auth flows and error codes.

Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

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.

Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

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.

Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

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.

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.

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.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

Implements versioning: multiple API versions simultaneously via ApiVersion, deprecation via Sunset header. Automates compatibility checks. Plans migration path.

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.

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.

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.

Independently designs schemas and optimizes queries with transactions and concurrency. Understands indexing and query execution plans. Uses Entity Framework Core effectively.

Works with sharded databases in .NET: uses Elastic Database Client Library for Azure SQL sharding, implements tenant-based routing via IDbContextFactory, configures EF Core with dynamic connection strings. Applies Unit of Work pattern for shard-aware transactions.