What a Junior } should know

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.

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.

Understands basic code quality principles for C#/.NET development. Follows team coding standards and Roslyn analyzer recommendations. Writes simple, clean methods following C# naming conventions. Accepts code review feedback and learns from established design patterns.

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.

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.

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.

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.

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.

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.

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.

Uses ASP.NET Core at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.

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.

Uses Elasticsearch / OpenSearch at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.

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.

Uses Redis via StackExchange.Redis/IDistributedCache. Caches frequently requested data with TTL. Understands basic structures: strings, hashes, sets. Configures connection via appsettings.json.

Designs schemas via EF Core: Entity classes, relationship Navigation Properties, owned types for value objects. Understands normalization. Uses Fluent API for configuration.

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.

Writes migrations via EF Core: Add-Migration, Update-Database. Creates tables, columns, indexes. Understands migration idempotency. Tests on dev environment before production.

Writes SQL queries for CRUD via Entity Framework Core / Dapper. Creates tables, indexes, foreign keys. Understands normalization to 3NF. Uses MySQL Workbench for analysis.

Works with PostgreSQL via EF Core (Npgsql): entity mapping, LINQ queries, raw SQL via FromSqlRaw. Understands PostgreSQL types: UUID, JSONB, arrays. Uses pgAdmin.

Understands N+1 problem in EF Core and solves via Include/ThenInclude. Uses AsNoTracking for read-only queries. Analyzes generated SQL through logging.

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.

Documents API via XML comments and Swagger annotations: summary, remarks, response types. Maintains Swagger UI. Describes parameters and examples.

Understands API versioning. Uses Asp.Versioning: URL segment, query string, header-based. Maintains backward compatibility. Knows semantic versioning.

Creates GraphQL schemas via Hot Chocolate: types, queries, mutations. Implements resolvers. Understands differences with REST. Tests via Banana Cake Pop.

Creates REST endpoints via ASP.NET Core Minimal API or Controllers: MapGet/MapPost, [HttpGet]/[HttpPost], model binding. Returns correct HTTP statuses via Results/IActionResult. Validates via FluentValidation.