Internet Systems & Architecture Engineering
Architects, distributed-systems engineers and staff-level engineers who design systems that survive at internet scale.
Architecture thesis — a geo-distributed system, chaos-tested, load-tested at 100k+ users, publicly defended.
Learning outcomes
Graduate this track able to work as:
Module timeline
20 modules across 6 phases. Tap any module to see its topics. P Practical H Hybrid T Theory
Advanced Networking & Internet Protocol Internals
8 weeks- TCP state machine
- Three-way handshake internals
- Congestion control (CUBIC, BBR)
- Slow start & congestion avoidance
- TCP head-of-line blocking
- UDP internals
- Packet loss & retransmission
- Nagle algorithm
- TCP buffer tuning
- Socket internals
- Kernel networking stack
Why this matters at Track 3: Cloudflare, Discord and Google built infra advantages here. Knowing why TCP congestion collapses under load lets you design systems that don’t.
- HTTP/1.1 limitations
- HTTP/2 multiplexing
- HPACK header compression
- HTTP/2 server push
- Stream prioritization
- QUIC protocol design
- QUIC connection migration
- 0-RTT resumption
- HTTP/3 over QUIC
- Protocol negotiation (ALPN)
- Building an HTTP/2 server from scratch
Lab: Implement a minimal HTTP/2 server in Node.js from raw TCP sockets. No frameworks — every frame type, header and stream state.
- DNS internals & resolution chain
- Anycast routing
- CDN architecture (Cloudflare-style)
- Edge computing
- Cache hierarchy design
- Origin shield patterns
- BGP basics
- GeoDNS & latency-based routing
- TLS at the edge
- DDoS mitigation architecture
Distributed Systems Foundations & Consensus
10 weeks- CAP theorem (rigorous proof)
- PACELC model
- Consistency models (linearizability, serializability, causal, eventual)
- Lamport clocks
- Vector clocks
- Happens-before relation
- Byzantine fault tolerance
- Two generals problem
- FLP impossibility theorem
- Failure modes taxonomy
Why this matters at Track 3: most engineers know CAP as a buzzword. You’ll prove it and explain what breaks when it’s violated — the difference between using and designing distributed systems.
- Paxos — single decree
- Multi-Paxos
- Raft leader election
- Raft log replication
- Raft membership changes
- Log compaction & snapshots
- Raft vs Paxos tradeoffs
- etcd internals
- ZooKeeper ZAB protocol
- Implementing Raft in code
Lab: Implement a working Raft node — leader election, log replication, basic fault tolerance. Run a 5-node cluster, kill nodes, verify consistency.
- Distributed locks (Redlock)
- Redlock correctness debate
- Fencing tokens
- Leader election patterns
- Gossip protocols
- SWIM protocol
- Failure detectors
- Phi-accrual failure detector
- Service mesh discovery
- Split-brain handling
- CQRS deep dive
- Event sourcing internals
- Saga orchestration vs choreography
- Outbox pattern in depth
- Two-phase commit
- Three-phase commit
- Distributed transaction alternatives
- CRDTs
- Operational transforms
Advanced System Design & Scalability Architecture
8 weeks- Designing for 1M+ RPS
- Geo-distributed architectures
- Active-active vs active-passive
- Global load balancing
- Latency vs consistency tradeoffs
- Hot partition problem
- Thundering herd prevention
- Cell-based architecture
- Bulkhead patterns at scale
- Chaos engineering principles
- Case studies: Twitter, Slack, Stripe internals
Why this matters at Track 3: Track 2 taught you to deploy systems — Track 3 teaches you to design systems that survive at internet scale.
- Service mesh internals (Istio / Envoy)
- Sidecar proxy pattern
- mTLS mesh
- Traffic management
- Observability in mesh
- API gateway design
- Rate limiting at gateway layer
- Auth at gateway
- Developer portals
- Internal platform engineering
- Platform-as-product thinking
- Building a key-value store from scratch
- LSM tree implementation
- SSTables & compaction
- Bloom filters
- Write amplification
- Distributed DB internals (CockroachDB, Spanner)
- NewSQL architecture
- Time-series database design
- Column-oriented storage
- Data lake architecture
Phase project: Design a system handling 500k write RPS and 2M read RPS with geo-distribution across 3 regions. Present decisions, tradeoffs and failure-mode analysis, then build the core storage layer.
AI Infrastructure & Systems Engineering
8 weeks- Attention mechanism (math)
- Multi-head attention
- Positional encoding
- Tokenization internals
- Context window mechanics
- KV cache
- Prefill vs decode phase
- Flash attention
- Sparse attention
- Model variants (GPT, BERT, T5)
Why this matters at Track 3: knowing the KV cache is why long context is expensive is what lets you build cost-efficient AI products.
- Quantization (INT8, INT4)
- Model pruning
- Knowledge distillation
- ONNX runtime
- vLLM internals
- Continuous batching
- GPU memory management
- Speculative decoding
- Inference cost modeling
- Latency vs throughput tradeoffs
- Edge inference
- Embedding models internals
- ANN algorithms (HNSW, IVF)
- HNSW graph construction
- Approximate vs exact search tradeoffs
- Vector index design
- Hybrid search (vector + BM25)
- RAG pipeline architecture
- Chunking strategies
- Re-ranking systems
- RAG evaluation metrics
- Production RAG at scale
- Agent loop internals
- Tool-calling architecture
- Multi-agent coordination
- Agent memory systems
- Long-horizon planning
- Agent evaluation
- MCP protocol design
- AI workflow orchestration
- Human-in-the-loop patterns
- AI safety in production
- Cost & latency budgets for agents
Phase project: Build a production AI infrastructure layer for the HRMS — self-hosted vLLM inference, HNSW vector search, a multi-agent HR workflow and a cost dashboard. Everything observable and benchmarked.
Enterprise Architecture & Engineering Philosophy
6 weeks- BPM systems internals
- Workflow engine design
- Rule engines
- ERP architecture
- Multi-org tenancy models
- Governance systems
- Compliance architecture
- Audit-trail systems at scale
- Data-residency architecture
- Enterprise integration patterns (EIP)
- Middleware & ESB patterns
- Simplicity vs flexibility tradeoffs
- Cost vs performance reasoning
- When NOT to distribute
- Boring-technology principles
- Premature optimization
- Technical-debt taxonomy
- Architecture decision records (ADRs)
- Conway’s Law
- Org structure & system-design coupling
- Migrations at scale
- Principles: Netflix, Stripe, Cloudflare
Why this matters at Track 3: the best architects know when NOT to use the sophisticated thing. Understanding tradeoffs is what makes someone a principal engineer.
- Writing architecture proposals
- RFC process
- Design review process
- Stakeholder communication
- Technical roadmapping
- Incident post-mortems
- Engineering metrics & KPIs
- Hiring & interview design
- Mentoring junior engineers
- Staff vs principal engineer scope
Architecture Thesis & Industry Simulation
12–16 weeks- Choose a complex system to design from scratch
- Write a full architecture proposal (RFC style)
- Define SLIs, SLOs, SLAs
- Identify all failure modes
- Data-flow diagrams
- Capacity planning
- Cost modeling
- Present to panel for critique
- Implement the designed system
- Geo-distributed deployment across 2+ regions
- Chaos engineering (fault injection)
- Load test: 100k+ concurrent users
- Full observability stack
- Incident simulation & response
- Performance report
- Security audit
- Present architecture decisions to a panel of engineers
- Defend every tradeoff made
- Live system demo under load
- Answer adversarial failure-mode questions
- Publish an architecture post (public portfolio piece)
Final deliverable: A fully defended, production-deployed distributed system — geo-replicated, chaos-tested, load-tested at 100k+ users, with a published architecture document. The principal-engineer portfolio piece.
Practical labs & phase projects
Why this matters at Track 3: Cloudflare, Discord and Google built infra advantages here. Knowing why TCP congestion collapses under load lets you design systems that don’t.
Lab: Implement a minimal HTTP/2 server in Node.js from raw TCP sockets. No frameworks — every frame type, header and stream state.
Why this matters at Track 3: most engineers know CAP as a buzzword. You’ll prove it and explain what breaks when it’s violated — the difference between using and designing distributed systems.
Lab: Implement a working Raft node — leader election, log replication, basic fault tolerance. Run a 5-node cluster, kill nodes, verify consistency.
Why this matters at Track 3: Track 2 taught you to deploy systems — Track 3 teaches you to design systems that survive at internet scale.
Phase project: Design a system handling 500k write RPS and 2M read RPS with geo-distribution across 3 regions. Present decisions, tradeoffs and failure-mode analysis, then build the core storage layer.
Why this matters at Track 3: knowing the KV cache is why long context is expensive is what lets you build cost-efficient AI products.
Phase project: Build a production AI infrastructure layer for the HRMS — self-hosted vLLM inference, HNSW vector search, a multi-agent HR workflow and a cost dashboard. Everything observable and benchmarked.
Why this matters at Track 3: the best architects know when NOT to use the sophisticated thing. Understanding tradeoffs is what makes someone a principal engineer.
Final deliverable: A fully defended, production-deployed distributed system — geo-replicated, chaos-tested, load-tested at 100k+ users, with a published architecture document. The principal-engineer portfolio piece.
Projects you'll ship
HTTP/2 Server From Scratch
A minimal HTTP/2 server built on raw TCP sockets — every frame type, header and stream state, no frameworks.
Raft Consensus Node
A working Raft implementation with leader election and log replication, verified on a 5-node cluster under node failures.
Geo-Distributed Storage Layer
Core storage for a system handling 500k write / 2M read RPS across 3 regions, with a full tradeoff analysis.
AI Infrastructure Layer
Self-hosted vLLM inference, HNSW vector search, a multi-agent HR workflow and a benchmarked cost dashboard.
Architecture Thesis (Capstone)
A geo-replicated, chaos-tested system load-tested at 100k+ users — publicly defended before an engineering panel.
Tools & technologies covered
Career outcomes
This track is built to make you employable at the level above where you started. Pair it with your deployed capstone and public write-ups, and you walk into interviews with proof, not promises.
See the full career roadmapTrack 3 FAQs
Enroll in Track 3
Track 1 + Track 2 graduates, or engineers with 3+ years production background — this is where you start. Talk to an advisor to confirm it's the right fit.