Infosys Senior MERN Developer Interview Prep

Key Concepts:

• Automatic Batching: React 18 batches multiple state updates into a single re-render even inside Promises, setTimeout, or native event handlers.
• `useTransition` & `useDeferredValue`: Allows marking state updates as non-urgent transitions so the UI remains responsive during expensive renders.
• Custom Hook Best Practices: Keep side-effects isolated, return standard tuples or objects, and cleanly cancel asynchronous operations using `AbortController`.

import { useState, useEffect } from 'react';

export function useDebouncedFetch(url, delay = 300) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  useEffect(() => {
    if (!url) return;
    const controller = new AbortController();
    const handler = setTimeout(async () => {
      setLoading(true);
      try {
        const res = await fetch(url, { signal: controller.signal });
        if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
        const result = await res.json();
        setData(result);
        setError(null);
      } catch (err) {
        if (err.name !== 'AbortError') {
          setError(err.message);
        }
      } finally {
        setLoading(false);
      }
    }, delay);

    return () => {
      clearTimeout(handler);
      controller.abort(); // Cancel pending network request on unmount/re-render
    };
  }, [url, delay]);

  return { data, loading, error };
}

Node.js operates on a single-threaded event loop backed by Libuv's thread pool (default size: 4). Understanding memory management and avoiding event loop blocking is critical for high-throughput microservices.

Handling Large Data Datasets with Streams & Backpressure:

const { Transform, pipeline } = require('stream');
const fs = require('fs');

// High-performance log transform stream avoiding memory spikes
const logTransformer = new Transform({
  transform(chunk, encoding, callback) {
    const lines = chunk.toString().split('\n');
    const filtered = lines.filter(line => line.includes('ERROR'));
    this.push(filtered.join('\n') + '\n');
    callback();
  }
});

pipeline(
  fs.createReadStream('./production-large.log'),
  logTransformer,
  fs.createWriteStream('./error-audit.log'),
  (err) => {
    if (err) console.error('Pipeline failed:', err);
    else console.log('Log processing complete cleanly.');
  }
);

For Infosys applications processing millions of records, unindexed queries cause COLLSCAN (collection scans) which degrade performance. Use explain("executionStats") to verify index hits.

// Efficient single-pass query retrieving data + total count
db.orders.aggregate([
  { $match: { status: "DELIVERED", createdAt: { $gte: new Date('2026-01-01') } } },
  {
    $facet: {
      metadata: [{ $count: "totalRecords" }],
      data: [
        { $sort: { createdAt: -1 } },
        { $skip: 20 },
        { $limit: 10 },
        { $project: { _id: 1, customerId: 1, totalAmount: 1, createdAt: 1 } }
      ]
    }
  }
]);

Task: Create a custom Express middleware to prevent API abuse by limiting each IP address to N requests per window without external dependencies.

function createRateLimiter({ windowMs = 60000, maxRequests = 100 }) {
  const ipStore = new Map();

  return (req, res, next) => {
    const clientIP = req.ip || req.connection.remoteAddress;
    const now = Date.now();

    if (!ipStore.has(clientIP)) {
      ipStore.set(clientIP, { count: 1, resetTime: now + windowMs });
      return next();
    }

    const record = ipStore.get(clientIP);

    if (now > record.resetTime) {
      record.count = 1;
      record.resetTime = now + windowMs;
      return next();
    }

    if (record.count >= maxRequests) {
      return res.status(429).json({
        error: 'Too Many Requests',
        retryAfterMs: record.resetTime - now
      });
    }

    record.count++;
    next();
  };
}

module.exports = createRateLimiter;

Task: Implement an LRU Cache with get(key) and put(key, value) operating in O(1) time complexity using Map.

class LRUCache {
  constructor(capacity) {
    this.capacity = capacity;
    this.cache = new Map(); // Map preserves insertion order
  }

  get(key) {
    if (!this.cache.has(key)) return -1;
    const val = this.cache.get(key);
    // Refresh key to recent position
    this.cache.delete(key);
    this.cache.set(key, val);
    return val;
  }

  put(key, value) {
    if (this.cache.has(key)) {
      this.cache.delete(key);
    } else if (this.cache.size >= this.capacity) {
      // Evict least recently used (first key in map iterator)
      const oldestKey = this.cache.keys().next().value;
      this.cache.delete(oldestKey);
    }
    this.cache.set(key, value);
  }
}