Interview Roadmap

Goal: Build a rock-solid base in JavaScript fundamentals and start thinking about time complexity from day one.

Topics

Key Concepts

• How let, const, and var differ in scoping and the Temporal Dead Zone (TDZ)
• Hoisting rules for variables vs functions — know what moves where
• Arrow functions vs regular functions: no own this, no arguments, no new
• Big O complexity analysis — being able to look at code and say “that’s O(n log n)”
• Recognizing two-pointer and sliding window patterns in array problems

Practice

• Write a function that uses destructuring + spread together to merge and reshape objects
• Implement a basic sliding window maximum for a fixed window size
• Pick 3 functions of varying complexity and analyze their Big O — justify your answer
• Solve 2 two-pointer problems (e.g., pair sum, remove duplicates from sorted array)

~14 topics · ~1.5 hrs/day · Focus: read the linked notes, then code each concept

Goal: Master JavaScript function patterns and start working with core data structures and database fundamentals.

Topics

Key Concepts

• Closures and their classic interview patterns (counter, private variables, loop traps)
• When to reach for call vs apply vs bind — and why they exist
• Memoization as a caching strategy for expensive function calls
• Hash map O(1) lookups and how they unlock elegant solutions to array problems
• SQL vs NoSQL tradeoffs — when to pick which, and why it matters

Practice

• Implement Function.prototype.bind from scratch (this one comes up a lot)
• Write a generic memoize() function that works with any pure function
• Solve 2 array problems using hash maps (e.g., two sum, group anagrams)
• Compare SQL and NoSQL for 3 real scenarios — justify your picks

~12 topics · ~1.5 hrs/day · Focus: read the linked notes, then code each concept

Goal: Understand how JavaScript actually runs your code, get comfortable with async patterns, and start writing SQL that does real work.

Topics

Key Concepts

• How this changes based on call context — global, method, arrow, explicit binding
• Execution context creation (memory phase vs execution phase)
• Promise chaining vs async/await — same thing, different syntax, different readability
• Promise.all vs Promise.allSettled vs Promise.race — know when to use each
• ACID guarantees and why they matter for data integrity
• Types of SQL joins — inner, left, right, full, cross — and when each makes sense
• Prefix sum technique for O(1) range queries

Practice

• Predict the value of this in 5 different scenarios (method call, arrow in object, class, setTimeout, explicit bind)
• Convert a callback-hell example to clean async/await code
• Write JOIN queries for 3 scenarios: user orders, employee departments, optional relationships
• Solve a prefix sum problem (e.g., subarray sum equals K)

~13 topics · ~2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Go deeper on async JavaScript (event loop is a favorite interview topic), understand JS objects and inheritance, and round out foundational DBMS + DSA knowledge.

Topics

Key Concepts

• Event loop phases: call stack, microtask queue (promises), macrotask queue (setTimeout) — the order matters
• Debounce vs throttle: both limit function calls, but in very different ways
• Prototype chain lookup — how JS finds properties you didn’t define on an object
• class syntax vs constructor functions — syntactic sugar, same prototype mechanics underneath
• CAP theorem tradeoffs — you can only pick two, and the choice shapes your architecture
• Merge sort (stable, O(n log n) guaranteed) vs quick sort (in-place, O(n log n) average)
• Linked list pointer manipulation — reversing, detecting cycles, finding middle

Practice

• Predict event loop output for 3 code snippets mixing setTimeout, Promise, and queueMicrotask
• Implement debounce and throttle from scratch — both are common interview asks
• Reverse a linked list iteratively and recursively
• Write a window function query to rank employees by salary within each department

~12 topics · ~1.5 hrs/day · Focus: read the linked notes, then code each concept

Goal: Learn how JavaScript interacts with the browser (events, DOM, storage) and master database schema design — both are staples of product company interviews.

Topics

Key Concepts

• Event bubbling vs capturing flow — events bubble up by default, capturing goes top-down
• Event delegation: attach one listener to a parent instead of N listeners to children (huge for dynamic elements)
• Map vs plain objects: Map preserves insertion order, allows any key type, has .size
• localStorage vs sessionStorage vs cookies — storage limits, persistence, and when to use each
• Normalization forms (1NF through BCNF) — eliminating redundancy step by step
• When denormalization is actually worth it (read-heavy workloads, reporting tables)
• ER diagram notation and how to translate it to actual tables

Practice

• Build a todo list using only DOM manipulation + event delegation (no framework, just vanilla JS)
• Design a normalized schema for a blog platform (users, posts, comments, tags) — go through 1NF to 3NF
• Compare your normalized schema with a denormalized version — list the tradeoffs

~13 topics · ~1.5 hrs/day · Focus: read the linked notes, then code each concept

Goal: Finish JavaScript (all 43 topics!) and start stack/queue data structures. This is a big milestone — celebrate it.

Topics

Key Concepts

• ES modules (import/export) vs CommonJS (require/module.exports) — know the differences and when each is used
• Proxy for metaprogramming — intercept property access, validation, logging, and more
• Polyfill writing pattern: check if the method exists, define it on the prototype if not
• Stack LIFO pattern — used in parsing, backtracking, undo systems, and browser history
• Monotonic stack for “next greater element” type problems — a pattern that shows up a lot
• Heap (priority queue) for top-K problems, merge K sorted lists, median finding
• Database migrations as version control for your schema — up/down, idempotent, safe rollbacks

Practice

• Write polyfills for Promise.all and Array.prototype.flat — understand every edge case
• Implement a min-heap with insert, extractMin, and peek operations
• Solve “next greater element” using a monotonic stack
• Go through 5 output-based JS questions and predict the answer before running them

~12 topics · ~2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Blow through Python fundamentals quickly (it’s revision, not new ground) and spend the real energy on DBMS indexing — that’s the meaty part this week.

Topics

Key Concepts

• Mutable vs immutable tradeoffs — why tuples exist alongside lists, and when to reach for each
• List comprehension patterns — filtering, mapping, and nested comprehensions in one line
• B-tree vs B+ tree structure — leaf-level linking and why B+ trees dominate in databases
• Reading EXPLAIN output — spotting sequential scans, understanding cost estimates
• Index selection strategies — covering indexes, composite indexes, and when NOT to index

Practice

• Solve 3 problems using list comprehensions (flatten a 2D list, filter + transform, nested grouping)
• Run EXPLAIN on 3 queries in PostgreSQL and identify missing indexes — add them and compare plans
• Design a data structure that supports insert, delete, and getRandom in O(1)

~13 topics · ~1.5 hrs/day · Focus: read the linked notes, then code each concept

Goal: Level up Python with functional patterns and generators, then understand how databases keep your data safe with transactions and locking.

Topics

Key Concepts

• *args/**kwargs and how Python resolves argument order
• The decorator pattern — wrapping functions to add behavior without modifying them
• Generator lazy evaluation with yield — why it’s memory-efficient for large datasets
• Isolation level tradeoffs — read committed vs serializable, and the phantom read problem
• Deadlock prevention strategies — lock ordering, timeouts, deadlock detection
• The binary search template — getting the boundary conditions right every time

Practice

• Write a @timer decorator that logs how long any function takes to execute
• Implement a generator for the Fibonacci sequence — verify it’s lazy with next()
• Explain why READ COMMITTED is the default in PostgreSQL (hint: it’s about the throughput vs safety tradeoff)
• Implement binary search with both iterative and recursive approaches

~14 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Start thinking at scale — system design foundations and Python OOP for the language round. This week flips your mindset from “how does this function work” to “how does this system work.”

Topics

Key Concepts

• The system design interview framework: requirements -> estimation -> high-level design -> deep dive
• Back-of-envelope math — estimating QPS, storage, and bandwidth without a calculator
• Python MRO (C3 linearization) — how Python decides which parent method to call
• Dunder methods for operator overloading — making your objects behave like built-in types
• @staticmethod vs @classmethod — when you need cls and when you don’t
• Tree serialization patterns — preorder with null markers is the classic approach

Practice

• Estimate QPS for a URL shortener (100M URLs/month, read-heavy, 100:1 read/write ratio)
• Design a Python class hierarchy for a simple card game — use inheritance, dunder methods, and abstract classes
• Implement tree serialization/deserialization using preorder traversal
• Find the LCA of two nodes in a binary tree — both recursive and iterative

~12 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Learn the infrastructure building blocks that every system design answer needs, pair it with NoSQL knowledge, and start conquering graph algorithms.

Topics

Key Concepts

• L4 vs L7 load balancing — when you need protocol awareness and when raw throughput wins
• Cache invalidation strategies — write-through, write-behind, and cache-aside patterns
• Pub/sub vs message queue — fan-out vs exactly-once processing, and when to use each
• When to use MongoDB vs Redis vs PostgreSQL — there’s no universal answer, only tradeoffs
• Adjacency list vs adjacency matrix — space/time tradeoffs for sparse vs dense graphs
• BFS for shortest path (unweighted) vs DFS for exploration and cycle detection

Practice

• Draw the architecture of any website you use daily — identify the LB, cache, CDN, and queue layers
• Pick 3 real apps and justify which database type (document, key-value, relational) fits best
• Implement BFS and DFS on a graph — both iterative and recursive
• Build a Trie and implement autocomplete search

~13 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Go deep on how databases scale in distributed systems — replication, sharding, and consistent hashing are interview favorites. Keep Python and graph algorithms moving forward.

Topics

Key Concepts

• Master-slave vs multi-master replication — consistency vs availability tradeoffs
• Horizontal vs vertical sharding strategies — range-based, hash-based, and directory-based
• Consistent hashing ring — why it minimizes data movement when nodes join or leave
• Python’s LEGB scope resolution — Local, Enclosing, Global, Built-in
• Shallow vs deep copy pitfalls — nested mutable objects are where bugs hide
• Dijkstra’s vs Bellman-Ford — greedy vs relaxation, and when negative edges matter
• Union-Find with path compression and union by rank — near O(1) amortized operations

Practice

• Design a sharding strategy for a user table with 100M rows — justify your shard key choice
• Implement Dijkstra’s algorithm from scratch — test it on a weighted graph
• Implement Union-Find with both path compression and union by rank
• Write code that demonstrates the difference between shallow and deep copy with nested lists

~12 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Transition from HLD to LLD — start thinking about class-level design alongside system-level design. By the end of this week, you should be comfortable at both zoom levels.

Topics

Key Concepts

• When to scale horizontally vs vertically — cost curves, bottleneck analysis, and practical limits
• Microservice boundaries — decompose by business domain, not by technical layer
• API gateway patterns — rate limiting, auth, routing, and request aggregation
• CQRS read/write split — separate models for reads and writes when access patterns diverge
• Composition over inheritance — why “has-a” often beats “is-a” in real-world code
• The four OOP pillars — encapsulation, abstraction, inheritance, polymorphism
• DP overlapping subproblems and optimal substructure — the two properties that make DP work

Practice

• Argue microservices vs monolith for an e-commerce startup — consider team size, deployment, and complexity
• Identify which OOP pillar each code snippet demonstrates (prepare 4 snippets, one per pillar)
• Design a materialized view refresh strategy for a dashboard with 5-minute staleness tolerance
• Solve 2 classic DP problems — start with Fibonacci (top-down and bottom-up), then try coin change

~13 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Understand distributed system tradeoffs (CAP, consistency, failover) and master the SOLID principles — the design vocabulary every interviewer expects you to speak fluently.

Topics

Key Concepts

• CAP theorem real-world examples — classify systems as CP (MongoDB, HBase) vs AP (Cassandra, DynamoDB)
• Strong vs eventual consistency — when each is acceptable and the spectrum in between
• Active-passive vs active-active failover — tradeoffs in cost, complexity, and recovery time
• REST best practices — idempotency, proper status codes (2xx/4xx/5xx), resource naming, HATEOAS
• WebSocket vs SSE vs polling — pick the right tool: bidirectional (WebSocket), server-push (SSE), simple (polling)
• Each SOLID principle with code violations and fixes — learn to spot and refactor anti-patterns
• SRP: one reason to change. OCP: extend without modifying. LSP: subtypes must be substitutable
• ISP: no client should depend on methods it doesn’t use. DIP: depend on abstractions, not concretions
• 1D DP patterns — climbing stairs, house robber, decode ways, coin change variations

Practice

• Classify 5 real databases as CP or AP and justify your reasoning
• Design a RESTful API for a bookstore — define resources, endpoints, status codes, and error responses
• Refactor a God class that handles user auth, email sending, and logging into SRP-compliant classes
• Solve the house robber problem using both top-down and bottom-up DP

~14 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Month 4 begins — learn the design patterns that show up in every LLD interview. By Friday you should be able to name, explain, and implement at least 7 patterns from memory.

Topics

Key Concepts

• When Singleton becomes an anti-pattern — global state, hidden dependencies, testing nightmares
• Factory vs Builder — Factory for object families, Builder for complex construction with many optional params
• Adapter for incompatible interfaces — wrap a third-party class to match your expected interface
• Decorator for runtime extension — add behavior without subclassing (think Java I/O streams)
• Facade for simplified APIs — hide subsystem complexity behind a single clean interface
• Observer for event systems — publisher-subscriber decoupling, the backbone of reactive programming
• Strategy for interchangeable algorithms — swap sorting, pricing, or payment logic at runtime
• 0/1 knapsack vs unbounded knapsack — the subtle difference that changes the entire DP transition
• 2D DP grids — unique paths, minimum path sum, edit distance
• Redis strings, lists, sets, sorted sets, hashes — know when to use each data structure

Practice

• Implement the Observer pattern for a notification system (email + SMS + push subscribers)
• Implement the Strategy pattern for a payment processor (credit card, PayPal, crypto)
• Solve the 0/1 knapsack problem — then modify it for unbounded knapsack and compare
• Use Redis CLI to model a leaderboard with sorted sets

~13 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Time to practice real system design questions — the ones actually asked in interviews. This week you stop learning theory and start designing systems end-to-end.

Topics

Key Concepts

• URL shortener — base62 encoding, read-heavy workload (~100:1 read-to-write), key generation service
• Rate limiter — token bucket vs sliding window log vs sliding window counter, where to place it
• Chat system — WebSocket for real-time, message queue for reliability, presence/online status
• Social media feed — fan-out on write (push) vs fan-out on read (pull), celebrity problem
• Cache-aside vs write-through vs write-behind — pick the right pattern for your access profile
• RDB vs AOF persistence — RDB for snapshots (faster recovery), AOF for durability (less data loss)
• Leader-follower replication — read replicas, replication lag, and failover promotion
• Sharding strategies — hash-based vs range-based, resharding pain, consistent hashing
• Python context managers — with statement, __enter__/__exit__, contextlib shortcuts
• PEP 8 essentials — naming conventions, line length, imports order, and when to break the rules

Practice

• Whiteboard a full URL shortener design in 30 minutes — requirements, API, storage, and scale estimates
• Explain the cache-aside pattern with code — show the read and write paths clearly
• Write a Python context manager for database connections (both class-based and @contextmanager)
• Solve a longest common subsequence problem using interval DP

~12 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: Practice LLD machine coding questions — design classes, relationships, and implement core logic. This is the week where OOP theory meets real implementation.

Topics

Key Concepts

• Parking lot — vehicle hierarchy (car, bike, truck), strategy for spot allocation, fee calculation
• Elevator system — state machine (idle, moving up, moving down), scheduling algorithm (LOOK, SCAN)
• BookMyShow — seat locking with TTL, concurrency handling, payment timeout flows
• Vending machine — state pattern (idle, coin inserted, dispensing), inventory management
• Snake & Ladder — board modeling, dice abstraction, game loop, player turns
• Greedy choice property — locally optimal leads to globally optimal (activity selection, fractional knapsack)
• Backtracking template — choose, explore, unchoose (N-Queens, permutations, subsets)
• Binary search on answer — when the answer space is monotonic (minimum time, maximum distance)
• Interval problems — merge, insert, non-overlapping count, meeting rooms
• Docker fundamentals — images, containers, volumes, networks, and the build-ship-run workflow
• Dockerfile best practices — multi-stage builds, layer caching, minimal base images

Practice

• Code the Parking Lot system end-to-end — classes, relationships, and a working CLI demo
• Solve 2 interval problems — merge intervals and meeting rooms II
• Containerize a simple Node.js app with a Dockerfile — use multi-stage build for production
• Solve an N-Queens variant using the backtracking template

~12 topics · ~1.5-2 hrs/day · Focus: read the linked notes, then code each concept

Goal: The final push! Wrap up remaining topics and shift into full revision mode. You’ve put in the work — this week is about consolidating everything into interview-ready confidence.

Topics

Revision Checklist

Go back and re-read these high-impact pages:

JavaScript (most asked):

• Closures · Event Loop · Promises · Prototypal Inheritance · this Keyword

DSA (pattern recognition):

• Common Interview Patterns · Binary Search · BFS and DFS · DP Fundamentals

System Design (framework):

• How to Approach System Design · Design URL Shortener · Design Chat System

DBMS (backend must-knows):

• Indexing · Transactions · SQL vs NoSQL · Caching Patterns

LLD (design skills):

• SOLID Principles · Design Parking Lot · Observer Pattern

Key Concepts

• This week is about filling gaps and building confidence — the new topics are relatively light
• DNS resolution flow — recursive vs iterative, caching at every level
• HTTP fundamentals — GET vs POST vs PUT vs PATCH vs DELETE, status code families, common headers
• Docker Compose for multi-container setups — services, networks, volumes, depends_on
• CI/CD pipelines — build, test, deploy stages, GitHub Actions basics
• Python module system — __init__.py, relative vs absolute imports, package structure
• ATM design — state pattern (idle, card inserted, PIN entered, transaction), transaction types
• Common interview patterns — sliding window, two pointers, fast/slow, BFS/DFS, DP, greedy
• Spend most of your time on revision — you already know this material, now make it instant recall

Practice

• Do a mock system design interview with a 45-minute timer — pick any HLD question and go end-to-end
• Do a mock LLD round — design a system from scratch in 60 minutes, write actual code
• Solve 5 DSA problems under time pressure (20 min each) — one from each pattern family
• Review your weakest collection and re-read at least 3 topics from it

~10 new topics + revision · You’ve covered 216 topics across 8 collections — you’re ready!