What a Senior } should know

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Designs solutions based on ASP.NET Core for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.

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.

Designs search solutions: Elastic.Clients.Elasticsearch for .NET, custom analyzers, nested documents, aggregations. Optimizes mapping and bulk indexing pipeline. Integrates with CQRS read model.

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.

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.

Designs distributed caching: Redis Cluster, Lua scripts for atomic operations, Redis Streams for event-driven invalidation. Uses StackExchange.Redis pipelining for batch operations.

Designs connection management for .NET microservices: configures multi-database routing with separate pools (read replicas), implements connection resilience via Polly retry policies, designs connection drain for graceful shutdown. Diagnoses pool fragmentation and connection leaks via diagnostics.

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.

Designs indexing strategy: partial indexes, covering indexes, GIN for JSONB. Analyzes index bloat. Configures monitoring via DMV (SQL Server) or pg_stat_user_indexes.

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.

Designs sharding for .NET microservices: implements custom shard router with consistent hashing, configures cross-shard queries via Elastic Query (Azure SQL) or custom scatter-gather, designs resharding with zero-downtime. Optimizes connection pooling for hundreds of shards.

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.

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.

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.

Designs transaction model: distributed transactions via Saga (MassTransit), eventual consistency, compensating transactions. Optimizes transaction scope. Uses TransactionScope for cross-DbContext.

Builds documentation pipeline: auto-generation + manual guides, versioned docs. Uses NSwag for client SDK generation. Integrates with developer portal.

Designs versioning strategy: consumer-driven contracts, schema evolution via Protobuf. Automates breaking change detection in CI. Manages migration between versions.

Designs GraphQL architecture: Schema Stitching/Federation for microservices, subscriptions via WebSocket, persisted queries. Optimizes execution engine and complexity analysis.

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.

Designs rate limiting for .NET microservices: implements token bucket with concurrency limiter for CPU-bound endpoints, configures YARP reverse proxy with rate limiting, designs adaptive limiting via health checks integration. Optimizes for minimal GC pressure in high-throughput scenarios.

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.

Designs Docker strategy: base images, AOT compilation for minimal containers, security scanning via Trivy. Optimizes startup via ReadyToRun. Configures Buildpacks.

Designs K8s architecture: namespace-per-team, service mesh, GitOps via ArgoCD/Flux. Optimizes .NET in K8s: ServerGC vs WorkstationGC, container-aware GC settings.

Designs infrastructure solutions with Microsoft Azure. Optimizes cost and performance. Implements best practices and security hardening.

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 CI/CD: reusable workflows, artifact promotion, canary deployments. Integrates quality gates: SonarQube, OWASP dependency check, container scanning.

Designs integration testing strategy: slice tests vs full integration, contract testing via Pact-Net, load testing via NBomber. Optimizes CI time.

Introduces TDD/BDD culture: outside-in TDD for domain layer, SpecFlow + ASP.NET TestServer for integration. Designs testable architecture via DI.

Designs TestContainers.NET testing architecture for .NET microservices: shared container networks, custom health check strategies, and test data migration pipelines. Optimizes test execution time with container reuse and parallel test isolation patterns.

Designs unit testing strategy: test fixtures, shared utilities, ArchUnitNET for architectural rules. Optimizes test suite: parallel execution. Mentors on testing patterns.

Designs auth architecture: centralized IdP (Duende IdentityServer), token exchange, fine-grained authorization (OPA/Cedar). Multi-tenancy via claims. Token security: rotation, revocation.

Designs security architecture: threat modeling (STRIDE), SAST/DAST in CI, dependency scanning (Snyk/Dependabot). Implements security-as-code via ASP.NET Core middleware pipeline.

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.

Maximizes productivity: generates SQL, K8s manifests, NBomber performance tests. Builds workflow where AI accelerates routine.

Designs with Hexagonal Architecture: ports for business logic, adapters for EF/Kafka/REST. Refactors legacy. Anti-corruption layers between bounded contexts.

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.

Designs .NET system architecture: decomposition into microservices, event-driven via MassTransit, CQRS. Defines API contracts (OpenAPI, gRPC). Capacity planning via BenchmarkDotNet.

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.

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.

Designs tracing architecture: sampling strategies, context propagation via messaging, custom instrumentation. Optimizes overhead and costs.

Designs .NET platform monitoring: RED metrics, .NET runtime dashboards, distributed tracing. SLI/SLO dashboards. Optimizes cardinality.

Designs logging for .NET platform: correlation via Activity/DiagnosticSource, distributed tracing via OpenTelemetry. Log sampling for high-throughput. Integration with Grafana Loki.

Architectural review: system impact, backward compatibility, performance. Migrations, API contracts, DI configurations. Mentors through review.

Defines branching strategy: trunk-based with feature flags, release branches. Git hooks for quality gates (dotnet format, analyzers). Semantic versioning via GitVersion.