Preparing for a SQL interview at Uber involves not only understanding SQL concepts but also being able to work with practical examples. Here, we’ll provide 15 unique SQL questions you might encounter during an interview at Uber, along with detailed database setups and explanations. Each question will include the query, output, and thorough explanations to help you grasp the concepts.

By practicing with these real-world examples, you’ll gain the hands-on experience and confidence you need to tackle even the toughest SQL challenges at Uber. From querying ride data to analyzing user behavior, these questions will put your skills to the test and prepare you for success in your interview.

List of Most Asked Uber SQL Interview Questions

Here’s a complete list of the 15 best Uber SQL interview questions, carefully curated to help you prepare and succeed. This list covers everything from basic query writing to complex data analysis. Whether you’re a seasoned data professional or a newcomer to the field, these questions will challenge your knowledge and skills, and help you develop the expertise needed to excel in a data role at Uber.

1. Identify Overlapping Event Time Slots

Write a query to find events that have overlapping time slots. This question tests the use of joins and date/time functions to find overlapping events.

Create Database:

CREATE TABLE Events (
    EventID INT PRIMARY KEY,
    EventName VARCHAR(100),
    StartTime DATETIME,
    EndTime DATETIME
);

INSERT INTO Events (EventID, EventName, StartTime, EndTime) VALUES
(1, 'Event A', '2024-07-11 10:00:00', '2024-07-11 12:00:00'),
(2, 'Event B', '2024-07-11 11:30:00', '2024-07-11 13:00:00'),
(3, 'Event C', '2024-07-11 14:00:00', '2024-07-11 15:00:00');

Output:

EventID	EventName	StartTime	EndTime
1	Event A	2024-07-11 10:00:00	2024-07-11 12:00:00
2	Event B	2024-07-11 11:30:00	2024-07-11 13:00:00
3	Event C	2024-07-11 14:00:00	2024-07-11 15:00:00

Query:

SELECT e1.EventID AS EventID1, e1.EventName AS EventName1,
       e2.EventID AS EventID2, e2.EventName AS EventName2
FROM Events e1
JOIN Events e2 ON e1.EventID < e2.EventID
              AND ((e1.StartTime <= e2.StartTime AND e1.EndTime > e2.StartTime)
                   OR (e2.StartTime <= e1.StartTime AND e2.EndTime > e1.StartTime));

Output:

EventID1	EventName1	EventID2	EventName2
1	Event A	2	Event B

Explanation: Event A (EventID 1) overlaps with Event B (EventID 2) because Event A starts at 10:00 AM and ends at 12:00 PM, and Event B starts at 11:30 AM and ends at 1:00 PM, overlapping between 11:30 AM to 12:00 PM.

2. Temperature Drop Analysis

Write a query to find the days with the highest drop in temperature compared to the previous day. This question evaluates window functions to analyze data across rows.

Create Database:

CREATE TABLE Temperature (
    Date DATE PRIMARY KEY,
    Temperature INT
);

INSERT INTO Temperature (Date, Temperature) VALUES
('2024-07-09', 30),
('2024-07-10', 25),
('2024-07-11', 20),
('2024-07-12', 22);

Output:

Date	Temperature
2024-07-09	30
2024-07-10	25
2024-07-11	20
2024-07-12	22

Query:

WITH TemperatureChanges AS (
    SELECT 
        Date,
        Temperature,
        LAG(Temperature) OVER (ORDER BY Date) AS PreviousTemperature,
        Temperature - LAG(Temperature) OVER (ORDER BY Date) AS TemperatureDrop
    FROM Temperature
)
SELECT Date, TemperatureDrop
FROM TemperatureChanges
WHERE TemperatureDrop = (SELECT MAX(TemperatureDrop) FROM TemperatureChanges);

Output:

Date	TemperatureDrop
2024-07-12	2

Explanation: The LAG function is used to access the temperature of the previous day, and the difference is calculated to find the largest drop.

3. Doctors Specializing in Rare Diseases

Write a query to find doctors who specialize in rare diseases mentioned in their profiles. This question involves string functions to search for keywords in text data.

Create Database:

CREATE TABLE Doctors (
    DoctorID INT PRIMARY KEY,
    Name VARCHAR(100),
    Specialization VARCHAR(255)
);

INSERT INTO Doctors (DoctorID, Name, Specialization) VALUES
(1, 'Dr. Smith', 'Cardiology, Rare Diseases, Neurology'),
(2, 'Dr. Jones', 'General Medicine, Pediatrics'),
(3, 'Dr. Brown', 'Rare Diseases, Oncology');

Query:

SELECT DoctorID, Name, Specialization
FROM Doctors
WHERE Specialization LIKE '%Rare Diseases%';

DoctorID	Name	Specialization
1	Dr. Smith	Cardiology, Rare Diseases, Neurology
3	Dr. Brown	Rare Diseases, Oncology

Explanation: The query returns two doctors (Dr. Smith and Dr. Brown) who have ‘Rare Diseases’ mentioned in their Specialization profiles.

4. Products in High Demand but Low Stock

Write a query to find products that have high sales but low stock levels. This question requires a subquery to compare sales and stock levels.

Create Database:

CREATE TABLE Products (
    ProductID INT PRIMARY KEY,
    ProductName VARCHAR(100),
    Stock INT
);

CREATE TABLE Sales (
    SaleID INT PRIMARY KEY,
    ProductID INT,
    Quantity INT
);

INSERT INTO Products (ProductID, ProductName, Stock) VALUES
(1, 'Product A', 50),
(2, 'Product B', 5),
(3, 'Product C', 30);

INSERT INTO Sales (SaleID, ProductID, Quantity) VALUES
(1, 1, 100),
(2, 2, 200),
(3, 3, 50);

Query:

SELECT p.ProductID, p.ProductName, p.Stock, SUM(s.Quantity) AS TotalSales
FROM Products p
JOIN Sales s ON p.ProductID = s.ProductID
GROUP BY p.ProductID, p.ProductName, p.Stock
HAVING SUM(s.Quantity) > p.Stock;

Output:

ProductID	ProductName	Stock	TotalSales
1	Product A	50	100
2	Product B	5	200
3	Product C	30	50

Explanation: Product A (ProductID 1) has a stock of 50 and total sales of 100, indicating high sales relative to stock. Product B (ProductID 2) has a stock of 5 and total sales of 200, indicating very high sales relative to stock.

5. Sales Performance by Region and Quarter

Write a query to show sales performance by region and quarter in a pivot table format. This question tests to pivot data for reporting purposes.

Create Database:

CREATE TABLE Sales (
    SaleID INT PRIMARY KEY,
    Region VARCHAR(50),
    SaleDate DATE,
    Amount DECIMAL(10, 2)
);

INSERT INTO Sales (SaleID, Region, SaleDate, Amount) VALUES
(1, 'North', '2024-01-15', 1000),
(2, 'South', '2024-04-20', 1500),
(3, 'East', '2024-07-10', 1200),
(4, 'West', '2024-10-05', 1700);

Query:

SELECT 
    Region,
    SUM(CASE WHEN EXTRACT(QUARTER FROM SaleDate) = 1 THEN Amount ELSE 0 END) AS Q1,
    SUM(CASE WHEN EXTRACT(QUARTER FROM SaleDate) = 2 THEN Amount ELSE 0 END) AS Q2,
    SUM(CASE WHEN EXTRACT(QUARTER FROM SaleDate) = 3 THEN Amount ELSE 0 END) AS Q3,
    SUM(CASE WHEN EXTRACT(QUARTER FROM SaleDate) = 4 THEN Amount ELSE 0 END) AS Q4,
    SUM(Amount) AS Total
FROM Sales
GROUP BY Region
ORDER BY Region;

Output:

Region	Q1	Q2	Q3	Q4	Total
East	0.00	0.00	1200.00	0.00	1200.00
North	1000.00	0.00	0.00	0.00	1000.00
South	0.00	1500.00	0.00	0.00	1500.00
West	0.00	0.00	0.00	1700.00	1700.00

Explanation: This table shows sales performance (Amount) for each quarter (Q1, Q2, Q3, Q4) and the total sales (Total) for each region (North, South, East, West). For example, East had sales of 1200 in Q3 (Q3 column), and West had sales of 1700 in Q4 (Q4 column).

6. Department Heads with Long Tenures

Write a query to find department heads who have been in their position for more than 5 years. This question involves joining tables and using date functions to calculate tenure.

Create Database:

CREATE TABLE DepartmentHeads (
    HeadID INT PRIMARY KEY,
    Name VARCHAR(100),
    StartDate DATE
);

INSERT INTO DepartmentHeads (HeadID, Name, StartDate) VALUES
(1, 'John Doe', '2015-01-10'),
(2, 'Jane Smith', '2020-02-15'),
(3, 'Alice Johnson', '2012-03-20');

Query:

SELECT HeadID, Name, StartDate
FROM DepartmentHeads
WHERE DATEDIFF(CURDATE(), StartDate) > 5 * 365;

Output:

HeadID	Name	StartDate
1	John Doe	2015-01-10
3	Alice Johnson	2012-03-20

Explanation: The query calculates the difference between the current date and the start date, filtering for those greater than 5 years (365 * 5 days).

7. Users with Pending Orders

Write a query to identify users who have orders that have not been shipped yet. This question tests your ability to join tables and filter data based on specific conditions.

Create Database:

CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    UserName VARCHAR(100)
);

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    UserID INT,
    Status VARCHAR(50)
);

INSERT INTO Users (UserID, UserName) VALUES
(1, 'Alice'),
(2, 'Bob'),
(3, 'Charlie');

INSERT INTO Orders (OrderID, UserID, Status) VALUES
(1, 1, 'Shipped'),
(2, 2, 'Pending'),
(3, 3, 'Pending');

Query:

SELECT u.UserID, u.UserName
FROM Users u
JOIN Orders o ON u.UserID = o.UserID
WHERE o.Status = 'Pending';

Output:

UserID	UserName
2	Bob
3	Charlie

Explanation: The query returns users (Bob and Charlie) who have orders that are still pending (Status = ‘Pending’). This query effectively identifies users with pending orders using SQL joins and filtering based on specific conditions in the Orders table.

8. Monthly Active Users by Device

Write a query to find the number of monthly active users categorized by the type of device they use. This question involves grouping and counting based on specific criteria.

Create Database:

CREATE TABLE UserActivity (
    ActivityID INT PRIMARY KEY,
    UserID INT,
    DeviceType VARCHAR(50),
    ActivityDate DATE
);

INSERT INTO UserActivity (ActivityID, UserID, DeviceType, ActivityDate) VALUES
(1, 1, 'Mobile', '2024-07-01'),
(2, 2, 'Desktop', '2024-07-02'),
(3, 1, 'Mobile', '2024-07-03'),
(4, 3, 'Tablet', '2024-07-04');

Query:

SELECT 
    DeviceType,
    COUNT(DISTINCT UserID) AS MonthlyActiveUsers
FROM UserActivity
WHERE MONTH(ActivityDate) = MONTH('2024-07-01')  -- Filter for July 2024
AND YEAR(ActivityDate) = YEAR('2024-07-01')
GROUP BY DeviceType;

Output:

DeviceType	MonthlyActiveUsers
Mobile	2
Desktop	1
Tablet	1

Explanation: This query effectively calculates the number of monthly active users by device type for a specified month using SQL grouping and counting functions. Adjust the WHERE clause date conditions as needed to query different months or periods.

9. Patients with Specific Allergies

Write a query to find patients who have allergies to a specific list of substances. This question tests to use string functions and conditional filtering.

Create Database:

CREATE TABLE Patients (
    PatientID INT PRIMARY KEY,
    Name VARCHAR(100),
    Allergies VARCHAR(255)
);

INSERT INTO Patients (PatientID, Name, Allergies) VALUES
(1, 'John Doe', 'Peanuts, Shellfish, Pollen'),
(2, 'Jane Smith', 'Dust, Pollen'),
(3, 'Alice Johnson', 'Peanuts, Latex');

Query:

SELECT PatientID, Name, Allergies
FROM Patients
WHERE Allergies LIKE '%Peanuts%' OR Allergies LIKE '%Shellfish%';

Output:

PatientID	Name	Allergies
1	John Doe	Peanuts, Shellfish, Pollen
3	Alice Johnson	Peanuts, Latex

Explanation: This query effectively identifies patients with specific allergies using SQL string functions (LIKE) and conditional filtering. Adjust the LIKE conditions as needed to search for other substances or combinations of substances.

10. Delayed Shipment Analysis

Write a query to find shipments that have been delayed beyond the expected delivery date. This question involves selecting and filtering data based on date comparisons.

Create Database:

CREATE TABLE Shipments (
    ShipmentID INT PRIMARY KEY,
    ExpectedDeliveryDate DATE,
    ActualDeliveryDate DATE
);

INSERT INTO Shipments (ShipmentID, ExpectedDeliveryDate, ActualDeliveryDate) VALUES
(1, '2024-07-10', '2024-07-12'),
(2, '2024-07-15', '2024-07-14'),
(3, '2024-07-20', '2024-07-22');

Query:

SELECT *
FROM Shipments
WHERE ActualDeliveryDate > ExpectedDeliveryDate;

Output:

ShipmentID	ExpectedDeliveryDate	ActualDeliveryDate
1	2024-07-10	2024-07-12
3	2024-07-20	2024-07-22

Explanation: This query effectively identifies delayed shipments based on date comparisons using SQL. Adjustments can be made to include additional conditions or refine the date comparisons depending on specific requirements.

11. Average Resolution Time by Support Agent

Write a query to calculate the average resolution time of support tickets handled by each agent. This question involves joining tables and using date functions to calculate averages.

Create Database:

CREATE TABLE SupportTickets (
    TicketID INT PRIMARY KEY,
    AgentID INT,
    OpenDate DATETIME,
    CloseDate DATETIME
);

INSERT INTO SupportTickets (TicketID, AgentID, OpenDate, CloseDate) VALUES
(1, 1, '2024-07-01 08:00:00', '2024-07-01 12:00:00'),
(2, 2, '2024-07-01 09:00:00', '2024-07-01 10:30:00'),
(3, 1, '2024-07-01 10:00:00', '2024-07-01 14:00:00');

Query:

SELECT
    AgentID,
    AVG(TIMESTAMPDIFF(HOUR, OpenDate, CloseDate)) AS AvgResolutionTimeInHours
FROM SupportTickets
GROUP BY AgentID;

Output:

AgentID	AvgResolutionTimeInHours
1	4.0
2	1.5

Explanation: This query effectively calculates the average resolution time per support agent using SQL date functions (TIMESTAMPDIFF) and aggregation (AVG), providing insights into agent performance metrics. Adjustments can be made to the query to include different date units or additional conditions as per specific requirements.

12. Unique Courses with High Ratings

Write a query to find unique courses that have an average rating above 4.5. This question tests your ability to use aggregate functions and grouping.

Create Database:

CREATE TABLE Courses (
    CourseID INT PRIMARY KEY,
    CourseName VARCHAR(100),
    Rating DECIMAL(2, 1)
);

INSERT INTO Courses (CourseID, CourseName, Rating) VALUES
(1, 'Course A', 4.7),
(2, 'Course B', 4.3),
(3, 'Course C', 4.8),
(4, 'Course A', 4.6);

Query:

SELECT CourseName, AVG(Rating) AS AvgRating
FROM Courses
GROUP BY CourseName
HAVING AVG(Rating) > 4.5;

Output:

CourseName	AvgRating
Course A	4.65
Course C	4.8

Explanation: This query effectively identifies unique courses with high average ratings using SQL aggregate functions (AVG) and grouping (GROUP BY), providing insights into popular or highly-rated courses based on the criteria specified.

13. Annual Revenue Growth Rate by Product Line

Write a query to calculate the annual revenue growth rate for each product line. This question involves using aggregate functions and date functions to calculate growth rates.

Create Database:

CREATE TABLE Revenue (
    ProductLine VARCHAR(50),
    Year INT,
    Revenue DECIMAL(10, 2)
);

INSERT INTO Revenue (ProductLine, Year, Revenue) VALUES
('Electronics', 2023, 100000),
('Electronics', 2024, 150000),
('Clothing', 2023, 50000),
('Clothing', 2024, 60000);

Query:

SELECT
    ProductLine,
    ((Revenue_Year2 - Revenue_Year1) / Revenue_Year1) * 100 AS AnnualGrowthRate
FROM
    (SELECT
        ProductLine,
        MAX(CASE WHEN Year = 2023 THEN Revenue ELSE NULL END) AS Revenue_Year1,
        MAX(CASE WHEN Year = 2024 THEN Revenue ELSE NULL END) AS Revenue_Year2
    FROM Revenue
    GROUP BY ProductLine) AS YearlyRevenue;

Output:

ProductLine	AnnualGrowthRate
Electronics	50.00
Clothing	20.00

Explanation: This query effectively computes the annual revenue growth rate for each product line using SQL aggregate functions and calculations, providing insights into the growth trends across different product categories. Adjustments can be made to include more years or refine the calculations as per specific analytical needs.

14. Actors with Most Screen Time in Award-Winning Movies

Write a query to find actors with the most screen time in award-winning movies. This question involves using aggregate functions and grouping to analyze screen time data.

Create Database:

CREATE TABLE Movies (
    MovieID INT PRIMARY KEY,
    Title VARCHAR(100),
    IsAwardWinning BOOLEAN
);

CREATE TABLE Actors (
    ActorID INT PRIMARY KEY,
    Name VARCHAR(100)
);

CREATE TABLE MovieActors (
    MovieID INT,
    ActorID INT,
    ScreenTime INT,
    PRIMARY KEY (MovieID, ActorID)
);

INSERT INTO Movies (MovieID, Title, IsAwardWinning) VALUES
(1, 'Movie A', TRUE),
(2, 'Movie B', FALSE),
(3, 'Movie C', TRUE);

INSERT INTO Actors (ActorID, Name) VALUES
(1, 'Actor 1'),
(2, 'Actor 2'),
(3, 'Actor 3');

INSERT INTO MovieActors (MovieID, ActorID, ScreenTime) VALUES
(1, 1, 120),
(1, 2, 100),
(3, 1, 90),
(3, 3, 110);

Query:

SELECT
    a.ActorID,
    a.Name AS ActorName,
    SUM(ma.ScreenTime) AS TotalScreenTime
FROM
    Movies m
JOIN
    MovieActors ma ON m.MovieID = ma.MovieID
JOIN
    Actors a ON ma.ActorID = a.ActorID
WHERE
    m.IsAwardWinning = TRUE
GROUP BY
    a.ActorID, a.Name
ORDER BY
    TotalScreenTime DESC
LIMIT 1;

Output:

ActorID	ActorName	TotalScreenTime
1	Actor 1	210

Explanation: This query effectively retrieves the actor with the most screen time in award-winning movies by leveraging SQL joins, grouping, and aggregation functions (SUM), providing insights into which actors have had significant roles in successful films.

15. Detailed Order Summary for VIP Customers

Write a query to provide a detailed summary of orders placed by VIP customers, including order value, date, and items purchased. This question involves joining tables and selecting detailed information based on specific criteria.

Create Database:

CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    CustomerName VARCHAR(100),
    IsVIP BOOLEAN
);

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    OrderValue DECIMAL(10, 2)
);

CREATE TABLE OrderItems (
    OrderID INT,
    ItemName VARCHAR(100),
    Quantity INT,
    PRIMARY KEY (OrderID, ItemName)
);

INSERT INTO Customers (CustomerID, CustomerName, IsVIP) VALUES
(1, 'Alice', TRUE),
(2, 'Bob', FALSE),
(3, 'Charlie', TRUE);

INSERT INTO Orders (OrderID, CustomerID, OrderDate, OrderValue) VALUES
(1, 1, '2024-07-01', 100),
(2, 2, '2024-07-02', 50),
(3, 3, '2024-07-03', 150);

INSERT INTO OrderItems (OrderID, ItemName, Quantity) VALUES
(1, 'Item A', 2),
(1, 'Item B', 1),
(3, 'Item C', 3);

Query:

SELECT
    c.CustomerID,
    c.CustomerName,
    o.OrderID,
    o.OrderDate,
    o.OrderValue,
    oi.ItemName,
    oi.Quantity
FROM
    Customers c
JOIN
    Orders o ON c.CustomerID = o.CustomerID
JOIN
    OrderItems oi ON o.OrderID = oi.OrderID
WHERE
    c.IsVIP = TRUE;

Output:

CustomerID	CustomerName	OrderID	OrderDate	OrderValue	ItemName	Quantity
1	Alice	1	2024-07-01	100.00	Item A	2
1	Alice	1	2024-07-01	100.00	Item B	1
3	Charlie	3	2024-07-03	150.00	Item C	3

Explanation: This query effectively provides a detailed summary of orders placed by VIP customers, demonstrating their order history, including specific items purchased and quantities, aiding in understanding their purchasing patterns and preferences.

Conclusion

Mastering SQL is the key to unlocking a successful data career at Uber, and with these 15 interview questions, you’re well on your way to achieving your goal. Remember, practice is the name of the game, so be sure to try out each question and review the explanations carefully. With dedication and persistence, you’ll be able to tackle even the toughest SQL challenges and drive your career forward.

Uber SQL Interview Questions – FAQs

What type of SQL questions can I expect in an Uber interview?

You can expect a mix of basic to advanced SQL questions, including queries on data analysis, data modeling, and data visualization.

How can I prepare for Uber SQL interview questions?

Practice with real-world examples, review SQL concepts, and familiarize yourself with Uber’s data schema and tools.

What is the most important SQL skill for an Uber data role?

The ability to write efficient and optimized queries to extract insights from large datasets.

Can I use SQL tools like Excel or Tableau to answer questions in an Uber interview?

No, you will be expected to write raw SQL queries to answer questions.