Uber Interview Preparation and Recruitment Process

About Uber

Uber Technologies, Inc. is a global technology platform headquartered in San Francisco, California, founded in 2009 by Garrett Camp and Travis Kalanick. Originally launched as UberCab, it reimagined transportation by connecting riders with drivers through a smartphone app, pioneering the ride-hailing model. Uber operates in approximately 70 countries and 15,000 cities, serving over 150 million monthly active users with 6 million active drivers and couriers, coordinating 28 million trips daily.

Uber Interview Preparation

Core Services

Uber operates through three main segments:

* Mobility: Connects riders with drivers for ride-hailing services, including cars, auto rickshaws, motorbikes, and taxis, plus carsharing, micromobility (bikes, scooters), and public transit integrations.

* Delivery: Includes Uber Eats, enabling food, grocery, and retail delivery, and Uber Direct, a white-label delivery service for businesses.

* Freight: A logistics platform connecting shippers and carriers with transparent pricing and digital booking.

Financials and Growth

* Revenue: $44 billion in 2024, with a net income of $9.8 billion.

* Market Cap: $151 billion as of April 2025, with a stock price of $72.28.

* Profitability: Uber reported its first annual profit of $1.89 billion in 2023, after years of losses totaling nearly $30 billion from 2016 to 2023.

* Take Rate: 28.7% for mobility and 18.3% for delivery in 2023.

* IPO: Went public in 2019, valued at $82 billion, though its share price initially struggled. By 2025, it nearly doubled from its IPO price, launching a $7 billion buyback program.

History and Innovation

Born from Camp and Kalanick’s frustration with finding a taxi in Paris in 2008, Uber started as a luxury "black-car" service but pivoted to a broader ride-hailing app. It launched in San Francisco in 2010, expanded globally by 2012, and introduced UberX (low-cost rides) to compete with Lyft. Uber Eats and Uber Freight followed, diversifying its offerings.

* Milestones: Hit 1 billion trips by 2015, 5 billion by 2017, and 47 billion total by 2023.

* Innovations: Introduced UberPOOL (carpooling), partnerships with public transit, and healthcare ride-scheduling solutions. Recent expansions include on-demand beauty product delivery with Sally Beauty via Uber Eats.

Controversies

Uber’s disruptive model has sparked debates:

* Congestion: Studies show Uber increases urban congestion by replacing walking, biking, and bus trips, with low vehicle occupancy rates. Some cities impose ridesharing taxes.

* Labor: Drivers, classified as independent contractors, have filed lawsuits for employee status. Uber’s monopsony power is estimated to depress wages by 14%.

* Data Breaches: A 2016 breach exposed data of 57 million customers and 600,000 drivers, with Uber paying a $100,000 ransom to conceal it. A 2018 settlement cost $148 million.

* Workplace Issues: Faced allegations of sexism, harassment, and a toxic culture, leading to a $7 million settlement in 2018 for gender discrimination claims.

* Legal Challenges: Uber faces frequent lawsuits, maintaining a substantial legal budget. It’s banned in some countries for disrupting taxi industries.

Sustainability and Safety

* Environmental Goal: Aims for a fully electric, zero-emission platform by 2040, supporting drivers’ transition to electric vehicles.

* Safety: Implements background checks, real-time verification, and a Safety Advisory Board. Critics note inconsistencies in driver quality due to remote management.

Leadership

* CEO: Dara Khosrowshahi, since 2017, previously led Expedia.

* Founders: Kalanick resigned as CEO in 2017 amid controversies and left the board in 2019. Camp remains influential.

Current Sentiment

Recent posts on X highlight mixed views:

* Uber’s expansion into autonomous vehicles (e.g., Waymo partnerships) boosts ride volume, but driverless cars pose competitive risks.

* Concerns linger about consumer spending trends and unemployment impacting demand, though Uber reports stronger supply issues.

* Critics raise ethical concerns over Uber’s involvement in surveillance bots and legal maneuvers in lawsuits.

Critical Perspective

Uber’s innovation transformed mobility but often prioritized growth over ethics, contributing to gig economy exploitation and urban strain. Its pivot to profitability and sustainability shows adaptability, yet labor and regulatory challenges persist. The company’s narrative of empowerment for drivers clashes with data on wage suppression and precarious work conditions, suggesting a need for systemic reform in its model.

Recruitment Process

1. Interview Process

Like other interviews, the Uber interview process begins with a candidate applying for a job position. If someone is a good fit for the job, Uber will schedule an interview with you. Uber recruiters may also propose roles that are a better fit for your profile than the one you applied for. You will then go through a technical phone screen and a series of on-site or online interviews after being shortlisted. Each phone screen and the on-site interview lasts about 60 minutes in most circumstances. So, to summarise, the Uber Interview process consists of the following steps:

* Online Test (On platforms like Hackkerank, HackerEarth, etc.)

* On-site or Online Technical Interview Rounds

* One System Design Round

* Human Resources or HR Round.

2. Interview Rounds

1. Online Test (Coding Round): The online test of Uber is of medium to hard difficulty and very critically evaluates the problem-solving ability of an individual. It is usually a coding round that is conducted on platforms like Hackkerank, HackerEarth, etc. and the candidates are asked to solve two to three questions based on Data Structures and Algorithms. These questions require the candidates to apply their problem-solving skills and knowledge of various Data Structures and Algorithms to solve the given problem. The candidates then have to code their solution in a programming language of their choice, for instance, C++, Java, Python, etc. This round can be skipped for experienced folks as seems necessary to the Recruiters.

2. On-site or Online Technical Interviews: The Uber on-site or online Technical interviews will entail a series of four to six face to face interviews. To tackle the challenges, your interviewers will either ask you to use HackerRank or a whiteboard. One can expect five to ten minutes of conversation on previous work experience in each interview, as well as situational and behavioural interview questions. A series of questions about Data Structures and Algorithms are asked after that. The interviewing panel may also the candidate to code their responses for them, who will evaluate the code quality, logic, and other issues. The candidate's technical expertise is then assessed through a series of questions.

To pass these Uber walk-in-interview rounds, you must have a strong understanding of computer science principles. Candidates should be knowledgeable with data structures and algorithms, database management systems, operating systems, networking, object-oriented programming ideas, and their preferred programming languages, such as C++, Java, Python, and others. During this stage, if the candidate is an experienced Software Engineer, a few questions on their previous internship experiences and projects may be asked. The panel will also ask you questions on your resume, so make sure you understand everything you've written. The Uber technical interview questions are similarly of a moderate to the high difficulty level.

The last five to ten minutes are all yours! One can inquire about the employment role with the interviewer. One can also prepare a list of questions about your employment, the project or division for which you are applying, and other relevant facts such as employee diversity, inclusion policies, and so on and so forth. These rounds are also eliminative in nature. A thing to note over here is that there can be multiple technical interviews based on requirements and previous interview performances of the candidate as seen fit by the recruiters.

3. System Design Round: After a series of interviews on technical skills, candidates are assessed for their ability to design distributed systems. For freshers, the interviewers usually ask the candidates to use Object-Oriented programming to create the design for a product on a high level by asking them to classify the important features of the system first. Later on, the candidates are asked to scale the solution they have come up with using various concepts like Load balancing, caching, etc. It is important to add only the necessary features for the solution you are developing in this round and communicate well with the interviewer so that they can relate to the system being built. Learn More.

4. The Human Resources (HR) or Managerial Round: The Human Resources or HR round of the Uber Recruitment Process aims to determine whether or not the candidate is a cultural match for Uber. Candidates should learn more about Uber and Uber products in order to ace these interviews.

During these rounds, candidates may be asked puzzle based questions to determine their overall intelligence and how effectively they react to awkward and challenging situations. If an applicant meets all of the above criteria and has demonstrated great technical talents in previous rounds, he or she will almost certainly be hired at Uber, India. The following are some of the questions that may be asked during the Human Resources or HR round:

* What are some of your strengths and weaknesses?

* What is the reason behind you wanting to join Uber?

* Please provide me with some information which you know about Uber.

* What value do you bring to Uber, and how do you see yourself making a difference in the world while there?

* Is it conceivable for you to migrate to a different region of the country?

* Describe yourself and what you know about yourself.

* What drew you to Uber in the first place?

* What do you believe your pay will be?

Uber Interview Questions :

1 .

In operating systems, define spooling.

Spooling is the temporary storage of data so that it can be used and processed by a device, software, or system. Data is supplied to and stored in memory or other volatile storage until it is required by a programme or computer for execution. SPOOL is an abbreviation for "Simultaneous Peripheral Operations Online." The spool is typically stored in physical memory, buffers, or interrupts for Input/Output devices on the computer. To process the spool in ascending order, the FIFO (first in, first out) approach is employed. Spooling is the process of gathering data from a large number of Input/Output processes and storing it in a buffer. This buffer is a memory or hard disc area that Input/Output devices can access. In a distributed context, an operating system does the following:

* Controls data spooling for Input/Output devices with varying data access rates.

* Maintains the spooling buffer, which acts as a data holding space while the slower device catches up.

* The spooling procedure preserves parallel computing since a computer can perform Input/Output in parallel sequence. The computer can now read data from a tape, write data to disc, and print data to a tape printer all at the same time.

Printing is the most visible application of spooling. Before being added to the printing queue, the papers to be printed are held in the SPOOL. Several programmes can run and use the CPU during this period without having to wait for the printer to finish printing on each paper individually. Many additional features, such as defining priorities, receiving notifications when the printing process is complete, and selecting different types of paper to print on based on the user's preferences, can be added to the Spooling printing process.

2 .

What is Servlet Collaboration?

The process of communicating information among the servlets of a Java web application is known as servlet collaboration. This enables data to be transmitted from one servlet to another via method invocations. Java's Servlet API (Application Programming Interface), which exposes two interfaces, is the primary method for achieving Servlet Collaboration.

* javax.servlet.RequestDispatcher
* javax.servlet.http.HttpServletResponse

These two interfaces contain the approaches for achieving the purpose of servlet information exchange.

3 .

What is the difference between Swapping and Paging.

SWAPPING	PAGING
In swapping, the whole process in its entirety is moved to the secondary memory.	Paging is done when some part of a process is being transferred to secondary memory.
In Swapping, the temporary transfer of a process from the main memory to secondary memory takes place.	In Paging, a contiguous block of memory is made non-contiguous but of fixed size called frame or pages.
Swapping requires no memory management.	Paging requires non-contiguous Memory Management.
The direction regarding the solution in it is provided in swapping.	No direction regarding the solution in it is provided in Paging.

4 .

In the context of operating systems, define microkernels.

One of the kernel's classes is the microkernel. Because it is a kernel, it is in charge of all system resources. In a microkernel, however, user and kernel services are implemented in separate address zones. Because user services are placed in user address space and kernel services are located in kernel address space, the kernel and operating system are both smaller. It just offers the minimal essentials in terms of process and memory management. The execution microkernel is slowed by message forwarding, which is used to establish communication between client programs/applications and services executing in user address space. Because user and kernel services are separated, the Operating System is unaffected if one fails. As a result, one of the microkernel's advantages is enhanced. It's simple to extend since new services are added to the user address space rather than the kernel address area, requiring no kernel changes. It's also portable, secure, and dependable.

The following are some of Microkernel's advantages:

* This kernel performs better because of its compact and isolated architecture.

* The system can be expanded more easily since it can be added to the system application without disrupting the kernel.

5 .

What do you know about demand paging in operating systems?

Demand paging in operating systems is a strategy for loading pages (a page is the smallest unit of data for memory management in a virtual memory operating system). A page frame is the smallest contiguous unit of physical memory with a predetermined length into which the operating system maps memory pages) only when they are needed. Virtual Memory is a storage allocation method that makes it possible to address secondary memory as if it were the main memory. The addresses used by a program to refer to memory are different from the addresses used by the memory system to designate physical storage sites, and the addresses created by the program are automatically converted to machine addresses. The quantity of secondary memory available is defined by the number of main storage sites available rather than the actual number of main storage locations, and the capacity of virtual storage is restricted by the computer system's addressing scheme.

When a place on the page is addressed during execution, the page is only brought into memory. The following are the steps for getting a page into the main memory or demand paging:

* An attempt is made by the operating system to visit the page.

* If the page is valid, the CPU proceeds to process instructions as usual (in memory).

* When a page is wrong, the operating system performs a page fault trap.

* The operating system then examines the memory reference to see if it is a valid reference to a secondary memory location. The process will be cancelled if this is not the case (illegal memory access). Otherwise, the operating system will have to read the page from the main memory.

* The operating system arranges a disc operation to read the desired page into the main memory.

* The operation that was paused as a result of the operating system trap is then restarted or continued.

6 .

What do you know about a VPN (Virtual Private Network)? What are the many types of virtual private networks (VPNs)?

A virtual private network (VPN) connects users' computers to a private network across a public network, allowing them to send and receive data as if they were physically connected to the private network. Using a VPN gives you more capability, security, and control over your private network. Telecommuting professionals typically use it to acquire access to resources that aren't available on the public network. Although encryption is common, a VPN connection does not require it. A VPN is created by creating a virtual point to point connection over existing networks utilising dedicated circuits or tunnelling technology. Some of the advantages of a wide area network can be acquired by connecting to a VPN over the public Internet (WAN). From the user's perspective, the resources supplied within the private network can be accessed remotely.

The following are the various types of VPNs :

* Site to Site VPN: A Site to Site VPN, also known as a Router to Router VPN, joins the networks of two offices in different locations. There are two subcategories, as indicated below:

* Intranet VPN: Intranet VPNs are used for connecting remote offices in various locations utilising one single infrastructure, that is, the servers, internet connectivity, etc., as a private WAN and the same accessibility policies (wide area network).

* Extranet VPN: Extranet VPN uses common infrastructure to connect intranet users, suppliers, consumers, partners, and other entities via dedicated connections.

* Access VPN: An access VPN is a sort of virtual private network that allows mobile users and telecommuters to connect to the internet from a remote location. Dial-up or ISDN (Integrated Services Digital Network) connections can be replaced with it. It's a budget-friendly alternative with a variety of connectivity possibilities.

7 .

What exactly is a Bootstrap Program in terms of operating systems?

* A Bootstrap Program is typically a program that initialises the operating system during the startup of a computer system, in other words, the first program that runs when a computer system starts up. Booting is a method or application for loading the operating system. Overall, the bootstrap program is completely responsible for the operating system's performance and functionality.

* It is totally stored in boot blocks at a specific spot on the disc. It also locates and loads the kernel into the main memory before starting the program.

* The Bootstrap Program, as shown in the figure below, lies in the Read-Only Memory (ROM) of our computers and is responsible for reading the Operating Systems and loading them into the RAM (Random Access Memory) of our computers. After then, the operating systems can start other computer devices such as graphics cards, keyboards, and mice.

8 .

State your understanding of Distributed Database Management Systems with Transparency?

The transparent Distributed Database Management System is a type of database management system that hides the physical structure of the database from users. Physical structure, also known as physical storage structure, refers to the memory manager of a database management system and describes how data is saved on a disc. There is less abstraction as a result of this. In Distributed Database Management Systems (or DDBMS), there are four forms of transparency:

* Transparency in transactions.

* Transparency in performance.

* Transparency in relational databases.

* Transparency in distribution.

9 .

Write functional code for solving the problem given below:

Given an undirected tree, each node is assigned a weight. We must remove an edge in such a way that the difference between the sum of weights in one subtree and the sum of weights in the other subtree is as small as possible.

So for the example given below, we have to remove an edge to reduce the subtree sum difference.

We have 6 edge deletion options in the below given tree:

* edge 0-1, subtree sum difference = 21 - 2 = 19
* edge 0-2, subtree sum difference = 14 - 9 = 5
* edge 0-3, subtree sum difference = 15 - 8 = 7
* edge 2-4, subtree sum difference = 20 - 3 = 17
* edge 2-5, subtree sum difference = 18 - 5 = 13
* edge 3-6, subtree sum difference = 21 - 2 = 19

Clearly, we should remove the edge 0-2 in an optimal solution.

C ++ function which solves the given Data Structures and Algorithm problem is given below:

/* DFS traversal through edges helps us to calculate the subtree sum at every node and updates the difference between the subtrees */
void dfs(int s, int par, int sumTotal,
       vector<int> adj[], int sub[], int& result)
{
   int sum = sub[s];
 
   /* looping for all adjacent nodes except for the parent and
       aggregating the sum over all subtrees */
   for (auto v: adj[s])
   {
       if (v != par)
       {
           dfs(v, s, sumTotal, adj, sub, result);
           sum += sub[v];
       }
   }
 
   // storing the sum for current node in its subtree index
   sub[s] = sum;
 
   /* For one side, the subtree sum has to be 'sum' and for the other side, the subtree sum has to be 'sumTotal - sum' and therefore,
   their difference is going to be sumTotal - 2*sum. We update our result's value using this */
   if (s != 0 && abs(sumTotal - 2*sum) < result)
       result = abs(sumTotal - 2*sum);
}
 
// Function for returning the minimum subtree sum difference
int getMinimumDiff(vector<int> value, vector<int> adj[], int n)
{
   int sumTotal = 0;
   int sub[n];
 
   /* Finding the total sum of the values in the tree and initialising subtree sum's by vertex values */
   for (int j = 0; j < n; j++)
   {
       sub[j] = value[j];
       sumTotal += value[j];
   }
 
  int result = INT_MAX;
 
   // a call to the dfs method at node 0 with parent as -1
   dfs(0, -1, sumTotal, adj, sub, result);
   return result;
}

DFS can help us tackle this problem. One straightforward way is to delete each edge one by one and compare the subtree sum difference. Finally, select the bare minimum of them. This method requires a quadratic amount of time complexity. By calculating the sum of both subtrees using the entire sum of the tree, an efficient technique can solve this problem in linear time. We may obtain the sum of another tree by subtracting the sum of one subtree from the total sum of the tree; thus, the subtree sum difference can be computed at each node in O(1) time. First, we compute the weight of the entire tree, and then, while doing DFS at each node, we compute its subtree sum; by combining these two values, we can compute the subtree sum difference. Another array subtree is used in the following code to hold the sum of subtrees rooted at node i in subtree[i]. DFS is invoked with the current node index and the parent index each time to loop through the children at each node. Please see the code above for a better understanding.

10 .

Write functional code for solving the problem given below:

You are at point 'A,' the top-left cell of a m X n matrix, and your destination is the point 'B,' the bottom-right cell of the same matrix. Your job is to find the total number of unique pathways from point ‘A’ to point ‘B’. In other words, you will be provided with the matrix dimensions as integers 'm' and 'n', and your objective will be to find the total number of unique paths from the cell arr[0][0] to arr[m - 1][n - 1]. At each phase, you can move either Right or Down in the matrix. For instance, in a given place arr[i] [j], you can go to arr[i + 1][j] or arr[i][j + 1]. Sample input and output for the given problem is as follows:

Input : m = 2, n = 2;
Output : 2

C ++ function which solves the given Data Structures and Algorithm problem is given below:

int totalPathCount(int m, int n)
{
   /* Creating a two dimensional table for storing the answers of the subproblems*/
   int dp[m][n];

   // Total number of paths to reach any cell in the first column is 1
   for (int i = 0; i < m; i++)
       dp[i][0] = 1;

   // Total number of paths to reach any cell in the first row is 1
   for (int j = 0; j < n; j++)
       dp[0][j] = 1;

   // Calculating total number of paths for other cells in
   // bottom-up manner using dynamic programming
   for (int i = 1; i < m; i++) {
       for (int j = 1; j < n; j++)
       {
           dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
   }
   return dp[m - 1][n - 1];
}

The given problem can be solved using dynamic programming. We can claim that the number of paths to reach any cell in the first column is one as one can only move downwards. Similarly, the number of paths to reach any cell in the first row is again one since one can only move rightwards. For the rest of the cells, we can calculate the total number of ways to reach it using the following recurring relation:

Arr[i][j] = Arr[i-1][j] + Arr[i][j-1]

11 .

Write functional code for solving the problem given below:

You are provided with an array containing n non-negative numbers, as well as a non-negative number sum. You must determine the number of subarrays in a whose sum is less than the sum. We can make the assumption that there is no overflow. Sample input and output for the given problem is as follows:

Input: a = [2, 5, 6]
sum = 10
Output: 4

C ++ function which solves the given Data Structures and Algorithm problem is given below:

int foo(vector<int> &a, int sum) {
   int answer = 0;
   int s = 0, left = 0,right = 0;
   while(right < a.size()){
       s += a[right];
       while(s >= sum){
           s -= a[left ++];
       }
       answer += (right - left + 1);
       right ++;
   }
   return answer;
}

The sliding window technique is an efficient solution that can be utilised to tackle the problem. We utilise two pointers, left and right, to indicate the sliding window's beginning and ending points. Initially, both left and right point to the array's beginning, i.e. index 0. Let's try adding a new element from the array. There are two probable outcomes:

* In the first scenario, if the sum is smaller than the sum, increment the right by one position. As a result, the contiguous arrays produced by this phase are (right-left). We additionally add the current element to the preceding total. There are as many of these arrays as the window's length.

* In the second case, the current subarray sum becomes more than or equal to the maximum allowed sum given, we must deduct the starting element from the total such that the sum becomes less than the maximum allowed sum given once more. As a result, we alter the window's left border by increasing the value of the left pointer.

We repeat this technique until the right pointer reaches the end of the array.

12 .

Write functional code for solving the problem given below:

An integer interval [A, B] is a collection of all successive integers between A and B, including A and B. You are given a 2D array A of dimensions N x 2, with each row representing an interval. Find the smallest size of a set S such that the intersection of S with Z has a size of at least two for every integer interval Z in A. Sample input and output for this problem is given below:

Input: a = [[1, 3], [1, 4], [2, 5], [3, 5]]
Output: 3

C ++ function which solves the given Data Structures and Algorithm problem is given below:

int findIntersectingSet(vector<vector<int> > &a) {
        int length = a.size();
        sort(a.begin(), a.end(), [&](vector<int> A, vector<int> B){
            if(A[1] != B[1])
                return A[1] < B[1];
            return A[0] < B[0];
        });
        vector<int> answer;
        answer.push_back(a[0][1] - 1);
        answer.push_back(a[0][1]);
        for (int j = 1; j < length; j ++) {
            int s = a[j][0];
            int e = a[j][1];
            int sizeOfAnswer = answer.size();
            int lastAddedNumber = answer[sizeOfAnswer - 1];
            int secondLastAddedNumber = answer[sizeOfAnswer - 2];
            if (s > lastAddedNumber) {
                answer.push_back(e - 1);
                answer.push_back(e);
            } else if (s == lastAddedNumber) {
                answer.push_back(e);
            }
            else if (s > secondLastAddedNumber ) {
                answer.push_back(e);
            }
        }
        return answer.size();
}

In order to solve this problem, we must arrange the intervals by the right border first (ascending), followed by the left border (ascending). Then we add the first interval's end and end - 1. Then we look at the current interval's boundaries. To make the present interval fit the problem condition, we must either add zero, one, or at most two points.

13 .

Write functional code for solving the problem given below:

Given an array of both positive and negative numbers, find out the largest sum that can be achieved by considering any-one subarray of the given array. Sample input and output for the given problem is given below:

Input: arr = [5,-2,4,-2,1]
Output: 7

C ++ function which solves the given Data Structures and Algorithm problem is given below:

int maximumSumOfSubarray(vector<int> arr)
{
  int n = arr.size();
  int res = 0;
  int curMax = 0;

  for (int j = 0; j < n; j ++)
  {
       curMax = max(arr[j], curMax + arr[j]);
       res = max(res, curMax);
  }
  return res;
}

We use Kadane's algorithm to solve this given problem. The basic idea behind Kadane's approach is to search the array for all positive contiguous segments (curMax is utilised for this) and maintain a record of the maximum sum contiguous segment among all positive segments (res is used for this). When we get a positive total, we compare it to the variable res and update the res variable if the sum found is bigger.

14 .

Write functional code for solving the problem given below: Detect whether or not a given linked list contains a cycle.

C ++ function which solves the given Data Structures and Algorithm problem is given below:

bool detectCycle(ListNode* root)
{
   ListNode *slow = root, *fast = root;

   while (slow && fast && fast -> link) {
       slow = slow->link;
       fast = fast->link->link;
       if (slow == fast) {
           return true;
       }
   }
   return false;
}

For solving this question, we can use Floyd's Approach to Find cycle in a linked list. It is stated below:

* Two pointers are used for traversing the linked list.

* One pointer (slow) should be moved by one, while another pointer (fast) should be moved by two.

* There is a loop if these points intersect at the same node. A linked list does not have a loop if the pointers do not meet.