SERIES
A practical, .NET-first guide to system design. Twenty-six chapters that start from real interview questions and production symptoms, then walk through the architecture, the back-of-envelope numbers, and the concrete ASP.NET Core / EF Core / Redis / message-queue code that makes them work. Read one chapter when you have a problem in front of you, or read in order from foundations to nine end-to-end case studies. Available in English and Vietnamese.
Introduction to a 26-chapter system design series for .NET engineers. Covers the seven-question chapter shape, the .NET 10 stack, and how to read it.
A repeatable six-step framework for answering system design interviews in 45 minutes: clarify, estimate, architect, deep-dive, optimise, recap.
Wrap-up of System Design .NET A -> Z: five lessons that outlive specific case studies, the production .NET architecture checklist, and what to read next.
The scalability words every system design discussion uses: throughput vs latency, vertical vs horizontal, QPS, p50/p99, SLA vs SLO vs SLI. Defined for .NET engineers.
How to estimate QPS, storage, bandwidth, and latency budget on a whiteboard. The numbers every system design interview and capacity-planning exercise reuses.
What CAP really says, why PACELC is the version you actually use, and how consistency models map to .NET databases. Vocabulary for every storage choice.
How to use Redis with ASP.NET Core: IMemoryCache vs IDistributedCache, cache-aside vs write-through, invalidation strategies, and the wiring code that scales.
How to pick a database for a .NET service: when Postgres scales further than you think, when document stores win, and when read replicas help.
How to pick a message queue for .NET: RabbitMQ, Azure Service Bus, Kafka. Queue vs topic, MassTransit vs raw client, at-least-once semantics.
How to pick between REST, gRPC, and GraphQL in .NET, when a BFF helps, and what each style actually costs in latency and developer time.
When LIKE queries stop scaling and you need real search. How to wire Postgres full-text search and Elasticsearch into a .NET service.
How to pick between JWT and cookie auth in ASP.NET Core, when to outsource to OIDC (Duende, OpenIddict, Keycloak), and how refresh-token rotation actually works.
How to make HTTP endpoints and queue consumers idempotent, and how the outbox pattern guarantees that a database write and a queue publish stay consistent.
How to wire Polly and Microsoft.Extensions.Http.Resilience into a .NET service: retry with exponential backoff, circuit breaker, timeout, and bulkhead isolation.
How to coordinate multi-step business workflows across .NET services. Choreography vs orchestration, MassTransit sagas, and compensation events.
How to wire OpenTelemetry into ASP.NET Core for distributed traces, metrics, structured logs. The single instrumentation pipeline that powers alerts.
How to use the built-in ASP.NET Core rate limiter: fixed window, sliding window, token bucket, concurrency. Per IP vs per user, distributed via Redis.
End-to-end design for a URL shortener: capacity estimation, base62 encoding, Postgres + Redis storage, click analytics, and the ASP.NET Core code that ties it together.
End-to-end design of a distributed rate limiter: token bucket vs sliding window vs fixed window, Lua atomic scripts on Redis, and the .NET wrapper used by every service.
Fan-out on write vs fan-out on read, the celebrity problem, and how to build a Twitter-style timeline service in .NET with Postgres + Redis + Kafka.
How to build a realtime chat service in .NET with SignalR: WebSocket fan-out, Redis backplane for scale-out, presence tracking, and message ordering across rooms.
How to build a notification service in .NET: email, SMS, push channels, preference store, deduplication, and the queue pipeline that delivers reliably.
How to build a file upload service in .NET: presigned URLs, chunked resumable uploads to Azure Blob or S3, virus scanning pipeline, and metadata in Postgres.
How to build search-as-you-type autocomplete in .NET: trie data structure, Redis sorted set rankings, debouncing on the client, and freshness via streaming updates.
How to build a payment system in .NET: idempotency keys, saga orchestration, double-charge prevention, refund flow, and integration with Stripe/Adyen.
How to build an event analytics pipeline in .NET: SDK ingestion, Kafka streaming, schema evolution, ClickHouse for OLAP, and the lambda architecture trade-offs.