What a Lead } should know

Sets performance budgets for .NET services. Conducts reviews focused on algorithmic complexity and allocations. Implements BenchmarkDotNet in CI for performance regression testing.

Defines async strategy in .NET: async/await best practices, Channel<T> for producer-consumer, IAsyncEnumerable for streaming. Implements CancellationToken and ValueTask standards.

Establishes .NET code quality standards: .editorconfig, Roslyn analyzers, SonarQube quality gates. Implements Architecture Decision Records. Balances speed and quality through continuous refactoring.

Defines data handling standards: record types, immutable collections, value objects. Reviews collection choices for performance (Span<T>, ArrayPool). Implements source generators for optimization.

Establishes .NET team architectural standards: MediatR for CQRS, FluentValidation, Options pattern. Defines Dependency Injection conventions. Conducts architectural reviews.

Defines generics usage standards: constraints, covariance/contravariance, generic host builders. Reviews API design focused on type safety and ergonomics.

Defines .NET team concurrency standards: SemaphoreSlim vs lock, ConcurrentDictionary, Interlocked operations. Implements concurrent code testing practices. Conducts thread safety reviews.

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.

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.

Defines Kafka strategy: topic naming, schema evolution policy, MassTransit vs raw Confluent.Kafka. Implements event-driven communication standards and consumer lag monitoring.

Defines ASP.NET Core architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Defines caching standards: what data to cache, TTL policies, invalidation strategies. Implements metrics and alerting. Balances data freshness and latency.

Defines full-text search strategy: Elasticsearch for search vs SQL for filtering, ILM, capacity planning. Implements monitoring via Kibana.

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.

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.

Defines product caching strategy: multi-level cache, warming, invalidation policies. Establishes metrics and SLA for cache performance. Chooses between Redis and Garnet.

Standardizes connection management for .NET: creates NuGet package for standard pool setup with health checks and metrics, defines connection policies for Azure SQL/PostgreSQL deployments. Designs connection governance with per-service budgets and centralized monitoring.

Defines modeling standards: EF Core conventions, naming strategy, documentation. Reviews models for DDD compliance and performance.

Defines indexing standards: mandatory query plan review in PRs, index naming conventions, automatic missing index detection.

Defines migration standards: EF Core vs DbUp vs FluentMigrator, review process for schema changes, rollback strategies. Tests migrations on production data copies.

Standardizes sharding in .NET ecosystem: creates NuGet packages for standard sharding setup, designs migration tooling for per-shard schema management, implements health monitoring and auto-rebalancing. Determines when Cosmos DB partitioning vs SQL sharding.

Defines MySQL standards for team: naming conventions, migration workflow via EF Core Migrations, performance budgets. Conducts schema and query reviews.

Defines PostgreSQL standards: extension policy, schema review, monitoring via pg_stat_statements. Chooses between EF Core, Dapper and raw Npgsql for different scenarios.

Defines query performance standards: execution time budgets, mandatory profiling. Implements automatic slow query monitoring.

Defines transaction standards: DbContext lifetime rules, isolation levels, conflict handling strategies. Conducts transaction boundary reviews.

Defines documentation standards: mandatory sections, examples, changelog format. Implements docs-as-code. Ensures developer experience.

Defines versioning policy: deprecation strategy, minimum support window, communication plan. Implements automated compatibility testing.

Defines GraphQL strategy: schema conventions, federation architecture, performance budgets. Implements schema registry and breaking change detection.

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.

Standardizes rate limiting in .NET ecosystem: creates NuGet packages for standard setup, designs centralized rate limit service for microservices, implements metrics via OpenTelemetry. Defines API management policies for enterprise API products.

Defines product API standards: naming conventions, error format (ProblemDetails), pagination, versioning policy. Implements contract-first approach. Conducts API design reviews.

Defines Docker standards: base image policy, layer caching, size budgets. Implements automated scanning. Standardizes docker-compose.

Defines K8s standards: deployment strategies, resource quotas, pod security. Implements GitOps and IaC. Conducts capacity planning.

Defines infrastructure strategy with Microsoft Azure. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.

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

Defines CI/CD standards: pipeline templates, branching strategy, release process. Implements automated rollback and feature flags.

Defines standards: mandatory scenarios for endpoints, test environment management, test data strategy. Implements contract testing.

Defines testing strategy: test pyramid, coverage targets, BDD for acceptance criteria. Implements quality gates. Balances speed and coverage.

Defines Testcontainers standards: shared container definitions, custom modules for internal services, CI configuration. Optimizes via container reuse.

Defines unit testing standards: coverage requirements, naming conventions, mutation testing (Stryker.NET). Monitors test health metrics.

Defines auth strategy: SSO, MFA, session management. Implements identity governance. Conducts security review of auth solutions.

Defines security standards: OWASP compliance checklist, security review process, incident response. Trains on secure coding.

Establishes secure coding standards: security checks in PRs, approved crypto libraries, data classification. Implements security training.

Introduces Copilot to team: policies, boundaries, training. Evaluates ROI. Security aspects: secret leaks, licenses.

Defines architectural standards: solution structure, dependency rules, ArchUnitNET tests. Balances cleanliness and speed.

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.

Makes architectural decisions: monolith vs microservices, MassTransit vs raw Kafka, sync vs async. Documents ADRs. Mentors senior developers.

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.

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.

Defines OpenTelemetry standards: Activity naming, tag conventions, mandatory spans. Trace-based alerting. Dependency mapping.

Defines monitoring strategy: mandatory metrics, SLO, error budget. Observability culture. Post-mortem with metrics.

Defines logging standards: mandatory enrichers, log levels, retention. Implements log-based alerting. Compliance requirements.

Shapes code review culture: level-based checklists, SLAs, automated checks (SonarQube, ArchUnitNET). Resolves disagreements. Reviews ADRs.

Shapes Git workflow: branching model, PR process, CODEOWNERS, required checks. Mono vs multi-repo. Automates dependabot.