MERN Advanced Developer Roadmap for senior-level packages

Must-learn (interviews ask this)
High value
Good to know
new Trending / differentiator
Phase 1 · 0–3 months Core Foundations

Fill gaps that every senior dev is expected to know. These come up in every interview.

Data Structures & Algorithms
must Arrays & Strings
Sliding window, two pointers, prefix sums. Foundation of 40% of LC problems.
  • Two pointer technique
  • Sliding window
  • Kadane's algorithm
  • Subarray problems
must HashMaps & Sets
Most-asked in FAANG/product companies. O(1) lookup patterns, frequency maps, grouping.
  • Anagram problems
  • Two sum variations
  • Group by key patterns
must Stacks & Queues
Monotonic stacks, BFS queues. Used in real code too (undo systems, job queues).
  • Valid parentheses
  • Next greater element
  • BFS traversal
must Trees & Graphs
DFS, BFS, binary trees. Graph problems dominate senior-level rounds.
  • Binary tree traversals
  • BST operations
  • Graph DFS/BFS
  • Cycle detection
must Recursion & Backtracking
Permutations, combinations, N-queens. Builds intuition for DP.
  • Subsets & combinations
  • Word search
  • N-queens pattern
high Dynamic Programming
Start with 1D DP (Fibonacci, climbing stairs), then 2D (grids, strings). Top 10 patterns cover 80%.
  • 0/1 Knapsack
  • Longest common subsequence
  • Coin change
  • House robber
high Linked Lists
Reverse, detect cycle, merge sorted lists. Classic pointer manipulation.
  • Fast & slow pointers
  • Reverse in groups
  • LRU Cache (combines LL + HashMap)
good Heaps & Priority Queues
Top-K problems, median finding, scheduling. Min/max heap operations.
  • K largest elements
  • Merge K sorted lists
  • Task scheduler
good Sorting & Searching
Binary search variations (rotated arrays, answer-space BS). Know merge sort internals.
  • Binary search variants
  • Search in rotated array
  • Merge sort (stable)
good Tries
Autocomplete, prefix matching. Very common in product company rounds.
  • Insert & search
  • Autocomplete system
  • Word dictionary
Database — SQL & MongoDB
must SQL Indexing
B-tree index internals, composite indexes, covering indexes. Know when NOT to index.
  • B-tree vs hash index
  • Composite index order matters
  • Explain / query plan
  • Index on JOIN columns
must SQL Joins & Aggregations
Inner/outer/left/right joins, GROUP BY, HAVING, window functions (ROW_NUMBER, RANK).
  • Window functions
  • CTEs (WITH clause)
  • Subqueries vs joins
must Transactions & ACID
Atomicity, isolation levels (read committed, repeatable read), deadlock prevention.
  • BEGIN / COMMIT / ROLLBACK
  • Dirty reads, phantom reads
  • Optimistic vs pessimistic locking
must MongoDB Aggregation
$match, $group, $lookup, $project, $unwind pipelines. The most-asked MongoDB topic.
  • $lookup (join equivalent)
  • $facet for multi-result
  • $bucket for ranges
  • Aggregation indexes
high MongoDB Indexing
Single field, compound, text, geospatial, TTL indexes. Explain() output reading.
  • Compound index strategies
  • Text search index
  • TTL for auto-expiry
high Schema Design Patterns
Embedding vs referencing, bucket pattern, polymorphic schema. Anti-patterns to avoid.
  • One-to-many embedding
  • Bucket pattern for time-series
  • Polymorphic pattern
good Database Normalization
1NF to 3NF, BCNF. When to denormalize for performance. SQL interview classic.
  • 1NF, 2NF, 3NF explained
  • Functional dependencies
  • When to denormalize
good Query Optimization
Reading EXPLAIN plans, N+1 problem, batching queries, connection pooling.
  • N+1 problem & solutions
  • Batch vs individual queries
  • Connection pool config
Phase 2 · 3–6 months Advanced Backend

These topics appear in every senior backend interview and are asked at companies like Razorpay, Swiggy, and Adobe.

Caching & Redis
must Redis Core
Strings, hashes, lists, sets, sorted sets. Persistence (RDB vs AOF). Redis as a primary DB vs cache.
  • 5 core data structures
  • EXPIRE & TTL management
  • Pub/Sub basic
  • RDB vs AOF persistence
must Caching Strategies
Cache-aside, write-through, write-behind, read-through. Cache invalidation is the hard part.
  • Cache-aside (lazy loading)
  • Write-through vs write-behind
  • Cache invalidation strategies
  • Stale-while-revalidate
must Rate Limiting
Token bucket, sliding window counter, fixed window using Redis. Must for any API product.
  • Token bucket algorithm
  • Sliding window with sorted sets
  • Leaky bucket
high Redis Pub/Sub & Streams
Pub/Sub for real-time events. Redis Streams for durable message queues (Kafka-lite).
  • Pub/Sub channels
  • XADD, XREAD, consumer groups
  • Stream vs Pub/Sub tradeoffs
high Distributed Locks
Redlock algorithm for distributed mutual exclusion. Prevents race conditions in scaled apps.
  • SETNX pattern
  • Redlock across nodes
  • Lock expiry & renewal
good CDN Caching
Cache-Control headers, ETag, stale-while-revalidate at CDN level. Edge caching strategy.
  • Cache-Control directives
  • ETag & conditional GETs
  • CloudFront / Cloudflare basics
Real-Time Communication
must WebSockets
Full-duplex over TCP. Handshake, rooms/namespaces (Socket.IO), scaling with Redis adapter.
  • WS handshake protocol
  • Socket.IO rooms & namespaces
  • Reconnection logic
  • Scaling with Redis adapter
must Server-Sent Events
Unidirectional server→client stream. Perfect for notifications, live feeds. Simpler than WS.
  • EventSource API
  • Reconnect with Last-Event-ID
  • SSE vs WebSocket tradeoffs
high Webhooks
Event-driven HTTP callbacks. Signature verification (HMAC), retry logic, idempotency.
  • HMAC-SHA256 verification
  • Retry with exponential backoff
  • Idempotency keys
  • Webhook queuing
high Long Polling
Fallback for real-time when WS unavailable. How Comet/BOSH works. HTTP/2 server push.
  • Long poll vs short poll
  • Timeout & reconnect
  • HTTP/2 push (replaced by SSE)
good WebRTC
P2P audio/video/data. STUN/TURN servers, ICE negotiation, SDP. Used in video apps.
  • Signaling server (via WS)
  • STUN/TURN/ICE
  • RTCPeerConnection API
  • Data channels
Message Queues & Async Processing
must Message Queue Concepts
Producer/consumer, dead letter queues, acknowledgments, at-least-once vs exactly-once delivery.
  • DLQ patterns
  • At-least-once delivery
  • Consumer groups
  • Back-pressure
must BullMQ / BullJS
Node-native job queues backed by Redis. Cron jobs, retries, priorities, concurrency control.
  • Job priorities & delays
  • Repeatable (cron) jobs
  • Job events & progress
  • Worker concurrency
high RabbitMQ
Exchange types (direct, topic, fanout), bindings, prefetch count, pub/sub at scale.
  • Exchange types
  • Routing keys & bindings
  • Prefetch & QoS
  • Dead letter exchange
high Apache Kafka
Partitions, consumer groups, offsets, retention. Essential for high-throughput event streaming.
  • Topics, partitions, replicas
  • Consumer group offsets
  • Kafka vs RabbitMQ
  • Exactly-once semantics
high Sync vs Async Patterns
When to use async processing, event-driven vs request-response, saga pattern, outbox pattern.
  • Event-driven architecture
  • Saga pattern (distributed txns)
  • Outbox pattern
  • Choreography vs orchestration
good gRPC
Protocol Buffers, streaming RPCs, code generation. Used heavily in microservice-to-service comm.
  • Protobuf schema design
  • Unary vs streaming RPC
  • gRPC vs REST vs GraphQL
  • Server reflection
Authentication & Security
must JWT Deep Dive
Access + refresh token rotation, RS256 vs HS256, token blacklisting strategies.
  • RS256 asymmetric signing
  • Refresh token rotation
  • Token blacklist via Redis
  • JWK endpoint
must OAuth 2.0 & OIDC
Authorization code flow with PKCE, client credentials flow, token introspection.
  • Authorization code + PKCE
  • Client credentials flow
  • Scopes & claims
  • OpenID Connect ID token
must OWASP Top 10
SQL injection, XSS, CSRF, broken access control, insecure deserialization. With Node.js examples.
  • Injection prevention
  • XSS via CSP headers
  • CSRF tokens
  • Rate limiting & brute force
high RBAC & ABAC
Role-based and attribute-based access control. Policy design, permission inheritance.
  • Role hierarchy
  • Permission middleware pattern
  • Casbin / OPA basics
Phase 3 · 6–9 months Advanced Frontend & DevOps

What separates a ₹12 LPA dev from a ₹25 LPA dev on the frontend side and infrastructure.

Advanced React & Frontend
must React Performance
useMemo, useCallback, React.memo, virtualization. Profiler usage. Avoiding unnecessary re-renders.
  • React Profiler DevTools
  • Virtual list (react-window)
  • Lazy loading & Suspense
  • Code splitting routes
must State Management
Zustand, Redux Toolkit, Jotai. Know when to use each. Context vs external store tradeoffs.
  • Redux Toolkit (RTK Query)
  • Zustand for local state
  • React Query for server state
  • Context performance pitfalls
must SSR / SSG / ISR
Next.js rendering strategies. When to use each. App Router vs Pages Router. Streaming SSR.
  • getServerSideProps vs ISR
  • App Router server components
  • Streaming with Suspense
  • Edge runtime
high Web Vitals & Core Web Vitals
LCP, FID/INP, CLS. How to measure and improve each. Lighthouse CI in pipelines.
  • Largest Contentful Paint
  • Interaction to Next Paint
  • Cumulative Layout Shift
  • Lighthouse CI setup
high Frontend Security
CSP headers, Trusted Types, CORS deep dive, SameSite cookies, subresource integrity.
  • Content Security Policy
  • Trusted Types API
  • CORS preflight & credentials
  • SameSite cookie attribute
high Frontend Caching
Service workers, Cache API, stale-while-revalidate, React Query caching strategies.
  • Service worker lifecycle
  • Cache API strategies
  • IndexedDB for offline
  • React Query cache config
good Micro-Frontends
Module Federation (Webpack 5), single-spa, routing strategies. Used in large orgs.
  • Webpack Module Federation
  • Shared dependencies
  • Single-SPA framework
good Accessibility (a11y)
ARIA roles, keyboard navigation, screen reader testing. Required at enterprise companies.
  • ARIA landmark roles
  • Focus management
  • axe-core testing
  • WCAG 2.1 AA basics
Docker & CI/CD
must Docker Fundamentals
Dockerfile best practices, multi-stage builds, layer caching, slim images. Non-root user.
  • Multi-stage builds
  • Layer caching order
  • Alpine vs distroless
  • .dockerignore
must Docker Compose
Multi-service local dev, health checks, volume mounts, environment config, networks.
  • Service dependencies
  • Health check config
  • Named volumes
  • Environment files
must CI/CD Pipelines
GitHub Actions: lint → test → build → deploy. Branch strategies, env secrets, matrix builds.
  • GitHub Actions workflows
  • Caching in CI
  • Environment secrets
  • Deploy to staging/prod
high Kubernetes Basics
Pods, deployments, services, ingress, configmaps, secrets. Horizontal pod autoscaling.
  • Pod vs Deployment
  • Services (ClusterIP, NodePort)
  • Ingress controller
  • HPA with CPU metrics
high Observability
The 3 pillars: logs, metrics, traces. OpenTelemetry, Prometheus + Grafana, structured logging.
  • Structured logging (pino/winston)
  • Prometheus metrics
  • Distributed tracing (Jaeger)
  • OpenTelemetry SDK
good Nginx & Reverse Proxy
Load balancing, rate limiting, SSL termination, gzip, caching static assets.
  • Upstream load balancing
  • SSL/TLS termination
  • Gzip compression
  • Location blocks
Phase 4 · 9–12 months System Design & Architecture

The round that decides ₹25 LPA+. Learn to design systems you've never built, at scale you've never seen.

System Design Topics
must Microservices
Service decomposition, API gateway, service mesh, inter-service communication patterns.
  • Domain-driven decomposition
  • API gateway (Kong/NGINX)
  • Service discovery (Consul)
  • Circuit breaker (Hystrix)
must Scalability Patterns
Horizontal vs vertical scaling, sharding, replication, CQRS, event sourcing.
  • DB read replicas
  • Horizontal sharding strategies
  • CQRS pattern
  • Event sourcing
must Classic SD Problems
URL shortener, chat app, notification system, ride-sharing, search autocomplete, newsfeed.
  • URL shortener (hashing, redirect)
  • Chat (WS + message store)
  • Notification service
  • News feed (push vs pull)
must CAP Theorem
Consistency, availability, partition tolerance tradeoffs. BASE vs ACID. Eventual consistency.
  • CP vs AP systems
  • Eventual consistency
  • Vector clocks basics
  • Consensus algorithms (Raft)
high Load Balancing
Round robin, weighted, least connections, consistent hashing. Layer 4 vs Layer 7 LB.
  • Consistent hashing
  • Sticky sessions
  • Health checks
  • Global vs regional LB
high API Design
RESTful best practices, versioning, pagination (cursor vs offset), GraphQL, API contracts.
  • Cursor-based pagination
  • API versioning strategies
  • OpenAPI / Swagger specs
  • Breaking vs non-breaking changes
high Resilience Patterns
Circuit breaker, retry with backoff, bulkhead, timeout, fallback. Node.js implementations.
  • Circuit breaker states
  • Exponential backoff + jitter
  • Bulkhead isolation
  • Opossum (Node CB library)
good Distributed Tracing
Trace context propagation, W3C TraceContext, Jaeger, Zipkin. Correlating logs across services.
  • Trace & span model
  • Context propagation headers
  • Sampling strategies
Node.js Internals (asked at senior level)
must Event Loop Deep Dive
Phases (timers, I/O, poll, check, close), microtask queue, nextTick vs Promise, libuv.
  • 6 event loop phases
  • Microtask priority
  • process.nextTick vs setImmediate
  • Blocking the loop (bad patterns)
must Streams
Readable, Writable, Duplex, Transform streams. Backpressure. Piping. Used in file processing.
  • Stream modes (flowing vs paused)
  • Backpressure handling
  • Transform stream pattern
  • pipeline() vs pipe()
high Worker Threads & Cluster
CPU-bound work in worker threads, cluster module for multi-core, shared memory (SharedArrayBuffer).
  • Worker threads for CPU work
  • Cluster for multi-core
  • SharedArrayBuffer + Atomics
  • IPC message passing
high Memory Management
V8 heap, garbage collection, memory leaks (closures, event listeners, global refs), heap profiling.
  • V8 generational GC
  • Common leak patterns
  • --inspect + Chrome DevTools
  • Heap snapshots
₹25 LPA strategy: Companies like Adobe, Razorpay, Atlassian test DSA (2 rounds) + system design (1 round) + depth in 2–3 backend areas. Pick Redis + Kafka + microservices as your depth stack. Solve 150 LC problems (focus on medium). Read "Designing Data-Intensive Applications" — it covers 70% of system design questions.