Skip to content
Senior .NET Full-Stack Study Guide
Study Guide
Initializing search
Senior .NET Full-Stack Study Guide
C# Language
C# Language
Value vs Reference Types
Nullable Reference Types
Exception Design
Cancellation Tokens
DateTime & TimeProvider
Channels & Async Streams
Concurrency Primitives
Async — State Machine
Async — SyncContext & Deadlocks
Async — ValueTask & Perf
Span, Memory & ref structs
Generics & Variance
LINQ & Deferred Execution
Expression Trees
Pattern Matching & Records
C# 13/14 Features
System.Text.Json
Regex & SearchValues
Disposable & Resource Mgmt
Reflection & Runtime Codegen
Delegates, Events & Weak Events
Equality, Hashing & Ordering
Operator Overloading & Generic Math
Numeric Types & Precision
P/Invoke & LibraryImport
Strings, Encoding & Interpolation
Unsafe, Pointers & fixed
Tuples & Deconstruction
Runtime & CLR
Runtime & CLR
MSBuild & Build System
GC Fundamentals
GC Tuning & Diagnosing
JIT & Tiered Compilation
NativeAOT & Trimming
Source Generators & Analyzers
Memory Allocations & Pooling
Assembly Loading & LoadContext
Hardware Intrinsics & SIMD
ThreadPool Internals & Tuning
EventSource & EventPipe
Globalization (ICU vs NLS)
Portable PDB & SourceLink
Cross-Runtime (CoreCLR/Mono/AOT/WASM)
Roslyn Compiler & Workspaces
Async Stack Traces & Debugger
Roslyn Analyzers in CI
PolyType & TypeShape
ASP.NET Core
ASP.NET Core
Hosting & Transport
Hosting & Transport
Hosting & Kestrel
HTTP/2, HTTP/3 & Transports
Hosted Services & Background Work
Forwarded Headers & Reverse-Proxy
IIS & Windows Service Hosting
Types of Web Projects
Pipeline
Pipeline
Middleware Pipeline
Dependency Injection
Configuration & Options
HttpContext & Features
Routing
Model Binding & Validation
Filters & Action Pipeline
Endpoint Filters & Route Groups
API Surface
API Surface
Minimal APIs
API Versioning & Contracts
OpenAPI & Swagger
Output Formatters & Content Negotiation
API Client SDK Generation
ProblemDetails & Error Handling
Cross-cutting Features
Cross-cutting Features
Output & Response Caching
Rate Limiting
Health Checks
Request/Response Compression
Globalization & Localization
Static Assets & MapStaticAssets
Specific Endpoints
Specific Endpoints
Identity Endpoints (MapIdentityApi)
Server-Sent Events (.NET 10)
WebHooks (Send & Receive)
Real-Time & RPC
Real-Time & RPC
SignalR
gRPC
gRPC Advanced
WebSockets & SSE
Binary Serialization
GraphQL with HotChocolate
Distributed Systems
Distributed Systems
Distributed Fundamentals
Distributed Fundamentals
CAP Theorem & PACELC
Messaging Fundamentals
Idempotency Keys — Deep
Distributed Locks
Messaging Patterns
Messaging Patterns
Outbox & Inbox Patterns
Sagas — Orchestration vs Choreography
Saga Compensation — Deep
Workflow Engines
Backpressure Across Queues
CQRS Read-Model Rebuilding
Brokers & Transport
Brokers & Transport
Brokers Comparison
Kafka — Deep
MassTransit & Wolverine
Resilience & Caching
Resilience & Caching
Resilience — Polly v8
IHttpClientFactory Patterns
Caching Strategies
Topology & Routing
Topology & Routing
YARP Reverse Proxy
Load Balancing Strategies
Service Discovery
Multi-Region Replication
Background Work
Background Work
Scheduled Jobs — Quartz/Hangfire
Data Access
Data Access
Data Fundamentals
Data Fundamentals
Database Normalization
Connection Pooling & Isolation
SQL Server Internals for Devs
EF Core
EF Core
EF Core Fundamentals
EF Core — Querying & Projections
EF Core — Performance
EF Core — Migrations
EF Core — Concurrency & Transactions
EF Core 9/10 Changes
Beyond EF Core
Beyond EF Core
Dapper & Raw SQL
NoSQL & Event Stores
Web Fundamentals
Web Fundamentals
JavaScript Fundamentals
TypeScript Fundamentals
CSS Flexbox, Grid & Responsive
SPA vs SSR vs SSG
Angular with .NET
Blazor
Blazor
Render Modes — Server, WASM, Auto
Component Lifecycle & State
Forms & Validation
JS Interop & Prerendering
Performance & Virtualization
PWA & Static Assets
Auth in Blazor
Web Components with Blazor
React + .NET
React + .NET
React SPA + ASP.NET Core Integration
Auth Flows — React + API
SignalR from React
API Design for SPA Clients
Astro with .NET API
MVC / Razor
MVC / Razor
Server-Rendered Overview
MVC & Razor Pages
Tag Helpers & View Components
Forms & Antiforgery
HTMX with ASP.NET Core
Cross-Platform
Cross-Platform
Blazor Hybrid & .NET MAUI
Architecture & Patterns
Architecture & Patterns
Patterns Fundamentals
Patterns Fundamentals
GoF Design Patterns
SOLID & Pragmatic Trade-offs
Result Pattern vs Exceptions
Object Mapping Libraries
When NOT to Apply a Pattern
Architectural Styles
Architectural Styles
Clean / Onion / Hexagonal
DDD Tactical Patterns
CQRS & MediatR
Vertical Slice Architecture
Monolith, Modular Monolith, Microservices
Migration Patterns — Strangler-Fig & Sidecar
Repository & UoW Debate
Security
Security
Authentication Fundamentals
JWT Validation Pitfalls
OAuth2 & OIDC Flows
Refresh Token Rotation & Revocation
Identity Providers Comparison
Keycloak for .NET
Authorization — Policies & Claims
Data Protection API
OWASP Top 10 in ASP.NET Core
Secrets Management
Antiforgery & CORS
ASP.NET Core Identity — Deep
Observability
Observability
Structured Logging
OpenTelemetry — Traces, Metrics, Logs
Distributed Tracing
OTel Exporters
Diagnostics Tools
Sampling Strategies
Logging at Scale
OTEL Collector
eBPF Observability
Performance
Performance
BenchmarkDotNet
Async Performance Pitfalls
Parallelism & Data-Parallel
Allocation Hunting
String & Buffer Perf
Profiling Tools
Testing
Testing
Test Fundamentals
Integration Testing — WebApplicationFactory
Testcontainers for .NET
Snapshot & Mutation Testing
Test Architecture & Coverage
End-to-End with Playwright
TDD & Test Doubles
Property-Based Testing with FsCheck
Architectural Unit Testing
Performance & Load Testing
Mutation Testing — Deep
Cloud & DevOps
Cloud & DevOps
Containers & Orchestration
Containers & Orchestration
Docker & Containers
Kubernetes for .NET
Aspire — Cloud-Native
Dapr for .NET
Azure Container Registry
Azure Container Instances
Azure Container Apps & AKS
Azure Compute
Azure Compute
Azure App Service & Functions
Azure Static Web Apps
Azure Data
Azure Data
Azure Storage
Azure Storage — Deep
Azure CosmosDB Specifics
Azure Cosmos DB Modes — Deep
Azure Cache for Redis
Azure Cache for Redis Tiers — Deep
Azure Messaging
Azure Messaging
Azure Service Bus & Event Hubs
Azure Event Grid
Azure Logic Apps & Power Automate
Azure SignalR Service
Azure Networking & Edge
Azure Networking & Edge
Azure Networking Basics
Azure Front Door & CDN
Azure API Management
Azure Regions & Zone Redundancy
Azure Identity & Config
Azure Identity & Config
Azure Entra ID & RBAC
Azure Key Vault & Managed Identity
Azure App Configuration
Azure Ops & Cost
Azure Ops & Cost
Azure Monitor & App Insights
Azure Monitor & App Insights — Deep
Azure Cost Optimization
DevOps & IaC
DevOps & IaC
Bicep & IaC
Terraform with Azure
Azure CLI & azd
CI/CD Pipelines
Feature Flags
AWS
AWS
AWS for .NET — Overview
AI / LLM Integration
AI / LLM Integration
Lookup & Reference
Lookup & Reference
AI Layer Overview
Deprecated & Outdated
Microsoft Stack
Microsoft Stack
Agent Framework
Model Context Protocol
Semantic Kernel — Legacy
Patterns & Storage
Patterns & Storage
Local & Edge Inference
Hosting & Tooling
Hosting & Tooling
GitHub Copilot Tooling
Operations
Operations
AI Security
System Design
System Design
Framework for .NET System Design
Case: High-Throughput Public API
Case: Event-Driven Order Pipeline
Case: Multi-Tenant SaaS
Case: Real-Time Collaboration App
Case: Batch Processing Pipeline
Case: RAG App on .NET
Soft Skills
Soft Skills
Code Review Checklist
Trade-off Framing
Mentoring & Tech Leadership
Git Workflows & Branching
Stakeholder Communication
ADRs at Scale
Tech-Debt Management
Refactoring Legacy Codebases
Blameless Postmortems
Bookmarks
Back to top