# System Design
All System Design notes →Chapter 1 — Observability Architecture
Metrics, logs, traces, and profiles as the four correlated signal types every observability platform is built around.
Chapter 2 — Telemetry Pipelines
OpenTelemetry, OTLP, collectors, sampling, and aggregation as the pipeline that gets a signal from emission to storage without becoming the outage itself.
Chapter 3 — Monitoring at Scale
Prometheus, Mimir, Cortex, and Thanos as the horizontally-scaled answer to a single Prometheus instance running out of room.
Chapter 4 — Alerting Systems
Multi-window burn-rate alerts, recording rules, routing, and deduplication as the difference between an actionable page and noise.
Chapter 1 — What Changes at L6/L7
Why the bar shifts from correct designs to defensible trade-offs, and what interviewers are actually scoring for at the Principal/Staff level.
Chapter 2 — Thinking in Systems
Feedback loops, bottlenecks, failure domains, and Conway's Law as the lens principal engineers use to reason about a system before drawing a single box.
Chapter 3 — Performance Fundamentals
Latency, throughput, tail latency, Little's Law, queueing theory, Amdahl's Law, and the Universal Scalability Law as the quantitative vocabulary for every capacity conversation.
Chapter 1 — Distributed System Fundamentals
Why distributed computing is fundamentally about partial failure and unbounded message delay, not just "more than one machine."
Chapter 2 — Consistency Models
The spectrum from linearizability through sequential, session, and eventual consistency, and which guarantee each one actually buys you.
Chapter 3 — CAP Theorem & PACELC
Why CAP only describes behavior during a partition, and why PACELC's latency-vs-consistency trade-off matters far more often in practice.
Chapter 4 — Consensus Algorithms
How Paxos and Raft achieve agreement despite failures, and where leader election, quorums, and split-brain prevention show up in real systems.
Chapter 5 — Distributed Transactions
Two-phase and three-phase commit, the Saga pattern, outbox/inbox, and idempotency as the toolkit for correctness across service boundaries.
Chapter 6 — Data Replication
Leader-follower, multi-leader, and leaderless replication topologies, and the replication-lag trade-offs each one accepts.
Chapter 7 — Partitioning & Sharding
Hashing strategies, consistent hashing, rebalancing, and how hot partitions emerge even with a theoretically even hash function.
Chapter 1 — Database Selection
A decision framework for SQL vs. NoSQL vs. time-series vs. graph vs. vector vs. object storage, driven by access pattern rather than familiarity.
Chapter 2 — Indexing
B+ trees, LSM trees, bloom filters, and secondary indexes, and why the write/read trade-off between them decides the storage engine underneath.
Chapter 3 — Storage Engines
How RocksDB, WiredTiger, InnoDB, and Cassandra's SSTables implement the indexing trade-offs above as production engines.
Chapter 4 — Data Lifecycle
Archival, tiered storage, TTLs, retention policy, and compression as the discipline that keeps storage cost from growing linearly with data volume forever.
Chapter 1 — Network Fundamentals
TCP, UDP, QUIC, and the HTTP/1.1 to HTTP/2 to HTTP/3 evolution, and which transport trade-off each protocol is actually optimizing for.
Chapter 2 — RPC: REST, GraphQL, gRPC
The trade-offs between REST, GraphQL, gRPC, and ConnectRPC for service-to-service and client-facing APIs at scale.
Chapter 3 — Load Balancing
L4 vs. L7 load balancing, anycast routing, and global load balancing as the layer that decides which failures are invisible to callers.
Chapter 4 — CDN & Edge Caching
Edge compute, cache hierarchy design, and cache invalidation as the hardest of the "two hard problems" at global scale.
Chapter 1 — Message Brokers
Kafka, Pulsar, RabbitMQ, and SQS compared on delivery guarantees, ordering, and operational model, not just throughput benchmarks.
Chapter 2 — Event Streaming, CQRS & Event Sourcing
How event sourcing and CQRS split the write and read models, and where stream processing sits between them.
Chapter 3 — Workflow Systems
Temporal and Cadence's durable-execution model as the answer to long-running, failure-resistant business processes that outlive any single process.
Chapter 1 — Cache Design Patterns
Cache-aside, write-through, write-behind, and refresh-ahead, and the staleness/consistency trade-off each pattern accepts.
Chapter 2 — Distributed Cache
Redis and Memcached at scale — consistent hashing for shard ownership and the cache-coherence problem when writes fan out.
Chapter 1 — Reliability: SLI, SLO, SLA & Error Budgets
How SLIs roll up into SLOs, SLOs into error budgets, and error budgets into the release-velocity decisions a principal engineer actually gets asked to defend.
Chapter 2 — Resilience Patterns
Retry, timeout, circuit breaker, bulkhead, hedging, and adaptive concurrency as the patterns that contain a failure instead of letting it cascade.
Chapter 3 — Disaster Recovery
RTO and RPO as the two numbers that actually define a DR strategy, and the backup/restore and multi-region trade-offs behind hitting them.
Chapter 4 — Chaos Engineering & Game Days
Fault injection and game days as the practice of finding a system's failure modes on your own schedule instead of production's.
Chapter 1 — Compute Platforms
VMs, Kubernetes, serverless, and containers compared on the operational responsibility each one leaves with your team.
Chapter 2 — Cloud Storage Services
Blob storage, object storage, and distributed file systems, and which durability/latency/cost point each is built around.
Chapter 3 — Multi-Cloud Architecture
Hybrid cloud, cloud migration, and the vendor lock-in trade-offs that make "just go multi-cloud" harder than it sounds.
Chapter 1 — Identity: OAuth, OIDC, JWT, SPIFFE, mTLS
The identity stack for humans and workloads — OAuth/OIDC for users, JWTs as bearer tokens, SPIFFE/mTLS for service-to-service trust.
Chapter 2 — Security Architecture & Zero Trust
Zero trust, secrets management, and encryption/KMS as the assumption that the network perimeter was never actually the security boundary.
Chapter 1 — Scaling Patterns
Horizontal vs. vertical scaling, autoscaling, and load shedding as the toolkit for absorbing load spikes without over-provisioning permanently.
Chapter 2 — Geo-Distributed Systems
Multi-region active-active vs. active-passive topologies, and the consistency and failover trade-offs each one makes.
Chapter 3 — Cost Engineering & FinOps
Capacity planning, FinOps, and resource optimization as the discipline that keeps reliability decisions honest about what they cost.
Chapter 4 — Capacity Planning System
Growth modeling, headroom analysis, cost vs. reliability simulation.
Chapter 1 — Monoliths & the Modular Monolith
Why a well-modularized monolith is a legitimate architecture choice, and how it evolves into services under real pressure, not fashion.
Chapter 2 — Microservices
Service boundary design and the anti-patterns — distributed monolith, shared database, chatty synchronous calls — that erase the benefits microservices promise.
Chapter 3 — Event-Driven Architecture
Decoupling services through events rather than direct calls, and the ordering/consistency trade-offs that decoupling introduces.
Chapter 4 — Data Mesh
Decentralizing data ownership to domain teams as a data-platform architecture, and the governance model that keeps it from fragmenting.
Chapter 5 — Service Mesh
Sidecar-based traffic management, mTLS, and observability at the network layer, and when the operational cost is worth paying.
Chapter 6 — Platform Engineering
Why platform engineering is the organizational answer to microservices and infrastructure sprawl at scale.
Chapter 1 — Designing AI Systems: RAG & Vector Databases
Retrieval-augmented generation, vector databases, embeddings, and agent architectures as the components of an LLM-backed system design.
Chapter 2 — AI Infrastructure
GPU scheduling, inference serving, and model-serving architecture as the infrastructure layer underneath every AI product design.
Chapter 3 — AI Observability
Extending metrics, logs, and traces to LLM-specific signals — token cost, latency per generation step, and quality/hallucination drift.
Chapter 1 — Interview Methodology
Requirement gathering, capacity estimation, API design, data modeling, scaling, and bottleneck analysis as the repeatable sequence behind every design in this book.
Chapter 2 — Whiteboarding & Communication
Diagramming and narrating a design out loud so an interviewer can follow the trade-off reasoning, not just the final architecture.
Chapter 3 — Architecture Reviews: Defending Decisions
Handling interviewer pushback and "what if 10x scale" challenges without abandoning a defensible design under pressure.
Chapter 1 — Telemetry Ingestion Pipeline
Principal/Staff-level design of a high-throughput telemetry ingestion pipeline — requirements, architecture, deep dives, and trade-offs at 10x scale.
1. Clarify Requirements First
The first-5-minutes clarifying questions for the telemetry ingestion pipeline design — signal types, scale envelope, consistency/durability, multi-tenancy, and protocol — whose answers change the entire architecture.
2. High-Level Architecture
The producers → ingestion gateway → Kafka → processors → storage diagram for the telemetry ingestion pipeline, plus the push-over-pull key insight to state early in the interview.
3.1 Layer 1: Ingestion Frontier
Layer 1 of the telemetry ingestion pipeline: the ingestion frontier — responsibilities, fan-in at 100K+ agents, protocol negotiation, batching, backpressure, and rate limiting.
3.2 Layer 2: Durable Buffer (Kafka)
Layer 2 of the telemetry ingestion pipeline: the Kafka durable buffer — topic design, partitioning strategy, hot-spots, retention, retry/delivery semantics, producer config, consumer lag, and schema evolution.
3.3 Layer 3: Processing / Enrichment
Layer 3 of the telemetry ingestion pipeline: processing and enrichment — the metric processor, cardinality enforcement, tail-based sampling, the log processor, metric temporality, and Kubernetes metadata enrichment.
3.4 Scaling Each Layer
Scaling unit and trigger for every layer of the telemetry ingestion pipeline, from the ingestion gateway through to storage.
3.5 Failure Modes and Mitigations
Failure modes and mitigations across the telemetry ingestion pipeline — gateway crashes, broker failure, processor crashes, span explosion, cardinality rejection, storage saturation, and clock skew.
3.6 Multi-Tenancy
Multi-tenancy isolation layers and quota enforcement points across the telemetry ingestion pipeline, from network inbound to the storage write path.
3.7 Data Tiering and Compaction (Mimir/Thanos)
Data tiering and compaction in Mimir/Thanos — the ingester-to-object-store journey, compaction levels, vertical compaction/dedup, compaction storms, and the config knobs that control them.
3.8 Global Deployment Topology
Global deployment topology for the telemetry ingestion pipeline — regional writes vs. a global cluster, async replication to a global query tier, and agent failover.
4. Observability of the Pipeline Itself
What to instrument at every layer of the telemetry ingestion pipeline, the pipeline's own SLOs, distributed tracing of the pipeline itself, and the synthetic canary that catches stalls no component metric surfaces.
5. Trade-offs at 10x Scale
The 'what would you do differently at 10x' trade-off questions for the telemetry ingestion pipeline: Kafka vs. direct write, trace-assembly sharding, schema-on-read vs. write, sampling strategy, protocol choice, and push vs. pull.
6. Interview Anchor Points (What to Say Out Loud)
The sentences that signal principal-level thinking for the telemetry ingestion pipeline design — ready to say unprompted in an interview.
7. Component Map (What Exists in the Wild)
OSS and managed-SaaS options for every layer of the telemetry ingestion pipeline, mapped against ShipSolid's own production experience.
8. Quick-Reference Cheat Sheet
One-line answers for every load-bearing design decision in the telemetry ingestion pipeline — the last thing to review before an interview.
9. Practice Interview Questions
Twelve full-length practice prompts for the telemetry ingestion pipeline design, each linked to its own worked, principal-level answer.
Authentication at the Ingestion Frontier: mTLS, Bearer Tokens, API Keys
How the gateway proves an agent's credential is valid — mTLS handshake validation, JWT bearer token signature checks, and API key lookups — with the revocation-speed vs operational-complexity trade-off between them, and credential rotation at 10M-agent scale.
Head vs. Tail Sampling for Distributed Traces
The sampling decision point determines whether a trace pipeline needs to buffer spans in memory — head-based decides at trace start, tail-based decides after the trace completes.
Protocol Termination at the Ingestion Frontier
What actually happens where the wire protocol ends — TCP/TLS handoff, HTTP/2 frame demux, gRPC message decode, protobuf deserialization — and why L4 vs L7 termination and connection-lifecycle tuning are the load-bearing decisions here, not the crypto itself.
Q1: 500M Samples/Sec, Zero Drop on Rolling Deploy
Full principal-level solution: design a telemetry ingestion pipeline for 500M metric samples/sec from 100K services globally with a zero-drop guarantee during rolling deployment of the ingestion tier.
Q10: Self-Service Tenant Onboarding With Zero Platform-Team Involvement
Full principal-level solution: design a self-service tenant onboarding API for a telemetry pipeline that protects shared infrastructure from a misbehaving new tenant on day one.
Q11: Redesigning the Ingestion Frontier for a Compromised-Agent Threat Model
Full principal-level solution: redesign the telemetry ingestion frontier assuming a compromised agent sends malformed and adversarial payloads — oversized batches, spoofed tenant IDs, garbage label values.
Q12: Exactly-Once for One Billing Tenant While Others Stay At-Least-Once
Full principal-level solution: support exactly-once ingestion for a single billing-critical tenant in a shared pipeline that is at-least-once everywhere else, and account for what it costs.
Q2: Cardinality Storm — Detect and Mitigate Without Affecting Other Tenants
Full principal-level solution: a tenant sends 50M unique label combinations/minute causing TSDB compaction storms — design detection and mitigation that isolates the blast radius to that tenant.
Q3: Trace Sampling Loses Spans During Incident Peaks — Redesign
Full principal-level solution: the trace pipeline drops spans exactly when incidents spike trace volume — diagnose the failure mode and redesign the tail-sampling pipeline to survive it.
Q4: A Metric's Journey From Pod to Dashboard — Every Failure Point
Full principal-level solution: trace a single metric data point from a Kubernetes pod to a queryable dashboard, identifying every failure point along the way and how each is detected.
Q5: Adding Continuous Profiling to an Existing MELT Pipeline
Full principal-level solution: extend an existing metrics + logs + traces pipeline with continuous profiling as a fourth signal, without a full redesign.
Q6: Compactor Queue Backing Up During a Multi-Tenant Flush
Full principal-level solution: diagnose a compactor backlog causing query latency spikes during a large multi-tenant flush, and mitigate it without pausing ingestion.
Q7: A Region's Gateway Goes Dark — Blast Radius Walkthrough and Redesign
Full principal-level solution: walk through the consequences of a 10-minute regional ingestion gateway outage, then redesign the topology to shrink the blast radius.
Q8: Counters Resetting to Zero After an OTel SDK Upgrade
Full principal-level solution: diagnose and fix a tenant's dashboards showing counters reset to zero every few minutes after an OTel SDK upgrade, without requiring instrumentation changes.
Q9: Cut Ingestion Infrastructure Cost 40% Without Violating SLOs
Full principal-level solution: a FinOps-driven cost-reduction pass on a telemetry ingestion pipeline — where to look first, what levers exist at each layer, and what you trade away.
Rate Limiting Architecture: Token Bucket, Gossip, and Envoy Global Limits
Three ways to enforce rate limits across a replicated gateway fleet — centralized Redis token bucket, decentralized gossip-based estimation, and Envoy's sidecar-plus-global-service pattern — with the precision/SPOF/latency trade-offs between them.
Retry Policies and the Delivery Semantics They Produce
Every retry decision is made along three axes — trigger, backoff, budget — before delivery semantics even enter the picture. At-least-once, at-most-once, and exactly-once are the accumulated side effect of those decisions at every hop, not a separate design choice.
Schema Validation and Rejection at the Ingestion Frontier
What the gateway actually checks before accepting a payload — structural validation vs semantic cardinality checks, why rejection has to happen before the buffer, OTLP PartialSuccess as an alternative to whole-batch rejection, and the forward-compatibility trap of validating too strictly.
Telemetry Gateways: Protocol-Specific Ingestion Points
The ingestion frontier is a fleet of protocol-specific gateways — OTLP, Prometheus remote-write, Syslog, Kafka, and legacy tracing/metrics protocols — each terminating a different producer's wire format before a shared auth/rate-limit/tenant-routing layer.
Tenant Identification and Routing at the Ingestion Frontier
How the gateway decides whose data this is — cert/API-key-derived tenant identity, propagation as a Kafka header and X-Scope-OrgID, and the shared-topic-with-filter vs per-tenant-topic vs shuffle-sharded-pool routing trade-off.
Chapter 2 — Metrics Storage (TSDB)
Write amplification, chunk encoding, compaction, cardinality explosion.
Chapter 3 — Log Aggregation System
Structured vs. unstructured, schema-on-read vs. schema-on-write, deduplication.
Chapter 4 — Distributed Tracing Backend
Trace assembly from spans, tail-based vs. head-based sampling.
Chapter 5 — OpenTelemetry Collector Pipeline
Multi-pipeline routing, processor chaining, exporter fan-out.
Chapter 6 — Multi-tenant Observability Platform
Tenant isolation, quota enforcement, cost attribution.
Chapter 7 — SLO / Error Budget Tracking System
Burn rate calculation, multi-window alerting, budget ledger.
Chapter 8 — Distributed Message Queue (Kafka-like)
Partitioning, consumer groups, at-least-once vs. exactly-once.
Chapter 9 — Distributed Key-Value Store (DynamoDB-like)
Consistent hashing, replication, read/write quorum.
Chapter 10 — Stream Processing System (Flink-like)
Watermarks, windowing, stateful operators, exactly-once.
Chapter 11 — Rate Limiter (Distributed)
Token bucket, leaky bucket, sliding window, Redis-backed global limiter.
Chapter 12 — Consensus & Leader Election
Raft/Paxos, split-brain prevention, fencing tokens.
Chapter 13 — Runbook Automation / AIOps Engine
LLM-powered diagnosis, trigger-action mappings, safety guardrails.
Chapter 14 — Observability Data Lake
Cold/warm/hot tiers, Parquet storage, query federation (Thanos/Cortex/Mimir).
Chapter 15 — Cost Optimization Pipeline
Adaptive sampling, metric drop rules, cardinality-aware ingestion.
Chapter 16 — Incident Management Platform
Alert correlation, incident lifecycle, escalation, runbook automation.
Chapter 17 — Distributed Search Engine (Elasticsearch-like)
Inverted indexes, sharding, near-real-time indexing.
Chapter 18 — URL Shortener
The canonical warm-up case study — ID generation strategy and read-heavy caching are the whole design.
Chapter 19 — Distributed Cache (Case Study)
Designing a Redis/Memcached-like distributed cache end-to-end: sharding, eviction, and cache-coherence under concurrent writes.
Chapter 20 — Notification Platform
Fan-out to push, email, and SMS channels with per-channel rate limits, retries, and delivery-guarantee trade-offs.
Chapter 21 — Chat System
Real-time message delivery, presence, and ordering guarantees at the scale of a WhatsApp/Messenger-like system.
Chapter 22 — Video Streaming
Transcoding pipelines, adaptive bitrate delivery, and CDN placement for a YouTube/Netflix-like streaming platform.
Chapter 23 — News Feed
Fan-out-on-write vs. fan-out-on-read ranking delivery for a Facebook/Twitter-like feed at scale.
Chapter 24 — Collaborative Document Editor
Operational transforms and CRDTs for real-time multi-user editing in a Google Docs-like system.
Chapter 25 — Ride-Hailing Platform (Uber-like)
The end-to-end system: rider/driver matching, geospatial indexing, and surge pricing under real-time load.
Chapter 26 — Ride Matching Engine
The matching sub-problem in isolation — geospatial indexing (geohash/quadtree/H3) and the matching algorithm's latency budget.
Chapter 27 — Payment System
Idempotent transaction processing, ledger design, and exactly-once semantics where a bug means real money moves twice.
Chapter 28 — Distributed Lock Service
A ZooKeeper/etcd-like coordination service — leases, fencing tokens, and the split-brain failure mode that makes distributed locks genuinely hard.
Chapter 29 — Kubernetes Control Plane
etcd, the API server, schedulers, and controllers as a distributed-systems case study in their own right, not just an operator's tool.
Chapter 30 — GitHub-Scale Version Control
Git object storage, fork/merge at scale, and the read-heavy caching layer behind a GitHub-like hosting platform.
Chapter 31 — API Gateway
Routing, auth, rate limiting, and protocol translation as the single front door for a large service fleet.
Chapter 32 — Multi-Tenant SaaS Platform
Tenant isolation, noisy-neighbor containment, and per-tenant cost attribution for a shared-infrastructure SaaS product.
Chapter 33 — Recommendation Engine
Candidate generation, ranking, and the online/offline serving split behind a recommendation system at scale.
Chapter 34 — Feature Flag Platform
Low-latency flag evaluation, targeting rules, and safe rollout/rollback as a system design in its own right.
Chapter 35 — Secrets Manager
Envelope encryption, key rotation, and access-audit trails for a Vault/KMS-like secrets platform.
Chapter 36 — Distributed Scheduler
Cron-at-scale: exactly-once trigger semantics, backfill, and leader election for the scheduler itself.
Chapter 37 — CI/CD Platform
Build queueing, artifact caching, and progressive-delivery rollout as a system design for a GitHub Actions/Jenkins-like platform.
Chapter 38 — Object Storage (S3-like)
Erasure coding, durability math, and the eventually-consistent vs. strongly-consistent listing trade-off behind an S3-like store.
Chapter 39 — Cloud File Storage (Google Drive-like)
Chunked upload/sync, conflict resolution, and metadata-service design for a Drive/Dropbox-like file-sync system.
Chapter 40 — Distributed SQL Database
A Spanner/CockroachDB-like design combining consensus-replicated storage with a SQL query layer and distributed transactions.
Chapter 41 — Large-Scale AI Agent Platform
Serving thousands of concurrent LLM agent sessions — tool-call orchestration, memory/state, and cost-aware model routing at fleet scale.
Chapter 1 — Architectural Decision Records
Why an ADR outlives the meeting that produced it, and the Context/Decision/Consequences structure that makes one actually useful later.
Chapter 2 — Evolutionary Architecture
Designing for incremental change rather than a big-bang rewrite, and the fitness functions that keep an architecture from drifting.
Chapter 3 — Build vs. Buy
The decision framework for build-vs-buy that goes beyond cost — differentiation, lock-in, and long-term maintenance burden.
Chapter 4 — Organization Scaling
How team topology and Conway's Law force architecture decisions as an org grows past the size where everyone fits in one room.
Chapter 5 — Platform Strategy
Positioning a platform as an internal product with a roadmap, not a shared-services team that reacts to tickets.
Chapter 6 — Engineering Economics
Framing technical decisions in terms of cost, risk, and opportunity cost so they're defensible to a non-engineering stakeholder.
Chapter 7 — Technical Debt Management
Distinguishing deliberate from accidental technical debt, and the prioritization model for paying it down against feature work.
Chapter 8 — Leading Cross-Functional Architecture
Driving an architecture decision across teams that don't report to you, using influence rather than authority.
Chapter 9 — Executive Communication
Translating an architecture decision into the risk/cost/timeline framing an executive audience actually needs to approve it.
Chapter 10 — Principal Engineer Interview Preparation
How the L6/L7 loop differs from senior-level loops — the narrative, leadership, and technical-vision signals interviewers are calibrated to look for.
System Design
Principal/Staff-level system design reference collection for MAANG interview preparation — observability pipelines, distributed systems, reliability engineering, and beyond.
# Data Engineering
All Data Engineering notes →1 — Batch Processing System Design
Open-ended batch processing system design — log analytics platforms, ETL platforms, and reporting pipelines.
2 — Streaming System Design
Open-ended streaming system design — clickstream analytics, fraud detection, IoT platforms, and real-time metrics systems.
3 — Data Lakehouse Design
Designing a lakehouse end to end — bronze/silver/gold layering, incremental pipeline design, and cross-team data sharing.
4 — ML Data Platform Design
Designing the data platform underneath ML systems — feature stores, offline and online stores, and the pipelines that feed model training and serving.
# Dbms
All Dbms notes →1 — Choosing the Right Database
Covers how to choose a database for a system design — SQL vs NoSQL, read-heavy vs write-heavy workloads, time-series, and graph use cases.
2 — Designing Data Models
Covers data modeling for common system-design domains — user service, e-commerce, banking, messaging, and social networks.
3 — Scaling Databases
Covers the standard database scaling toolkit — sharding, replication, read replicas, caching, and CQRS.
4 — Interview Case Studies
Walks through database design for classic interview case studies — Instagram, WhatsApp, Uber trips, YouTube metadata, and Amazon's catalog.
# Kubernetes
All Kubernetes notes →1 — Kubernetes in Distributed Systems
Why the reconciliation loop — declare desired state, continuously converge toward it — replaces imperative orchestration as Kubernetes' core distributed-systems primitive.
2 — Running Thousands of Microservices
Why organizational boundaries, not etcd or scheduler limits, become the real constraint on cluster and namespace design once service count crosses into the thousands.
3 — Event-Driven Platforms
Why event-driven platforms on Kubernetes trade request-response simplicity for the ability to absorb bursty load and isolate producer and consumer failure domains.
4 — AI/ML Platforms on Kubernetes
Why GPU scheduling — bin-packing, MIG partitioning, gang scheduling for distributed training — is the hard problem in running ML workloads on Kubernetes, not container orchestration itself.
5 — Platform Engineering at Scale
Why platform teams that ship a self-service golden path scale sublinearly with tenant count, while teams that field tickets scale linearly with headcount.
6 — Large-Scale Observability
Why cardinality, not raw data volume, is the constraint that breaks observability pipelines first once a platform spans hundreds of clusters.
7 — Designing Control Planes
Why every control plane is a distributed consensus problem in disguise — the API server and etcd exist to answer 'what is true right now' under concurrent writers.
8 — Architecture Interview Case Studies
Why the strongest system-design interview answers name the failure mode they're trading against, not just the components drawn on the whiteboard.
# Networks
All Networks notes →OSI Layer Model (L1-L7)
What L1 through L7 actually mean, why 'L7 gateway' and 'L4 load balancer' are load-bearing terms in system design interviews, and why this numbering is unrelated to the pipeline's own Layer 1/2/3 architecture labels.
Protocol Inventory
Every protocol referenced across the telemetry ingestion pipeline design, plus a general L7-termination reference table for the broader 'design an API gateway / load balancer' interview question.
HTTP/2 vs HTTP/1.1
Why the ingestion gateway prefers HTTP/2 (multiplexed gRPC) over HTTP/1.1 — connection reuse, binary framing, and header compression at 100K+ agent fan-in.
gRPC
What gRPC actually is underneath the shorthand this design uses it for — call shapes, status-code backpressure, deadline propagation, and the connection-level load-balancing gotcha at 100K+ agent fan-in.
TLS Offload
Terminating TLS at the ingestion frontier instead of in every backend pod — why it's a Layer 1 responsibility, what it costs in defense-in-depth, and how mTLS re-encryption closes the gap.