System Design
Architect systems that scale. Trade-off analysis, design patterns, and real-world architecture decisions.
Intermediate
Sync vs Async Communication — REST, gRPC & Message Queues
How microservices talk to each other: synchronous (REST, gRPC) vs asynchronous (message queues, events). When to use each, choreography vs orchestration, the Outbox pattern for reliable publishing, and correlation IDs across services.
Microservices — What They Are and What They Actually Cost
Understand what microservices are, why companies move to them, and what they actually cost in operational complexity, distributed transactions, testing overhead, and team effort. Learn when NOT to use them.
Service Discovery & API Gateway Patterns
How microservices find each other: client-side vs server-side discovery, service registries (Consul, Kubernetes DNS), API gateway responsibilities, YARP for .NET, the BFF pattern, and when to use an API gateway vs service mesh.
Caching Strategies — When to Cache and When Not To
A deep dive into caching strategies: cache-aside, write-through, write-back, read-through, eviction policies, Redis patterns, CDN caching, and the hard problem of cache invalidation.
CAP Theorem — Why You Can't Have Everything
Understand the CAP theorem, why partition tolerance is non-negotiable in distributed systems, how CP vs AP databases differ, and how the PACELC extension gives you a more complete picture of real-world trade-offs.
Case Study: Design a Real-Time Chat App
Design a real-time chat system from scratch — WebSockets, message persistence, presence detection, fan-out at scale, and the architectural trade-offs that come up in system design interviews.
Database Choices — SQL vs NoSQL, Sharding & Replicas
How to choose the right database for any workload: relational, document, key-value, column-family, and graph. Plus read replicas, sharding strategies, indexing deep-dive, connection pooling, and NewSQL.
Scalability, Availability & Reliability — The Core Trade-offs
Master the foundational concepts every system designer needs: scalability, availability nines, reliability vs availability, latency vs throughput, and back-of-envelope estimation with real calculation examples.
How to Ace a System Design Interview (Framework + Examples)
A repeatable framework for system design interviews — how to structure your answer, what to cover in each phase, common mistakes that fail candidates, and worked examples for URL shortener, chat app, and notification system.
System Design Interview: 40 Questions & Model Answers
40 system design interview questions with model answers — covering scalability, databases, caching, messaging, microservices, and classic case studies. Organised by difficulty from junior to architect level.
Load Balancing — How to Distribute Traffic at Scale
Everything about load balancing: L4 vs L7, algorithms (round-robin, least connections, IP hash), sticky sessions, health checks, DNS load balancing, global anycast, and the difference between a load balancer and an API gateway.
Case Study: Design a Notification System (Email/SMS/Push)
Design a scalable multi-channel notification system from scratch — message queues, fanout, deduplication, rate limiting, delivery guarantees, and the trade-offs that come up in system design interviews.
Case Study: Design a Rate Limiter
Design a distributed rate limiter from first principles — fixed window, sliding window, token bucket, and leaky bucket algorithms, with Redis implementation patterns and the trade-offs interviewers want to hear.
Case Study: Design a URL Shortener (like bit.ly)
Walk through designing a production URL shortener from scratch — hashing strategies, redirect latency, analytics, abuse prevention, and the exact trade-offs you'll be asked about in a system design interview.
API Design Patterns: REST, gRPC, GraphQL & Event-Driven
A deep-dive into API design patterns — REST best practices, versioning strategies, gRPC for inter-service communication, GraphQL for flexible queries, and event-driven integration. With .NET implementation examples.
Domain-Driven Design (DDD): A Practical Guide
Learn Domain-Driven Design from the ground up — bounded contexts, aggregates, value objects, domain events, and how DDD maps to Clean Architecture in .NET with real code examples.
Software Architecture: Monolith to Microservices — A Complete Guide
Understand every major architectural style — monolith, modular monolith, SOA, microservices, event-driven, and serverless — with real code, trade-offs, migration strategies, and when to use each.
Advanced
System Design: Event Journal and Audit Trail in .NET — Append-Only Storage, Retention, and Point-in-Time Queries
Design a high-throughput audit journal in .NET: append-only ledger with PostgreSQL, write batching, retention policies with table partitioning, point-in-time entity reconstruction, hash-chain tamper detection, and the event sourcing vs audit log trade-off.
System Design: Core Banking Platform in .NET — Double-Entry, Event Sourcing, and Regulatory Compliance
Design a production banking system in .NET: double-entry accounting, ACID transaction guarantees, event sourcing for audit trails, optimistic concurrency for account balances, idempotent transfers, and regulatory reporting.
CQRS in Practice — Real Challenges, When It Hurts, and Alternatives That Actually Work
An honest look at CQRS in production .NET systems: eventual consistency pain points, projection lag causing stale reads, read model sync failures, the complexity cost, and when simpler alternatives (read services, database views, compiled queries) solve the same problem with less risk.
System Design: Multi-Tenant Delivery Platform in .NET — Order Lifecycle, Route Optimization, and Driver Tracking
Design a multi-tenant delivery platform like Deliveroo or DoorDash in .NET: order state machine, real-time driver tracking with geospatial queries, route batching, tenant isolation, and the challenges of maintaining SLA across tenants with different throughput.
System Design: E-Commerce Checkout in .NET — Inventory Reservation, Idempotent Payments, and Distributed Failure Handling
Design a production e-commerce checkout flow in .NET: inventory reservation with optimistic concurrency, idempotent Stripe payment, distributed saga for order fulfilment, failure compensation, and the challenges of consistency under concurrent purchases.
System Design: Ophthalmic Practice Management Platform in .NET — FHIR, PHI Compliance, and Appointment Scheduling
Design an ophthalmology/optometry practice management system (Opterek-style) in .NET: FHIR-compatible patient records, appointment scheduling with resource constraints, PHI data isolation, prescription management, insurance billing, and audit trails for compliance.
System Design: Library Management System in .NET — Catalog, Reservations, Multi-Branch, and Fine Calculation
Design a multi-branch library management system in .NET: book catalog with full-text search, reservation queue, loan lifecycle, overdue fine calculation, RFID integration, and branch federation — plus the CQRS trade-offs for a read-heavy catalog.
System Design: Multi-Tenant SaaS in .NET — Isolation, Onboarding, Billing, and Per-Tenant Customisation
Design a production multi-tenant SaaS platform in .NET: tenant isolation strategies (row-level, schema, database), onboarding automation, Stripe subscription billing, per-tenant feature flags, and configuration overrides.
System Design: Real-Time Notification Platform in .NET — Fan-Out, Multi-Channel Delivery, and Deduplication at Scale
Design a production notification system in .NET: fan-out strategies for high-follower accounts, multi-channel delivery (email, SMS, push, in-app), deduplication, preference management, and SignalR at scale with Redis backplane.
System Design: Ride-Sharing Platform in .NET — Real-Time Location, Matching, and Distributed State
Design an Uber-style ride-sharing platform in .NET: real-time driver location tracking with Redis geo-hash, driver-rider matching algorithm, trip state machine, surge pricing, and distributed coordination without distributed transactions.
System Design: Instagram-Style Social Platform in .NET — Feed Generation, Media Pipeline, and Follow Graph at Scale
Design an Instagram-like social platform in .NET: push vs pull feed generation, fanout-on-write for small followings, fanout-on-read for celebrities, media upload pipeline with CDN, follow graph in Redis, and notification fan-out.
System Design Interview Deep Dive — Worked Examples, Trade-offs, and Common Mistakes
Advanced system design interview preparation: detailed worked examples for URL shortener, chat application, and social feed; trade-off analysis for key design decisions; and the specific mistakes that fail senior engineers.
Case Study: 500 Tenants, One PostgreSQL Database
How a SaaS platform scaled from 20 to 500 tenants on a shared PostgreSQL database: row-level security, per-tenant connection pooling, query cost isolation, and the point where they finally added schema separation.
Architecture Patterns: Interview-Critical Guide
The four architectural styles every senior engineer must know — Monolith, Modular Monolith, SOA, Microservices, and Event-Driven. Architect-level trade-offs, decision frameworks, and the questions you will be asked in interviews.
Cloud Integration on Azure: Service Bus, Event Grid, Functions & Hybrid Architecture
Architect-level guide to cloud-native integration on Azure — Service Bus internals, Event Grid routing, serverless Functions patterns, and hybrid on-premises/cloud architectures. With production .NET examples throughout.
Event-Driven Architecture: Deep Dive
Architect-level guide to event-driven systems — event taxonomy, Kafka internals, consumer group mechanics, exactly-once semantics, backpressure, schema evolution, and event sourcing with CQRS. With .NET examples throughout.
Reliability, Testing & Monitoring: The Senior Engineer's Playbook
The complete operational reliability picture for distributed systems — testing pyramid for microservices, structured logging, distributed tracing, SLIs/SLOs, circuit breaker and retry patterns, and the error handling model that makes systems production-grade.
Security & Governance for Architects: OAuth, JWT, API Security & Data Privacy
Architect-level security guide — OAuth 2.0 flows for real systems (including service-to-service), JWT internals and validation pitfalls, API gateway security patterns, mTLS, zero trust, and data privacy controls for production APIs.
Senior System Design Interview: Identity Verification System
Full senior/staff-level interview walkthrough — design an identity verification system with high read traffic, auditability, Redis caching, queue architecture, CI/CD pipeline, and rollback strategy. Real answers you can use.
Data Management in Microservices — The Hardest Part
How to manage data across microservices: database-per-service, eventual consistency, CQRS, the Saga pattern for distributed transactions, event sourcing, and the API Composition pattern for cross-service queries.
Deploying Microservices — Docker, Kubernetes & CI/CD per Service
Each service gets its own Docker image and CI pipeline. Covers .NET multi-stage builds, docker-compose for local dev, Kubernetes per-service manifests, Helm packaging, independent deployments, blue-green and canary releases, HPA autoscaling, and GitOps with Argo CD.
Resilience Patterns — Circuit Breaker, Retry & Bulkhead
Deep-dive into retry with exponential backoff + jitter, circuit breaker states, bulkhead isolation, timeout and hedging patterns. With .NET 8 Microsoft.Extensions.Resilience pipelines, Polly v8, and a real MicroMart circuit-breaker example.
Security in Microservices — mTLS, JWT Propagation & Zero Trust
How authentication and authorization work across microservices. Covers JWT claim propagation, service-to-service auth (API keys vs mTLS vs SPIFFE), mutual TLS with cert-manager, Zero Trust networking, secrets management per service, and inter-service authorization.
Service Boundaries — How to Split a Monolith Without Regret
The most important microservices decision: where to draw service boundaries. Learn how to use bounded contexts from DDD, avoid the distributed monolith anti-pattern, and correctly decompose an e-commerce system.
Testing Microservices — Unit, Integration & Contract Tests
The testing pyramid for microservices: unit testing handlers and domain logic, integration testing with Testcontainers, consumer-driven contract tests with Pact, end-to-end testing trade-offs, and testing async messaging.
Distributed Systems Patterns: Saga, Outbox, Circuit Breaker & More
Deep-dive into essential distributed systems patterns — Saga (choreography & orchestration), Transactional Outbox, Circuit Breaker, Retry with exponential backoff, Idempotency, and Bulkhead. With .NET and MassTransit examples.
Observability in Distributed Systems: Logs, Metrics & Traces
Master observability for distributed systems — structured logging with Serilog, metrics with Prometheus and Grafana, distributed tracing with OpenTelemetry, health checks, and alerting. Full .NET implementation guide.
System Design: Complete Guide with Real-World Examples
Master system design from fundamentals to senior-level interviews. Covers scalability, databases, caching, message queues, API design, CAP theorem, and full design walkthroughs for URL shortener, Twitter feed, and payment systems.