I recently had my interview for the SDE1 role at Uber. It was a focused session on problem-solving, and I encountered a specific coding challenge. The interviewer asked me to find the kth smallest square in a given sorted array, with a particular emphasis on achieving a time complexity better than O(k), which made the problem quite interesting.

I recently had a phone screen for an SDE 3 position at Uber. The interviewer presented a system design problem where I needed to build an API to manage meeting schedules across a predefined set of conference rooms. The core task was to implement a scheduleMeeting(startTime, endTime) method. This method should identify and reserve any available room during the specified time, returning the room's identifier. If no rooms were available for the given time slot, the API should throw an error. The problem statement included several example scenarios using Unix timestamps to demonstrate the expected behavior, such as assigning rooms with overlapping start times, handling fully booked periods, and re-assigning rooms once they become free. The interviewer also specified an expected time complexity of log(meetings) + O(rooms).

I interviewed with Uber for an SSE (Senior Software Engineer) position. It was a screening round, and unfortunately, I was rejected after this stage. The main part of the interview involved solving a coding problem. I had to identify robots in a 2D grid that satisfied specific movement requirements based on a query array. It was an interesting problem that tested my ability to navigate a grid and check conditions efficiently.

Initial Contact

An Uber recruiter reached out to me on LinkedIn in the second week of September 2025 regarding this opportunity. After completing the OA the next week, I requested some prep time until the end of October 2025, which they kindly agreed to.

Round 1 - Coding Interview

My first coding round happened a couple of days ago. The problem was exactly this one: Alien Dictionary — LeetCode.

Unfortunately, I hadn’t come across this question before since it’s a premium one, but I managed to solve it during the interview. There were a bunch of follow-ups and optimizations which I was able to answer within 1 hour of the interview. The interviewer emphasized time and space complexity, so being prepared to explain my approach clearly and optimize where possible was crucial.

Round 1 - Post-Interview Update

I got a call from the recruiter afterward — she mentioned that the round went really well, and they’d be scheduling the second coding round soon. That’s where things stand for now. I’ll keep this post updated as I progress through the next rounds. 🙌

Phone Round

My phone round involved a straightforward problem: finding the k-th smallest element in an array. I approached this by using a limited size heap, which felt like the most appropriate solution.

On Site Rounds

1. Data Structures & Algorithms (DSA)

This round featured a problem similar to Number of Islands II. Initially, I mistook it for Number of Islands I, but I quickly realized that the matrix would change and be queried multiple times, which pointed towards the 'II' version. Thankfully, I was familiar with the proper solution using Union Find and managed to implement it correctly just in the nick of time. I'm hoping this was a Strong Hire.

2. System Design

The system design problem was to design Google Calendar. I had prepared for this, but it felt like some of my planned points weren't entirely relevant, so the interviewer took more control, asking specific questions like "how to do A?" and "how to do B?". I was able to answer all their questions successfully, but I felt like I lost an opportunity to go above and beyond. Uber seems to have this interview style where you can either do well or extra well. I believe this was at least a Hire; the interviewer even mentioned they had "everything they needed," which I took as a positive sign.

3. Behavioral

This round is always hard to gauge. I believe I responded effectively to all questions based on my past work experiences. I have no reason to think it was anything less than a Hire.

4. Specialization - Front End

I consider this the most challenging round because it could be either a UI-building task or a LeetCode-style Javascript question. Despite having four years of React experience, I'm not accustomed to solving LeetCode problems in Javascript, which was a mistake in my preparation. I had prepared primarily for a UI question, but was surprised by a Javascript question involving graphs and async jobs. I struggled quite a bit, as I'm not used to implementing graph algorithms or using Sets in Javascript. The interviewer allowed me to use Google, but that definitely eats into precious time. Nevertheless, I managed to solve the problem, again, just in the nick of time, though I did have one minor loose end which I later corrected and emailed to the interviewer. Once more, the interviewer stated they had "everything they needed," leading me to believe I passed the minimum bar for a Hire.

Based on my performance (Strong Hire, Hire, Hire, Hire), I believe it should be sufficient, but you never truly know with Uber. I've noticed their evaluation process can extend further, with reviewers scrutinizing interviewers' feedback, which explains why some candidates get surprising rejections even after positive interviewer interactions.

Honestly, I'm quite pessimistic and anticipate a rejection. When you're not absolutely perfect, anything can hinder your evaluation. I fear the evaluations might be lower, like Lean Hire, Hire, Hire, Lean Hire, which might not be enough for an offer.

Appeared for SSE (L5-A) backend position

1. https://leetcode.com/problems/water-and-jug-problem/
   Interviewer won't help at all. He pasted the question and then turned off his audio video. Optimized working solution is expected. [Rejected]
2. I again appeared for different job ID for same SSE position
   
   1. You are given a list of edges [[a,b], [b,c], [d,f], [f,g]]. Here a,b means a is manager of b. You have to implement 3 functions:
        a. Return total number of employees under a manager (both direct and indirect)
        b. Change the manager of an employee. If that employee has some reportees then those will also be affected.
        c. Add new employees. Eg: [c,d] needs to be added.
      
      Input format was not hardcoded. You have to write the main function on how input will be given to these apis.
      
      Basically if you create a tree structure you would be able to solve this question. The key was to have optimized solution such that (a) part should have TC - O(1)
      
      I couldn't come up with optimized solution in the given time.
      [Rejected]

A few months ago, I applied for a Software Engineer II position at Uber through a referral. My interview process began with a CodeSignal test where I successfully solved both coding questions.

Technical Screening

This round focused on Data Structures & Algorithms, specifically a dynamic programming question which I solved successfully.

Coding Round 1 (Algorithms & Data Structures)

I faced two coding questions in this round, with a strong emphasis on Time Complexity and Space Complexity. The problems were:

1. Cheapest Flights Within K Stops
2. Maximum Points You Can Obtain from Cards

Coding Round 2 (Depth in Specialization - Low-Level Design)

This round involved implementing file system APIs: mkdir, pwd, and cd. The mkdir and pwd functionalities were straightforward, but cd presented a challenge due to a wildcard * which needed to match '.', '..', or any child directory.

Design & Architecture (High-Level Design)

I was asked to design a backend system for an e-commerce website, specifically for the browsing experience and excluding the purchase process. The system needed to use popularity data to highlight top items. Additionally, I had to design an event processor for various product-related events ('Product added to Cart,' 'Product viewed,' etc.), discussing data storage and prioritizing consistency versus availability. I also had to elaborate on the data structure for product catalog storage.

Collaboration & Leadership

This round was scheduled but later canceled.

After completing these rounds, I received an offer from Uber and happily accepted it!

I recently interviewed with Uber and was presented with a system design challenge. The interviewer asked me to design a chat application similar to Facebook Messenger, focusing on several core features. I had to describe the overall system architecture, including server-side storage, APIs, and how various components would interact. Key aspects I needed to address included 1:1 and group conversations, handling offline users, delivery and read receipts, message history, and group management functionalities like adding or removing users.

I interviewed for an L4 Frontend role at Uber, bringing 4.5 years of experience. The interview process was comprehensive, covering various aspects of frontend development and problem-solving.

Screening Round

My screening round involved a UI component design and implementation task. I was asked to build a voting poll UI. The requirements were quite specific:

• Display four voting options with buttons.
• Dynamically update vote counts and percentage distribution upon a click.
• Show a colored progress bar for each option, reflecting its current percentage, with smooth, real-time updates.

Optional features included distinct colors, animations, and total vote counters.

Loop Interviews

Coding 1 (DSA)

This round focused on Data Structures & Algorithms, specifically involving concurrency. I was tasked with designing and implementing a task queue in TypeScript. The queue needed to support controlled concurrency, executing up to K tasks in parallel, and queuing additional tasks until slots became available. Each task required a unique ID and support for success and error callbacks. An interesting design constraint was allowing a custom executor for logging, retries, or rate limiting.

Coding 2 (UI Coding)

The second coding round was another UI implementation challenge. I had to design and implement a modal component using any UI framework. The modal needed several features:

• Primary and secondary action buttons (e.g., “Save” and “Cancel”).
• An optional close icon ('X').
• Configurable priority levels to manage modal stacking.
• A mechanism to automatically close all other open modals when a new, higher-priority modal opens.

UI System Design

This was a more extensive design round where I had to design a calendar application similar to Google Calendar. Key features to cover included:

• User authentication (sign up, log in, log out).
• Event management (create, edit, delete, accept invitations), with events having title, time, date, participants, and description.
• Multiple calendar views (Month, Week, Day) with seamless switching.

Manager Round (Zoom Collaboration)

The final round was with a manager, where we discussed leadership and collaboration. The questions were primarily behavioral, drawing from my past experiences to assess my approach to teamwork and leadership.

My interview journey for the SWE II Backend role at Uber's Grocery organization, which is apparently their second largest vertical by gross revenue after Rideshare, was quite comprehensive. It started with an Online Assessment, which was similar to Codesignal GCA, featuring two easy questions, one tricky and confusing, and one algorithmic.

After passing a pretty chill recruiter phone screen that mostly served as a vibe check and confirmed my interest, I proceeded to the onsite rounds.

The first coding onsite was a 60-minute DSA round. It involved implementing an interface for a 2D MxN array of restaurants, specifically openRestaurant(r, c), countOpenRestaurants(r, c), and hasOpenRestaurant(r, c). The core challenge was countDeliveryZones(), which required finding connected components of open restaurants based on directional adjacency (up, down, left, right). I initially developed a working solution using DFS/BFS, but the interviewer indicated that Uber seems to highly favor Union-Find for such problems and was looking for a more optimal solution. The interviewer was unfortunately uncooperative and didn't offer hints like a coworker would.

The second 60-minute DSA round focused on implementing scheduleMeeting(startTime, endTime) to assign rooms within an office. The implementation itself wasn't too bad, but the follow-ups were quite insightful:

• What would happen if we had 10,000 concurrent requests to scheduleMeeting? What would be the bottleneck, and how would you solve it?
• My solution was initially O(M*N) where M is the number of rooms and N is the number of bookings. How could this be improved? A hint was given: what if bookings are sorted? Perhaps use binary search to achieve logarithmic time complexity by smartly checking likely intervals for overlap.

Next was the System Design interview, where I designed a Cart Management System, specifically in the context of a grocery delivery order application.

Finally, I had a great behavioral interview with the Hiring Manager, which was a pleasant conversation and the best part of the interview process. Overall, the recruiter and hiring manager were nice, but some of the technical interviewers were unfortunately not the most collaborative people. Uber also didn't really want to budge on the base salary, even with a competing offer, only offering to bump the sign-on bonus.

During my interview process for a Frontend role at Uber, I was presented with a coding challenge focused on core JavaScript concepts. Specifically, I had to implement my own version of the Promise function, demonstrating an understanding of its asynchronous behavior and state transitions.

I applied for the SSE L5-A role at Uber in Bangalore without a referral. My experience is 5 years.

BPS Round

In this round, I was presented with a grid problem:

• You have an n x n grid.
• Each cell (i, j) has a direction (U, D, L, R).
• If you move in the same direction as indicated, cost = 0.
• If you move in a different direction, cost = 1.
• Find minimum cost to go from (0, 0) to (n-1, n-1).

I solved this problem using a 0/1 BFS approach and successfully cleared the round.

Onsite

DSA Round

1. The first question was a variation of LeetCode 1438: Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit.
2. The second question was: Given an integer N, find the smallest palindromic number greater than N.

I managed to solve both questions. For the second question, I had a bug in one test case, but I clearly explained my thought process and how I would resolve it, which satisfied the interviewer.

LLD/MC Round

I was asked to design a vending machine with several specific and somewhat unusual requirements. Unfortunately, I missed one crucial requirement during my implementation, and due to time constraints, I couldn't rewrite my solution to incorporate it. It felt like a very extensive implementation for a 1-hour round.

I am fairly certain that I won't be moving forward to the subsequent HLD and Hiring Manager rounds. It appears this is the end of my interview journey with Uber this time.

Overall Experience

I had a very positive interview experience at Uber for an L4 role in the US. Everyone I interacted with was friendly and genuinely seemed to want me to succeed. The interviewers were also very diverse, which was great to see. The difficulty felt reasonable overall, and I was fortunate with some of the problems I encountered.

OA Round

My journey began with a CodeSignal Online Assessment. I managed to solve problems 1, 2, and 4, though I couldn't crack problem 3. This was sufficient to pass and move on to the next stage.

Phone Screen

The phone screen involved a LeetCode Hard problem, LC 269 (Alien Dictionary). I was able to solve it, and I received an invitation for the on-site rounds within two days.

On-Site Interviews

I. Bar Raiser DSA

This round focused heavily on Data Structures & Algorithms. I was given LC 564 (Find the Closest Palindrome), which I successfully solved. I thoroughly explained my solution, and the interviewer continued to ask follow-up questions until the very end, seemingly pushing to find my limits, but I managed to hold my ground.

II. Hiring Manager Round

This round was with a TPM and focused on behavioral aspects. I was asked to share negative experience stories from my current company, which I structured using the CARL framework. There was a strong emphasis on collaboration, and the interviewer asked questions to understand how I work with a team and ensure I am a team player. They also inquired about how I handle team overburn and stay resilient during stressful periods.

III. Low-Level Design (LLD) / DSA

I had anticipated a Machine Coding round and had prepared extensively with Java patterns and template problems like a parking lot design. However, it turned out to be another Data Structures round. I was given a question similar to LC 230 (Kth Smallest Element in a BST). I was able to solve it, and the interviewer was very supportive. It felt like they wanted me to pass, as they gave me what seemed like an easy problem with a reasonable medium follow-up. I definitely felt lucky in this round.

IV. High-Level Design (HLD)

This round was conducted by a very knowledgeable backend Tech Lead. The main problem was to design a restaurant recommendation system based on user location. The initial requirements were quite straightforward, allowing me to sketch out a design in less than 10 minutes. However, things became much more interesting when the latency requirements were significantly decreased. After developing a high-level design with optimizations for various regions, caching strategies, and sharding, I was asked to explain geohashing to someone without prior knowledge. I then discussed quad trees, geohashing, database indexing, and the various tradeoffs involved.

Outcome & Negotiation

The recruiter contacted me within three days, immediately after the interview panel meeting concluded, confirming a strong 'hire' recommendation from all interviewers. I initially received an offer package of TC $310k for Year 1 and $270k for Year 2. After a week of negotiation, I finalized an improved offer of TC $335k for Year 1 and $310k for Year 2.

Overall, it was a smooth process, and I'm very happy with the outcome!

Background

I am a Frontend engineer with 7.5 years of experience, currently working in Big Tech.

Interview Process

Business Phone Screen [1 hour]

This round involved implementing a JavaScript memoization utility to cache responses from a callback-based async function, along with follow-up questions.

Coding 1 [1 hour]

I was presented with a problem similar to LeetCode 764, "Largest Plus Sign". The interviewer also asked follow-up questions on how to handle the problem efficiently in a sparse matrix.

Coding 2: Depth in Specialization [1 hour]

This was a React-based coding challenge where I had to build a Drag and Drop interface, similar to a Jira Board. I was allowed to reference MDN documentation during this round.

Design [Bar Raiser] [1 hour]

The design round focused on the end-to-end design of a configurable UI widget builder, including its client-side integration.

Hiring Manager (HM) [1 hour 45 mins]

This final round was split into two parts: a series of behavioral questions and a discussion/walkthrough of my previous projects.

The entire process took approximately 3 weeks.

My interview journey at Uber for an L4 Software Engineer role began with a BPS round, which focused on data structures and algorithms. I successfully tackled the 'Alien Dictionary' problem, covering all edge cases, and my solution ran perfectly on the first try within 20 minutes.

The first official DSA round, which had been postponed multiple times, presented two problems. One involved reversing every 'k' nodes in a linked list, leaving the remaining nodes untouched if fewer than 'k' were left (e.g., A->B->C->D->E, k=2 becomes B->A->D->C->E). The other problem was similar to the 'Bus Routes' problem, though I don't recall the exact details.

My second round, the Machine Coding round, turned out to be my most challenging interview experience in 4.8 years. After some initial scheduling hiccups where the interviewer asked me to rejoin after 30 minutes, I was given only 40 minutes for the entire session. A significant portion of this time (15-20 minutes) was spent discussing my past experience in detail. The problem itself was similar to a job scheduler. The interviewer, a Staff Engineer, emphasized that the expectation for this round was both Low-Level Design (LLD) and High-Level Design (HLD). I quickly outlined an HLD, but as I only had about 10 minutes left, I intended to move to LLD. However, he kept interjecting with questions about push vs. pull flows, which further consumed my time. Despite explaining various patterns and their rationale, I barely had 5 minutes left and couldn't write or run much code, only managing to sketch out structures and explain my approach.

Following this, although the machine coding round was difficult, the strong performance in my first round led HR to push me forward to a Bar-Raiser + Hiring Manager stage. Unfortunately, I fell ill after these interviews were scheduled, leading to the Bar-Raiser round being postponed and the Hiring Manager round being canceled.

The third round, the HLD/Bar Raiser round, was a system design challenge: 'Design the Uber Eats home page for customers traveling on a train, taking PNR as input and allowing food ordering based on the delivery station.' This time, I made sure to follow a structured approach. I started by detailing Functional Requirements (FR) and Non-Functional Requirements (NFRs), including capabilities and scalability. I then defined core entities, presented my High-Level Design, discussed database and caching strategies, and delved into specific components. The interviewer posed many questions, which I answered, and in some instances, he provided corrections. I am currently unsure about the outcome of this round. The overall process is still awaiting feedback; based on the Bar-Raiser verdict, they will decide whether to proceed to the Hiring Manager round or drop my application.

I went through a comprehensive interview process for the SDE-2 (L4) role at Uber in Bangalore, initiated through a referral. With 3 years of experience as an SDE-1, I faced a total of 5 challenging rounds.

📌 Round 0 – Elimination Coding Round

This round featured a problem statement: Given an array of integers nums and an integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is ≤ limit. This was similar to LeetCode 1438 and framed in a driver-cab domain context. I explained four distinct approaches step by step:

• Brute force (4 loops) to generate all subarrays and check conditions.
• An improved brute force (3 loops) to avoid redundant calculations.
• Further optimization (2 loops) by tracking min/max with sliding windows.
• The optimal solution (Deque + Sliding Window, O(n)) using two deques to maintain min/max.

The interviewer was very particular about base cases and required me to explain the time and space complexity for each approach. I successfully cleared this round.

📌 Round 1 – DSA + DSU Problem

I was given logs in the format UserA-Shared-UserB-timestamp, indicating that UserA and UserB shared a cab. The problem had two versions:

• For each log, return how many cabs are currently running.
• For a given set of logs, return the timestamp when all users get into one cab.

I initially started discussing DFS/BFS for connected components, but then shifted to a more optimal Disjoint Set Union (DSU) approach for handling the problem. I implemented DSU from scratch, explaining path compression and union by rank/size, and also detailed the time and space complexity for my solution. This round was also successful.

📌 Round 2 – Low-Level Design (LLD)

The problem statement was to design a Train-Platform Management System with functionalities to: assign trains to platforms based on input, query which train is at a given platform at a specific time, and query which platform a train is at for a specific time. I was expected to write runnable code in Java, explain design patterns, and walkthrough every step while coding. I designed core classes such as Train, Platform, Scheduler, and Schedule Manager. I coded using a minHeap strategy and then explained a random assigning strategy, focusing on writing extensible code. My primary focus was on implementing time-based queries and accurately mapping train schedules. The interviewer continuously cross-questioned my design choices and pushed me to deliver a clean design with working code within the 60–75 minute timeframe.

📌 Round 3 – High-Level Design (HLD)

This round involved designing the Uber Eats Homepage. I focused on several key areas:

• Location-based search, using concepts like GeoHashing and GeoIndexing.
• Designing APIs for the homepage and search results.
• Schema design for Restaurants, Dishes, and Orders.
• Choosing between SQL and NoSQL databases and justifying my choice.
• Implementing caching strategies for performance.

I also discussed how to capture metrics such as the most ordered restaurant, most ordered dish, and orders per restaurant. I utilized HackerRank’s design whiteboard/drawing tool to illustrate my architectural design. The interviewer was very friendly, listened attentively, and supported my approaches while also providing constructive feedback on my explanations.

📌 Round 4 – Managerial + Behavioural

This round was a discussion centered around my past work experience. We covered topics such as the good coding practices I followed, my specific roles in previous projects, and the ownership and impact of the work I delivered. Towards the end, the manager gave me approximately 15 minutes to ask questions about the team, the role, and available growth opportunities at Uber.

✅ Outcome

I am delighted to share that I finally received an offer for the Uber SDE-2 position in Bangalore! 🎉

I recently had my phone screen interview for an SDE 2 role at Uber. My interviewer was based in Canada, and while they mentioned their camera wasn't working, we proceeded with the interview. The main coding question I received was very similar to LeetCode 305, 'Number of Islands II', with only minor differences. Having solved this problem before, I felt quite confident in my ability to tackle it. I proceeded to explain two potential approaches: one utilizing Depth-First Search (DFS) and another employing the Union Find data structure. After discussing both, I received approval to implement the Union Find solution. However, as I was coding and verbalizing my thought process, the interviewer interrupted me several times to question my choices. Each interruption broke my concentration, and I had to re-explain my logic, sometimes even reading my code aloud for clarity. These frequent interruptions, occurring about three or four times, severely impacted my time management and disrupted my problem-solving flow. Towards the end of the almost hour-long session, I identified a bug—a 'return' statement in a loop that should have been a 'continue'. Despite my explanation, the interviewer insisted the bug was elsewhere and, due to time constraints, did not allow me to debug it further. I'm feeling quite disheartened by the outcome, but I hope sharing this experience offers some insight into the interview process at Uber and the types of questions they might ask.

My interview journey for the Staff Software Engineer L5 position at Uber India consisted of five comprehensive rounds, stretching over roughly two months.

Round 1: Data Structures & Algorithms

This round focused on a complex DSA problem involving a binary tree. The problem description itself was quite detailed and involved player interactions and point calculations based on node visitation order and timing.

Round 2: Data Structures & Algorithms

The second DSA round presented a problem where I had to process a 2D location map and a query array. The goal was to identify robots that could satisfy specific movement conditions based on distances to blockers, including map boundaries.

Round 3: High-Level Design

In this round, the discussion revolved around designing a system for real-time aggregated metrics for Uber Eats restaurants. The key requirements were to calculate total order values and top K food items over various time intervals, emphasizing real-time updates.

Round 4: Low-Level Design

This round required me to implement a meeting room booking system with fixed room numbers and varying sizes. I needed to handle booking availability, maintain history, and abstract different scheduling implementations, with the expectation of delivering fully working code within an hour.

Round 5: Hiring Manager Round

The final round was with the Hiring Manager. It began with standard behavioral questions. Following that, I was asked to deep-dive into the complete architecture of the most complex system I had built previously. The manager posed numerous follow-up questions concerning design trade-offs, challenges, learnings, and my technology stack choices during my explanation.

I recently had my interview for the SDE1 role at Uber. The interview consisted of three challenging problems, primarily focusing on graph algorithms and array manipulations. I managed to solve two of them completely and the third one partially, achieving a score of 14/15. Despite my performance, Uber shared feedback emphasizing the importance of 'coding profile strength' and encouraged me to reapply for future roles.

Although I didn't receive an offer this time, I consider this a valuable learning experience, particularly in handling complex graph edge cases. The hiring for my specific role later closed, but I received positive feedback and encouragement from the Uber team to reapply.

I recently had the opportunity to interview for an SDE 2 position at Uber, and I'm pleased to share a breakdown of my experience across all rounds.

1. Recruiter Connect:

2. Online Screening Round:

3. Loop Rounds:

✅ DSA/Coding Round

✅ Code Design Round

✅ System Design Round

✅ Behavioral Round

Verdict: