Myntra, one of India's largest fashion e-commerce platforms, interviewed a candidate for a Senior Frontend Engineer position at their Bangalore office. The role promised work on complex frontend challenges including React architecture, state management at scale, and mobile-first design for millions of users. However, the interview process revealed a significant mismatch between the job description and the actual assessment methods.
The candidate, experienced in React development and modern frontend practices, prepared extensively for role-relevant topics. What followed was an experience that highlights a broader industry issue: the disconnect between what companies claim to seek in frontend engineers and how they actually evaluate candidates.
Interview Process
The interview process consisted of two rounds:
Round 1: Online Assessment
Format: Remote, online evaluation
Duration: Standard assessment window
Topics: JavaScript fundamentals, React concepts, CSS and responsive design
Focus: Practical frontend development skills
Round 2: Onsite Technical Round
Format: In-person at Myntra's Bangalore office
Duration: Approximately 45 minutes
Topics: Algorithmic problem-solving, data structures
Format: Whiteboard coding (pen and paper)
The candidate successfully cleared the online assessment and was invited to the Bangalore office for what was expected to be a deeper dive into frontend architecture and system design. Instead, the onsite round focused exclusively on algorithmic problems unrelated to the daily responsibilities of a frontend engineer.
Technical Rounds
Round 1: Online Assessment
The online assessment aligned with typical frontend role expectations and covered practical skills:
React Concepts: Hooks, component lifecycle, state management patterns
Problem-Solving: Logic-based questions rather than heavy algorithms
CSS and Responsive Design: Layout techniques, media queries, flexbox/grid
The candidate found this round appropriately scoped for a senior frontend position. The questions reflected actual day-to-day development work and tested relevant competencies.
Round 2: Onsite Algorithmic Focus
Original Source
This experience was originally published on javascript.plainenglish.io. Support the author by visiting the original post.
The onsite round took an unexpected turn. A senior software engineer conducted the interview and explicitly stated the focus would be on "problem-solving skills and algorithmic thinking." The candidate was handed pen and paper to solve two classic algorithmic problems.
Problem 1: Non-Overlapping Intervals
Question: Given a collection of intervals, find the minimum number of intervals to remove to make the rest non-overlapping.
function eraseOverlapIntervals(intervals) {
if (intervals.length <= 1) return 0;
intervals.sort((a, b) => a[0] - b[0]);
let removed = 0;
let prevEnd = intervals[0][1];
for (let i = 1; i < intervals.length; i++) {
if (intervals[i][0] < prevEnd) {
removed++;
prevEnd = Math.min(prevEnd, intervals[i][1]);
} else {
prevEnd = intervals[i][1];
}
}
return removed;
}
Complexity: O(n log n) due to sorting
The interviewer suggested sorting by end time instead of start time, prompting the candidate to reconsider the approach. Writing and debugging this solution on paper without the ability to test iterations proved challenging.
Problem 2: Kth Largest Element
Question: Find the kth largest element in an unsorted array.
Example: [3,2,1,5,6,4], k=2 → Answer: 5
The candidate initially provided a sorting solution:
function findKthLargest(nums, k) {
nums.sort((a, b) => b - a);
return nums[k - 1];
}
Complexity: O(n log n)
When asked for a more optimal approach, the candidate attempted to implement the quickselect algorithm, which achieves average O(n) time complexity. However, implementing the partition logic correctly on paper without testing proved difficult:
The candidate acknowledged uncertainty in the partition implementation and noted that in a real development environment, they would test and iterate step by step.
System Design
Notably absent from the interview process was any system design discussion. For a Senior Frontend Engineer role, the candidate expected questions about:
The complete absence of these topics represented a significant missed opportunity to evaluate the candidate's actual expertise and suitability for the role's responsibilities.
Key Takeaways
For Candidates
Expect Role Mismatches: Despite job descriptions emphasizing frontend-specific skills, many companies still default to generic software engineering interview formats. Prepare for algorithmic questions regardless of the role's actual requirements.
Practice Whiteboard Coding: While archaic, writing code by hand remains common in Indian tech interviews. Practice implementing algorithms without IDE support, debugging tools, or the ability to run code.
DSA Preparation Is Necessary: Whether relevant to daily work or not, data structures and algorithms questions are prevalent. Treat DSA preparation as a necessary job-seeking skill distinct from professional development.
Don't Internalise Rejection: An interview focused on irrelevant skills doesn't reflect your actual competence as a frontend engineer. Your value isn't determined by your ability to implement quickselect from memory.
For Interviewers
Align Assessment with Role: A Senior Frontend Engineer should be evaluated on frontend expertise—component design, state management, performance optimization, accessibility—not on algorithmic problems that rarely appear in their daily work.
Provide Constructive Feedback: Generic rejection without specific feedback helps neither the candidate nor the company in improving the hiring process.
Consider Modern Tools: Paper-based coding tests remove the tools that make modern developers productive. Consider practical coding environments that better simulate actual work conditions.
Industry Reflections
This experience highlights a broader issue in tech hiring: the gap between what job descriptions promise and what interviews assess. Companies seeking frontend specialists should design interview processes that evaluate frontend competencies. Pure algorithmic assessments may filter out excellent frontend engineers who excel at building user interfaces but don't regularly implement graph algorithms.
The industry is gradually evolving toward more relevant interview processes, with some companies implementing take-home assignments, pair programming sessions, and system design discussions specific to frontend roles. Until this becomes standard practice, candidates must prepare for both the job they want and the interview process they'll likely face.