PayU SDE-2 Frontend Interview Experience

Overview

The following outlines the interview experience for a Software Engineer II (Frontend) position at PayU. The process involved multiple technical rounds designed to assess the candidate's knowledge of JavaScript, React, frontend system design, and problem-solving abilities. The interviews emphasized a deep understanding of core concepts and their practical application in real-world scenarios.

Interview Rounds

Round 1: Core JavaScript & React Fundamentals

This round focused on foundational JavaScript and React concepts. The interviewer explored the candidate's understanding of execution contexts, memory management, and modern JavaScript features. Key topics included:

• Difference between let, const, and var: Explanation of hoisting behavior and temporal dead zone.

  console.log(a); // undefined (hoisted)
  var a = 10;
  
  console.log(b); // ReferenceError (temporal dead zone)
  let b = 20;
  
  const c = 30; // must be initialized during declaration
  

• Arrow Functions vs. Regular Functions: Differences in this binding, arguments object, and use cases.

• Deep Copy vs. Shallow Copy: Understanding the implications of each and implementation of deep copy.

  // Shallow Copy
  const obj = { a: 1, nested: { b: 2 } };
  const shallow = { ...obj };
  shallow.nested.b = 99;
  console.log(obj.nested.b); // 99 😱
  
  // Deep Copy (recursive)
  function deepCopy(item) {
    if (item === null || typeof item !== "object") return item;
    if (Array.isArray(item)) return item.map(deepCopy);
  
    const copy = {};
    for (let key in item) copy[key] = deepCopy(item[key]);
    return copy;
  }
  
  const deep = deepCopy(obj);
  deep.nested.b = 42;
  console.log(obj.nested.b); // 2 ✅
  

• Higher-Order Components (HOCs): Advantages, disadvantages, and why hooks are now preferred.

• CORS Error: Causes, browser enforcement, and frontend workarounds (e.g., proxies).

• Hooks: Deep dive into useState, useRef, useMemo, and useContext (with context API usage).

• Redux & Redux Thunk: Relevance of Redux, appropriate use cases, and Thunk middleware for asynchronous operations.

• Closures:

  function counter() {
    let count = 0;
    return function () {
      count++;
      return count;
    };
  }
  
  const increment = counter();
  console.log(increment()); // 1
  console.log(increment()); // 2