Technical Interview Study Guide

Comprehensive materials for software engineering interviews

56
Study Topics
60+
Python Examples
50+
Interactive Guides
∞
Interview Confidence

Welcome to Your Study Hub

This comprehensive collection covers essential topics for technical interviews including data structures, algorithms, distributed systems, system design, and infrastructure. Each resource is designed to provide both theoretical understanding and practical implementation knowledge.

How to use: Click on any card below to open the study material. Python files can be run directly to see examples in action. HTML files provide interactive guides with detailed explanations.

Data Structures & Algorithms

Core CS fundamentals with Python implementations

🗄
LSM Tree
Log-Structured Merge Tree with Mermaid architecture diagrams showing write/read paths and compaction. Complete guide to how Cassandra, RocksDB, and LevelDB work.
Interactive Guide 📈
Big O Time Complexity
Interactive complexity analysis with Chart.js visualization showing growth curves. Code examples for O(1) through O(2^n) with real-world comparisons.
Interactive Guide 🕸
Graph Algorithms
Complete guide to BFS, DFS, Dijkstra's algorithm, topological sort, and Union-Find. Covers graph representations (adjacency list vs matrix), shortest path algorithms, cycle detection, connected components, and when to use each algorithm. Includes Python implementations with complexity analysis.
Comprehensive Guide 🏗
Data Structures Deep Dive
Comprehensive guide covering Arrays, Stacks (LIFO), Queues (FIFO), Hash Tables, Trees, Heaps, Graphs with real-world usage examples (database indexes, filesystems, social networks). Includes advanced structures: Bloom Filters, Count-Min Sketch, HyperLogLog, Consistent Hashing, Merkle Trees, and Skip Lists.
Comprehensive Guide 🔢
Number Systems: Binary, Hex & ASCII
Binary (base-2), Hexadecimal (base-16), and ASCII encoding explained. Covers two's complement, bitwise operations, masks, bit shifting, and practical applications. Includes subnet mask calculations and real-world use cases in networking and low-level programming.
Fundamentals Guide 💻
LeetCode Patterns & Solutions
Master coding interviews with detailed tutorials on top LeetCode problems. Covers Two Sum, Container With Most Water, Longest Substring, Reverse Linked List, Validate BST, and more. Each problem includes: WHY the solution works (intuition), HOW to solve it (step-by-step), heavily commented Python code, complexity analysis, common mistakes, and pattern recognition tips.
Interview Prep

Performance & Fundamentals

Core computer science concepts every engineer should know

⚡
Latency Numbers Every Programmer Should Know
Jeff Dean's famous performance numbers with 2024-2025 updates. Understand the massive performance differences: L1 cache (0.5ns) vs RAM (100ns) vs SSD (150us) vs network (150ms). Includes logarithmic visualizations, human-scale analogies, design implications, and real-world examples. Essential for system design and optimization decisions.
Essential Reference 🔀
Concurrency vs Parallelism
Deep dive into threading models: Python's Global Interpreter Lock (GIL) vs Go's goroutines. Complete explanation of why Python can't achieve true parallelism for CPU-bound tasks, M:N threading, the Go scheduler, channels, and when to use multiprocessing vs threading vs async/await. Includes code examples in both Python and Go.
Comprehensive Guide

Distributed Systems

Consensus, consistency, and distributed computing concepts

🔺
CAP Theorem
Consistency, Availability, and Partition Tolerance. Real-world database examples and trade-off decisions.
Interactive Guide 🤝
Paxos Consensus
Comprehensive guide with Mermaid sequence diagrams showing the 2-phase protocol (Prepare/Promise, Accept/Accepted). Includes competing proposers scenario and real-world usage.
Interactive Guide ⚡
Raft Consensus
Complete guide with Mermaid state diagrams and sequence flows. Covers leader election, log replication, and term transitions. Designed for understandability - easier than Paxos!
Interactive Guide 🔁
Idempotency Patterns
Six practical implementations: idempotency keys, natural idempotency, state machines, conditional updates, message deduplication, and distributed locks. Complete with Python examples for payments, order processing, and queue consumers.
Implementation Guide

System Design

Design patterns, heuristics, and interview strategies

🧭
When to Use What - Decision Guide
Comprehensive decision guide: "If you see X, use Y, here's why." Covers data structures (Hash Table, Heap, Trie, Bloom Filter), algorithms (BFS, DFS, DP, Binary Search), rate limiting (Token Bucket, Sliding Window), caching (LRU, Write-Through), databases (SQL vs NoSQL), messaging (Kafka vs RabbitMQ), and distributed patterns (Sharding, Saga, CQRS).
Decision Guide 💡
System Design Heuristics
Quick reference patterns: Write+Spike->Queue, Latency+Global->CDN, and 16 more proven heuristics for system design.
Quick Reference 🎯
System Design Interviews
Complete guide to designing Twitter, Uber, YouTube, and more. Includes framework, components, and scaling strategies.
Interview Guide 💻
System Design - Python Solutions Part 1
Functional Python implementations of system design algorithms and components: Dijkstra's algorithm, A* pathfinding, Traveling Salesman Problem (TSP) with 2-opt optimization, Geohash for location indexing, QuadTree spatial queries, LRU Cache with O(1) operations, Consistent Hashing for distributed systems. All with complexity analysis and real-world use cases (Uber routing, maps navigation, delivery optimization).
Code Examples 🎲
System Design - Python Solutions Part 2
Advanced implementations: Bloom Filter (membership testing), Count-Min Sketch (frequency estimation for trending topics), URL Shortener with Snowflake IDs, Rate Limiters (Token Bucket, Sliding Window), News Feed fan-out strategies (push vs pull), Autocomplete Trie, Database Sharding (hash/range/geo-based), Idempotency patterns for payments. Production-ready code for Twitter, bit.ly, Stripe-like systems.
Code Examples 🌐
TCP Protocol
Deep dive into TCP: sliding window, congestion control, exponential backoff, reliability mechanisms, and more.
Protocol Guide

Infrastructure & Orchestration

Container orchestration and cloud-native architectures

☸
Kubernetes Architecture
Complete K8s guide: API Server, etcd, scheduler, kubelet, CNI, Services, Deployments, and all core components explained.
Comprehensive Guide 🕸
Service Mesh: Istio & Envoy
Comprehensive guide to service mesh architecture. Covers Envoy proxy (data plane), Istio control plane, mTLS security, traffic management (canary deployments, circuit breaking, retries), observability (metrics, tracing), and when to use vs not use a service mesh. Includes Mermaid architecture diagrams, YAML examples, and comparison with Linkerd and Consul.
Infrastructure Guide 🐳
Docker & Container Fundamentals
Complete guide to containerization: Linux kernel features (namespaces, cgroups, union filesystems), Docker architecture, Dockerfile best practices with multi-stage builds, networking (bridge, host, overlay), volumes and storage, Docker Compose for multi-container apps, image optimization techniques, security hardening, and container runtime comparison (Docker vs containerd vs CRI-O). Includes production-ready examples and essential commands.
Comprehensive Guide

Networking Fundamentals

CCNA-level concepts, routing protocols, and how the internet works

🔌
Networking Fundamentals
TCP/IP stack, BGP, OSPF, EIGRP, RIP, route convergence, CIDR, subnetting, VLANs, STP, MTU, CRC, and ACLs. Complete refresh of CCNA-level concepts with "why it was invented" context.
Comprehensive Guide 🏢
ISP Services & Internet Infrastructure
DNS (how the internet phonebook works), DHCP, Email (SMTP/POP/IMAP), FTP/TFTP, LDAP/Active Directory, Caching strategies (Redis, CDN, browser cache), Rate Limiting algorithms, and Firewall architectures. Real-world ISP experience.
Services Guide

Senior/Distinguished Engineer Preparation

Advanced patterns, architectures, and system design for senior-level interviews

🏛
Gang of Four Design Patterns
All 23 classic design patterns with Python implementations. Creational, Structural, and Behavioral patterns explained with real-world use cases.
Comprehensive Guide 🏗
Architectural Patterns
Microservices, Event-Driven Architecture, CQRS, Saga Pattern, and Hexagonal Architecture with Python examples.
Architecture Guide 🗃
Distributed Systems Comparison
RDBMS vs NoSQL vs Messaging systems. PostgreSQL, MongoDB, Redis, Cassandra, Neo4j, Kafka - when to use each.
Comparison Guide ⚠
Classic Distributed Systems Problems
Thundering Herd, Byzantine Generals, Split Brain, FLP Impossibility, and solutions with Python implementations.
Problem Patterns 🚦
Rate Limiting Strategies
Token Bucket, Leaky Bucket, Sliding Window - all 5 algorithms with Python and Redis implementations for production.
Implementation Guide 💾
Database Design & Optimization
Normalization, indexing strategies, query optimization, N+1 problem, connection pooling, and transaction isolation levels.
Database Guide 🗄
Datastore Comparison: Redis, RocksDB & More
Comprehensive comparison of PostgreSQL, MongoDB, Redis (7 data structures with use-cases!), RocksDB (embedded storage), Cassandra, DynamoDB, and Elasticsearch. Includes real-world architecture examples and decision framework. Redis use-cases: caching, sessions, rate limiting, queues, leaderboards, pub/sub, streams.
Database Comparison 📝
SQL Deep Dive
Query execution internals, indexing strategies (B-tree, covering, partial), EXPLAIN plans, window functions, CTEs, transactions, isolation levels, locking, and interview patterns.
SQL Guide 🔌
API Design Patterns
REST, GraphQL, and gRPC - complete comparison with Python implementations. Learn when to use each API style.
API Design Guide 🔐
Security & Authentication
OAuth 2.0, JWT, OWASP Top 10 vulnerabilities - SQL injection, XSS, CSRF prevention with Python implementations.
Security Guide ⚡
Caching Strategies
Cache-aside, write-through, write-behind patterns. Redis caching, LRU implementation, cache invalidation, and CDN strategies.
Performance Guide 📊
Monitoring & Observability
Logs, metrics, traces - RED/USE methods, Prometheus, distributed tracing, SLIs/SLOs, health checks, and alerting strategies.
Observability Guide 🔄
State Machines & Actors
Finite state machines, Actor model (Akka), Temporal workflows - evolution from manual state management to modern workflow orchestration with resilience patterns and crash recovery.
Architecture Guide 📮
Messaging Systems & Event Streaming
Comprehensive guide to message queues, pub/sub, and event streaming systems. Covers AWS SQS/SNS/Kinesis/EventBridge, Apache Kafka/MSK, RabbitMQ/Amazon MQ, and Redis Pub/Sub. Detailed comparisons, when to use each system, throughput/latency characteristics, Python code examples, and architecture patterns including fan-out, event sourcing, and microservices decoupling.
Messaging Guide 📊
Streaming Systems Deep Dive
Kafka internals (partitions, replication, ISR), exactly-once semantics (idempotent producers, transactions), stream processing (Kafka Streams, Flink), and patterns (event sourcing, CQRS, CDC, Saga). Includes consumer groups, offset management, windowing, and real-world use cases for real-time analytics and event-driven microservices.
Streaming Guide ☁
AWS Architecture Guide
Complete AWS architecture from the ground up: AWS Organizations & multi-account strategy, VPC networking (peering, Transit Gateway, Direct Connect), compute services (EC2, Lambda, ECS, EKS, Fargate), storage (S3, EBS, EFS), databases (RDS, Aurora, DynamoDB, ElastiCache), and security (IAM, KMS, GuardDuty, Security Hub). Includes Terraform examples, comparison tables, Mermaid architecture diagrams, and real-world patterns: multi-tier web apps, serverless microservices, and data pipelines.
Cloud Architecture 💾
Database Internals Deep Dive
How production databases really work: B+ Tree implementation (disk-optimized indexes), MVCC (readers never block writers), Write-Ahead Logging (WAL) for crash recovery, and database replication (streaming, logical, async vs sync). Includes working Python implementations of B+ Trees with range queries, MVCC snapshot isolation, WAL replay, and replication protocols. Essential for understanding PostgreSQL, MySQL internals.
Deep Dive 🚀
CI/CD & Deployment Strategies
Zero-downtime deployment patterns: Blue-Green deployment (instant switchover with rollback), Canary deployment (gradual rollout with automated metrics monitoring), Feature Flags (decouple deployment from release), and rollback strategies. Includes Python implementations of load balancers, canary controllers, and feature flag systems. Real-world examples from Netflix, Amazon, Google deploying thousands of times per day.
DevOps Guide 🔨
Build Redis & Message Queue
Production-quality implementations from scratch: MiniRedis with GET/SET/TTL/LRU eviction/Pub-Sub/atomic operations, and Kafka-like Message Queue with producer/consumer pattern, acknowledgments, retries, dead letter queue, and consumer groups. Thread-safe, O(1) operations, at-least-once delivery guarantees. Learn by building the systems you use every day.
Implementation Guide 🌐
Advanced Distributed Systems
Expert-level distributed systems patterns: Vector Clocks (detect causality & conflicts without synchronized clocks), CRDTs (conflict-free replicated data types: G-Counter, PN-Counter, LWW-Register, OR-Set), Two-Phase Commit (2PC atomic transactions), and Saga Pattern (long-running workflows with compensating transactions). Working Python implementations for Dynamo, Riak, microservices coordination.
Expert Patterns

Netflix Compute Runtime — Targeted Study Plan

22-week program for Netflix L5/L6 Distributed Systems Engineer (Compute Runtime)

🎯
Netflix Compute Runtime Study Plan
Complete 22-week study program: Go language mastery, container runtime internals (containerd, runc, NRI), kubelet deep dive, Linux performance debugging, and a KaaS multi-cloud capstone project. Includes gap analysis, weekly schedule, open source contribution strategy, and interview prep.
Career Target 🛠
KaaS Portal — Learn-by-Building Guide
Step-by-step build guide for a multi-cloud Kubernetes-as-a-Service portal in Go. Covers modern Go patterns, Kind/EKS/GKE providers, client-go, async concurrency, and container runtime internals. Includes deep analysis of Netflix's "Noisy Neighbor Detection with eBPF" and "Mount Mayhem" blog posts.
Hands-On Project

Quick Start Guide

For Coding Interviews:

For System Design Interviews:

For Networking/Infrastructure Roles:

For Senior/Distinguished Engineer Interviews:

Study Tips: