Lessons in .NET Web API

81 lessons ready
·
13 modules
·
71 more planned

Start course Course overview

Course content

81 lessons ready to read

Across 13 modules · 71 more planned

Free · No signup

RESTful API Best Practices for .NET Developers

20 minNext up

Learn the core principles of Web APIs and RESTful design that form the foundation of modern application development.

Understanding HTTP Status Codes – Returning Proper API Responses

15 min

Select appropriate HTTP status codes to provide clear, standards-compliant feedback to API consumers.

Environment-based Configuration – appsettings.json, Environment Variables & Launch Profiles

18 min

Configure your .NET application for different environments using configuration files, environment variables, and launch profiles.

Middlewares in ASP.NET Core .NET 10 – The Complete Guide to Request Pipeline, Custom Middleware, and IMiddleware

28 min

Master ASP.NET Core middleware in .NET 10 - execution order, custom middleware, IMiddleware, short-circuiting, and the middleware vs filters decision matrix.

Dependency Injection (DI) in ASP.NET Core – Deep Dive into DI and Its Benefits

22 min

Implement effective dependency injection patterns in ASP.NET Core to improve code maintainability and testability.

Service Lifetimes – Singleton vs Scoped vs Transient in .NET 10

15 min

How transient, scoped and singleton services behave across a request, when to use each, and how to fix the captive dependency bug.

Keyed Services in .NET – Advanced DI Techniques Using Keyed Services

12 min

Utilize keyed services to solve complex dependency injection scenarios requiring multiple implementations of the same interface.

Scrutor – Auto-Registering Dependencies for Cleaner DI Management

14 min

Streamline dependency registration with Scrutor's assembly scanning capabilities to reduce boilerplate code.

Filters in ASP.NET Core .NET 10 - Action, Resource, Exception, Result, and Endpoint Filters

28 min

Master all 6 filter types in ASP.NET Core .NET 10 with decision matrices for filters vs middleware.

ProblemDetails in ASP.NET Core – Standardizing Error Responses in APIs

12 min

Implement RFC 7807 ProblemDetails standard to provide consistent, machine-readable error responses in your APIs.

Global Exception Handling – Centralized Error Handling for Better Maintainability

16 min

Develop a centralized exception handling strategy to manage errors consistently across your entire API.

Watch video

Structured Logging with Serilog – Implementing Structured Logging in .NET APIs

20 min

Configure Serilog for structured logging to enhance troubleshooting capabilities with queryable, context-rich log data.

Minimal API Endpoints – Understanding and Using Minimal APIs in ASP.NET Core

25 min

Build concise, performant API endpoints using the Minimal API paradigm introduced in recent ASP.NET Core versions.

API Documentation – Generating OpenAPI Docs and Exploring Swagger Alternatives

18 min

Generate comprehensive API documentation using OpenAPI specifications and evaluate alternatives to Swagger UI.

Migrating from Swagger to Scalar – Porting Auth, Filters, and XML Comments in .NET 10

22 minComing soon

Migrate a full Swashbuckle setup to Scalar in .NET 10 - port document, operation, and schema filters to transformers, wire JWT auth so the authorize lock appears, keep XML comments, and harden the docs for production.

File-Based Apps in .NET 10 – Run C# Without a Project File

18 min

Learn how to run C# code directly from a single file using dotnet run app.cs. Perfect for scripting, prototyping, and quick experiments.

Migrating from .sln to .slnx in .NET 10 – The New XML-Based Solution Format

18 min

Migrate from .sln to .slnx in .NET 10. Covers the new XML-based solution format, migration methods, CI/CD compatibility, and team adoption strategy.

Best Libraries for ASP.NET Core in 2026: 12 Free NuGet Packages

20 min

The 12 NuGet packages I install in ASP.NET Core projects on .NET 10, one for each job, with the install command, working code and license for every package.

CRUD with EF Core – Implementing Basic CRUD Operations in ASP.NET Core

30 min

Build a production-ready .NET 10 Web API with Entity Framework Core, PostgreSQL, and Domain-Driven Design. Learn CRUD operations, code-first migrations, DTOs, Minimal APIs, and new EF Core 10 features like named query filters.

Watch video

Configuring Entities with Fluent API – Entity Configuration Best Practices

20 min

Use Fluent API to configure entity mappings, constraints, and relationships for clean, maintainable EF Core models.

Relationships in EF Core – Configuring One-to-One, One-to-Many, and Many-to-Many

22 min

Model and configure entity relationships in EF Core to represent complex data structures in your database.

Pagination, Sorting & Searching – Optimizing Queries for Large Datasets

22 min

Implement efficient pagination, dynamic sorting, and search in ASP.NET Core Web API using EF Core 10. Covers offset and keyset pagination, IQueryable extensions, and performance tips for large datasets.

Global Query Filters – Applying Filters Globally to Avoid Repetitive Queries

18 min

Learn how to use global query filters in EF Core 10 to automatically apply soft delete, multi-tenancy, and custom filters. Includes named query filters, IgnoreQueryFilters, performance tips, and common pitfalls.

Soft Deletes – Implementing Logical Deletes Without Removing Data

16 min

Implement soft delete patterns in EF Core 10 using SaveChangesInterceptor, named query filters, cascade soft delete, undo/restore, and performance best practices.

Bulk Operations – Optimizing Insert, Update, and Delete Operations in EF Core

22 min

Optimize database operations for large datasets using bulk operation techniques in Entity Framework Core. Covers AddRange, ExecuteUpdate, ExecuteDelete, third-party libraries, benchmarks, and a decision matrix.

Concurrency Control – Preventing Data Conflicts with Optimistic Locking

20 min

Implement optimistic concurrency control with EF Core 10 to detect and resolve conflicting data modifications. Covers RowVersion tokens, DbUpdateConcurrencyException handling, retry strategies, and a decision matrix for choosing between optimistic and pessimistic approaches.

Multiple DB Contexts – Using Multiple Database Contexts in a Single Application

22 min

Design applications that interact with multiple databases through separate DbContext instances with proper separation.

Running Migrations – Best Practices for Applying Database Migrations

20 min

Learn 5 ways to apply EF Core 10 migrations in development and production. Covers CLI, Migrate(), SQL scripts, migration bundles, and EnsureCreated with a decision matrix and production checklist.

Cleaning Migrations – Squash, Reset & Organize Your Migration History

18 min

Learn when and how to clean EF Core 10 migrations. Covers squashing, resetting, removing migrations, resolving team conflicts, and a decision matrix for choosing the right cleanup strategy.

Tracking vs. No-Tracking Queries – Understanding Performance Implications

18 min

Select appropriate tracking behaviors for your EF Core queries to optimize performance based on specific use cases.

Transactions in EF Core – Ensuring Data Consistency with Database Transactions

16 minComing soon

Implement transaction management strategies to maintain data integrity during complex operations affecting multiple entities.

EF Core Interceptors - The Complete Guide to All 7 Types

18 min

Master EF Core interceptors in .NET 10 - all 7 types, registration, audit fields, soft deletes, and how to inject the current user without breaking dependency injection.

Seeding Initial Data – Populating the Database with Default Data

12 min

Implement reliable data seeding strategies to ensure consistent initial state across different environments.

Stored Procedures – Executing Raw SQL and Stored Procedures Efficiently

18 minComing soon

Incorporate stored procedures and raw SQL operations into your EF Core application for performance-critical scenarios.

Lazy, Eager & Explicit Loading – Managing How Related Entities Are Retrieved

20 minComing soon

Select appropriate loading strategies for related data to optimize performance and prevent N+1 query problems.

Compiled Queries – Boosting Performance for Hot Query Paths

18 minComing soon

Use compiled queries to improve performance for frequently executed queries by caching query execution plans.

DbContext Pooling for Performance – Reusing Context Instances at Scale

18 minComing soon

Use DbContext pooling to reduce allocation overhead and boost throughput in high-traffic APIs. Covers AddDbContextPool, pool sizing, state reset gotchas, and when pooling helps vs hurts.

The N+1 Query Problem in EF Core – And How to Kill It

20 minComing soon

Diagnose and eliminate the N+1 query problem in EF Core. Covers eager loading, projections, split queries, query logging to catch it, and benchmarks showing the impact on API latency.

Fastest Way to Bulk Insert Thousands of Rows in EF Core

20 min

Benchmark every way to bulk insert in EF Core 10 - AddRange with SaveChanges, chunking, EFCore.BulkExtensions, and raw Npgsql COPY and SqlBulkCopy. Real BenchmarkDotNet numbers, the parameter-limit trap, and a decision matrix for choosing the right approach.

Filtering by a Large List - Contains and the 2,100 Parameter Wall

20 min

Filter an EF Core 10 query by thousands of ids without guessing. Covers what Contains really sends to SQL Server, the 2,098 parameter ceiling and the silent switch to OPENJSON above it, EF.Constant vs EF.Parameter vs MultipleParameters, temp tables, and BenchmarkDotNet numbers with a decision matrix by list size.

Audit Trail & Change Tracking in EF Core (.NET 10)

22 minComing soon

Build a production-ready audit trail in EF Core 10. Capture who changed what and when using the ChangeTracker and SaveChanges interceptors, persist before/after values, and store audit logs without polluting your domain entities.

Second-Level Caching in EF Core – Caching Query Results Across Requests

20 min

Add a second-level cache to EF Core 10 with EFCoreSecondLevelCacheInterceptor, Redis, and HybridCache. Covers the v5 provider setup, real benchmarks, the SaveChanges vs ExecuteUpdate invalidation trap, multi-instance staleness, and what to cache vs what not to.

EF Core + Dapper Hybrid – When to Use Which

20 minComing soon

Combine EF Core and Dapper in the same application for the best of both worlds. Use EF Core for writes and complex change tracking, drop to Dapper for hot read paths and raw SQL performance, all sharing one connection and transaction.

Options Pattern in ASP.NET Core – Managing Configurations Effectively

18 min

Implement the options pattern to handle application configuration with strong typing and validation.

FluentValidation – Writing Clean & Reusable Request Validations

30 min

Create maintainable, reusable validation rules using FluentValidation to enforce data integrity.

CQRS & MediatR – Building Scalable, Decoupled APIs

35 min

Implement the CQRS pattern with MediatR in .NET 10 to separate read and write operations. Includes decision matrix, notifications, and complete CRUD with Minimal APIs.

Build Your Own CQRS Dispatcher in .NET 10 (No MediatR)

30 min

MediatR went commercial. Build your own CQRS dispatcher in .NET 10 with pipeline behaviors, AOT support, and a FrozenDictionary core that benchmarks 4x faster than MediatR.

Validation with MediatR Pipeline and FluentValidation

18 min

Build a robust validation pipeline that automatically validates commands and queries before processing.

Validating Options Pattern with FluentValidation

12 minComing soon

Apply validation to configuration options to catch misconfigurations early during application startup.

Result Pattern – No More Exceptions for Flow Control

22 min

Implement the Result pattern to handle operation outcomes without relying on exceptions for control flow.

Decorator Pattern in .NET – Cross-Cutting Concerns Made Easy

18 minComing soon

Apply the decorator pattern to add behavior to services without modifying their implementation.

Specification Pattern – Encapsulating Query Logic Cleanly

16 minComing soon

Use the specification pattern to create reusable, composable query logic for complex filtering scenarios.

AutoMapper vs Mapster vs Manual Mapping in .NET 10 - Pick the Right One in 2026

24 min

Compare AutoMapper, Mapster, Mapperly, and manual mapping in .NET 10 with BenchmarkDotNet results, a decision matrix, and a migration guide.

Feature Flags – Enabling & Disabling Features Dynamically

16 minComing soon

Implement feature flags to manage feature rollout and enable/disable functionality without redeployment.

Implementing API Versioning – Managing Breaking Changes

18 min

Apply versioning strategies to evolve your API while maintaining compatibility with existing clients. Covers the modern Asp.Versioning package, URL vs header vs query schemes, Minimal APIs and controllers, OpenAPI + Scalar, and Sunset-header deprecation in .NET 10.

Webhooks – Enabling Event-Driven API Communication

20 minComing soon

Design and implement webhook systems to enable event-driven integration between applications.

Real-Time APIs with SignalR – Implementing WebSockets

25 minComing soon

Add real-time communication capabilities to your application using SignalR and WebSockets.

Outbox Pattern – Reliable Messaging in Distributed Systems

20 minComing soon

Implement the outbox pattern to ensure reliable message delivery in distributed architectures.

Benchmarking .NET APIs – Measuring & Optimizing Performance

20 minComing soon

Use benchmarking tools to identify performance bottlenecks and validate optimization efforts.

Profiling .NET APIs – dotnet-trace, dotnet-counters & More

18 minComing soon

Use built-in .NET profiling tools to find performance bottlenecks and memory issues.

Response Compression & Content Negotiation – Optimizing Payload Size

14 minComing soon

Implement response compression and content negotiation to reduce bandwidth usage and improve API response times.

In-Memory Caching – Reducing Database Calls

18 min

Apply in-memory caching patterns to reduce database load and improve response times for frequently accessed data.

Distributed Caching with Redis – Scaling API Performance

22 min

Implement Redis-based distributed caching to share cached data across multiple application instances.

Output Caching in .NET – Built-In Response Caching

16 minComing soon

Use .NET's built-in output caching to cache entire responses at the middleware level.

Response Caching with MediatR in ASP.NET Core – Powerful Pipeline Behavior

20 min

Build a caching pipeline component using MediatR behaviors to transparently cache query results.

HybridCache in ASP.NET Core .NET 10 – L1 + L2 Caching with Stampede Protection

25 min

Master HybridCache with BenchmarkDotNet results, stampede protection demo, tag-based invalidation, Redis L2 setup, and migration from IDistributedCache.

Async Streams & IAsyncEnumerable – Handling Large Datasets Efficiently

16 minComing soon

Use async streams to process large datasets without loading everything into memory.

Memory Management & Avoiding Allocations – Span<T>, ArrayPool & Object Pooling

20 minComing soon

Reduce memory allocations and GC pressure using modern .NET memory management techniques.

10 EF Core Performance Mistakes (and How to Fix Them) in .NET 10

25 min

10 EF Core performance mistakes that ship to production - N+1 queries, missing projections, lazy loading, AsNoTracking, bulk ops - and how to fix each in .NET 10.

HttpClient Factory in .NET – Managing HTTP Clients Efficiently

18 min

Configure HttpClientFactory to manage HttpClient instances properly and avoid common socket exhaustion issues.

Best Way to Use HTTP Clients in .NET APIs

20 minComing soon

Apply best practices for creating and managing HTTP clients to consume external services reliably.

Using Refit for Simplified API Calls in .NET

18 minComing soon

Streamline HTTP client code using Refit's interface-based approach to API consumption.

Handling Timeouts & Cancellation Tokens – Reliable HTTP Calls

16 minComing soon

Implement proper timeout handling and cancellation token support for robust HTTP communication.

Resilient API Calls with Polly – Handling Failures Gracefully

22 minComing soon

Implement resilience patterns using Polly to handle transient failures in service-to-service communication.

Retry Policies & Circuit Breakers Deep Dive – Advanced Polly Patterns

24 minComing soon

Master advanced Polly patterns including timeouts, fallbacks, bulkhead isolation, and circuit breakers.

Solving HttpClient Authentication with Delegating Handlers

16 minComing soon

Create custom DelegatingHandlers to manage authentication tokens and other cross-cutting HTTP client concerns.

Logging & Monitoring HTTP Calls – Tracking and Debugging Outgoing Requests

14 minComing soon

Implement comprehensive logging for external service calls to simplify troubleshooting of integration issues.

Understanding IHostedService & BackgroundService

18 min

Use built-in .NET abstractions to run background tasks within your ASP.NET Core application.

Scheduled Jobs with Quartz.NET

22 minComing soon

Implement complex job scheduling with cron expressions and job persistence using Quartz.NET.

Background Job Processing with Hangfire

20 minComing soon

Set up Hangfire for reliable background job processing with built-in dashboard and retry support.

Recurring Jobs & Job Scheduling Patterns

16 minComing soon

Implement recurring jobs and understand common scheduling patterns for background processing.

Long-Running Tasks & Graceful Shutdown

18 minComing soon

Handle long-running background tasks with proper cancellation and graceful shutdown support.

Worker Services in .NET

20 minComing soon

Build standalone worker services for background processing outside of the web application context.

Processing Queues in Background

18 minComing soon

Implement queue-based background processing for decoupled, scalable task handling.

Uploading Files in ASP.NET Core

18 minComing soon

Implement file upload endpoints with proper streaming and memory management.

Validating File Uploads – Size, Type & Security

16 minComing soon

Implement comprehensive file validation to prevent security vulnerabilities and ensure data integrity.

Downloading & Streaming Large Files

18 minComing soon

Serve files efficiently using streaming to handle large files without memory issues.

Storing Files in AWS S3 - Upload, Download & Delete

22 min

Upload, download and delete files in AWS S3 from ASP.NET Core on .NET 10 with AWS SDK V4, Minimal API endpoints, presigned URLs and IAM best practices.

Storing Files in Azure Blob Storage

22 minComing soon

Integrate with Azure Blob Storage for cloud-based file storage and management.

Image Processing & Resizing

18 minComing soon

Process and resize images on the server using ImageSharp or similar libraries.

PDF Generation in .NET – Creating Reports & Documents

18 min

Implement PDF document generation for reports, invoices, and other business documents directly from your API.

Generating Excel Files with ClosedXML or EPPlus

16 minComing soon

Create Excel spreadsheets programmatically for data exports and reporting.

API Key Authentication – Securing APIs with API Keys

30 min

Production-grade API key authentication in ASP.NET Core .NET 10 with hashed keys, DB-backed store, AuthenticationHandler, HybridCache validation, decision matrix, and a full source repo.

Implementing JWT Authentication – Adding Token-Based Authentication

25 min

Configure JWT-based authentication to secure your APIs with stateless, token-based access control.

Refresh Tokens in ASP.NET Core – Extending Authentication Session Securely

20 min

Implement secure refresh token patterns to maintain user sessions without compromising security.

Role-Based Authorization – Controlling Access to API Endpoints

18 min

Apply role-based authorization to restrict access to API resources based on user permissions.

Claims-Based Authorization – Fine-Grained Access Control

18 min

Implement claims-based authorization for flexible, attribute-based access control scenarios.

Policy-Based Authorization – The Modern Way to Handle Complex Auth Rules

20 min

Create reusable authorization policies for complex access control requirements.

Permission-Based Authorization – Runtime-Managed Access Control

28 min

Build permission-based authorization on .NET 10 with a dynamic policy provider, runtime-managed role permissions, and a measured look at what happens when permissions ride in the token.

OAuth 2.0 & OpenID Connect – Implementing Modern Authentication

30 minComing soon

Configure OAuth 2.0 and OpenID Connect protocols to enable secure, standards-based authentication.

Identity API Endpoints - When to Use MapIdentityApi

22 min

MapIdentityApi gives you register, login and refresh for free in .NET 10. Exactly when to use the built-in Identity API endpoints and when to roll your own.

Custom User Management – Users, Roles & Profiles

28 min

Build a custom user model, admin endpoints to list, search, role-manage and lock users, and self-service profile endpoints on top of ASP.NET Core Identity.

Two-Factor Authentication (2FA) – Adding Extra Security

22 minComing soon

Implement two-factor authentication to add an extra layer of security to user accounts.

Keycloak Integration – Authentication & Authorization with Keycloak

28 minComing soon

Connect your application to Keycloak to leverage its comprehensive identity and access management capabilities.

CORS in ASP.NET Core (.NET 10) - Cross-Origin Done Right

28 min

Configure CORS in .NET 10 without opening holes. Covers the preflight handshake, named vs endpoint policies, config-driven origins, the AllowAnyOrigin plus AllowCredentials throw, wildcard subdomains, the Vary Origin caching trap, reverse-proxy duplicate headers, and preflight integration tests.

Security Headers – HSTS, CSP, X-Frame-Options & More

16 minComing soon

Configure security headers to protect your API from common web vulnerabilities.

HTTPS Enforcement & Certificate Handling

14 minComing soon

Enforce HTTPS and properly handle SSL/TLS certificates in production environments.

Rate Limiting in ASP.NET Core (.NET 10) - Complete Guide

30 min

Production-grade rate limiting in ASP.NET Core .NET 10. All 4 algorithms, partitioning by user/IP/API key, Redis backplane, OnRejected with Retry-After, multi-tenant tiers, and a decision matrix.

Understanding API Architecture – Monolith vs Modular Monolith vs Microservices

25 minComing soon

Compare architectural approaches to select the most appropriate pattern for your project's specific requirements.

SOLID Principles in Practice – Applied to .NET APIs

28 minComing soon

Apply SOLID principles to write maintainable, extensible API code with practical examples.

20+ .NET 10 Best Practices & Tips from a Senior Developer

35 min

The habits that separate senior .NET code from junior code - project structure, async, EF Core, configuration, logging and error handling, with the reasoning behind each one.

Repository Pattern – Do You Really Need It?

20 min

Understand when the repository pattern adds value and when it introduces unnecessary complexity.

Watch video

Unit of Work Pattern – Managing Transactions Across Repositories

18 minComing soon

Implement the unit of work pattern to coordinate changes across multiple repositories.

Domain-Driven Design (DDD) in .NET – Applying DDD Principles

30 minComing soon

Apply Domain-Driven Design principles to model complex business domains effectively in your API architecture.

Onion Architecture vs Clean Architecture – Understanding the Differences

22 minComing soon

Compare Onion and Clean Architecture to understand their similarities, differences, and when to use each.

Implementing Clean Architecture in .NET – Step-by-Step Guide

35 min

Build a movie management API across Domain, Application, Infrastructure, and API layers on .NET 10. Use DbContext directly instead of a repository, apply light DDD, and wire it all up with .NET Aspire.

Vertical Slice vs Clean Architecture – The Pragmatic Hybrid

22 min

Compare Clean Architecture and Vertical Slice Architecture on the same Product API, count the files each makes you touch per feature, and build the hybrid: a Domain project, feature folders, Shared folder rules, and architecture tests.

Modular Monolith Step-by-Step – Building Maintainable Monoliths

30 minComing soon

Build a modular monolith that offers the simplicity of monoliths with the maintainability of microservices.

When to Use Microservices (And When Not To)

18 min

Microservices solve an organizational and scaling problem, not a code-quality one. Learn the signals that justify the split, the ones that scream don't, the hidden costs of every network boundary, and why a modular monolith is the right default.

Structuring Large .NET Solutions – Project Organization & Folder Structure

18 minComing soon

Organize large .NET solutions with clear project structure and folder conventions.

Anti-Patterns to Avoid in .NET APIs

22 min

10 .NET 10 API anti-patterns ranked by blast radius - async void, sync-over-async, fat controllers, runtime-reflection mappers in AOT, and the modern 2026 ones.

Health Checks in ASP.NET Core – Ensuring API Reliability

25 min

Add database, Redis and custom health checks, split liveness from readiness with tags, and wire the endpoints into Kubernetes without turning a database blip into a restart storm.

Correlation IDs & Request Tracing – Tracking Requests Across Services

16 minComing soon

Implement correlation IDs to trace requests across multiple services and simplify debugging.

OpenTelemetry in .NET – Distributed Tracing & Observability

25 minComing soon

Configure OpenTelemetry to collect metrics, traces, and logs for comprehensive application monitoring.

Centralized Logging with Seq – Structured Log Analysis

18 minComing soon

Set up Seq for centralized log aggregation and powerful structured log querying.

Centralized Logging with ELK Stack – Elasticsearch, Logstash & Kibana

25 minComing soon

Implement the ELK stack for scalable log aggregation, search, and visualization.

Metrics Collection with Prometheus – Capturing API Performance Metrics

20 minComing soon

Implement Prometheus metrics collection to gather and analyze performance data from your .NET applications.

Grafana Dashboards for .NET APIs – Visualizing Metrics

20 minComing soon

Create Grafana dashboards to visualize API metrics and monitor application health.

Distributed Tracing with Jaeger & Zipkin – Visualizing Request Flows

22 minComing soon

Configure distributed tracing to track and visualize request flows through complex multi-service architectures.

Writing Unit Tests for .NET APIs – Best Practices

22 minComing soon

Apply proven unit testing techniques to verify the behavior of individual API components in isolation.

Integration Testing in .NET Web APIs – Step-by-Step Guide

25 minComing soon

Create comprehensive integration tests to validate the behavior of your API endpoints end-to-end.

Using TestContainers for API Testing in .NET

20 minComing soon

Implement TestContainers to run integration tests against real dependencies in isolated Docker containers.

Automated Test Pipelines – Running CI/CD Tests for APIs

18 minComing soon

Configure automated test execution in your CI/CD pipeline to maintain code quality during deployment.

Handling API Contracts – Preventing Breaking Changes

16 minComing soon

Implement contract testing to detect potential breaking changes before they affect API consumers.

Getting Started with Docker – Containerizing Your API

25 min

Package your .NET API as a Docker container for consistent deployment across different environments.

Containerize .NET Apps Without a Dockerfile - Built-In SDK Container Support

25 min

Learn how to containerize .NET 10 apps without a Dockerfile using dotnet publish. Includes image size benchmarks, Alpine/Chiseled comparisons, CI/CD with GitHub Actions, and a production checklist.

Aspire for .NET Developers – Replace Docker Compose with One C# File

30 min

Orchestrate your entire local stack with Aspire: the AppHost model, WaitFor vs WaitForCompletion, automatic connection strings, the dashboard with logs and traces, and running React, Node, and Python apps from the same file.

Watch video

Building & Deploying .NET APIs with GitHub Actions

22 min

Configure GitHub Actions workflows to automate building, testing, and deploying your .NET API applications.

Managing API Gateway with YARP in .NET

20 minComing soon

Implement API Gateway patterns using YARP to route, transform, and aggregate requests across multiple services.

Final API Checklist – Best Practices Before Going Live

15 minComing soon

Apply this comprehensive pre-launch checklist to ensure your API meets security, performance, and reliability standards.

.NET Interview Questions: The 2026 Guide (300+ Real Questions)

25 min

The master hub for .NET interview prep. Cross-topic greatest-hits questions, how .NET interviews actually run round by round, and links into every topic-specific question set in this track.

45 .NET Web API Interview Questions That Actually Get Asked in 2026

35 min

Scenario-based Web API interview questions covering REST design, status codes, versioning, validation, auth, and error handling - each with a great answer, a red-flag answer, and a follow-up.

30 EF Core Interview Questions That Actually Get Asked in 2026

30 min

EF Core interview questions on tracking, relationships, migrations, query performance, concurrency, and bulk operations - mapped to real production scenarios.

30 ASP.NET Core Interview Questions That Actually Get Asked in 2026

30 min

ASP.NET Core internals interview questions - middleware pipeline order, DI lifetimes, hosting model, configuration and options, filters, model binding, and Kestrel.

30 .NET System Design Interview Questions That Actually Get Asked in 2026

35 min

Senior-level system design scenarios for .NET - pick between HybridCache and Redis, design a background job system, scale SignalR past one instance, and make a write API provably idempotent.

30 C# Interview Questions That Actually Get Asked in 2026

30 minComing soon

C# language interview questions on value vs reference types, records, spans, async internals, and C# 14 - each with the red-flag answer and the interviewer's follow-up.

25 C# Async & Multithreading Interview Questions That Actually Get Asked in 2026

30 minComing soon

Async/await and multithreading interview questions - Task vs Thread, deadlocks, ConfigureAwait, cancellation, channels, and common concurrency bugs.

25 LINQ Interview Questions That Actually Get Asked in 2026

25 min

LINQ interview questions on deferred vs immediate execution, IEnumerable vs IQueryable, projection, grouping, and the EF Core query-translation gotchas interviewers probe.

30 .NET Microservices Interview Questions That Actually Get Asked in 2026

30 min

Microservices interview questions for .NET - service boundaries, inter-service communication, resilience, distributed transactions, the outbox pattern, and observability.

35 Senior .NET Developer Interview Questions That Actually Get Asked in 2026

40 min

Role-based prep for senior .NET interviews - GC and memory, thread pool starvation, production diagnostics with the dotnet-* CLI tools, measurement discipline, and the architecture-judgment calls that test experience rather than memorization.

20 SQL Server Interview Questions for .NET Developers in 2026

25 minComing soon

SQL Server interview questions aimed at .NET developers - indexing, execution plans, isolation levels, deadlocks, and the query-tuning topics that come up alongside EF Core.

20 Docker & DevOps Interview Questions for .NET Developers in 2026

25 minComing soon

Docker and DevOps interview questions for .NET - multi-stage builds, image optimization, CI/CD pipelines, secrets management, and container deployment.

Getting Started with .NET Web API

17 lessons · 1 planned

RESTful API Best Practices for .NET Developers 20 min

Understanding HTTP Status Codes – Returning Proper API Responses 15 min

Environment-based Configuration – appsettings.json, Environment Variables & Launch Profiles 18 min

Middlewares in ASP.NET Core .NET 10 – The Complete Guide to Request Pipeline, Custom Middleware, and IMiddleware 28 min

Dependency Injection (DI) in ASP.NET Core – Deep Dive into DI and Its Benefits 22 min

Service Lifetimes – Singleton vs Scoped vs Transient in .NET 10 15 min

Keyed Services in .NET – Advanced DI Techniques Using Keyed Services 12 min

Scrutor – Auto-Registering Dependencies for Cleaner DI Management 14 min

Filters in ASP.NET Core .NET 10 - Action, Resource, Exception, Result, and Endpoint Filters 28 min

ProblemDetails in ASP.NET Core – Standardizing Error Responses in APIs 12 min

Global Exception Handling – Centralized Error Handling for Better Maintainability 16 min

Structured Logging with Serilog – Implementing Structured Logging in .NET APIs 20 min

Minimal API Endpoints – Understanding and Using Minimal APIs in ASP.NET Core 25 min

API Documentation – Generating OpenAPI Docs and Exploring Swagger Alternatives 18 min

Migrating from Swagger to Scalar – Porting Auth, Filters, and XML Comments in .NET 10 22 min

File-Based Apps in .NET 10 – Run C# Without a Project File 18 min

Migrating from .sln to .slnx in .NET 10 – The New XML-Based Solution Format 18 min

Best Libraries for ASP.NET Core in 2026: 12 Free NuGet Packages 20 min

Database Management with Entity Framework Core

17 lessons · 8 planned

CRUD with EF Core – Implementing Basic CRUD Operations in ASP.NET Core 30 min

Configuring Entities with Fluent API – Entity Configuration Best Practices 20 min

Relationships in EF Core – Configuring One-to-One, One-to-Many, and Many-to-Many 22 min

Pagination, Sorting & Searching – Optimizing Queries for Large Datasets 22 min

Global Query Filters – Applying Filters Globally to Avoid Repetitive Queries 18 min

Soft Deletes – Implementing Logical Deletes Without Removing Data 16 min

Bulk Operations – Optimizing Insert, Update, and Delete Operations in EF Core 22 min

Concurrency Control – Preventing Data Conflicts with Optimistic Locking 20 min

Multiple DB Contexts – Using Multiple Database Contexts in a Single Application 22 min

Running Migrations – Best Practices for Applying Database Migrations 20 min

Cleaning Migrations – Squash, Reset & Organize Your Migration History 18 min

Tracking vs. No-Tracking Queries – Understanding Performance Implications 18 min

Transactions in EF Core – Ensuring Data Consistency with Database Transactions 16 min

EF Core Interceptors - The Complete Guide to All 7 Types 18 min

Seeding Initial Data – Populating the Database with Default Data 12 min

Stored Procedures – Executing Raw SQL and Stored Procedures Efficiently 18 min

Lazy, Eager & Explicit Loading – Managing How Related Entities Are Retrieved 20 min

Compiled Queries – Boosting Performance for Hot Query Paths 18 min

DbContext Pooling for Performance – Reusing Context Instances at Scale 18 min

The N+1 Query Problem in EF Core – And How to Kill It 20 min

Fastest Way to Bulk Insert Thousands of Rows in EF Core 20 min

Filtering by a Large List - Contains and the 2,100 Parameter Wall 20 min

Audit Trail & Change Tracking in EF Core (.NET 10) 22 min

Second-Level Caching in EF Core – Caching Query Results Across Requests 20 min

EF Core + Dapper Hybrid – When to Use Which 20 min

Advanced API Features & Design Patterns

8 lessons · 7 planned

Options Pattern in ASP.NET Core – Managing Configurations Effectively 18 min

FluentValidation – Writing Clean & Reusable Request Validations 30 min

CQRS & MediatR – Building Scalable, Decoupled APIs 35 min

Build Your Own CQRS Dispatcher in .NET 10 (No MediatR) 30 min

Validation with MediatR Pipeline and FluentValidation 18 min

Validating Options Pattern with FluentValidation 12 min

Result Pattern – No More Exceptions for Flow Control 22 min

Decorator Pattern in .NET – Cross-Cutting Concerns Made Easy 18 min

Specification Pattern – Encapsulating Query Logic Cleanly 16 min

AutoMapper vs Mapster vs Manual Mapping in .NET 10 - Pick the Right One in 2026 24 min

Feature Flags – Enabling & Disabling Features Dynamically 16 min

Implementing API Versioning – Managing Breaking Changes 18 min

Webhooks – Enabling Event-Driven API Communication 20 min

Real-Time APIs with SignalR – Implementing WebSockets 25 min

Outbox Pattern – Reliable Messaging in Distributed Systems 20 min

Performance Optimization & Caching

5 lessons · 6 planned

Benchmarking .NET APIs – Measuring & Optimizing Performance 20 min

Profiling .NET APIs – dotnet-trace, dotnet-counters & More 18 min

Response Compression & Content Negotiation – Optimizing Payload Size 14 min

In-Memory Caching – Reducing Database Calls 18 min

Distributed Caching with Redis – Scaling API Performance 22 min

Output Caching in .NET – Built-In Response Caching 16 min

Response Caching with MediatR in ASP.NET Core – Powerful Pipeline Behavior 20 min

HybridCache in ASP.NET Core .NET 10 – L1 + L2 Caching with Stampede Protection 25 min

Async Streams & IAsyncEnumerable – Handling Large Datasets Efficiently 16 min

Memory Management & Avoiding Allocations – Span<T>, ArrayPool & Object Pooling 20 min

10 EF Core Performance Mistakes (and How to Fix Them) in .NET 10 25 min

HTTP Clients & Resilient API Communication

1 lesson · 7 planned

HttpClient Factory in .NET – Managing HTTP Clients Efficiently 18 min

Best Way to Use HTTP Clients in .NET APIs 20 min

Using Refit for Simplified API Calls in .NET 18 min

Handling Timeouts & Cancellation Tokens – Reliable HTTP Calls 16 min

Resilient API Calls with Polly – Handling Failures Gracefully 22 min

Retry Policies & Circuit Breakers Deep Dive – Advanced Polly Patterns 24 min

Solving HttpClient Authentication with Delegating Handlers 16 min

Logging & Monitoring HTTP Calls – Tracking and Debugging Outgoing Requests 14 min

Background Processing

1 lesson · 6 planned

Understanding IHostedService & BackgroundService 18 min

Scheduled Jobs with Quartz.NET 22 min

Background Job Processing with Hangfire 20 min

Recurring Jobs & Job Scheduling Patterns 16 min

Long-Running Tasks & Graceful Shutdown 18 min

Worker Services in .NET 20 min

Processing Queues in Background 18 min

File Handling & Storage

2 lessons · 6 planned

Uploading Files in ASP.NET Core 18 min

Validating File Uploads – Size, Type & Security 16 min

Downloading & Streaming Large Files 18 min

Storing Files in AWS S3 - Upload, Download & Delete 22 min

Storing Files in Azure Blob Storage 22 min

Image Processing & Resizing 18 min

PDF Generation in .NET – Creating Reports & Documents 18 min

Generating Excel Files with ClosedXML or EPPlus 16 min

API Security, Authentication & Authorization

11 lessons · 5 planned

API Key Authentication – Securing APIs with API Keys 30 min

Implementing JWT Authentication – Adding Token-Based Authentication 25 min

Refresh Tokens in ASP.NET Core – Extending Authentication Session Securely 20 min

Role-Based Authorization – Controlling Access to API Endpoints 18 min

Claims-Based Authorization – Fine-Grained Access Control 18 min

Policy-Based Authorization – The Modern Way to Handle Complex Auth Rules 20 min

Permission-Based Authorization – Runtime-Managed Access Control 28 min

OAuth 2.0 & OpenID Connect – Implementing Modern Authentication 30 min

Identity API Endpoints - When to Use MapIdentityApi 22 min

Custom User Management – Users, Roles & Profiles 28 min

Two-Factor Authentication (2FA) – Adding Extra Security 22 min

Keycloak Integration – Authentication & Authorization with Keycloak 28 min

CORS in ASP.NET Core (.NET 10) - Cross-Origin Done Right 28 min

Security Headers – HSTS, CSP, X-Frame-Options & More 16 min

HTTPS Enforcement & Certificate Handling 14 min

Rate Limiting in ASP.NET Core (.NET 10) - Complete Guide 30 min

Architecting .NET APIs – Clean Code & Best Practices

6 lessons · 7 planned

Understanding API Architecture – Monolith vs Modular Monolith vs Microservices 25 min

SOLID Principles in Practice – Applied to .NET APIs 28 min

20+ .NET 10 Best Practices & Tips from a Senior Developer 35 min

Repository Pattern – Do You Really Need It? 20 min

Unit of Work Pattern – Managing Transactions Across Repositories 18 min

Domain-Driven Design (DDD) in .NET – Applying DDD Principles 30 min

Onion Architecture vs Clean Architecture – Understanding the Differences 22 min

Implementing Clean Architecture in .NET – Step-by-Step Guide 35 min

Vertical Slice vs Clean Architecture – The Pragmatic Hybrid 22 min

Modular Monolith Step-by-Step – Building Maintainable Monoliths 30 min

When to Use Microservices (And When Not To) 18 min

Structuring Large .NET Solutions – Project Organization & Folder Structure 18 min

Anti-Patterns to Avoid in .NET APIs 22 min

Tracing, Monitoring & Observability

1 lesson · 7 planned

Health Checks in ASP.NET Core – Ensuring API Reliability 25 min

Correlation IDs & Request Tracing – Tracking Requests Across Services 16 min

OpenTelemetry in .NET – Distributed Tracing & Observability 25 min

Centralized Logging with Seq – Structured Log Analysis 18 min

Centralized Logging with ELK Stack – Elasticsearch, Logstash & Kibana 25 min

Metrics Collection with Prometheus – Capturing API Performance Metrics 20 min

Grafana Dashboards for .NET APIs – Visualizing Metrics 20 min

Distributed Tracing with Jaeger & Zipkin – Visualizing Request Flows 22 min

Testing & Quality Assurance

Coming soon · 5 planned

Writing Unit Tests for .NET APIs – Best Practices 22 min

Integration Testing in .NET Web APIs – Step-by-Step Guide 25 min

Using TestContainers for API Testing in .NET 20 min

Automated Test Pipelines – Running CI/CD Tests for APIs 18 min

Handling API Contracts – Preventing Breaking Changes 16 min

Deployment, DevOps & Scaling

4 lessons · 2 planned

Getting Started with Docker – Containerizing Your API 25 min

Containerize .NET Apps Without a Dockerfile - Built-In SDK Container Support 25 min

Aspire for .NET Developers – Replace Docker Compose with One C# File 30 min

Building & Deploying .NET APIs with GitHub Actions 22 min

Managing API Gateway with YARP in .NET 20 min

Final API Checklist – Best Practices Before Going Live 15 min

Getting Interview Ready & Landing the Job

8 lessons · 4 planned

.NET Interview Questions: The 2026 Guide (300+ Real Questions) 25 min

45 .NET Web API Interview Questions That Actually Get Asked in 2026 35 min

30 EF Core Interview Questions That Actually Get Asked in 2026 30 min

30 ASP.NET Core Interview Questions That Actually Get Asked in 2026 30 min

30 .NET System Design Interview Questions That Actually Get Asked in 2026 35 min

30 C# Interview Questions That Actually Get Asked in 2026 30 min

25 C# Async & Multithreading Interview Questions That Actually Get Asked in 2026 30 min

25 LINQ Interview Questions That Actually Get Asked in 2026 25 min

30 .NET Microservices Interview Questions That Actually Get Asked in 2026 30 min

35 Senior .NET Developer Interview Questions That Actually Get Asked in 2026 40 min

20 SQL Server Interview Questions for .NET Developers in 2026 25 min

20 Docker & DevOps Interview Questions for .NET Developers in 2026 25 min

71 more lessons in progress

New lessons added regularly

Progress

Getting Started with .NET Web API

Database Management with Entity Framework Core

Advanced API Features & Design Patterns

Performance Optimization & Caching

HTTP Clients & Resilient API Communication

Background Processing

File Handling & Storage

API Security, Authentication & Authorization

Architecting .NET APIs – Clean Code & Best Practices

Tracing, Monitoring & Observability

Testing & Quality Assurance

Deployment, DevOps & Scaling

Getting Interview Ready & Landing the Job

Free course All Levels

Free No credit card

Start course Source code

.NET Web API

Free · 60+ hours

Start course