Go From Writing .NET
to Owning the Interview.
8 modules. 300+ interview Q&As. A real production project. Everything you need to pass a senior .NET interview — structured, deep, and completely free.
C# · ASP.NET Core · Clean Architecture · EF Core · CQRS · JWT · Redis · Testing · DevOps
Built For You If…
Who Is This Bootcamp For?
Mid-level .NET developers
You write .NET code daily but interviews feel different. This bridges the gap between writing code and explaining it architecturally.
Developers targeting senior roles
Senior interviews test depth — DI internals, async gotchas, architecture trade-offs. This covers exactly that depth.
Self-taught or bootcamp grads
You can build things but have gaps in the fundamentals that senior engineers notice. This fills those gaps systematically.
Engineers switching to .NET
Java, Python, or Node background? This gets you fluent in .NET idioms, patterns, and production conventions fast.
New — Full Guides
Essential .NET & AI Guides
Senior Interview Focus
High-Priority Topics — Deep Dive
The seven areas senior .NET interviews hit hardest — middleware, DI lifetimes, EF Core performance, concurrency, background services, cloud configuration, and API design — plus realistic architecture, cloud, DevOps, and security questions answered with tradeoffs, not definitions.
Middleware Pipeline
Order, auth vs authorization, short-circuiting, exception handling, custom middleware
DI Lifetimes
Singleton vs Scoped vs Transient, DbContext, captive dependencies
EF Core Performance
IQueryable, AsNoTracking, N+1, Include, projection, pagination, indexes
Concurrency & Transactions
Optimistic concurrency, row version, deadlocks, retries
Background Services
BackgroundService, Hangfire, Quartz, cancellation, graceful shutdown
Configuration & Cloud
appsettings, secrets, Options pattern, Azure deployment, zero-downtime
API Design
REST, versioning, validation, ProblemDetails, JWT, rate limiting, OpenAPI
Also covered in the full guide
- Architecture, performance, cloud & DevOps interview questions
- Async/threading, security (JWT, OAuth, OWASP)
- Senior answer style — tradeoffs and context, not definitions
- Questions to ask interviewers & likely interview flow
What You'll Walk Away With
Interview-Ready in Every Layer of .NET
By the end of this bootcamp you won't just know .NET — you'll be able to explain your decisions, defend your architecture, and answer the follow-up questions that trip up most candidates.
- Answer any C# or .NET question at mid-to-senior level with confidence
- Explain Clean Architecture, CQRS, and Domain Events clearly in interviews
- Debug EF Core query issues and optimise them live
- Discuss JWT auth, OAuth flows, and security trade-offs without hesitation
- Walk through your .NET project architecture in system design rounds
- Understand async/await at the state-machine level
- Handle caching, messaging, and background job questions at senior depth
- Ship a production .NET project you can demo in interviews
8 Modules
Full Curriculum
Every module ends with the exact interview questions that module covers — not generic questions, the precise ones that catch candidates off guard.
C# & Language Fundamentals
Interview focus: String internals, boxing, yield return, interface vs abstract class
- Dev environment setup — SDK, IDE, Docker, user-secrets (Windows / macOS / Linux)
- C# 14 — field keyword, extension blocks, Span improvements
- C# 12 features — primary constructors, collection expressions, pattern matching
- Async/await deep dive — ConfigureAwait, deadlocks, CancellationToken
- LINQ, memory (Span<T>), and modern nullability
ASP.NET Core & REST APIs
Interview focus: Request lifecycle, middleware order, IActionResult vs ActionResult<T>
- Minimal API vs Controller-based — when each makes sense
- Middleware pipeline — order matters more than you think
- Model binding, validation with FluentValidation, ProblemDetails
- Versioning, OpenAPI with Scalar, rate limiting
- Output caching, response compression, CORS
Dependency Injection & Architecture
Interview focus: Singleton vs Scoped vs Transient, SOLID principles, Separation of Concerns
- DI container internals — service lifetimes, captive dependencies
- Clean Architecture — layers, dependencies direction, why it works
- CQRS with MediatR — commands, queries, pipeline behaviors
- Domain Events and the Outbox Pattern
- Vertical Slice Architecture — when to use it over Clean Arch
Entity Framework Core
Interview focus: Change tracking internals, lazy vs eager loading, transaction management
- Code-first vs Database-first — trade-offs in production
- Relationships — owned entities, TPH/TPT/TPC, shadow properties
- Query optimization — N+1 problem, compiled queries, AsNoTracking
- Concurrency tokens, soft delete, global query filters
- Migrations in CI/CD — idempotent scripts, zero-downtime deploys
Auth, Security & Identity
Interview focus: JWT vs sessions, OAuth flows, how refresh tokens work
- JWT — signing, validation, refresh tokens, rotation strategy
- ASP.NET Core Identity — custom stores, two-factor auth
- Policy-based authorization, resource-based auth
- OAuth 2.0 and OpenID Connect with external providers
- Common security mistakes — SQL injection, CORS misconfig, SSRF
Caching, Messaging & Background Jobs
Interview focus: Cache invalidation strategies, at-least-once vs exactly-once delivery
- Redis — string, hash, sorted set, pub/sub, Lua scripts
- IMemoryCache vs IDistributedCache — when each is appropriate
- Azure Service Bus / RabbitMQ — competing consumers, dead-letter queues
- Hangfire and Quartz.NET — scheduling, retries, dashboard
- SignalR real-time updates — hubs, groups, backplane scaling
Testing in .NET
Interview focus: Why mocking the DB is dangerous, test doubles (mock vs stub vs spy)
- Unit testing with xUnit — Arrange/Act/Assert, theories
- Mocking with Moq and NSubstitute — what to mock and what not to
- Integration testing with WebApplicationFactory and Testcontainers
- Contract testing with Pact.NET
- Test pyramid — balancing unit, integration, and E2E tests
Observability, DevOps & Shipping
Interview focus: Distributed tracing, blue/green deploys, 12-factor app principles
- Structured logging with Serilog — correlation IDs, enrichers, sinks
- OpenTelemetry — traces, metrics, logs — one SDK for everything
- Health checks, readiness and liveness probes
- Docker multi-stage builds, GitHub Actions CI/CD pipeline
- YARP reverse proxy, load balancing, A/B routing
Built Into Every Module
Sample Interview Q&As
These aren't the easy ones. These are the questions that separate mid-level from senior candidates.
What's the difference between IEnumerable and IQueryable?
MidIEnumerable executes in memory — LINQ runs on the .NET side. IQueryable builds an expression tree and translates to SQL (or another provider). Use IQueryable when filtering at the database, IEnumerable when you already have data in memory.
Explain the difference between Transient, Scoped, and Singleton lifetimes.
MidTransient: new instance every time. Scoped: one instance per HTTP request. Singleton: one instance for the app lifetime. The gotcha: injecting a Scoped service into a Singleton causes a captive dependency — the Scoped service lives as long as the Singleton.
How does async/await work under the hood?
SeniorThe compiler transforms async methods into a state machine. Each await point is a state transition. The continuation runs on a thread pool thread by default. ConfigureAwait(false) avoids capturing the synchronisation context — critical in library code to prevent deadlocks in UI/ASP.NET classic apps.
What problem does CQRS solve and when is it overkill?
SeniorCQRS separates read and write models. Solves impedance mismatch when read requirements differ from write requirements, enables separate scaling, and supports event sourcing. Overkill for simple CRUD apps — the overhead of two models is only worth it when read/write profiles genuinely differ.
How do you prevent the N+1 problem in EF Core?
MidUse Include/ThenInclude for eager loading, or project to a DTO with Select. AsSplitQuery for large collections. AsNoTracking for read-only queries. Always check the generated SQL — .ToQueryString() or logging. Alternatively, raw SQL with Dapper for complex reads.
What is the Outbox Pattern and why use it?
SeniorWhen you write to the DB and publish an event, either can fail independently — leaving inconsistent state. The Outbox Pattern writes the event to the same DB transaction as the business write, then a background worker reads unprocessed events and publishes them. Guarantees at-least-once delivery without distributed transactions.
300+ more Q&As built into the course modules
Start the bootcampBuild the OrderFlow API — Production-Grade, Start to Ship.
Every module builds a piece of a real production API. By the end you have a fully deployed system you can walk through in any technical interview.
- Clean Architecture with CQRS and Domain Events
- EF Core + PostgreSQL with optimised queries
- JWT auth with refresh token rotation
- Redis caching, SignalR real-time updates
- OpenTelemetry observability stack
- GitHub Actions CI/CD, Docker, deployed to cloud
Developer Stories
What Developers Are Saying
“The CQRS and Outbox Pattern sections finally clicked for me here. I landed a senior .NET role 3 weeks after going through this.”
Dan W.
Mid → Senior .NET Engineer
“I'd been writing .NET for 4 years but couldn't explain DI lifetimes clearly. This bootcamp fixed that in one session. Passed my system design round first attempt.”
Riya M.
Backend Engineer interviewing at a scale-up
“The interview Q&As built into every module are gold. Not generic questions — the exact ones that trip people up in real interviews.”
Tom K.
.NET Developer → Lead Engineer
100% Free · No account · Start in seconds
Your Next .NET Interview
Starts Here.
8 modules. 300+ interview Q&As. A real production project you can demo. Everything needed to pass a senior .NET interview — free, forever.