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.

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.

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.

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.

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.

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.