.NET Developer Roadmap 2026
What to learn to become a C# and .NET developer, in the order that makes each step easier than the last. Every stage links to free lessons on this site and shows roughly how long it takes.
The roadmap has three phases. Phase 1 takes you from nothing to writing complete C# programs. Phase 2 covers the tools you use to build real .NET applications every day. Phase 3 is about running .NET well in production: performance, architecture, distributed systems, the cloud and debugging live problems.
Where to start. New to programming? Start at stage 1 and use the week-by-week plan. Already code in another language? Skim Phase 1 and start properly at stage 7. Already ship C#? Jump to Phase 3.
The roadmap at a glance
| Stage | What you learn | Lessons | Time |
|---|---|---|---|
| 1 | Set up .NET and run your first program | 3 | 52 min |
| 2 | Learn the language basics | 7 | 2h 24m |
| 3 | Think in objects | 14 | 5h 38m |
| 4 | Collections, errors, files and dates | 18 | 6h 20m |
| 5 | Modern C# features | 9 | 3h 22m |
| 6 | Debug, tidy up and build projects | 8 | 3h |
| 7 | Object-oriented design and SOLID | 12 | 4h 40m |
| 8 | Generics, delegates and lambdas | 24 | 8h 20m |
| 9 | Query data with LINQ | 14 | 4h 42m |
| 10 | Dependency injection, configuration, logging and HTTP | 10 | 3h 20m |
| 11 | Databases with ADO.NET and EF Core | 14 | 4h 38m |
| 12 | Async and await | 10 | 3h 40m |
| 13 | Build intermediate projects | 6 | 2h 48m |
| 14 | How .NET runs your code | 35 | 14h 50m |
| 15 | Concurrency and performance | 26 | 10h 45m |
| 16 | Architecture and design patterns | 17 | 7h 15m |
| 17 | Production ASP.NET Core | 18 | 6h 23m |
| 18 | Data at scale | 11 | 4h 06m |
| 19 | Distributed systems | 12 | 4h 39m |
| 20 | Cloud and containers | 10 | 3h 20m |
| 21 | Testing and production debugging | 14 | 5h 21m |
| 22 | Stay current with C# 14 | 9 | 2h 53m |
| 23 | Capstone: build a complete system | 14 | 4h 26m |
Times are reading estimates that include typing the code and answering each lesson's quiz. The whole roadmap is about 118 hours of lessons. Plan extra time on top for practice: the code you write yourself is where most of the learning happens.
Phase 1: Write real C#
Beginner. No programming experience needed. About 22 hours of lessons.
1Set up .NET and run your first program
Install the .NET SDK and an editor, then write, build and run a console app. Knowing what dotnet run actually does removes a lot of early confusion.
Lessons: What Are C# and .NET?, Setting Up the Modern Environment, Your First C# Application
Checkpoint: You can create and run a C# project from the command line.
2Learn the language basics
Variables, types, strings, operators, if and switch, loops and methods. This is the grammar every later lesson uses, so take it slowly and type every example yourself.
Lessons: Variables and Constants, Built-in Data Types, Strings and Text, Type Conversion, Operators, Control Flow, Methods
Checkpoint: You can write a small program that makes decisions and repeats work.
3Think in objects
Classes, objects, properties, constructors, inheritance, polymorphism and interfaces. C# is object-oriented at its core, and most .NET code you will ever read looks like this.
Lessons: Classes and Objects, Fields and Properties, Constructors, Static Members, Access Modifiers, Encapsulation, Value vs Reference Types, Structs, Enums, Inheritance, Polymorphism, Overloading and Overriding, Interfaces — First Look, Composition vs Inheritance
Checkpoint: You can model a small domain, such as a bank account or a library, with classes.
4Collections, errors, files and dates
Arrays, List<T>, Dictionary and friends, then exceptions, files, streams, dates, time zones and JSON. These are the everyday tools of real programs.
Lessons: Arrays, Multidimensional Arrays, Jagged Arrays, Lists, Dictionaries, HashSet, Stack and Queue, Collection Interfaces, IEnumerable<T> — First Look, Exception Handling, Creating and Throwing, File and Directory Operations, Paths, Streams — Introduction, DateTime and DateTimeOffset, Time Zones, Working with JSON, Serialization
Checkpoint: You can load data from a file, work with it in collections and handle errors properly.
5Modern C# features
Nullable reference types, pattern matching, records, tuples, switch expressions and collection expressions. Modern C# code uses them everywhere, and they make code shorter and safer.
Lessons: Nullable Reference Types, Null-Safe Programming, Pattern Matching, Records — Introduction, Tuples & Deconstruction, Modern Switch Expressions, Modern Collection Expressions, required Members, Primary Constructors
6Debug, tidy up and build projects
Use the debugger, read stack traces, follow the naming conventions, then build two complete console projects from scratch.
Lessons: Debugging C# Applications, Reading Stack Traces, Writing Clean C#, Naming Conventions, Common Beginner Mistakes, Project: Expense Tracker, Project: Employee System, Fundamentals Challenge
Checkpoint: You can build and debug a complete console application on your own.
Phase 2: Build real .NET applications
Working developer. You know the C# basics. About 32 hours of lessons.
7Object-oriented design and SOLID
Abstract classes, sealed types, interface design and the SOLID principles that keep a growing codebase easy to change.
Lessons: OOP Revisited, Encapsulation in Real Applications, Inheritance, Composition, Polymorphism, Abstract Classes, Sealed Classes and Members, Interfaces, Multiple Interface Implementation, Interface Segregation, Explicit Interface Implementation, Dependency Inversion
8Generics, delegates and lambdas
Write type-safe reusable code with generics, see how collections really work, and pass behaviour around with delegates, lambdas and events.
Lessons: Generics, Generic Classes, Generic Methods, Generic Constraints, where Constraints, Covariance and Contravariance, Generic Collections, Dictionary Internals, Equality and Hashing, IComparable<T>, IEquatable<T>, Custom Collections, Delegates, Custom Delegates, Action, Func, Predicate, Lambda Expressions, Closures, Local Functions, Higher-Order Functions, Events, Event Patterns, Event-Driven Design
9Query data with LINQ
Query any collection by describing the result you want. LINQ appears in almost every .NET codebase, and deferred execution is a classic interview topic.
Lessons: Introduction to LINQ, IEnumerable and IQueryable, Filtering, Projection, Sorting, Grouping, Joining, Aggregation, Deferred Execution, Immediate Execution, LINQ Query Syntax, LINQ Method Syntax, Custom LINQ Extensions, LINQ Performance
10Dependency injection, configuration, logging and HTTP
The building blocks of every modern .NET app: the DI container, service lifetimes, appsettings.json, the options pattern, ILogger and HttpClient.
Lessons: Dependency Injection, Service Lifetimes, Configuration, Options Pattern, Logging, Environment-Based Configuration, HTTP Client, JSON APIs, REST Fundamentals, OpenAPI
11Databases with ADO.NET and EF Core
Talk to SQL databases safely with parameters and transactions, then use Entity Framework Core for entities, relationships, migrations and queries.
Lessons: ADO.NET Fundamentals, Database Connections, Commands, Parameters, Transactions, Entity Framework Core, DbContext, Entities, Relationships, Migrations, LINQ with EF Core, Tracking vs No-Tracking, Transactions and Concurrency, Repository Pattern — When and Why
12Async and await
Tasks, async and await, cancellation, Task.WhenAll and async streams. Async code is the default in ASP.NET Core, so this stage matters to every web developer.
Lessons: Synchronous vs Asynchronous, Task and Task<T>, async / await, CancellationToken, Task.WhenAll, Task.WhenAny, Exception Handling in Async, Async Streams, IAsyncEnumerable<T>, Common Async Mistakes
13Build intermediate projects
Build a REST API, an EF Core data project, a notification service and a background worker, each with a complete solution to compare against.
Lessons: REST API Project, Employee Management API, EF Core Database Project, Notification Service, Background Processing Service, Intermediate C# Challenge
Checkpoint: You have practised the skills junior .NET job listings commonly ask for: C#, LINQ, EF Core, ASP.NET Core APIs and async code.
Phase 3: Run .NET in production
Senior track. You build .NET apps and want to run them well. About 64 hours of lessons.
14How .NET runs your code
The CLR, the JIT, garbage collection, stack and heap, boxing and reflection, and how delegates, closures and LINQ work underneath.
Lessons: How Modern C# Executes, CLR and Runtime Internals, JIT Compilation, Garbage Collection, Generational GC, Memory Allocation, Stack vs Heap, Boxing and Unboxing, Value Types vs Reference Types, Records and Record Structs, Pattern Matching in Depth, Advanced Generics, Variance, Reflection, Attributes, Source Generators — Intro, Advanced Delegates, Action / Func / Predicate, Expression Trees, Lambda Internals, Closures, Advanced Events, Event Aggregation, Extension Methods, C# 14 Extension Members, IEnumerable<T> Internals, IQueryable<T>, Expression Trees, Deferred Execution, LINQ Performance, Custom LINQ Operators, LINQ to Objects, LINQ to EF Core, LINQ and SQL Translation, Avoiding LINQ Performance Traps
15Concurrency and performance
The thread pool, synchronization context, locks, channels and race conditions, then Span<T>, pooling and benchmarking for code that must be fast.
Lessons: Task Internals, Synchronization Context, ThreadPool, ValueTask, Cancellation, Parallel Programming, Parallel.ForEach, Channels, Concurrent Collections, Locking and Synchronization, Race Conditions, Deadlocks, Thread-Safe Design, Async Streams, High-Throughput Async, Span<T>, ReadOnlySpan<T>, Memory<T>, ArrayPool<T>, MemoryPool<T>, ref / in / out, ref struct, stackalloc, Zero-Allocation Programming, Performance Benchmarking, Profiling .NET Applications
16Architecture and design patterns
SOLID at scale, the classic design patterns in C#, Clean Architecture, hexagonal architecture and domain-driven design.
Lessons: SOLID Principles, Clean Code, Coupling and Cohesion, Dependency Injection at Scale, Design Patterns, Factory Pattern, Strategy Pattern, Decorator Pattern, Adapter Pattern, Observer Pattern, Builder Pattern, Mediator Pattern, Repository Pattern, Unit of Work, Clean Architecture, Hexagonal Architecture, Domain-Driven Design
17Production ASP.NET Core
Middleware, filters, minimal APIs and controllers, validation, authentication with JWT and OpenID Connect, rate limiting, caching, resilience and observability.
Lessons: ASP.NET Core Architecture, Middleware, Filters, Minimal APIs, Controllers, Model Binding, Validation, Authentication, Authorization, JWT, OAuth / OpenID Connect, Rate Limiting, Caching, Distributed Caching, Resilience & Fault Handling, Health Checks, Observability, OpenTelemetry
18Data at scale
EF Core performance, isolation levels, concurrency conflicts, bulk operations and finding slow queries.
Lessons: Advanced EF Core, Query Optimization, Compiled Queries, Transactions, Concurrency, Database Connection Mgmt, Stored Procedures, Bulk Operations, Caching Strategies, SQL vs EF Core, DB Performance Troubleshooting
19Distributed systems
Microservices, messaging, Kafka, idempotency, retries, circuit breakers, the outbox pattern and eventual consistency.
Lessons: REST API Architecture, Microservices, Message-Based Architecture, Queues, Kafka Fundamentals, Event-Driven Architecture, Idempotency, Retries, Circuit Breakers, Distributed Transactions, Outbox Pattern, Eventual Consistency
20Cloud and containers
Docker, cloud configuration, secrets, Kubernetes health probes, scaling and .NET Aspire.
Lessons: Configuration for Cloud, Docker and .NET, Containerized ASP.NET Core, Environment Variables, Secrets Management, Health Probes, Logging and Observability, Scaling .NET Applications, Cloud-Native .NET, .NET Aspire — Introduction
21Testing and production debugging
Unit, integration and API tests and load testing, then diagnosing memory leaks, high CPU, deadlocks and thread pool starvation in production.
Lessons: Unit Testing, Integration Testing, Mocking, Testcontainers, API Testing, Performance Testing, Load Testing, Debugging Production Issues, Memory Leaks, High CPU, Deadlocks, Thread Pool Starvation, Database Bottlenecks, Production Incident Analysis
22Stay current with C# 14
Every new C# 14 feature, explained with before-and-after code.
Lessons: What's New in C# 14, Extension Members, field Backed Properties, Null-Conditional Assignment, Enhanced Span Conversions, Lambda Parameter Modifiers, Partial Constructors, User-Defined Compound Assignment, Modern File-Based Apps
23Capstone: build a complete system
Put everything together in OrderFlow, a realistic order-management system, from architecture and authorization to messaging, monitoring and deployment.
Lessons: Designing Enterprise Apps, Clean Architecture, Authentication, Database, Caching, Background Processing, Messaging, Logging, Monitoring, Testing, Containerization, Performance Optimization, Production Deployment, Final Architecture Review
Checkpoint: You have designed, built, tested and deployed a distributed .NET system end to end.
Keep going
Track your progress through every stage in the course player, which remembers where you stopped. When you are preparing for interviews, the C# interview questions page links each answer back to the lesson that explains it, and the C# cheat sheet keeps the everyday syntax on one page.