Last Updated: March 2026

Uber Placement Papers 2026 - Complete Preparation Guide

📋 Company Overview

Uber Technologies, Inc. is an American mobility-as-a-service provider. It operates in over 70 countries and 10,000+ cities worldwide. Uber's platform connects riders with drivers, and also offers food delivery (Uber Eats), freight, and micro-mobility services.

Key Highlights:

Founded: March 2009 (as UberCab)
Headquarters: San Francisco, California, USA
Industry: Transportation / Technology / Food Delivery
Employees: 30,000+ globally
India Presence: Major tech centers in Bangalore and Hyderabad

Eligibility Criteria 2026

Parameter	Requirement
Education	B.Tech/B.E (CS, IT, ECE, EEE)
Batch	2025, 2026
Minimum CGPA	7.5/10 or 75%
Backlogs	No active backlogs
Coding Skills	Strong algorithmic problem solving

Uber CTC for Freshers 2026

Component	Amount (Approx.)
Base Salary	₹18-25 LPA
Joining Bonus	₹2-3 Lakhs
RSUs (Stock)	Variable
Benefits	Health, Wellness, Relocation
Total CTC	₹25-40 LPA

📝 Exam Pattern

Uber's recruitment process is highly competitive with 4-5 rigorous rounds:

Round	Duration	Questions	Topics
Online Coding	90-120 mins	3-4	Algorithms, Data Structures
Technical Round 1	60 mins	-	Coding, Problem Solving
Technical Round 2	60 mins	-	System Design, Coding
Technical Round 3	45 mins	-	Projects, Deep Dive
Hiring Manager	45 mins	-	Behavioral, Culture Fit

Key Points:

Very high coding standards expected
System design is crucial even for freshers (basic level)
Focus on writing production-quality code

🧮 Aptitude Questions (15 with Solutions)

Question 1: Numbers

Find the sum of first 50 odd natural numbers.

Solution: Shortcut: Sum of first n odd numbers = n² Sum = 50² = 2500

Question 2: Probability

In a class of 40 students, 25 play cricket, 20 play football, and 10 play both. How many play neither?

Solution: Using inclusion-exclusion: |C ∪ F| = |C| + |F| - |C ∩ F| = 25 + 20 - 10 = 35

Neither = 40 - 35 = 5 students

Question 3: Combinations

How many diagonals does a decagon (10-sided polygon) have?

Solution: Formula: n(n-3)/2 for n-sided polygon = 10 × (10-3) / 2 = 10 × 7 / 2 = 35 diagonals

Question 4: Speed & Distance

A car travels from A to B at 60 km/h and returns at 40 km/h. Find average speed.

Solution: Average speed = 2xy/(x+y) for equal distances = 2 × 60 × 40 / (60 + 40) = 4800 / 100 = 48 km/h

Question 5: Ratio & Proportion

Divide ₹782 into three parts proportional to 1/2 : 2/3 : 3/4.

Solution: Ratio = 1/2 : 2/3 : 3/4 LCM of denominators = 12 Multiply by 12: 6 : 8 : 9

Total parts = 6 + 8 + 9 = 23 First part = 6/23 × 782 = ₹204 Second part = 8/23 × 782 = ₹272 Third part = 9/23 × 782 = ₹306

Question 6: Profit & Loss

By selling 45 oranges for ₹160, a man loses 20%. How many oranges should he sell for ₹240 to gain 20%?

Solution: CP of 45 oranges = 160 / 0.8 = ₹200 SP for 20% profit = 200 × 1.2 = ₹240

He should sell 45 oranges for ₹240 to gain 20%.

Question 7: Time & Work

A and B together complete work in 12 days. A alone takes 20 days. How long does B take alone?

Solution: (A+B)'s 1 day work = 1/12 A's 1 day work = 1/20 B's 1 day work = 1/12 - 1/20 = (5-3)/60 = 2/60 = 1/30

B takes 30 days

Question 8: Compound Interest

A sum becomes 4 times in 6 years at compound interest. In how many years will it become 64 times?

Solution: 4 times in 6 years means 4 = (1+r)^6 64 times = 4³ = (1+r)^18

18 years

Question 9: Series

Find the next term: 5, 11, 23, 47, 95, ?

Solution: Pattern: ×2 + 1 5×2+1=11, 11×2+1=23, 23×2+1=47, 47×2+1=95 Next: 95×2+1 = 191

Question 10: Coding-Decoding

If WATER is coded as YCVGT, then what is the code for HONEY?

Solution: Pattern: Each letter +2 W→Y, A→C, T→V, E→G, R→T

HONEY: H→J, O→Q, N→P, E→G, Y→A = JQPGA

Question 11: Blood Relations

Pointing to a photograph, a man says, "She is the daughter of my grandfather's only son." How is the man related to the girl?

Solution: Grandfather's only son = Man's father Daughter of man's father = Man's sister

The man is her brother

Question 12: Direction Sense

A person walks 8km East, turns North and walks 6km, then turns West and walks 8km. How far from start?

Solution: East 8km, North 6km, West 8km Net: 0 East-West, 6km North Distance = 6 km

Question 13: Logical Reasoning

If all roses are flowers and some flowers are red, which conclusion follows? a) All roses are red b) Some roses are red c) Some red things are flowers d) None

Question 14: Pipes & Cisterns

Three pipes A, B, C can fill a tank in 6, 12, 18 hours respectively. If all three are opened together, how long to fill the tank?

Solution: Part filled in 1 hour = 1/6 + 1/12 + 1/18 = (6 + 3 + 2)/36 = 11/36

Time = 36/11 = 3 3/11 hours

Question 15: Data Interpretation

Uber ride data: Week 1 = 1000 rides, Week 2 = 1200 rides, Week 3 = 1500 rides, Week 4 = 1800 rides. Find average weekly growth.

Solution: Week 1→2: 20% growth Week 2→3: 25% growth Week 3→4: 20% growth

Average growth = (20 + 25 + 20)/3 = 21.67%

💻 Technical/CS Questions (10 with Solutions)

Question 1: Data Structures

Design a data structure for an Uber-like ride matching system.

class RideMatchingSystem:
    def __init__(self):
        self.available_drivers = {}  # location -> set of drivers
        self.active_rides = {}
    
    def find_nearest_driver(self, rider_location, radius=5):
        """Find nearest available driver within radius using geohash/quadtree"""
        nearby_drivers = self.query_nearby(rider_location, radius)
        return min(nearby_drivers, 
                  key=lambda d: self.calculate_distance(rider_location, d.location))
    
    def calculate_distance(self, loc1, loc2):
        # Haversine formula for geographic distance
        pass

Question 2: System Design

Design a ride-hailing system like Uber.

Dispatch Service: Matches riders with drivers using geospatial indexing
Location Service: Real-time tracking of drivers using WebSockets
Pricing Service: Dynamic pricing based on demand/supply
Payment Service: Handles fare calculation and payment processing
Notification Service: Push notifications to riders and drivers

Tech Stack:

Microservices architecture
Kafka for event streaming
Redis for caching driver locations
PostgreSQL for transactional data
MongoDB for location data

Question 3: Algorithms

Find the shortest path between two points considering traffic.

import heapq

def shortest_path_with_traffic(graph, start, end, traffic_data):
    """
    Dijkstra's algorithm with time-dependent edge weights
    """
    pq = [(0, start)]
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    
    while pq:
        current_dist, current = heapq.heappop(pq)
        
        if current == end:
            return current_dist
        
        if current_dist > distances[current]:
            continue
        
        for neighbor, base_time in graph[current]:
            # Adjust time based on traffic multiplier
            traffic_multiplier = traffic_data.get((current, neighbor), 1.0)
            time = base_time * traffic_multiplier
            distance = current_dist + time
            
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(pq, (distance, neighbor))
    
    return distances[end]

Question 4: Database Design

Design a database schema for a ride-sharing app.

-- Users table
CREATE TABLE users (
    user_id UUID PRIMARY KEY,
    name VARCHAR(100),
    phone VARCHAR(20),
    email VARCHAR(100),
    type ENUM('rider', 'driver'),
    created_at TIMESTAMP
);

-- Drivers table
CREATE TABLE drivers (
    driver_id UUID PRIMARY KEY,
    user_id UUID REFERENCES users(user_id),
    vehicle_info JSON,
    current_location GEOGRAPHY(POINT),
    status ENUM('available', 'busy', 'offline'),
    rating DECIMAL(2,1)
);

-- Rides table
CREATE TABLE rides (
    ride_id UUID PRIMARY KEY,
    rider_id UUID REFERENCES users(user_id),
    driver_id UUID REFERENCES drivers(driver_id),
    pickup_location GEOGRAPHY(POINT),
    dropoff_location GEOGRAPHY(POINT),
    status ENUM('requested', 'accepted', 'ongoing', 'completed', 'cancelled'),
    fare DECIMAL(10,2),
    started_at TIMESTAMP,
    completed_at TIMESTAMP
);

-- Create spatial index
CREATE INDEX idx_driver_location ON drivers USING GIST(current_location);

Question 5: Object-Oriented Design

Design the class structure for Uber's pricing system.

from abc import ABC, abstractmethod
from enum import Enum

class RideType(Enum):
    UBERX = "uberx"
    UBERBLACK = "uberblack"
    UBERPOOL = "uberpool"

class PricingStrategy(ABC):
    @abstractmethod
    def calculate_fare(self, distance, time, demand_multiplier):
        pass

class StandardPricing(PricingStrategy):
    BASE_FARE = 2.50
    PER_MILE = 1.50
    PER_MINUTE = 0.25
    
    def calculate_fare(self, distance, time, demand_multiplier):
        fare = self.BASE_FARE + (distance * self.PER_MILE) + (time * self.PER_MINUTE)
        return fare * demand_multiplier

class SurgePricing(PricingStrategy):
    def __init__(self, base_strategy, surge_multiplier):
        self.base_strategy = base_strategy
        self.surge_multiplier = surge_multiplier
    
    def calculate_fare(self, distance, time, demand_multiplier):
        base_fare = self.base_strategy.calculate_fare(distance, time, 1.0)
        return base_fare * self.surge_multiplier * demand_multiplier

class PricingService:
    def __init__(self):
        self.strategies = {
            RideType.UBERX: StandardPricing(),
            RideType.UBERBLACK: StandardPricing(),
        }
    
    def get_fare(self, ride_type, distance, time, demand_level):
        strategy = self.strategies.get(ride_type)
        surge = self.calculate_surge(demand_level)
        if surge > 1.0:
            strategy = SurgePricing(strategy, surge)
        return strategy.calculate_fare(distance, time, 1.0)
    
    def calculate_surge(self, demand_level):
        # Surge pricing logic based on demand/supply ratio
        pass

Question 6: Distributed Systems

How would you handle real-time location updates from millions of drivers?

WebSocket Connections: Maintain persistent connections with drivers
Message Queue (Kafka): Buffer location updates
Geospatial Database: Store and query locations efficiently using Redis Geo or PostGIS
Batch Processing: Aggregate location data periodically
CDN/Edge Computing: Process updates closer to the source
Rate Limiting: Limit updates to every few seconds per driver

Question 7: Algorithms

Implement an efficient rate limiter.

import time
from collections import deque

class SlidingWindowRateLimiter:
    def __init__(self, max_requests, window_size):
        self.max_requests = max_requests
        self.window_size = window_size
        self.requests = {}
    
    def is_allowed(self, user_id):
        current_time = time.time()
        
        if user_id not in self.requests:
            self.requests[user_id] = deque()
        
        # Remove old requests outside the window
        while (self.requests[user_id] and 
               current_time - self.requests[user_id][0] > self.window_size):
            self.requests[user_id].popleft()
        
        if len(self.requests[user_id]) < self.max_requests:
            self.requests[user_id].append(current_time)
            return True
        
        return False

# Token bucket rate limiter
class TokenBucketRateLimiter:
    def __init__(self, capacity, refill_rate):
        self.capacity = capacity
        self.refill_rate = refill_rate
        self.tokens = {}
        self.last_refill = {}
    
    def is_allowed(self, user_id):
        current_time = time.time()
        
        if user_id not in self.tokens:
            self.tokens[user_id] = self.capacity
            self.last_refill[user_id] = current_time
        
        # Refill tokens
        time_passed = current_time - self.last_refill[user_id]
        tokens_to_add = time_passed * self.refill_rate
        self.tokens[user_id] = min(self.capacity, self.tokens[user_id] + tokens_to_add)
        self.last_refill[user_id] = current_time
        
        if self.tokens[user_id] >= 1:
            self.tokens[user_id] -= 1
            return True
        
        return False

Question 8: SQL

Find top 3 drivers with highest average rating who completed at least 100 rides.

SELECT 
    d.driver_id,
    d.name,
    AVG(r.rating) as avg_rating,
    COUNT(r.ride_id) as total_rides
FROM drivers d
JOIN rides r ON d.driver_id = r.driver_id
WHERE r.status = 'completed'
GROUP BY d.driver_id, d.name
HAVING COUNT(r.ride_id) >= 100
ORDER BY avg_rating DESC, total_rides DESC
LIMIT 3;

Question 9: Scalability

How would you scale a ride-matching service to handle 10x load?

Horizontal Scaling: Add more application servers
Database Sharding: Partition data by geographic region
Caching: Cache popular routes and driver locations in Redis
Load Balancing: Distribute requests evenly
CDN: Cache static content at edge locations
Async Processing: Use message queues for non-critical operations
Microservices: Decompose monolith into smaller services

Question 10: Testing

How would you test a ride-hailing application?

Fare calculation logic
Distance calculation
Driver matching algorithm

Integration Tests:

End-to-end ride flow
Payment processing
Notification delivery

Load Tests:

Simulate peak traffic (New Year's Eve scenario)
Test database performance under load

Mock Tests:

Use mock GPS coordinates
Mock payment gateways
Mock SMS/email services

📝 Verbal/English Questions (10 with Solutions)

Question 1: Synonyms

Choose the word closest in meaning to "UBIQUITOUS": a) Rare b) Omnipresent c) Unique d) Scattered

Explanation: Ubiquitous means present, appearing, or found everywhere.

Question 2: Antonyms

Opposite of "ZENITH": a) Peak b) Nadir c) Apex d) Summit

Explanation: Zenith is the highest point; nadir is the lowest point.

Question 3: Error Spotting

Identify the error: "Neither the driver nor the riders were happy with the surge pricing."

Explanation: With "neither...nor", verb agrees with the nearest subject (riders - plural, so "were" is actually correct here).

Correction: The sentence is correct! With plural nearest subject, use plural verb.

Question 4: Sentence Completion

The _______ nature of the gig economy has led to debates about worker rights. a) stable b) precarious c) permanent d) rigid

Question 5: Para Jumbles

Arrange: (A) through the app (B) customers can book rides (C) in just a few taps

Question 6: Reading Comprehension

Passage: "Dynamic pricing adjusts ride costs based on real-time demand and supply conditions..."

Question: What determines dynamic pricing? Answer: Real-time demand and supply conditions.

Question 7: Idioms

Meaning of "to take someone for a ride": a) To give a lift b) To deceive someone c) To travel together d) To offer a job

Question 8: One Word Substitution

A person who starts their own business: a) Employee b) Entrepreneur c) Manager d) Investor

Question 9: Active to Passive

Convert: "The algorithm matches riders with nearby drivers."

Question 10: Analogy

Map : Navigation :: GPS : ? a) Satellite b) Tracking c) Signal d) Location

Explanation: A map is used for navigation; GPS is used for tracking.

💻 Coding Questions (5 with Python Solutions)

Question 1: Nearest Driver (Geospatial)

Find k nearest drivers to a rider location.

import heapq
import math

def haversine_distance(lat1, lon1, lat2, lon2):
    """Calculate great circle distance between two points"""
    R = 6371  # Earth's radius in km
    
    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
    dlat = lat2 - lat1
    dlon = lon2 - lon1
    
    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
    c = 2 * math.asin(math.sqrt(a))
    
    return R * c

def find_k_nearest_drivers(rider_lat, rider_lon, drivers, k):
    """
    drivers: list of (driver_id, lat, lon)
    Returns k nearest drivers
    """
    distances = []
    for driver_id, lat, lon in drivers:
        dist = haversine_distance(rider_lat, rider_lon, lat, lon)
        distances.append((dist, driver_id))
    
    # Use heapq.nsmallest for O(n log k) complexity
    return heapq.nsmallest(k, distances)

# Example
drivers = [
    ("D1", 12.9716, 77.5946),
    ("D2", 12.9352, 77.6245),
    ("D3", 12.9789, 77.6402)
]
rider = (12.9716, 77.5946)
print(find_k_nearest_drivers(rider[0], rider[1], drivers, 2))

Time Complexity: O(n log k), Space Complexity: O(k)

Question 2: Surge Pricing Calculator

Calculate ride fare with dynamic surge pricing.

def calculate_fare(distance_km, time_minutes, base_fare=2.50, 
                   per_km=1.50, per_min=0.25, surge=1.0):
    """
    Calculate total fare including surge pricing
    """
    distance_fare = distance_km * per_km
    time_fare = time_minutes * per_min
    subtotal = base_fare + distance_fare + time_fare
    total = subtotal * surge
    
    return {
        'base_fare': base_fare,
        'distance_fare': distance_fare,
        'time_fare': time_fare,
        'subtotal': subtotal,
        'surge_multiplier': surge,
        'total_fare': round(total, 2)
    }

def calculate_surge_multiplier(demand, supply):
    """
    Calculate surge based on demand/supply ratio
    """
    ratio = demand / max(supply, 1)
    if ratio < 1.2:
        return 1.0
    elif ratio < 1.5:
        return 1.5
    elif ratio < 2.0:
        return 2.0
    else:
        return min(ratio, 3.0)  # Cap at 3x

# Example
fare = calculate_fare(10, 20, surge=1.5)
print(f"Total fare: ${fare['total_fare']}")

Question 3: Ride Matching Algorithm

Match riders with optimal drivers using criteria.

from dataclasses import dataclass
from typing import List
import heapq

@dataclass
class Driver:
    id: str
    lat: float
    lon: float
    rating: float
    vehicle_type: str

@dataclass
class Rider:
    id: str
    lat: float
    lon: float
    preferred_vehicle: str

def calculate_match_score(rider, driver):
    """
    Calculate a match score (lower is better)
    Consider: distance, rating, vehicle type match
    """
    # Distance component (using simple Euclidean for demo)
    distance = ((rider.lat - driver.lat)**2 + (rider.lon - driver.lon)**2)**0.5
    
    # Rating component (normalize to 0-1 range)
    rating_score = (5 - driver.rating) / 5
    
    # Vehicle match bonus
    vehicle_match = 0 if driver.vehicle_type == rider.preferred_vehicle else 0.5
    
    # Weighted sum
    score = distance * 10 + rating_score + vehicle_match
    return score

def match_rider_to_driver(rider: Rider, available_drivers: List[Driver], top_k=3):
    """
    Find top k matching drivers for a rider
    """
    scored_drivers = []
    for driver in available_drivers:
        score = calculate_match_score(rider, driver)
        scored_drivers.append((score, driver))
    
    # Return top k matches
    return heapq.nsmallest(top_k, scored_drivers, key=lambda x: x[0])

# Example
rider = Rider("R1", 12.9716, 77.5946, "uberx")
drivers = [
    Driver("D1", 12.9718, 77.5948, 4.8, "uberx"),
    Driver("D2", 12.9720, 77.5950, 4.5, "uberxl"),
    Driver("D3", 12.9710, 77.5940, 4.9, "uberx")
]
matches = match_rider_to_driver(rider, drivers, top_k=2)
for score, driver in matches:
    print(f"Driver {driver.id}: Score {score:.2f}")

Question 4: ETA Calculator

Calculate estimated time of arrival with traffic.

def calculate_eta(distance_km, traffic_level='normal'):
    """
    Calculate ETA based on distance and traffic
    traffic_level: 'low', 'normal', 'high', 'severe'
    """
    base_speed = 40  # km/h in normal conditions
    
    traffic_multipliers = {
        'low': 1.3,
        'normal': 1.0,
        'high': 0.6,
        'severe': 0.3
    }
    
    adjusted_speed = base_speed * traffic_multipliers.get(traffic_level, 1.0)
    time_hours = distance_km / adjusted_speed
    time_minutes = time_hours * 60
    
    return {
        'distance_km': distance_km,
        'traffic_level': traffic_level,
        'estimated_speed_kmh': adjusted_speed,
        'eta_minutes': round(time_minutes, 1),
        'eta_formatted': f"{int(time_minutes)} min"
    }

# Example
print(calculate_eta(12, 'high'))

Question 5: Trip Analytics

Analyze ride statistics from trip data.

from collections import defaultdict
from datetime import datetime

def analyze_trips(trips):
    """
    trips: list of dicts with keys: driver_id, fare, distance, timestamp
    """
    stats = {
        'total_trips': len(trips),
        'total_revenue': 0,
        'total_distance': 0,
        'driver_stats': defaultdict(lambda: {
            'trips': 0, 
            'revenue': 0, 
            'distance': 0
        }),
        'hourly_distribution': defaultdict(int)
    }
    
    for trip in trips:
        driver_id = trip['driver_id']
        fare = trip['fare']
        distance = trip['distance']
        timestamp = datetime.fromisoformat(trip['timestamp'])
        
        # Global stats
        stats['total_revenue'] += fare
        stats['total_distance'] += distance
        
        # Driver stats
        stats['driver_stats'][driver_id]['trips'] += 1
        stats['driver_stats'][driver_id]['revenue'] += fare
        stats['driver_stats'][driver_id]['distance'] += distance
        
        # Hourly distribution
        hour = timestamp.hour
        stats['hourly_distribution'][hour] += 1
    
    # Calculate averages
    if stats['total_trips'] > 0:
        stats['avg_fare'] = stats['total_revenue'] / stats['total_trips']
        stats['avg_distance'] = stats['total_distance'] / stats['total_trips']
    
    return stats

# Example
trips = [
    {'driver_id': 'D1', 'fare': 250, 'distance': 8.5, 'timestamp': '2026-03-01T08:30:00'},
    {'driver_id': 'D2', 'fare': 180, 'distance': 6.2, 'timestamp': '2026-03-01T09:15:00'},
    {'driver_id': 'D1', 'fare': 320, 'distance': 12.0, 'timestamp': '2026-03-01T17:45:00'},
]
stats = analyze_trips(trips)
print(f"Total Revenue: ₹{stats['total_revenue']}")
print(f"Average Fare: ₹{stats['avg_fare']:.2f}")

🎯 Interview Tips

Technical Interview Tips:

Algorithm Mastery: Uber's coding interviews are extremely challenging. Practice LeetCode hard problems and focus on optimal solutions.
System Design Fundamentals: Even for freshers, understand basics of distributed systems, databases, and scalability.
Real-World Problem Solving: Think about edge cases, error handling, and production-ready code.
Domain Knowledge: Understand geospatial problems, real-time systems, and supply-demand dynamics.
Communication: Clearly explain your thought process. Uber values engineers who can articulate their solutions.

HR Interview Tips:

Uber's Mission: "We reimagine the way the world moves for the better" - show how you align with this mission.
Problem-Solving Stories: Prepare examples showing how you've tackled complex problems or overcome obstacles.

❓ Frequently Asked Questions

Q1: How tough is Uber's interview process?

A: Uber's interview process is among the most challenging in the industry. Expect multiple coding rounds with complex algorithmic problems and system design questions.

Q2: What programming languages are preferred?

A: Uber primarily uses Go, Java, Python, and JavaScript. Be proficient in at least one of these.

Q3: Is system design asked for freshers?

A: Yes, basic system design concepts are expected. Focus on understanding scalability, database design, and microservices architecture.

Q4: How important is domain knowledge?

A: While not mandatory, understanding transportation/logistics domain helps in framing better solutions during system design rounds.

Q5: What makes Uber different from other tech companies?

A: Uber operates at massive scale with real-time requirements. They look for engineers who can handle high-stakes, high-scale problems.

Best of luck with your Uber placement preparation! 🚗