Kanerika | Frontend Developer | September 2025 | 3.5 YOE
- Result
- Rejected
- Experience
- 3.5 years
- Posted
- 10 Sept 2025
Summary
I recently interviewed with Kanerika for a Frontend Developer role, which spanned four comprehensive rounds covering technical expertise, managerial acumen, and client interaction. Despite my perceived strong performance across all stages, I was ultimately not selected for the position.
How it went
I recently had an interview experience with Kanerika for a Frontend Developer position, encompassing a total of four rounds. Here's a detailed breakdown of my journey and the questions I faced:
1st Round: Technical Round
This round was purely technical and focused heavily on React, JavaScript fundamentals, and modern web development concepts. I was asked a wide array of questions, including:
- A deep dive into everything I knew about React.
- An explanation of Reconciliation in React.
- My experience with and reasons for knowing about class components.
- The various React Hooks I had used.
- Differences between
useEffectanduseMemo. - Questions about
npmandnvm. - The purpose of JavaScript Promises and the difference between
Promise.allandPromise.allSettled. - Pseudocode for a promise resolving after 2 seconds.
- Several output questions involving Promises, loops with
breakandreturn, and array destructuring. - Writing code to flatten a nested Object.
- Concepts of HOCs and Custom Hooks, including their differences and real-world examples.
- A CSS media query task to change background color based on width.
- Questions about API Integration Libraries and MicroFrontend architecture.
- How I would handle stale API calls.
2nd Round: Tech + Managerial Round
This round combined technical discussions with managerial and behavioral questions. It began with:
- A request for my self-introduction.
- A detailed description of my last project, covering objectives, my role, tech stack, challenges, and contributions.
- Strategies for optimizing a React application.
- How I design and structure React applications for modularity, reusability, and scalability.
- Differences between state management libraries like Redux and Zustand.
- Distinguishing between React.js and Next.js.
- My approach to maintaining code quality while mentoring junior developers under tight timelines.
- Examples of conflict resolution among team members.
- How I handle unclear or ambiguous client/stakeholder requirements.
- My step-by-step process for handling a production issue reported by a client/stakeholder.
3rd Round: HR Discussion
This was an in-person HR discussion. It focused primarily on assessing my confidence and communication skills, along with some basic HR-related questions. Towards the end, the HR informed me about an unexpected additional client interview round.
4th Round: Client Round
This final round was with the client and delved deep into JavaScript fundamentals:
- Differences between
nullandundefined. - Explanation of closures with an example.
- What an anonymous function is and converting my closure example into one.
- Self-invoking functions (IIFEs) with examples.
- What Higher-Order Functions (HOFs) are, with examples.
- Pseudocode for the
reducefunction. - Strategies for handling and replacing
nullorundefinedvalues from API responses. - JavaScript data types.
- Why arrays declared with
constcan still be modified (e.g.,push,pop). - The purpose and introduction of Promises.
- Currying in JavaScript.
- Web Workers and their use cases.
- Prototypes in JavaScript.
- Differences between normal functions and arrow functions.
- A comprehensive explanation of the
thiskeyword. - What
NaNis, how it's created, and its type. - Output questions like
console.log(NaN === NaN)andtypeof null.
Verdict:
I felt my performance in the interview was strong. However, I was ultimately not selected. The reason for the rejection was not communicated, but I hypothesize they found other candidates who were a better fit for the role.
Questions asked (55)
- 01
React Deep Dive
Data Structures & Algorithms
Explain your comprehensive knowledge about React, covering its core concepts, lifecycle, state management, and ecosystem.
- 02
React Reconciliation Process
Data Structures & Algorithms
Describe the React reconciliation process, including the Virtual DOM, diffing algorithm, and how React updates the actual DOM efficiently.
- 03
Experience with React Class Components
Data Structures & Algorithms
Detail your experience working with React class components. When did you use them, and what are their characteristics?
- 04
Importance of Class Components for React Developers
Data Structures & Algorithms
From a modern React development perspective, explain why it's still beneficial for a React developer to understand class components.
- 05
React Hooks Usage
Data Structures & Algorithms
List and briefly describe the various React Hooks you have utilized in your projects.
- 06
Difference between useEffect and useMemo
Data Structures & Algorithms
Explain the key distinctions between React's
useEffectanduseMemohooks, including their primary use cases and how they impact performance. - 07
What is npm?
Data Structures & Algorithms
Explain what npm (Node Package Manager) is, its primary purpose, and how it's used in web development.
- 08
What is nvm?
Data Structures & Algorithms
Describe nvm (Node Version Manager) and its utility for managing multiple Node.js versions on a single machine.
- 09
Purpose of JavaScript Promises
Data Structures & Algorithms
Explain the concept of a JavaScript Promise, what problem it solves, and its role in asynchronous programming.
- 10
Difference between Promise.all and Promise.allSettled
Data Structures & Algorithms
Distinguish between
Promise.allandPromise.allSettledin JavaScript, including their behavior when one or more promises reject. - 11
Pseudocode for a Timed Promise
Data Structures & Algorithms
Provide pseudocode for creating a JavaScript Promise that resolves successfully after a delay of 2 seconds.
- 12
JavaScript Promise Output Question
Data Structures & Algorithms
Given the following JavaScript code snippet involving a Promise and setTimeout, determine the exact order of console outputs:
const myPromise = new Promise((resolve) => { console.log("Log 1"); setTimeout(() => { console.log("Log 2"); resolve("Promise Resolved in 2 Secs"); console.log("Log 3"); }, 2000) console.log("Log 4"); }) myPromise.then((value) => console.log(value)) - 13
JavaScript Loop Output Question with Break and Return
Data Structures & Algorithms
Analyze the following JavaScript loop and determine its output. Pay attention to the 'break' and 'return' statements:
for(let i=0;i<10;i++) { if(i == 5) break; if(i == 2) return; console.log(i); } - 14
JavaScript Destructuring Assignment Output Question
Data Structures & Algorithms
Given the JavaScript destructuring assignment:
const [a,b, ...c] = [1] console.log(a); console.log(b); console.log(c);Predict the values that will be logged to the console for
a,b, andc. - 15
Flatten a Nested Object
Data Structures & Algorithms · Medium
Write JavaScript code to flatten a deeply nested object into a single-level object, preserving keys by concatenating them with a delimiter (e.g., dot notation).
- 16
What is a Higher-Order Component (HOC)?
Data Structures & Algorithms
Explain the concept of a Higher-Order Component (HOC) in React, its purpose, and how it's typically implemented.
- 17
Real-world HOC Example
Data Structures & Algorithms
Share a practical example of a Higher-Order Component (HOC) you have implemented or encountered in your own development experience, and explain its benefits.
- 18
What are React Custom Hooks?
Data Structures & Algorithms
Describe what React Custom Hooks are, their primary purpose, and how they contribute to code reusability and organization.
- 19
Difference between HOCs and Custom Hooks
Data Structures & Algorithms
Compare and contrast React's Higher-Order Components (HOCs) and Custom Hooks, highlighting their similarities, differences, and when to use each.
- 20
CSS Media Query for Specific Width Range
Data Structures & Algorithms
Write a CSS media query that applies a background color of 'red' when the viewport width is greater than 700 pixels AND less than 1000 pixels.
- 21
API Integration Libraries Experience
Data Structures & Algorithms
Discuss the different libraries or tools you have used for integrating APIs in your web development projects (e.g., Axios, Fetch API, etc.).
- 22
What is Micro-Frontend Architecture?
Data Structures & Algorithms
Explain the concept of Micro-Frontend architecture, including its benefits, challenges, and typical use cases in large-scale web applications.
- 23
Handling Stale API Calls
Data Structures & Algorithms
Describe strategies and techniques you would employ to effectively handle or prevent stale API calls in a frontend application.
- 24
Self-Introduction
Behavioral
Provide a brief introduction about yourself, highlighting your professional background, key skills, and career aspirations.
- 25
Detailed Project Description
Behavioral
Elaborate on your most recent project, covering its objectives, your specific role and responsibilities, the technology stack used, any challenges encountered and how you overcame them, and your key contributions to its success.
- 26
React Application Optimization Strategies
Data Structures & Algorithms
Discuss various techniques and best practices you would use to optimize the performance of a React application.
- 27
Designing Modular and Scalable React Applications
Data Structures & Algorithms
Explain your approach to designing and structuring React applications to ensure modularity, reusability of components, and scalability for future growth.
- 28
Difference between Redux and Zustand
Data Structures & Algorithms
Compare and contrast Redux and Zustand, two popular state management libraries for React, highlighting their core principles, API, and use cases.
- 29
Difference between React.js and Next.js
Data Structures & Algorithms
Explain the fundamental differences between React.js (client-side rendering) and Next.js (a React framework with server-side rendering capabilities), including their respective strengths and use cases.
- 30
Maintaining Code Quality with Mentorship and Deadlines
Behavioral
Describe your strategies for balancing the mentorship of junior developers and ensuring high code quality, all while adhering to tight project deadlines.
- 31
Conflict Resolution in Team
Behavioral
Provide an example of a time you experienced conflict among team members. Explain the situation, your role in it, and how you contributed to its resolution.
- 32
Handling Ambiguous Requirements
Behavioral
Explain your process for managing situations where client or stakeholder requirements are vague or ambiguous, ensuring clarity and successful project outcomes.
- 33
Production Issue Resolution Process
Behavioral
Outline your step-by-step approach to handling a critical production issue reported by a client or stakeholder, from initial assessment to resolution and communication.
- 34
Difference between null and undefined
Data Structures & Algorithms
Explain the distinctions between
nullandundefinedin JavaScript, including their types, origins, and common use cases. - 35
JavaScript Closures
Data Structures & Algorithms
Define what a closure is in JavaScript. Provide a clear code example to illustrate its concept and utility.
- 36
What is an Anonymous Function?
Data Structures & Algorithms
Explain what an anonymous function is in JavaScript and where it is typically used.
- 37
Convert Closure to Anonymous Function
Data Structures & Algorithms
Taking a previous example of a closure, demonstrate how to rewrite or integrate it using an anonymous function.
- 38
Immediately Invoked Function Expression (IIFE)
Data Structures & Algorithms
Describe what an IIFE (Immediately Invoked Function Expression) is in JavaScript. Provide a code example demonstrating its syntax and purpose.
- 39
What are Higher-Order Functions (HOFs)?
Data Structures & Algorithms
Explain the concept of Higher-Order Functions (HOFs) in JavaScript, emphasizing their role in functional programming.
- 40
Examples of Higher-Order Functions
Data Structures & Algorithms
Provide several common examples of Higher-Order Functions that are built-in or frequently used in JavaScript (e.g.,
map,filter,reduce). - 41
Pseudocode for JavaScript reduce() Function
Data Structures & Algorithms
Provide pseudocode that mimics the functionality of JavaScript's
Array.prototype.reduce()method. - 42
Handling Null/Undefined API Responses
Data Structures & Algorithms
Describe your approach and best practices for gracefully handling
nullorundefinedvalues that might be received from an API response in your frontend application. - 43
Replacing Null/Undefined Values
Data Structures & Algorithms
Following up on handling
null/undefinedAPI responses, explain how you would replace these values with a default or alternative value when necessary. - 44
JavaScript Data Types
Data Structures & Algorithms
List and briefly explain the various data types available in JavaScript (primitive and non-primitive).
- 45
Modifying const Array
Data Structures & Algorithms
Explain why it is possible to use methods like
push()andpop()to modify an array that has been declared using theconstkeyword in JavaScript. - 46
What is a Promise and its Introduction?
Data Structures & Algorithms
Define what a Promise is in JavaScript and explain the historical context or problems it was introduced to solve in asynchronous programming.
- 47
JavaScript Currying
Data Structures & Algorithms
Explain the concept of currying in JavaScript, including what it is and its benefits.
- 48
What are Web Workers?
Data Structures & Algorithms
Describe what Web Workers are in the context of web development, and explain their primary purpose and benefits for improving application performance.
- 49
JavaScript Prototypes
Data Structures & Algorithms
Explain the concept of prototypes and the prototype chain in JavaScript, and how they relate to inheritance.
- 50
Difference between Normal and Arrow Functions
Data Structures & Algorithms
Compare and contrast traditional
functiondeclarations/expressions with arrow functions in JavaScript, highlighting key differences likethisbinding, arguments object, and syntax. - 51
The 'this' Keyword in JavaScript
Data Structures & Algorithms
Provide a comprehensive explanation of the
thiskeyword in JavaScript, detailing its dynamic binding behavior in various contexts (global, function, method, constructor, arrow functions). - 52
What is NaN and How it's Created?
Data Structures & Algorithms
Define
NaN(Not-a-Number) in JavaScript. Explain common scenarios or operations that result inNaN. - 53
Type of NaN
Data Structures & Algorithms
What is the result of
typeof NaNin JavaScript? - 54
JavaScript NaN Comparison Output Question
Data Structures & Algorithms
Determine the output of the following JavaScript expression:
console.log(NaN === NaN) - 55
Type of null in JavaScript
Data Structures & Algorithms
What is the result of
typeof nullin JavaScript? Explain this peculiar behavior.