Recommended Learning Journey

Not sure where to begin? Follow this carefully designed learning path to build a rock-solid foundation in modern .NET development, progressing from language basics through production-grade APIs, distributed systems, AI features, and the architectural discipline that keeps a large codebase healthy.

1. 1

   Foundation — .NET 8 & C# Core

   Begin with .NET 8 Essentials to get comfortable with the runtime, then sharpen your C# skills through C# 12 Language Features. These two tutorials together give you the language and platform fundamentals every other step builds on.

2. 2

   Configuration & Secrets

   Before writing your first real endpoint, learn how to handle Configuration & Secrets in .NET 8 correctly — layered appsettings, environment overrides, user secrets, and strongly-typed options. Skipping this step is how secrets end up hardcoded in source control and environment-specific bugs appear only in production.

3. 3

   Patterns & Domain Logic

   Before building endpoints, establish how your application will handle outcomes and errors. Modern Patterns: Result & Pipeline teaches composable, exception-free application flows using the Result type, Map, and Bind operators. Learning this now means every service and handler you write from Step 4 onwards will be cleaner, more testable, and more explicit about failure.

4. 4

   Web APIs & Backend Services

   Build your first real backend with ASP.NET Core Fundamentals, then go further with Minimal APIs in the Real World for lightweight, cloud-ready services. Lock down your APIs with API Security in Practice (JWT authentication, rate limiting, CORS, safe error handling), then add Caching: Output Cache, Redis & Invalidation to make them fast without serving stale data.

5. 5

   Passwordless Authentication — Passkeys

   With your API secured, modernise how users actually sign in. Passkeys in ASP.NET Core Identity replaces shared secrets with origin-bound key pairs using the built-in passkey support — the WebAuthn registration and authentication ceremonies, username-less sign-in with conditional UI, and the account-recovery design that a passwordless app genuinely needs. Phishing resistance you get for free; recovery is the part you have to design.

6. 6

   Background Processing — Jobs & Queues

   Real applications need work that happens outside the request. Background Jobs: BackgroundService & Queues shows how to run reliable background workers with bounded channels, retry logic, and graceful shutdown, so long-running work never blocks an HTTP response or disappears on deployment.

7. 7

   Data Layer — Entity Framework Core

   Give your services a durable data layer. Start with EF Core 8: Modern Data Access, prove your queries with EF Core Testing: SQLite vs InMemory, then scale the model with Advanced Modeling & Performance and Multitenancy, Soft Delete & Auditing.

8. 8

   Choose Your Specialization — Blazor or Stay on the API Path

   If you want to build user interfaces in C#, branch into Blazor: Interactive UI with C#, then Blazor SSR & Interactive Islands and the Forms & Validation Masterclass. If your focus is backend and platform work, continue straight to Step 9 — nothing later depends on Blazor.

9. 9

   Reliable Messaging — The Transactional Outbox

   The moment your system publishes events, the dual-write problem appears: the database commits and the broker call fails, so the message is never sent. Transactional Outbox with EF Core fixes it properly — one atomic transaction, a background relay, safe concurrent dispatchers, and idempotent consumers, because delivery is at-least-once rather than exactly-once.

10. 10

    Observability & Production Operations

    You cannot operate what you cannot see. .NET 8 Observability with OpenTelemetry wires up structured logging, distributed tracing, and metrics so that a slow request or a failing dependency becomes a trace you can follow instead of a guess.

11. 11

    Resilience & Zero Downtime

    Distributed systems fail partially and constantly. Polly Resilience (Polly v8) teaches retries, timeouts, circuit breakers, and hedging done correctly, while Health, Resilience & Zero Downtime covers health checks, readiness gates, and deployments that do not drop traffic.

12. 12

    Containerize & Ship

    Package your application the way production expects it. Dockerizing ASP.NET Core: Clean Images covers multi-stage builds, non-root users, small and reproducible images, and container health checks — the difference between an image that runs and one you can safely operate.

13. 13

    Orchestrate the Whole System — Aspire

    Individual services are the easy part; running the whole system is where the day disappears. Orchestrate a Distributed System with Aspire models your web app, API, database and cache in one C# AppHost, starts everything with a single command, and gives you cross-service traces, logs and metrics in one dashboard — then generates the deployment assets for Compose, Azure Container Apps, or Kubernetes.

14. 14

    Add AI Features Without Vendor Lock-In

    With a solid platform underneath, add intelligence. Microsoft.Extensions.AI: Provider-Agnostic Chat Gateway puts every model behind one IChatClient contract so you can develop against a local model and switch to a cloud provider by changing configuration. Then give those models something accurate to work with using Hybrid Search with EF Core and pgvector, which fuses keyword and vector retrieval into a single ranking.

15. 15

    Make the Architecture Stick

    Everything you have built so far encodes decisions — which layer may depend on which, which module owns what. Architecture Testing in .NET turns those decisions into executable rules that fail the build the moment someone violates them, so the design you chose survives contact with deadlines and new team members.

16. 16

    Maximum Throughput — High-Performance C#

    Complete your journey by eliminating unnecessary allocations and squeezing every byte of throughput from .NET. High-Performance C#: Span<T>, Memory<T>, SIMD & Pipelines teaches zero-allocation parsing with Span, pooled buffer management with ArrayPool, vectorised hot paths with SIMD, and back-pressure-aware I/O with System.IO.Pipelines — all benchmarked with BenchmarkDotNet. After completing this journey, you will have the skills to build, secure, instrument, orchestrate, and ship production .NET applications end to end.