My Uber L4 Frontend Interview | 2026

I recently had my interview with Uber in March 2026 and wanted to share my experience for my fellow peers, I was eliminated on the Machine coding round and I have around 4years of experience.

Round 1: The DSA Elimination Round

The Problem

The interviewer handed me a classic 2D array problem: Count the Number of Islands. You’re given a grid where land and water are represented by specific characters, and you need to find clusters of connected land cells. Similar LeetCode Problem: LeetCode 200 — Number of Islands

How the Problem Progressed

I went with a recursive Depth-First Search (DFS) approach. The plan was simple: loop through the grid, find an unvisited land cell, bump up the island count, and use DFS to clear the rest of that connected island in place so I wouldn’t count it again.

Once that was done, the interviewer threw a couple of fast follow-ups at me:

• Handling Diagonals: Modify the logic so that land touching only at the corners counts as the same island (moving from 4-directional to 8-directional exploration). Similar LeetCode Problem: LeetCode 827 — Making A Large Island
• Closed Islands: Identify and count only the islands that are completely surrounded by water and don’t touch any of the outer borders of the grid. Exact LeetCode Problem: LeetCode 1254 — Number of Closed Islands

I was able to complete the original problem as well as modified my code as per the follow ups and I was selected for the next round.

Round 2: Core DSA & JavaScript Concurrency Round

Part 1: Organization Hierarchy (Graph Validation)

The first half asked me to validate if a list of manager-report pairs formed a legit company hierarchy, meaning exactly one ultimate boss, no cycles (loops), and no disconnected tracking trees. Similar LeetCode Problem: LeetCode 261 — Graph Valid Tree

I walked through an optimal graph approach using in-degrees to find the leader and DFS to check for cycles. However, the interviewer asked me to quickly write out a simple brute force approach O(N²) first. This involved building a map of subordinates to managers and climbing up the chain from every single person to ensure everyone hit the exact same leader without looping forever.

Part 2: Building a Concurrency-Limited Async Queue

The main challenge of this round was building an asynchronous queue processor that restricts execution based on a limit (e.g., executing a maximum of 5 or 10 tasks at the exact same time). Similar LeetCode/Frontend Problem: LeetCode 2636 — Promise Pool

Part 3: JS Fundamentals Quick Fire

We wrapped up the last few minutes with rapid-fire JS trivia questions:

• Hoisting: Explaining how variable declarations (var) are hoisted as undefined , while let and const sit in the Temporal Dead Zone (TDZ) until their line is executed.
• Call vs. Apply vs. Bind: Pointing out that call and apply execute a function immediately with a custom this context (taking arguments one by one or as an array) , while bind creates a brand new function to call later.

Where I Messed Up

• Getting Lost in Edge Cases: I spent a bit too much time talking through theoretical tracking patterns instead of just writing the implementation. Because of that, I ran out of time to write out a full testing script using setTimeout to show the concurrency limit working visually in the terminal.
• The Feedback: The interviewer noted that while my problem-solving logic was good , my raw speed with vanilla JS coding patterns under pressure needed some tuning.

Round 3: React In-Depth Specialization (Nested File Explorer)

The Problem

Implement a nested file-and-folder explorer tree view, basically like the sidebar panel in VS Code.

• Folders need to expand and collapse independently when clicked.
• Provide a working search bar that highlights matching files and auto-expands the folders leading directly to them.

My Solution

Instead of creating random database IDs for every file and folder, I used a path-based model. A file inside src/components/Button.js used that exact string path as its unique key. This made tracking matches and expanding parent folders a breeze without writing messy lookup functions.

Initially, I tracked a global state called expandedFolders (a flat JavaScript Set of open paths) at the root level and passed that entire Set down to every single folder component. The interviewer stopped me and asked a great performance question:

“If you are using React.memo to optimize your tree, won't passing the entire expandedFolders state object trigger a re-render across every folder anyway whenever someone opens a single item?"

He was right. Because a Set changes its reference whenever you update it, every folder component would see a brand-new prop and completely ignore React.memo.

• The Fix: Calculate the boolean state (isExpanded = expandedFolders.has(path)) inside the parent component, and pass only that true/false boolean down to the child folder. Since booleans are compared by value rather than reference, React.memo actually works perfectly and blocks unnecessary re-renders across the rest of the tree.

I was eliminated after this round.

Key Learnings

• Prioritize Execution Over Over-Thinking: Don’t get caught up in exploring every single edge case verbally before you write code. Get a working base implementation down fast so you have time to build test handlers and handle code execution comfortably.
• Break References to Protect Re-renders: When using React.memo for deeply nested UI trees, avoid passing parent collection references (like global sets or configuration blocks) directly into child components. Always derive state early at the parent level and pass primitives like booleans down the tree.
• Master Vanilla JavaScript Utilities: Machine coding challenges move fast. You need to be able to built common structural utilities like concurrent processors, async managers, and customized event listeners using raw vanilla JS under pressure.

Overall despite not clearing the 3rd round, it was a great learning experience for me and helped me identify my gaps.