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.
Sets performance budgets for .NET services. Conducts reviews focused on algorithmic complexity and allocations. Implements BenchmarkDotNet in CI for performance regression testing.
Defines .NET platform performance strategy. Designs solutions for high-throughput processing via Span<T>, Memory<T>, System.IO.Pipelines. Balances throughput, latency and GC pressure at architecture level.
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.
Defines data handling standards: record types, immutable collections, value objects. Reviews collection choices for performance (Span<T>, ArrayPool). Implements source generators for optimization.
Designs .NET platform data models: gRPC/Protobuf for inter-service communication, System.Text.Json source generators for serialization. Defines high-performance data processing strategy.
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.
Defines documentation standards: mandatory sections, examples, changelog format. Implements docs-as-code. Ensures developer experience.
Shapes documentation platform: unified portal for all APIs, automated SDK generation, interactive sandbox. Defines documentation governance.
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.
Defines versioning policy: deprecation strategy, minimum support window, communication plan. Implements automated compatibility testing.
Shapes organizational versioning strategy: unified rules, deprecation governance, cross-team coordination. Defines SLA for backward compatibility.
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.
Defines architectural standards: solution structure, dependency rules, ArchUnitNET tests. Balances cleanliness and speed.
Shapes architectural culture: reference architecture, domain/application/infrastructure layers. Shared kernel. Determines when clean architecture is justified.
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.
Defines caching standards: what data to cache, TTL policies, invalidation strategies. Implements metrics and alerting. Balances data freshness and latency.
Shapes enterprise caching strategy for .NET platform: CDN + application cache + database cache layers, cache budgets per service. Defines data freshness requirements for business domains and establishes cross-team caching governance standards.
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.
Defines product caching strategy: multi-level cache, warming, invalidation policies. Establishes metrics and SLA for cache performance. Chooses between Redis and Garnet.
Designs organizational caching platform: shared Redis infrastructure, partitioning strategy, cross-service cache coherence. Defines governance for cache keys and TTL policies.
Cloud Providers 1
▼
Understands Azure App Service and Azure SQL basics for hosting .NET applications. Deploys simple services using Azure CLI. Works with Azure Key Vault for secrets management.
Independently configures and manages Microsoft Azure. Writes IaC for typical tasks. Understands networking and security basics.
Defines infrastructure strategy with Microsoft Azure. Establishes IaC standards. Conducts architecture reviews. Optimizes FinOps.
Shapes organizational Azure strategy: landing zone, Azure DevOps vs GitHub, Azure-native services vs portable. Defines standards for .NET on Azure: App Service vs AKS vs Container Apps.
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.
Defines async strategy in .NET: async/await best practices, Channel<T> for producer-consumer, IAsyncEnumerable for streaming. Implements CancellationToken and ValueTask standards.
Designs .NET platform async architecture: event bus (MassTransit/NServiceBus), message broker, System.Threading.Channels for high-throughput. Defines backpressure and scaling strategy.
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.
Defines .NET team concurrency standards: SemaphoreSlim vs lock, ConcurrentDictionary, Interlocked operations. Implements concurrent code testing practices. Conducts thread safety reviews.
Designs .NET platform concurrency model: thread pool tuning, lock-free patterns, System.IO.Pipelines for I/O-bound workloads. Evaluates .NET capabilities for high-frequency trading and real-time processing.
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.
Defines modeling standards: EF Core conventions, naming strategy, documentation. Reviews models for DDD compliance and performance.
Designs platform data model: bounded context → database mapping, shared entities via domain events, data mesh. Defines schema evolution strategy.
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.
Defines migration standards: EF Core vs DbUp vs FluentMigrator, review process for schema changes, rollback strategies. Tests migrations on production data copies.
Designs platform migration strategy: coordination between services, database-per-service, backward compatibility policy. Defines data versioning approach.
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.
Defines indexing standards: mandatory query plan review in PRs, index naming conventions, automatic missing index detection.
Designs platform indexing strategy: cross-service search indexes, automated maintenance, capacity planning for I/O. Defines read vs write performance trade-offs.
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.
Defines query performance standards: execution time budgets, mandatory profiling. Implements automatic slow query monitoring.
Designs platform data access strategy: CQRS, materialized views, polyglot persistence. Defines SLA for query latency by operation type.
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.
Defines transaction standards: DbContext lifetime rules, isolation levels, conflict handling strategies. Conducts transaction boundary reviews.
Designs platform consistency model: strong vs eventual consistency by domain. Defines distributed transaction strategy between .NET services.
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.
Defines GraphQL strategy: schema conventions, federation architecture, performance budgets. Implements schema registry and breaking change detection.
Shapes organizational GraphQL platform: supergraph, schema governance, query analytics. Determines when GraphQL vs REST vs gRPC.
Message Queues & Event Streaming 2
▼
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.
Defines Kafka strategy: topic naming, schema evolution policy, MassTransit vs raw Confluent.Kafka. Implements event-driven communication standards and consumer lag monitoring.
Designs organizational event-streaming platform: multi-cluster, MirrorMaker 2, Kafka Connect for CDC from SQL Server. Defines governance for event contracts and schema registry.
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.
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 enterprise messaging strategy evaluating RabbitMQ vs alternatives (Azure Service Bus, Kafka). Shapes company-wide event-driven architecture standards and reference implementations. Establishes messaging governance and migration roadmaps.
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.
Establishes .NET team architectural standards: MediatR for CQRS, FluentValidation, Options pattern. Defines Dependency Injection conventions. Conducts architectural reviews.
Defines .NET platform architectural patterns: Clean Architecture, Vertical Slice, Event-Driven. Shapes reference architecture on ASP.NET Core. Evaluates trade-offs for business context.
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.
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.
Shapes .NET platform object model. Determines where OOP is optimal vs functional approach (F#-style, LINQ). Designs shared kernel and domain events between services.
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.
Defines MySQL standards for team: naming conventions, migration workflow via EF Core Migrations, performance budgets. Conducts schema and query reviews.
Designs data strategy: sharding, migration from monolithic DB to database-per-service, backup and DR. Determines when MySQL vs PostgreSQL vs SQL Server.
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.
Defines PostgreSQL standards: extension policy, schema review, monitoring via pg_stat_statements. Chooses between EF Core, Dapper and raw Npgsql for different scenarios.
Designs PostgreSQL platform: logical replication, Citus for distributed queries, TimescaleDB for time-series. Defines migration strategy.
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.
Defines full-text search strategy: Elasticsearch for search vs SQL for filtering, ILM, capacity planning. Implements monitoring via Kibana.
Designs organizational search platform: multi-tenant indexes, cross-cluster search, ML-based ranking. Defines indexing standards.
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.
Defines generics usage standards: constraints, covariance/contravariance, generic host builders. Reviews API design focused on type safety and ergonomics.
Designs platform-level generic frameworks: source generators for compile-time generics, generic math (INumber<T>), type-safe pipeline builders. Evaluates new C# version capabilities.
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.
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.
Shapes .NET platform typing standards. Evaluates C# evolution (discriminated unions, roles/extensions) and plans adoption. Designs type-safe inter-service contracts.
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.
Defines ASP.NET Core architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Defines ASP.NET Core strategy at company level. Evaluates new technologies and approaches. Shapes enterprise standards and reference architectures.