Here's your comprehensive 180-day JavaScript Interview Mastery Roadmap covering every concept that's frequently asked in interviews, from fundamentals to advanced topics.
Month 1: JavaScript Fundamentals & Core Concepts (Days 1-30) Day 1: JavaScript Basics & Data Types Primitive types (string, number, boolean, null, undefined, symbol, bigint)
typeof operator and type checking
Type coercion and conversion
Practice: 10 interview questions on data types
Day 2: Variables - var, let, const Differences between var, let, and const
Block scope vs function scope
Temporal Dead Zone (TDZ)
Practice: Tricky scope questions with var/let/const
Day 3: Hoisting Deep Dive Variable hoisting behavior
Function hoisting vs function expressions
let/const hoisting and TDZ
Practice: 15 hoisting interview questions
Day 4: Operators & Type Coercion == vs === (equality vs strict equality)
Truthy and falsy values
Implicit vs explicit coercion
Practice: Tricky coercion questions (e.g., 3+2+"7")
Day 5: Functions - Basics Function declarations vs expressions
Function parameters and arguments object
Default parameters (ES6)
Practice: Function-related interview questions
Day 6: Arrow Functions Arrow function syntax
Lexical this binding
When NOT to use arrow functions
Practice: Arrow function vs regular function questions
Day 7: this Keyword - Part 1 Global context this
Object method this
Function context this
Practice: 10 this keyword questions
Day 8: this Keyword - Part 2 call(), apply(), bind() methods
Arrow functions and this
Class methods and this
Practice: Advanced this binding questions
Day 9: Closures - Part 1 Closure definition and concept
Lexical scope and closure creation
Practical uses of closures
Practice: Basic closure interview questions
Day 10: Closures - Part 2 Closures in loops (var vs let)
Module pattern with closures
Memory implications
Practice: Tricky closure questions (setTimeout loop)
Day 11: Scope Chain Global, function, and block scope
Scope chain traversal
Lexical environment
Practice: Scope chain interview questions
Day 12: IIFE (Immediately Invoked Function Expression) IIFE syntax and use cases
Creating private variables
Avoiding global pollution
Practice: IIFE interview questions
Day 13: Objects - Part 1 Object creation methods
Property access (dot vs bracket notation)
Object methods and computed properties
Practice: Object manipulation questions
Day 14: Objects - Part 2 Object.keys(), Object.values(), Object.entries()
Object.assign() and spread operator
Object.freeze(), Object.seal()
Practice: Object methods interview questions
Day 15: Prototypes - Part 1 What is prototype?
[[Prototype]] internal property
proto vs prototype
Practice: Basic prototype questions
Day 16: Prototypes - Part 2 Prototype chain explained
Object.create()
hasOwnProperty() method
Practice: Prototype chain interview questions
Day 17: Prototypal Inheritance Inheritance through prototype
Constructor functions
Prototypal vs classical inheritance
Practice: Inheritance interview questions
Day 18: Constructor Functions new keyword behavior
Constructor pattern
instanceof operator
Practice: Constructor function questions
Day 19: ES6 Classes - Part 1 Class syntax
Constructor method
Class methods and properties
Practice: Basic class interview questions
Day 20: ES6 Classes - Part 2 Class inheritance with extends
super keyword
Static methods
Practice: Class inheritance questions
Day 21: Arrays - Part 1 Array creation and manipulation
Array methods (push, pop, shift, unshift)
splice() vs slice()
Practice: Array manipulation interview questions
Day 22: Arrays - Part 2 map(), filter(), reduce()
forEach() vs map()
find(), findIndex(), some(), every()
Practice: Array method interview questions
Day 23: Array Advanced Methods flat(), flatMap()
Array.from(), Array.of()
Removing duplicates ([...new Set(arr)])
Practice: Advanced array questions
Day 24: String Methods Template literals (ES6)
String manipulation methods
String search methods
Practice: String interview questions
Day 25: Destructuring - Part 1 Array destructuring
Object destructuring
Nested destructuring
Practice: Destructuring interview questions
Day 26: Spread & Rest Operators Spread operator (...)
Rest parameters
Differences between spread and rest
Practice: Spread/rest operator questions
Day 27: Default Parameters Default function parameters
Undefined vs null with defaults
Destructuring with defaults
Practice: Default parameter questions
Day 28: Enhanced Object Literals Shorthand property names
Shorthand method definitions
Computed property names
Practice: Object literal questions
Day 29: Symbols & BigInt Symbol primitive type
Symbol use cases (unique keys)
BigInt for large integers
Practice: Symbol and BigInt questions
Day 30: Month 1 Review & Practice Review all concepts learned
Practice: Solve 50 interview questions covering Month 1 topics
Month 2: Asynchronous JavaScript & Advanced Concepts (Days 31-60) Day 31: Synchronous vs Asynchronous Single-threaded nature of JavaScript
Blocking vs non-blocking code
Asynchronous programming need
Practice: Concept-based interview questions
Day 32: Callbacks - Part 1 Callback function basics
Callback patterns
Error-first callbacks
Practice: Callback interview questions
Day 33: Callbacks - Part 2 Callback hell problem
Pyramid of doom
Solutions to callback hell
Practice: Callback hell refactoring questions
Day 34: Promises - Part 1 Promise basics and states (pending, fulfilled, rejected)
Creating promises
then(), catch(), finally()
Practice: Basic promise interview questions
Day 35: Promises - Part 2 Promise chaining
Error handling in promise chains
Returning values from then()
Practice: Promise chaining questions
Day 36: Promise Static Methods Promise.all()
Promise.race()
Promise.allSettled()
Promise.any()
Practice: Promise static method questions
Day 37: Async/Await - Part 1 async function basics
await keyword
Error handling with try-catch
Practice: Basic async/await questions
Day 38: Async/Await - Part 2 Sequential vs parallel execution
Top-level await
Async/await best practices
Practice: Advanced async/await questions
Day 39: Event Loop - Part 1 Call stack explained
Web APIs and browser environment
Task queue (callback queue)
Practice: Event loop concept questions
Day 40: Event Loop - Part 2 Microtask queue vs macrotask queue
Priority of execution
queueMicrotask()
Practice: Microtask vs macrotask questions
Day 41: Event Loop - Part 3 (Output Questions) Predicting output with setTimeout
Promise execution order
Mixed async code output
Practice: 20 event loop output questions
Day 42: Event Loop in Node.js Node.js event loop phases
process.nextTick()
setImmediate() vs setTimeout()
Practice: Node.js event loop questions
Day 43: setTimeout & setInterval Timer functions usage
Clearing timers
setTimeout(fn, 0) behavior
Practice: Timer interview questions
Day 44: Error Handling - Part 1 try-catch blocks
throw statement
Error object and types
Practice: Error handling questions
Day 45: Error Handling - Part 2 Custom error classes
Error propagation
Global error handlers
Practice: Advanced error handling questions
Day 46: Generators & Iterators Generator functions (function*)
yield keyword
Iterator protocol
Practice: Generator interview questions
Day 47: Map, Set, WeakMap, WeakSet Map vs Object
Set for unique values
WeakMap and WeakSet use cases
Practice: Map/Set interview questions
Day 48: Modules - Part 1 ES6 modules (import/export)
Named exports vs default exports
Import syntax variations
Practice: Module system questions
Day 49: Modules - Part 2 Dynamic imports
Module pattern
CommonJS vs ES6 modules
Practice: Advanced module questions
Day 50: Regular Expressions RegEx basics in JavaScript
test(), match(), replace()
Common regex patterns
Practice: RegEx interview questions
Day 51: Higher-Order Functions Functions as first-class citizens
Higher-order function concept
Returning functions from functions
Practice: HOF interview questions
Day 52: Currying Currying concept
Implementing curry function
Practical use cases
Practice: Currying interview questions
Day 53: Function Composition Composing functions
pipe() and compose()
Functional programming concepts
Practice: Function composition questions
Day 54: Memoization Caching function results
Implementing memoization
Performance optimization
Practice: Memoization interview questions
Day 55: Debouncing Debouncing concept
Implementing debounce function
Real-world use cases (search input)
Practice: Debouncing interview questions
Day 56: Throttling Throttling concept
Implementing throttle function
Debounce vs Throttle
Practice: Throttling interview questions
Day 57: Polyfills - Part 1 What are polyfills?
map() polyfill
filter() polyfill
Practice: Polyfill implementation questions
Day 58: Polyfills - Part 2 reduce() polyfill
bind() polyfill
Promise polyfill
Practice: Advanced polyfill questions
Day 59: Deep vs Shallow Copy Shallow copy methods
Deep copy techniques
structuredClone()
Practice: Copy-related interview questions
Day 60: Month 2 Review & Practice Review asynchronous concepts
Practice: Solve 50 interview questions on async JavaScript
Month 3: DOM, Events & Browser APIs (Days 61-90) Day 61: DOM Basics What is DOM?
DOM tree structure
Selecting elements (getElementById, querySelector)
Practice: DOM manipulation questions
Day 62: DOM Manipulation Creating and removing elements
Modifying attributes and styles
innerHTML vs textContent vs innerText
Practice: DOM manipulation interview questions
Day 63: Event Handling - Part 1 addEventListener vs onclick
Event object properties
preventDefault() and stopPropagation()
Practice: Event handling questions
Day 64: Event Handling - Part 2 Event bubbling
Event capturing
Event delegation
Practice: Event bubbling/capturing questions
Day 65: Event Loop & DOM Rendering Render queue
requestAnimationFrame()
Layout, paint, composite
Practice: Rendering-related questions
Day 66: Browser Storage localStorage vs sessionStorage
Cookies
IndexedDB basics
Practice: Storage interview questions
Day 67: Web APIs - Part 1 Fetch API
XMLHttpRequest
CORS basics
Practice: Fetch API questions
Day 68: Web APIs - Part 2 Geolocation API
Notification API
Clipboard API
Practice: Web API questions
Day 69: JSON Methods JSON.stringify()
JSON.parse()
Handling circular references
Practice: JSON interview questions
Day 70: Date & Time Date object methods
Date formatting
Timestamp manipulation
Practice: Date-related questions
Day 71: Window Object window.location
window.history
window.navigator
Practice: Window object questions
Day 72: Timers Deep Dive setTimeout accuracy
Timer minimum delay
Canceling timers
Practice: Advanced timer questions
Day 73: Intersection Observer Lazy loading implementation
Infinite scroll
Visibility detection
Practice: Observer API questions
Day 74: Mutation Observer Watching DOM changes
Use cases
Performance considerations
Practice: Mutation Observer questions
Day 75: Performance APIs Performance.now()
Performance Observer
Navigation Timing API
Practice: Performance measurement questions
Day 76: Service Workers Service worker lifecycle
Caching strategies
Offline functionality
Practice: Service worker questions
Day 77: Web Workers Running scripts in background
postMessage() communication
Use cases
Practice: Web Worker questions
Day 78: WebSockets Real-time communication
WebSocket API
Socket.io basics
Practice: WebSocket questions
Day 79: History API pushState() and replaceState()
popstate event
SPA routing
Practice: History API questions
Day 80: URL & URLSearchParams URL parsing
Query string manipulation
URLSearchParams methods
Practice: URL handling questions
Day 81: FormData API Form submission
File uploads
FormData methods
Practice: FormData questions
Day 82: Canvas API Basics Drawing shapes
Canvas context
Basic animations
Practice: Canvas questions
Day 83: Drag and Drop API Draggable elements
Drop zones
dataTransfer object
Practice: Drag & drop questions
Day 84: Clipboard API Reading clipboard
Writing to clipboard
Permissions
Practice: Clipboard questions
Day 85: Media Queries in JavaScript matchMedia()
Responsive JavaScript
Breakpoint detection
Practice: Media query questions
Day 86: Custom Events Creating custom events
dispatchEvent()
Event-driven architecture
Practice: Custom event questions
Day 87: Shadow DOM Web Components
Encapsulation
Shadow DOM API
Practice: Shadow DOM questions
Day 88: Memory Management Garbage collection
Memory leaks
WeakMap/WeakSet for memory
Practice: Memory management questions
Day 89: Security Best Practices XSS prevention
CSRF protection
Content Security Policy
Practice: Security interview questions
Day 90: Month 3 Review & Practice Review DOM and Browser APIs
Practice: Solve 50 interview questions on DOM/Browser APIs
Month 4: ES6+ Features & Modern JavaScript (Days 91-120) Day 91: let & const Deep Dive TDZ in detail
Block scoping edge cases
const with objects/arrays
Practice: Tricky let/const questions
Day 92: Template Literals Advanced Tagged templates
Multiline strings
Expression interpolation
Practice: Template literal questions
Day 93: Object Property Shorthand Shorthand properties
Method definitions
Getters and setters
Practice: Object shorthand questions
Day 94: Computed Property Names Dynamic property names
Symbols as keys
Use cases
Practice: Computed property questions
Day 95: Destructuring Advanced Default values in destructuring
Renaming variables
Nested destructuring tricks
Practice: Advanced destructuring questions
Day 96: Array Methods - flat & flatMap Flattening nested arrays
flatMap use cases
Performance considerations
Practice: flat/flatMap questions
Day 97: Optional Chaining (?.) Safe property access
Optional chaining with functions
Nullish vs undefined
Practice: Optional chaining questions
Day 98: Nullish Coalescing (??) ?? vs ||
Default values
Combining with optional chaining
Practice: Nullish coalescing questions
Day 99: Logical Assignment Operators ||=, &&=, ??=
Short-circuit assignment
Use cases
Practice: Logical assignment questions
Day 100: Numeric Separators Readability improvement
BigInt with separators
Practice: Modern syntax questions
Day 101: Private Class Fields prefix for private fields Private methods
Encapsulation
Practice: Private field questions
Day 102: Static Class Features Static properties
Static blocks
Static private fields
Practice: Static feature questions
Day 103: Class Field Declarations Public class fields
Field initialization
Arrow functions as methods
Practice: Class field questions
Day 104: Proxy Object Proxy traps
get, set, has handlers
Validation and logging
Practice: Proxy interview questions
Day 105: Reflect API Reflect methods
Reflect vs Object methods
Meta-programming
Practice: Reflect questions
Day 106: Object.defineProperty() Property descriptors
Configurable, enumerable, writable
Getters and setters
Practice: Property descriptor questions
Day 107: Object Methods Advanced Object.getOwnPropertyDescriptor()
Object.preventExtensions()
Object.isExtensible()
Practice: Advanced object method questions
Day 108: Array.from() Advanced Map function parameter
Creating ranges
Converting iterables
Practice: Array.from() questions
Day 109: Array.of() Creating arrays
vs Array constructor
Use cases
Practice: Array.of() questions
Day 110: String Methods Advanced padStart(), padEnd()
trimStart(), trimEnd()
replaceAll()
Practice: Advanced string questions
Day 111: String.matchAll() Global regex matches
Iterator return
vs match() with /g
Practice: matchAll questions
Day 112: Promise.prototype.finally() finally() behavior
vs then/catch
Cleanup operations
Practice: finally() questions
Day 113: for...of Loop Iterating iterables
vs for...in
Breaking and continuing
Practice: for...of questions
Day 114: for...in Loop Object iteration
Prototype chain iteration
hasOwnProperty check
Practice: for...in questions
Day 115: Iteration Protocols Iterable protocol
Iterator protocol
Custom iterators
Practice: Iterator questions
Day 116: Async Iterators for await...of
Async generators
Streaming data
Practice: Async iterator questions
Day 117: Top-Level Await Module-level await
Use cases
Browser support
Practice: Top-level await questions
Day 118: Dynamic Import() Code splitting
Lazy loading
Conditional imports
Practice: Dynamic import questions
Day 119: import.meta Module metadata
import.meta.url
Use cases
Practice: import.meta questions
Day 120: Month 4 Review & Practice Review ES6+ features
Practice: Solve 50 modern JavaScript interview questions
Month 5: Design Patterns & Advanced Concepts (Days 121-150) Day 121: Module Pattern IIFE-based modules
Private/public members
Revealing module pattern
Practice: Module pattern questions
Day 122: Singleton Pattern Single instance
Implementation in JavaScript
Use cases
Practice: Singleton questions
Day 123: Factory Pattern Object creation
Factory functions
Abstract factory
Practice: Factory pattern questions
Day 124: Observer Pattern Publish-subscribe
Event emitters
Implementation
Practice: Observer pattern questions
Day 125: Decorator Pattern Adding functionality
Function decorators
Class decorators (proposal)
Practice: Decorator questions
Day 126: Strategy Pattern Algorithm selection
Context and strategies
Use cases
Practice: Strategy pattern questions
Day 127: Command Pattern Encapsulating requests
Undo/redo functionality
Implementation
Practice: Command pattern questions
Day 128: Prototype Pattern Cloning objects
Object.create()
Prototypal inheritance
Practice: Prototype pattern questions
Day 129: Builder Pattern Complex object creation
Method chaining
Fluent interfaces
Practice: Builder pattern questions
Day 130: Facade Pattern Simplifying interfaces
Abstraction layer
Use cases
Practice: Facade pattern questions
Day 131: Proxy Pattern (Design) Controlled access
Virtual proxy
Protection proxy
Practice: Proxy pattern questions
Day 132: Chain of Responsibility Request handling chain
Middleware pattern
Implementation
Practice: Chain of responsibility questions
Day 133: Recursion Recursive functions
Base case and recursive case
Tail call optimization
Practice: Recursion interview questions
Day 134: Call Stack Deep Dive Stack overflow
Maximum call stack size
Recursive limits
Practice: Call stack questions
Day 135: Execution Context Global execution context
Function execution context
Creation and execution phase
Practice: Execution context questions
Day 136: Variable Environment Environment record
Outer environment reference
Scope resolution
Practice: Environment questions
Day 137: Lexical Environment Lexical scoping
Environment nesting
Closure creation
Practice: Lexical environment questions
Day 138: Context vs Scope Differences explained
this vs scope
Common confusions
Practice: Context/scope questions
Day 139: Strict Mode Deep Dive "use strict" behavior
Restrictions and errors
Benefits of strict mode
Practice: Strict mode questions
Day 140: Coercion Edge Cases Type coercion rules
ToNumber, ToString, ToBoolean
Tricky coercion examples
Practice: 20 coercion output questions
Day 141: NaN & Infinity NaN behavior and checking
isNaN vs Number.isNaN
Infinity and -Infinity
Practice: NaN/Infinity questions
Day 142: valueOf() & toString() Object to primitive conversion
Custom valueOf/toString
Type coercion behavior
Practice: valueOf/toString questions
Day 143: Object.is() vs === SameValue algorithm
-0 and +0 comparison
NaN comparison
Practice: Comparison questions
Day 144: Property Enumeration for...in vs Object.keys()
Enumerable properties
Symbol properties
Practice: Enumeration questions
Day 145: Getters & Setters Accessor properties
Computed properties
Validation in setters
Practice: Getter/setter questions
Day 146: Object Immutability Object.freeze() deep dive
Object.seal()
Shallow vs deep freeze
Practice: Immutability questions
Day 147: Function Properties name, length properties
Function.prototype
arguments object
Practice: Function property questions
Day 148: Rest Parameters Deep Dive Rest vs arguments
Combining with other parameters
Destructuring with rest
Practice: Rest parameter questions
Day 149: Spread in Function Calls Function argument spreading
Array concatenation
Object merging
Practice: Spread operator questions
Day 150: Month 5 Review & Practice Review patterns and advanced concepts
Practice: Solve 50 advanced interview questions
Month 6: Tricky Questions & Interview Mastery (Days 151-180) Day 151-155: Output-Based Questions (25 per day) Mixed async/sync output prediction
Closure with loops and timers
this binding in different contexts
Hoisting tricky scenarios
Event loop execution order
Practice: 125 output-based questions total
Day 156-160: Code Writing Questions (10 per day) Implement polyfills (map, filter, reduce, bind, call, apply)
Debounce and throttle from scratch
Deep clone implementation
Flatten array/object
Custom Promise implementation
Practice: 50 coding questions total
Day 161-165: Debugging Questions (10 per day) Finding bugs in code snippets
Fixing memory leaks
Correcting async errors
Scope-related bugs
Performance issues
Practice: 50 debugging questions
Day 166: Tricky Interview Scenarios - Part 1 [] + [] = ?
[] + {} = ?
{} + [] = ?
typeof null = ?
Practice: 20 JavaScript quirks
Day 167: Tricky Interview Scenarios - Part 2 0.1 + 0.2 === 0.3 (false)
Floating point precision
Math.max() vs Math.min() with no args
Practice: 20 more quirks
Day 168: Tricky Interview Scenarios - Part 3 var hoisting edge cases
Function vs variable hoisting priority
TDZ scenarios
Practice: 20 hoisting quirks
Day 169: Tricky Interview Scenarios - Part 4 setTimeout in for loop (classic)
Closure variable capture
IIFE solutions
Practice: 20 closure quirks
Day 170: Tricky Interview Scenarios - Part 5 this in arrow vs regular functions
this in nested functions
Losing this context
Practice: 20 this binding quirks
Day 171: Performance Optimization Questions Time complexity analysis
Space complexity
Optimization techniques
Practice: 15 optimization questions
Day 172: Algorithm Implementation Two pointer technique
Sliding window
Hash map usage
Practice: 10 algorithm questions
Day 173: Data Structure Questions Implementing stack, queue
Linked list operations
Tree traversal
Practice: 10 DS questions
Day 174: System Design in JavaScript Designing autocomplete
Implementing cache with LRU
Rate limiter design
Practice: 5 system design questions
Day 175: Real-World Scenarios - Part 1 Form validation
Infinite scroll
Search with debounce
Practice: 10 practical questions
Day 176: Real-World Scenarios - Part 2 Image lazy loading
Virtual scrolling
Pagination
Practice: 10 more practical questions
Day 177: Behavioral + Technical Mix Explaining technical decisions
Trade-offs discussion
Best practices explanation
Practice: 10 conceptual questions
Day 178: Mock Interview Day 1 Complete 2-hour mock interview
45 mins coding questions
30 mins output questions
45 mins conceptual questions
Practice: Full mock interview
Day 179: Mock Interview Day 2 Another 2-hour mock interview
Different set of questions
Focus on weak areas
Practice: Second mock interview
Day 180: Final Review & Confidence Building Review all saved questions
Quick revision of key concepts
Common pitfalls checklist
Interview strategies
Practice: Final 100-question rapid-fire practice