112 topics
HTTP Status Codes: The Complete Reference
Every HTTP status code grouped by range — 100s (informational), 200s (success), 300s (redirection), 400s (client errors), 500s (server errors) — with what each one means and when to use it.
Big O Notation: Time & Space Complexity
Understand Big O as a language for describing how an algorithm's performance scales with input size — and how to identify the complexity of common operations at a glance.
Core Data Structures: Array, LinkedList, Stack & Queue
Know which data structure to reach for and why — with the time complexity of key operations and the .NET type to use for each.
Sorting Algorithms: Bubble, QuickSort & MergeSort
Understand the three foundational sorting approaches — their time complexity trade-offs, when each is appropriate, and why Array.Sort() in .NET beats a hand-rolled sort almost every time.
Searching: Linear Search vs Binary Search
Know when O(n) linear search is fine and when O(log n) binary search is essential — and how binary search's "halving" strategy works on sorted data.
How to Identify the Right Algorithm or Pattern
A practical decision framework for choosing the correct algorithm or design pattern — by analysing the problem type, data scale, and constraints before writing a single line of code.
Concurrency vs Parallelism: The Mental Model
Understand the fundamental distinction between concurrency (structure — managing multiple tasks) and parallelism (execution — running multiple tasks simultaneously on multiple CPU cores).
async void: Why It's Dangerous & When It's Allowed
Understand why async void methods swallow exceptions, make calling code unaware of completion, and should only ever appear in event handlers.
Collections: Dictionary vs Hashtable & When to Use Each
Understand why Dictionary<TKey,TValue> replaced Hashtable, how hash-based O(1) lookup works, and which collection type to reach for in modern .NET.
Dependency Injection Lifetimes
Understand Singleton, Scoped, and Transient lifetimes in ASP.NET Core DI — and how to avoid the captive dependency bug.
struct vs class: Value Types, Reference Types & Memory
Understand the fundamental memory model difference between structs (value types on the stack) and classes (reference types on the heap) — and when each is appropriate.
OOP Pillars: Encapsulation, Inheritance, Polymorphism & Abstraction
Master the four pillars of Object-Oriented Programming in C# — with concrete examples and the real-world trade-offs of inheritance vs composition.
POST Body vs Query String: API Design Best Practice
Understand why passing mutable, sensitive, or large data via query string is an anti-pattern — and when to use [FromBody], [FromQuery], and [FromRoute] correctly.
Records vs Classes: Value Identity vs Reference Identity
Classes are built for encapsulated behaviour and mutable state (identity-based). Records are built for transparent, immutable data (value-based). Understanding this distinction prevents subtle equality bugs and leads to cleaner domain models.
New Control Flow Syntax (Angular 17+)
Angular 17 replaced *ngIf and *ngFor with built-in @if, @for, @switch blocks — cleaner and more performant.
Dependency Injection & inject()
Angular's hierarchical DI system — providedIn: 'root', InjectionToken for config values, and the modern inject() function.
Time Complexity of an API Chain & DB Lookup
Understand the Big O of a chained API call that fetches a single record by ID — and why the database index type is the dominant factor in the overall complexity.
Docker Fundamentals: Images, Containers & Dockerfiles
Understand the core Docker mental model — the difference between an image and a container, how a Dockerfile builds an image layer by layer, and essential CLI commands.
Health Checks: Liveness, Readiness & Startup Probes
The three types of health checks every production service needs — what each one signals, what happens when they fail, and how to implement them in ASP.NET Core.
Threads, Locks & Synchronization Primitives
Understand the OS thread model, synchronization primitives (Lock, Mutex, SemaphoreSlim, ReaderWriterLockSlim), and when thread-safe collections eliminate the need for manual locking.
Task.WhenAll vs Task.WhenAny: Concurrent Task Patterns
Run multiple async operations concurrently and collect results efficiently — understand the performance difference between sequential awaits and parallel task fans.
Async / Await Best Practices
Avoid common async pitfalls in .NET — async void, ConfigureAwait, CancellationToken, and parallel task execution.
EF Core Loading Strategies: Eager, Lazy & Explicit
Know when to use Include(), lazy loading, and explicit loading — and how each choice affects query count, memory, and the N+1 problem.
EF Core Performance Patterns
Optimise Entity Framework Core for high-volume services with AsNoTracking, projections, split queries, and Dapper for complex reads.
Writing Custom Middleware in ASP.NET Core
Build class-based and inline middleware — short-circuiting requests, injecting scoped dependencies, and registering via extension methods.
Delegates, Events & the Publisher/Subscriber Pattern
Understand C# delegates as type-safe function pointers, how events enforce the pub/sub pattern, and when to use Action/Func vs custom delegates.
Resilience with Polly
Build resilient HTTP calls using Polly v8 — retry with exponential back-off, circuit breaker states, and bulkhead isolation.
API Versioning Strategies
Compare URL path, header, and query string versioning in ASP.NET Core — with practical guidance on when to use each.
SOLID Principles in C#
Apply the five SOLID principles in real .NET code — with practical examples and the common violations to watch for in code reviews.
Design Patterns in C#: Factory, Strategy, Observer & Decorator
Recognise and apply the most common GoF design patterns in .NET production code — and understand which problem each one solves.
IDisposable, Finalizers & GC.SuppressFinalize
Implement the full IDisposable pattern correctly — understand why GC.SuppressFinalize exists, when finalizers run, and the performance cost of not using "using".
LINQ: Deferred Execution, Pitfalls & Performance
Understand how LINQ's deferred execution works, common pitfalls like multiple enumeration and closure captures, and when to prefer EF Core over LINQ-to-Objects.
Synchronous API Chaining: The Slow UI Anti-Pattern
Understand why chaining API calls synchronously in the request path blocks the frontend, couples services together, and how to eliminate it with async event-driven design.
Background Workers & Azure Service Bus for Async Email
Decouple non-critical side effects (email, notifications) from the request path using Azure Service Bus and a .NET Background Worker — with retry logic and structured logging.
IHttpClientFactory: Why new HttpClient() Is a Bug
Understand why creating a new HttpClient per request causes socket exhaustion and TLS overhead — and how IHttpClientFactory solves this with managed, reusable connections.
ASP.NET Core Middleware Pipeline
Understand how the middleware pipeline processes HTTP requests and responses, the order middleware executes, and how to build reusable custom middleware classes.
ASP.NET Core Request Pipeline: Routing, Model Binding & Filters
The three pillars of the ASP.NET Core request pipeline — Routing finds the right action, Model Binding maps incoming data to C# objects, and Filters run cross-cutting logic before/after execution.
Modern C# Features: Records, Pattern Matching, Nullable Refs, Generics & More
A practical guide to the features that transformed C# from verbose Java-like syntax into a powerful, expressive language — Records, Pattern Matching, Nullable Reference Types, Extension Methods, LINQ, and the critical IEnumerable vs List distinction.
Angular Signals — Fine-Grained Reactivity
Replace Zone.js-based change detection with Signals — reactive primitives that track exactly which components depend on which values.
Signal-Based Inputs & Outputs (Angular 17.1+)
Replace @Input() / @Output() decorators with input() and output() — integrated with the signals reactivity graph.
RxJS Core Concepts: Observables, Subjects & the Push Model
Understand how RxJS models async data as streams — the difference between cold and hot observables, the four Subject types, and when to use each.
RxJS Operators: Transformation, Filtering & Error Handling
Master the essential RxJS operators — higher-order mapping, filtering, combination, and error handling — with practical patterns for every Angular scenario.
Bridging Observables and Signals with toSignal()
Convert RxJS Observables into Signals for use in templates — eliminating the async pipe and enabling signal-based change detection.
Angular Component Architecture: Class, Template & Communication
Understand what an Angular component is, how the three parts (class, template, metadata) work together, and the four patterns for component communication.
Dependency Injection Provider Scopes: Root, Module & Component
Understand the four DI provider scopes in Angular — when each is instantiated, how long it lives, and the real-world bugs that arise from choosing the wrong scope.
Diagnosing & Fixing Angular Performance Bottlenecks
A practical approach to identifying performance issues — from excessive change detection cycles and N+1 queries to large DOM renders — with the tools and fixes that make a measurable difference.
Caching Strategies: Cache-Aside vs Write-Through
Understand when to update the database first vs. the cache first — and why the order matters for consistency, performance, and concurrency.
Window Functions: ROW_NUMBER, RANK, DENSE_RANK & CTEs
Master the three ranking functions — understanding exactly how they differ when ties occur — plus correct TOP-N patterns, PARTITION BY, and when to reach for a CTE.
CTEs & Recursive Queries in SQL Server
Use Common Table Expressions to break down complex queries into readable building blocks — and unlock recursive CTEs for hierarchical data like org charts and category trees.
Index Seek vs Index Scan: How SQL Server Chooses
Understand the fundamental difference between an Index Seek (direct B-Tree navigation) and an Index Scan (full index read) — and how to write queries that always trigger a Seek.
Index Types: Choosing the Right Index for Every Query Pattern
Different index types are optimised for specific query patterns. Choosing correctly between B-Tree, Hash, Composite, Clustered, Filtered, Full-Text, GIN, and Bitmap indexes eliminates unnecessary disk I/O and dramatically speeds up query execution.
Transactions, ACID & Concurrency in SQL Server
Understand isolation levels, optimistic vs pessimistic concurrency, and deadlock prevention in SQL Server and EF Core.
Docker Compose: Multi-Container Local Development
Use docker-compose.yml to define and run multi-container applications — spinning up your API, database, and Redis together with a single command.
Kubernetes Fundamentals: Pods, Deployments & Services
Understand the core Kubernetes objects — Pods, Deployments, and Services — and how K8s manages container lifecycle, scaling, and self-healing across a cluster.
Kubernetes ConfigMaps, Secrets & Health Probes
Manage application configuration and credentials in K8s with ConfigMaps and Secrets — and ensure K8s only routes traffic to healthy Pods using liveness and readiness probes.
Azure → AWS Service Mapping: The Complete Mental Model
Translate your Azure knowledge directly into AWS equivalents across compute, storage, databases, networking, messaging, and identity — and understand the key architectural differences between the two platforms.
Rebuilding a .NET + Angular App in AWS
A practical architecture walkthrough for migrating a .NET Core API + Angular frontend from Azure to AWS — with real trade-offs, what breaks, and what actually gets better.
Queue vs Event: When to Use Each (And Why It Matters)
Understand the fundamental difference between a queue (one consumer, job processing) and an event (many consumers, something happened) — the most misunderstood distinction in distributed systems.
CI/CD Pipeline Design for .NET + Angular
Structure a complete build, test, and deploy pipeline for a full-stack .NET and Angular project using GitHub Actions or Azure DevOps.
Docker Best Practices for .NET Services
Multi-stage Dockerfile patterns, layer caching optimisation, networking, and health checks for containerised .NET microservices.
Production Readiness Checklist
A definitive pre-deploy checklist covering infrastructure, security, data integrity, API quality, and launch readiness — the difference between a hobby project and a professional-grade deployment.
IDOR: Insecure Direct Object Reference
Understand how IDOR works, why it is one of the most common and dangerous API vulnerabilities, and how to eliminate it with resource-level authorization checks.
JWT, OAuth2 & OIDC in ASP.NET Core
Implement secure authentication and authorisation using JWT bearer tokens, OAuth2 flows, and OIDC with providers like Cognito or Entra ID.
LINQ Deep Dive: Queries, Joins, First vs FirstOrDefault & Best Practices
A comprehensive guide to LINQ — from filtering and projection to joins, grouping, and the subtle but critical differences between First, FirstOrDefault, Single, and SingleOrDefault.
STAR: Raising Engineering Standards Without Slowing Delivery
How to answer: "Tell me about a time you raised engineering standards across a team while still delivering to deadlines."
STAR: Improving CI/CD Pipelines for Safer, Faster Releases
How to answer: "Tell me about a time you improved a CI/CD pipeline or release process to make deployments safer and faster."
STAR: Improving Observability to Reduce Incident Impact
How to answer: "Tell me about a time you improved observability for a production system and it materially reduced incident impact."
STAR: Security by Design for APIs and Cloud Services
How to answer: "Tell me about a time you designed security into an API or cloud solution and balanced it with usability and delivery speed."
STAR: Cross-Functional Collaboration Across Teams
How to answer: "Tell me about a time you aligned multiple teams to deliver an end-to-end feature with clear interfaces and non-functional requirements."
Securitization Fundamentals: Mechanics & SPVs
Understand how illiquid loan pools are transformed into tradable securities via a Special Purpose Vehicle — the core lifecycle from origination to investor issuance.
Credit Enhancement: Tranching, OC & Excess Spread
Learn how internal and external credit enhancement techniques protect senior investors and achieve investment-grade ratings on pools of sub-investment-grade loans.
System Design Foundations: Scalability, Availability & Reliability
Understand the core trade-offs in distributed systems — vertical vs horizontal scaling, availability vs reliability, and why designing for failure is the default assumption at scale.
Observability: Metrics, Logs & Distributed Traces
Monitoring tells you when something is broken. Observability tells you why. Master the three pillars — metrics, logs, and traces — and when to reach for each.
CAP Theorem: Consistency, Availability & Partition Tolerance
Every distributed system must choose between Consistency and Availability when a network partition occurs. Understand CP vs AP systems and when each is appropriate.
Load Balancers, Reverse Proxies & Traffic Routing
Understand how load balancers distribute traffic across server pools, the difference between L4 and L7 balancing, sticky sessions, health checks, and global traffic routing.
Caching Layers: CDN, Application Cache & Database Cache
Design a multi-layer caching strategy — from CDN edge caching to in-process memory to Redis — and understand eviction policies, cache stampedes, and invalidation strategies.
Splunk HEC + Serilog: Structured Logging via Middleware
Stream structured logs to Splunk HEC using Serilog — wired into ASP.NET Core middleware so every request is automatically captured without a single logger.Information() call in your controllers.
Interview: Improving Observability to Reduce Incident Impact (STAR)
A structured STAR answer for "Tell me about a time you improved observability for a production system and it materially reduced incident impact."
SQL vs NoSQL: Choosing the Right Database
Move beyond "just use Postgres" — understand the trade-offs between relational and document/key-value/wide-column stores and match the database type to the access pattern.
UUID Primary Keys & B-Tree Index Fragmentation
Why random UUIDs as primary keys silently destroy database write performance — and how sequential IDs or time-sorted UUIDs (UUIDv7) fix it.
Cursor-Based Pagination: Replacing OFFSET for 50M+ Row Tables
Why OFFSET/LIMIT collapses at page 10,000 — and how keyset (cursor) pagination keeps query time flat regardless of depth.
Preventing Double Booking in Distributed Systems
Why application-level mutex fails across multiple servers — and how to use SELECT FOR UPDATE, optimistic locking, and distributed locks correctly.
Idempotency Keys: Guaranteeing Exactly-Once Processing
Mobile networks drop connections. Clients retry. How to design payment and order endpoints that can be safely retried any number of times without duplicate side effects.
Cache Stampede (Thundering Herd): Causes & Prevention
What happens when a popular cache key expires under high traffic — and the three strategies that prevent your database from collapsing as a result.
Cache Eviction Policies: LRU, LFU, TTL & When to Use Each
Caches run out of memory. When they do, what gets deleted? Understanding eviction policies prevents surprise cache behaviour in production.
Cache Hit Ratio: When Redis Slows You Down
A cache with a poor hit ratio adds network latency on every request while providing almost no benefit. How to measure, diagnose, and improve cache effectiveness.
Rate Limiting: Fixed Window vs Sliding Window vs Token Bucket
Three different rate limiting algorithms — understand the double-spend boundary exploit of fixed windows, how sliding windows fix it, and why token bucket is the standard for API throttling.
Designing Large File Upload Endpoints (5GB+)
Why uploading large files through your API server is an anti-pattern — and how presigned URLs, chunked uploads, and direct-to-storage patterns eliminate the memory and throughput bottleneck.
Async Job Processing: Queues, Workers & Exactly-Once Delivery
Design a robust async job processing system — when to use queues vs cron, at-least-once vs exactly-once delivery, job deduplication, and failure handling with dead letter queues.
API Backwards Compatibility: Safe Changes vs Breaking Changes
Mobile apps live on devices for years. A breaking API change silently crashes them. Know the difference between safe and breaking changes — and the patterns that let you evolve your API without coordinating a simultaneous deploy.
Database Connection Pooling: Exhaustion, Sizing & Debugging
Connection pool exhaustion silently hangs requests. Understand how pools work, how to size them, what causes exhaustion, and how to diagnose it before it takes down production.
Graceful Shutdown: Draining In-Flight Requests Before Termination
When Kubernetes sends SIGTERM, your server has seconds to finish in-flight work and close cleanly. Poor shutdown handling drops requests, corrupts database transactions, and loses queued messages.
N+1 Query Problem: Detection, Root Causes & Fixes
The most common ORM performance bug — one query to get a list, then N queries to get each item's details. How to identify it, understand why ORMs generate it, and permanently fix it.
Message Queue Patterns: Pub/Sub, Fan-Out, Competing Consumers & DLQ
Go beyond "use a queue" — understand the specific patterns that make distributed systems reliable: fan-out for broadcasting, competing consumers for throughput, and dead letter queues for visibility into failures.
Task vs ValueTask
Understand when heap allocation from Task<T> causes GC pressure on hot paths — and when ValueTask<T> solves it without introducing footguns.
Async Deadlocks & Parallel Patterns
Diagnose and prevent async deadlocks caused by SynchronizationContext, and choose the right parallel tool for I/O vs CPU-bound work.
Clean Architecture Layers in .NET
Organise .NET services using Clean Architecture — Domain, Application, Infrastructure, and Presentation — with inward-only dependencies.
Span<T> Escape Analysis & Ref Struct Lifetime Rules
Understand why returning a Span<T> pointing to a local variable fails to compile — and how the C# compiler enforces memory safety through escape analysis.
.NET Garbage Collector & Memory Management
Understand generational GC, the Large Object Heap, IDisposable for deterministic cleanup, and how to avoid common memory pressure pitfalls.
DDD Aggregate Roots & Boundaries
Define aggregate boundaries correctly in Domain-Driven Design — small aggregates, ID-only cross-references, and domain events.
Outbox Pattern & Saga Orchestration
Guarantee at-least-once message delivery in microservices using the Transactional Outbox Pattern and Saga for distributed workflows.
NgRx: Redux Pattern in Angular
Understand NgRx — the Redux pattern applied to Angular with a single immutable state tree, actions, reducers, selectors, and effects for managing complex application state.
NgRx / Redux vs Angular Signals: Choosing the Right State Strategy
Understand the philosophical and practical differences between NgRx/Redux (centralised, action-driven, RxJS) and Angular Signals (local, reactive, synchronous) — and when to use each or combine both.
SQL Server Performance Tuning
Index strategy, execution plans, CTEs, window functions, and avoiding N+1 queries in high-volume production databases.
Designing for Testability from Day One
Architect .NET services so every layer is independently testable — from pure domain logic to full integration tests with real databases.
STAR: Cloud-Native Microservices Architecture Trade-offs
How to answer: "Tell me about a time you designed and delivered a cloud-native service and had to make architecture trade-offs for scalability and reliability."
STAR: Event-Driven Workflows & Messaging Reliability
How to answer: "Tell me about a time you implemented an event-driven workflow and ensured it was resilient — idempotency, retries, failure handling."
STAR: People Leadership, Coaching & Team Development
How to answer: "Tell me about a time you developed an engineer or helped the team grow technically and professionally."
Building a Waterfall Engine in C#/.NET
Implement a Sequential Pay waterfall engine and apply the Strategy Pattern to handle trigger-based switches between Sequential and Pro-Rata payment modes at runtime.
Structured Finance Data Architecture on Azure
Design a production-grade data pipeline for securitization platforms — from raw loan-level data ingestion to validated analytics and investor reporting.
OpenTelemetry: Vendor-Neutral Observability Across Services
Instrument .NET services once with OpenTelemetry and ship traces, metrics, and logs to any backend — Splunk, Azure Monitor, Datadog, or Jaeger — without vendor lock-in.
Distributed Locks: Redlock, ZooKeeper & Avoiding Single Points of Failure
A single Redis instance for distributed locking is a single point of failure. Understand Redlock, its controversies, and when to use ZooKeeper or PostgreSQL advisory locks instead.