MERN Stack Quiz (Advanced) - All Questions

This advanced MERN Stack quiz is designed for experienced full-stack developers and senior interview preparation. It covers real-world scenarios, performance optimization, security, scalability, and deep internals of MongoDB, Express, React, and Node.js.

Question 1: Why is indexing critical for MongoDB performance at scale?

It reduces document size
It avoids schema validation
It speeds up query execution
It enables sharding automatically

Explanation: Indexes significantly reduce query scan time.

Question 2: What is the main drawback of using $where in MongoDB?

Limited functionality
Poor performance
No indexing support
Syntax complexity

Explanation: $where executes JavaScript and is slow.

Question 3: Which MongoDB feature enables horizontal scaling?

Replica sets
Indexes
Sharding
Aggregation

Explanation: Sharding distributes data across multiple servers.

Question 4: What is the purpose of a replica set in MongoDB?

Faster queries
High availability and fault tolerance
Schema validation
Data compression

Explanation: Replica sets provide redundancy and failover.

Question 5: Why should passwords never be stored as plain text?

They increase DB size
They slow queries
They are insecure if leaked
They break authentication

Explanation: Plain text passwords are a major security risk.

Question 6: Which JWT vulnerability occurs if secret keys are exposed?

Token replay
Token forgery
CSRF
XSS

Explanation: Exposed secrets allow attackers to forge tokens.

Question 7: Why is HttpOnly cookie preferred for JWT storage?

Improves speed
Prevents XSS access
Enables CORS
Reduces payload size

Explanation: HttpOnly cookies block JavaScript access.

Question 8: Which attack is mainly prevented by CSRF tokens?

XSS
SQL Injection
CSRF
DDoS

Explanation: CSRF tokens protect against cross-site request forgery.

Question 9: Why is server-side pagination recommended for large datasets?

Better UI
Reduced memory usage
Faster rendering
Lower network and DB load

Explanation: Server-side pagination limits data transfer.

Question 10: Which MongoDB stage is most expensive in aggregation?

$match
$project
$group
$limit

Explanation: $group performs heavy computation.

Question 11: Why should React keys be stable and unique?

For styling
For correct reconciliation
For routing
For state initialization

Explanation: Keys help React optimize DOM updates.

Question 12: What problem does React.memo primarily solve?

State sharing
Avoiding unnecessary re-renders
Side effects
DOM access

Explanation: React.memo prevents re-rendering unchanged components.

Question 13: Which scenario causes infinite re-render in React?

useState in component
setState inside render
useEffect with empty dependency
useMemo usage

Explanation: State updates during render cause infinite loops.

Question 14: Why is lifting state up sometimes harmful?

Breaks hooks
Increases prop drilling
Reduces reusability
Causes memory leaks

Explanation: Excessive lifting increases prop drilling.

Question 15: Which React pattern helps avoid prop drilling at scale?

HOCs
Context API
Refs
Fragments

Explanation: Context shares state globally.

Question 16: What is the main risk of using useEffect without dependency array?

No execution
Memory leaks
Repeated execution
Broken UI

Explanation: It runs on every render.

Question 17: Why is blocking code dangerous in Node.js?

Consumes RAM
Blocks event loop
Crashes server
Breaks promises

Explanation: Blocking code halts the event loop.

Question 18: Which Node.js feature enables handling thousands of requests?

Multithreading
Worker threads
Event-driven non-blocking I/O
Child processes

Explanation: Non-blocking I/O allows high concurrency.

Question 19: What is the main purpose of clustering in Node.js?

Logging
Scaling across CPU cores
Database optimization
Security

Explanation: Clustering uses multiple CPU cores.

Question 20: Why should heavy CPU tasks be avoided in Node.js?

Memory usage
Event loop blocking
Network latency
Security risks

Explanation: CPU-heavy tasks block the event loop.

Question 21: Which Express practice improves security?

Disabling CORS
Using helmet
Using GET everywhere
Storing secrets in code

Explanation: Helmet adds secure HTTP headers.

Question 22: Why should environment variables not be committed to Git?

They slow builds
They break CI
They expose secrets
They increase bundle size

Explanation: Secrets must remain private.

Question 23: Which HTTP status code should be returned for validation errors?

Explanation: 422 represents unprocessable entity.

Question 24: What is the biggest drawback of monolithic MERN applications?

Hard UI design
Scalability limitations
Slow MongoDB
React complexity

Explanation: Monoliths scale poorly at large size.

Question 25: Why are microservices sometimes preferred over monoliths?

Less code
Independent scaling and deployment
Simpler debugging
Lower latency

Explanation: Microservices allow independent scaling.

Question 26: Which caching layer is commonly used with MERN?

Redis
Memcached
LocalStorage
SessionStorage

Explanation: Redis is widely used for caching.

Question 27: What problem does rate limiting solve?

Slow queries
XSS attacks
Brute-force and abuse
Memory leaks

Explanation: Rate limiting prevents abuse.

Question 28: Why is input validation mandatory in MERN APIs?

Better UI
Prevent malformed and malicious input
Faster responses
Schema enforcement

Explanation: Validation prevents attacks and crashes.

Question 29: Which MongoDB design avoids data duplication issues?

Over-embedding
Normalization with references
Random schemas
Flat collections

Explanation: References reduce duplication.

Question 30: What is the main cost of over-normalization in MongoDB?

Slow writes
Multiple queries and joins
Large documents
Index limits

Explanation: Over-normalization increases query complexity.

Question 31: Which React optimization helps large lists?

useMemo
Virtualization
Context API
Fragments

Explanation: Virtualization renders only visible items.

Question 32: Why should error boundaries be used in React?

Prevent server crashes
Handle async errors
Catch UI rendering errors
Improve performance

Explanation: Error boundaries catch rendering errors.

Question 33: Which React feature isolates side effects?

useEffect
useReducer
useContext
useRef

Explanation: useEffect manages side effects.

Question 34: Why is async/await preferred over callbacks?

Faster execution
Cleaner and readable code
Lower memory usage
Automatic retries

Explanation: Async/await improves readability.

Question 35: Which Node.js risk arises from unhandled promise rejections?

Memory leaks
Silent crashes
Slow responses
DB corruption

Explanation: Unhandled rejections can crash apps.

Question 36: Why should API responses be consistent?

Better caching
Easier frontend integration
Smaller payloads
Improved SEO

Explanation: Consistency simplifies frontend handling.

Question 37: Which logging practice is recommended in production?

console.log only
Structured logging
No logging
Client-side logs

Explanation: Structured logs improve observability.

Question 38: Which React pattern improves separation of concerns?

Smart/Dumb components
Inline hooks
Single component apps
Global state everywhere

Explanation: Smart/Dumb components improve structure.

Question 39: Why is schema validation important even in NoSQL?

Enforces UI rules
Prevents inconsistent data
Improves indexing
Speeds writes

Explanation: Validation maintains data integrity.

Question 40: Which Express feature handles centralized error handling?

try/catch
Error middleware
Promise chaining
Routes

Explanation: Error middleware centralizes errors.

Question 41: Which React hook is dangerous if misused with dependencies?

useEffect
useMemo
useCallback
useContext

Explanation: Wrong dependencies cause bugs.

Question 42: Why should API versioning be implemented?

SEO
Backward compatibility
Faster APIs
Smaller payloads

Explanation: Versioning avoids breaking clients.

Question 43: Which deployment issue commonly affects MERN apps?

JSX errors
CORS misconfiguration
Missing HTML
Broken CSS

Explanation: CORS issues are common in deployments.

Question 44: Why is monitoring essential in production MERN apps?

UI improvement
Detect failures early
Reduce code size
Improve routing

Explanation: Monitoring detects issues proactively.

Question 45: Which MERN practice improves scalability the most?

Monolith design
Stateless APIs
Client-side state only
Large payloads

Explanation: Stateless APIs scale easily.

Back to programming Quizzes

MERN Stack Quiz (Advanced)

Questions

Minutes

Min Limit