Course · 20 lessons · 8 hr 43 min

FullStack Engineering Course

Twenty lessons on building production systems across the full stack in .NET, Azure and React: async and memory internals, API and NFR patterns, caching and resilience, architecture and event-driven design, security and identity, data, Azure, DevOps and observability, testing, frontend architecture and performance, and AI engineering. Every lesson explains how things work underneath, shows production-style C# or TypeScript, and ends with a short review of the key ideas.

Start the course →
  1. Lesson 1 54 min

    Async, Threads and Concurrency in .NET

    What await really does, Task versus ValueTask, ConfigureAwait and the .Result deadlock, async void, cancellation, Task.WhenAll and Parallel.ForEachAsync, then shared state: lock, Interlocked, SemaphoreSlim, ConcurrentDictionary, Channels and how to spot thread pool starvation. The first lesson of the FullStack Engineering course.

  2. Lesson 2 44 min

    Memory Management and Garbage Collection in .NET

    Stack and heap, where value types really live, boxing and hidden allocations, how the generational garbage collector works, the Large Object Heap, Server GC and containers, IDisposable and finalisers, managed memory leaks, Span<T>, Memory<T>, ArrayPool and strings, and how to measure with BenchmarkDotNet, dotnet-counters and dotnet-gcdump. Lesson 2 of the FullStack Engineering course.

  3. Lesson 3 39 min

    SOLID, Design Principles and Dependency Injection in .NET

    The five SOLID principles with C# examples from a claims service, DRY, KISS and YAGNI and how they balance SOLID, composition over inheritance, then dependency injection in ASP.NET Core: lifetimes and captive dependencies, scope validation, background services, keyed services, decorators, the options pattern and TimeProvider. Lesson 3 of the FullStack Engineering course.

  4. Lesson 4 47 min

    Building Web APIs with ASP.NET Core

    The middleware pipeline and its order, minimal APIs and route groups, REST resources, methods and status codes, Problem Details (RFC 9457) and validation, versioning, OpenAPI and contract-first design, cursor pagination, rate limiting, JSON settings, gRPC, signed webhooks and API gateways. Lesson 4 of the FullStack Engineering course.

  5. Lesson 5 35 min

    Idempotency, Concurrency and Distributed Locks

    Keeping APIs correct under retries and concurrent users: idempotency keys in Redis with a unique-constraint backstop, lost updates, optimistic concurrency with EF Core row versions, conditional (compare-and-swap) updates, ETags with If-Match, distributed locks with leases and fencing tokens, and atomic Redis operations with Lua scripts. Lesson 5 of the FullStack Engineering course.

  6. Lesson 6 20 min

    Caching in .NET: Patterns, Redis and Invalidation

    Where caches live, cache-aside, read-through, write-through, write-behind and refresh-ahead, IMemoryCache, Redis and HybridCache, invalidation, stampedes, avalanches and penetration, Redis practice, and HTTP and output caching. Lesson 6 of the FullStack Engineering course.

  7. Lesson 7 18 min

    Resilience: Timeouts, Retries, Circuit Breakers and Health Checks

    Transient and persistent failures, timeouts, retries with exponential backoff and jitter, retry storms, circuit breakers, bulkheads, Polly pipelines and AddStandardResilienceHandler, EF Core execution strategies, fallbacks, graceful degradation, load shedding, and liveness, readiness and startup health checks. Lesson 7 of the FullStack Engineering course.

  8. Lesson 8 15 min

    Architecture Styles: DDD, Clean Architecture and Microservices

    Strategic and tactical domain-driven design (bounded contexts, aggregates, value objects, domain events), clean and hexagonal architecture, vertical slices, monoliths versus modular monoliths versus microservices, Conway's law, the Backend-for-Frontend pattern and micro-frontends. Lesson 8 of the FullStack Engineering course.

  9. Lesson 9 22 min

    Event-Driven Design: Messaging, Outbox, Sagas and CQRS

    Commands, events and queries, Azure Service Bus, Event Hubs, Event Grid and Kafka, delivery guarantees, dead-letter queues and poison messages, sessions and ordering, the Outbox and Inbox patterns, sagas with choreography or orchestration, CQRS, event sourcing, eventual consistency and the CAP theorem. Lesson 9 of the FullStack Engineering course.

  10. Lesson 10 18 min

    Integration and Migration: Strangler Fig, Anti-Corruption Layer, Multi-Tenancy and Real-Time

    Why big-bang rewrites fail, the Strangler Fig pattern with YARP, moving data during a migration, the Anti-Corruption Layer, multi-tenancy isolation models with EF Core query filters, and real-time updates with polling, Server-Sent Events, WebSockets and SignalR. Lesson 10 of the FullStack Engineering course.

  11. Lesson 11 19 min

    Architecture Practice: C4, ADRs, NFRs, Threat Modelling and FinOps

    Describing systems with the C4 model and diagrams as code, architecture decision records and RFCs, measurable non-functional requirements and design reviews, threat modelling with STRIDE, FinOps and unit economics, technology evaluations, paved roads and guardrails, and managing technical debt. Lesson 11 of the FullStack Engineering course.

  12. Lesson 12 20 min

    Identity and Security: OAuth, JWT, Entra ID, Access Control and OWASP

    Authentication and authorisation, OAuth 2.0 and OpenID Connect, authorization code with PKCE and client credentials, JWT validation in ASP.NET Core, Microsoft Entra ID and managed identities, RBAC, ABAC and ReBAC with OpenFGA, the OWASP Top 10, mTLS, zero trust, and handling secrets and sensitive data. Lesson 12 of the FullStack Engineering course.

  13. Lesson 13 17 min

    Data: SQL Tuning, Indexing, EF Core Performance, Scaling and CDC

    How the optimiser and execution plans work, Query Store, parameter sniffing, indexing and SARGable queries, isolation levels and deadlocks, EF Core performance, connection pooling, read replicas, partitioning and sharding, PostgreSQL essentials, and change data capture with SQL Server CDC and Debezium. Lesson 13 of the FullStack Engineering course.

  14. Lesson 14 20 min

    Azure Services for .NET: App Service, Functions, Containers, APIM and Key Vault

    Choosing between App Service, Functions, Container Apps, AKS and Logic Apps, deployment slots and Key Vault references, isolated Azure Functions and hosting plans, Durable Functions orchestrations, API Management policies, Key Vault, Blob Storage, Front Door and load balancing, and Azure networking with private endpoints. Lesson 14 of the FullStack Engineering course.

  15. Lesson 15 29 min

    DevOps: Containers, Kubernetes, Infrastructure as Code and CI/CD

    Multi-stage Docker images and tagging, Kubernetes objects and Helm, Terraform versus Bicep, CI/CD pipelines with GitHub Actions and OIDC, GitOps with Argo CD, trunk-based development, feature flags, rolling, blue-green, canary and ring deployments, expand-and-contract database changes, and the DORA metrics. Lesson 15 of the FullStack Engineering course.

  16. Lesson 16 18 min

    Observability and Reliability: OpenTelemetry, SLOs and Disaster Recovery

    Logs, metrics and traces, structured logging, RED and USE metrics and percentiles, distributed tracing with Activity, OpenTelemetry in .NET, Azure Monitor, Prometheus, Grafana and ELK, actionable alerts, SLIs, SLOs and error budgets, incidents and blameless postmortems, and disaster recovery with RPO, RTO and multi-region designs. Lesson 16 of the FullStack Engineering course.

  17. Lesson 17 23 min

    Testing: From Unit Tests to Load, Chaos and Security Testing

    Test strategy with the pyramid and honeycomb, xUnit unit tests and test doubles, TDD and BDD, integration tests with WebApplicationFactory and Testcontainers, contract testing with Pact, Playwright end-to-end tests, load testing with k6, chaos engineering, mutation testing with Stryker.NET, and SAST, SCA and DAST. Lesson 17 of the FullStack Engineering course.

  18. Lesson 18 22 min

    React Architecture: State, Data Fetching, Next.js and Design Systems

    How React renders, kinds of state, Context, Redux Toolkit and TanStack Query, optimistic updates, error boundaries, CSR, SSR, SSG, ISR and React Server Components in Next.js, structuring large SPAs, design systems with Storybook, monorepos with Nx and Turborepo, and testing components with React Testing Library. Lesson 18 of the FullStack Engineering course.

  19. Lesson 19 22 min

    Web Performance, Accessibility and Front-End Security

    Core Web Vitals (LCP, INP, CLS) and real user monitoring, code splitting, caching and CDNs, images, virtualisation, debouncing and web workers, service workers and PWAs, accessibility (WCAG), internationalisation, and front-end security: XSS, Content Security Policy, token storage, CSRF, CORS and the npm supply chain. Lesson 19 of the FullStack Engineering course.

  20. Lesson 20 21 min

    AI Engineering: LLMs, RAG, Agents and MCP in .NET

    LLM properties that shape design, calling models with Microsoft.Extensions.AI and structured output, embeddings and vector search with pgvector, retrieval-augmented generation in .NET and LangChain, function calling, agents with Semantic Kernel and LangGraph, the Model Context Protocol, evaluating AI features, guardrails against prompt injection, and AI-assisted development. Lesson 20 of the FullStack Engineering course.

Know someone who would like this course? Share it: LinkedIn X