SYS ARCHITECTLearning Platform

Phase 1

  • Interview Framework
  • Back-of-the-Envelope Estimation
  • ACID
  • CAP
  • Consistency vs Integrity
  • Idempotency
  • NFR
  • SPOF
  • Stateless vs Stateful
  • SOLID
  • SRP
  • OCP
  • LSP
  • DIP vs LSP
  • Clear Architecture Principles
  • 12-Factor App

    • Phase 2

  • SQL vs NoSQL
  • Normalization vs Denormalization
  • Partition vs Sharding
  • Sharding
  • Partition Tolerance
  • Serializable Transactions
  • MVCC
  • Optimistic vs Pessimistic Locking
  • Row Level Locking
  • Distributed Locks
  • Redis Lock
  • Replication
  • Primary Replica Setup
  • Eventual Consistency
  • Data Consistency
  • Quorum
  • Write Ahead Logs
  • Redo Logs
  • DB Durability
  • Data Recovery
  • Two Phase Commit
  • Saga Pattern
  • Cassandra
  • S3
  • HDFS
  • Timeseries DB

    • Phase 3

  • Caching
  • Cache Eviction Policies
  • Hot Keys
  • Hot Reads and Writes
  • Latency
  • Latency vs Throughput
  • Tail Latency
  • Low Latency Patterns
  • Backpressure
  • Sudden Traffic Spike
  • Buffer Burst

    • Phase 4

  • Replication
  • Consistent Hashing
  • Leader Election
  • Distributed Locking
  • Fault Tolerance
  • Resiliency
  • Raft Consensus
  • Paxos
  • Event Driven Architecture
  • Event Sourcing
  • Outbox Pattern
  • CQRS

    • Phase 5

  • How HTTP Works
  • HTTP vs HTTPS
  • TCP vs UDP
  • TLS
  • Long Polling vs WebSockets
  • Server Sent Events
  • Load Balancer
  • L4 vs L7
  • Load Balancer vs Reverse Proxy vs API Gateway
  • CDN
  • Geo DNS

    • Phase 6

  • JWT
  • OAuth2
  • Opaque vs JWT Token
  • TLS
  • OWASP
  • Secrets Management

    • Phase 7

  • Creating Docker Image
  • Kubernetes ConfigMap
  • Kubernetes Ingress
  • Persistent Volume
  • Prometheus and Grafana

    • Phase 8

  • Monolith vs Microservices
  • API Gateway
  • Unique ID Generator
  • Retry Mechanism
  • Deployment Strategy
  • Rate Limiting

    • Phase 9

  • URL Shortener
  • Chat System
  • News Feed
  • Web Crawler
  • Notifications Design
  • System Design Problems
    • Settings
    Theory

    How HTTP Works: The Request-Response Lifecycle

    📋 Overview

    HTTP (HyperText Transfer Protocol) is the foundational protocol of the World Wide Web. It is a stateless, application-layer protocol that facilitates communication between clients (browsers) and servers. Understanding HTTP involves tracing a message from a high-level string of text down to physical signals (light/radio) and back.

    🏗️ Core Principles & Characteristics

    • Request/Response Model: Every interaction starts with a client request and ends with a server response.
    • Statelessness: By default, each request is independent. State is managed via external mechanisms like Cookies or JWTs.
    • TCP/IP Foundation: HTTP traditionally sits on top of TCP (for reliability/ordering) and IP (for routing).
    • Methods & Status Codes: Standardized verbs (GET, POST, PUT, DELETE) and numerical responses (200 OK, 404 Not Found, 500 Error) define the intent and outcome.

    ⚖️ Trade-offs: Pros & Cons

    • Pros:
      • Simplicity: Human-readable text format makes debugging easy.
      • Extensibility: Headers allow for custom metadata (auth, caching, compression).
      • Ubiquity: Supported by every programming language and device.
    • Cons:
      • Overhead: Large text headers can be inefficient for small payloads (partially fixed by HTTP/2 Binary Framing).
      • Latency: The 3-way TCP handshake + TLS handshake adds significant "Time to First Byte" (TTFB).
      • HoL Blocking: In HTTP/1.1 and HTTP/2, a single lost packet can stall the entire stream.

    🌍 Real-World Implementation

    • The Journey of a Packet:
      1. Browser: Generates text request.
      2. OS: Wraps text in TCP segments.
      3. Network Card: Converts segments into Bits (0s and 1s).
      4. Physical Medium: Bits become Radio Waves (Wi-Fi) or Light Pulses (Fiber).
      5. Internet Backbone: Routers use BGP and IP tables to hop the packet to the destination.
      6. Server: Reassembles the segments and parses the HTTP text.

    💡 Interview "Gotchas" & Tips

    • HTTP/2 vs. HTTP/3: Know the difference. HTTP/2 uses Multiplexing over TCP. HTTP/3 uses QUIC over UDP to eliminate Head-of-Line blocking.
    • TCP 3-Way Handshake: Be ready to explain SYN -> SYN-ACK -> ACK.
    • HTTPS is not a separate protocol: It is HTTP inside a TLS (Transport Layer Security) tunnel.
    • Persistent Connections (Keep-Alive): Explain how HTTP/1.1 reuses the same TCP connection for multiple requests to avoid handshake overhead.

    📐 Suggested Architecture Primitives

    • Client (Browser/App): The initiator.
    • DNS Resolver: Translates domain names to IP addresses.
    • Load Balancer/Reverse Proxy: Terminates TLS and forwards requests.
    • API Gateway: Handles routing, auth, and rate limiting.
    • Application Server: Processes the logic and returns the response.
    Canvas