Design a Ride-Sharing App (Uber/Ola)

Java — Geohash encoding of (lat, lng) coordinates

// Geohash encode (lat, lng) to a given precision (1–12 chars)
public class Geohash {

    private static final String BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";

    public static String encode(double lat, double lng, int precision) {
        double[] latRange = {-90.0, 90.0};
        double[] lngRange = {-180.0, 180.0};
        StringBuilder hash = new StringBuilder();
        int bits = 0, bitsTotal = 0, hashValue = 0;
        boolean isLng = true;

        while (hash.length() < precision) {
            double[] range = isLng ? lngRange : latRange;
            double mid = (range[0] + range[1]) / 2;
            double value = isLng ? lng : lat;

            if (value >= mid) {
                hashValue = (hashValue << 1) | 1;
                range[0] = mid;
            } else {
                hashValue <<= 1;
                range[1] = mid;
            }
            isLng = !isLng;

            if (++bits == 5) {
                hash.append(BASE32.charAt(hashValue));
                bits = 0;
                hashValue = 0;
            }
        }
        return hash.toString();
    }

    // encode(12.9716, 77.5946, 6) → "tdnu2g"  (Bengaluru, ~1.2km cell)
    // encode(12.9716, 77.5946, 7) → "tdnu2gk"  (~150m cell)
}

Java — Location update ingestion + Redis GEO proximity query

@Service
public class LocationUpdateService {

    private final RedisTemplate<String, String> redis;
    private final KafkaTemplate<String, DriverLocationEvent> kafka;

    // Called for every incoming GPS ping
    public void handleLocationUpdate(String driverId, double lat, double lng) {
        // 1. Update geospatial index — O(log N)
        redis.opsForGeo().add(
            "drivers:geo",
            new Point(lng, lat),  // Redis GEO uses (lng, lat) order
            driverId
        );

        // 2. Refresh driver's last-seen TTL (expire if app dies)
        redis.expire("driver:active:" + driverId, Duration.ofSeconds(30));

        // 3. Async Kafka publish for downstream consumers (ETA, analytics)
        kafka.send("driver-locations", driverId,
            new DriverLocationEvent(driverId, lat, lng, Instant.now())
        );
    }

    // Find available drivers within radiusKm of (lat, lng)
    public List<String> findNearbyDrivers(double lat, double lng, double radiusKm) {
        GeoResults<RedisGeoCommands.GeoLocation<String>> results =
            redis.opsForGeo().radius(
                "drivers:geo",
                new Circle(new Point(lng, lat), new Distance(radiusKm, Metrics.KILOMETERS)),
                RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                    .includeDistance()
                    .sortAscending()
                    .limit(50)
            );

        return results.getContent().stream()
            .filter(r -> isDriverAvailable(r.getContent().getName()))
            .map(r -> r.getContent().getName())
            .collect(Collectors.toList());
    }

    private boolean isDriverAvailable(String driverId) {
        return Boolean.TRUE.equals(redis.hasKey("driver:active:" + driverId))
            && "AVAILABLE".equals(redis.opsForValue().get("driver:status:" + driverId));
    }
}

Java — Matching service with distributed driver offer lock

@Service
public class MatchingService {

    private static final int OFFER_TIMEOUT_SECS = 15;
    private final LocationUpdateService locationService;
    private final RedisTemplate<String, String> redis;
    private final TripRepository tripRepository;

    public Optional<String> matchDriver(String tripId, double pickupLat, double pickupLng) {
        double[] radii = {0.5, 1.0, 2.0, 5.0};

        for (double radiusKm : radii) {
            List<String> candidates = locationService.findNearbyDrivers(pickupLat, pickupLng, radiusKm);

            for (String driverId : candidates) {
                // Try to acquire exclusive offer lock for this driver
                String lockKey = "offer:lock:" + driverId;
                Boolean acquired = redis.opsForValue()
                    .setIfAbsent(lockKey, tripId, Duration.ofSeconds(OFFER_TIMEOUT_SECS));

                if (Boolean.TRUE.equals(acquired)) {
                    // Mark driver status as OFFERED
                    redis.opsForValue().set("driver:status:" + driverId, "OFFERED",
                        Duration.ofSeconds(OFFER_TIMEOUT_SECS));

                    // Persist offer record for crash recovery
                    tripRepository.saveOffer(tripId, driverId, Instant.now());

                    // Push offer to driver via WebSocket (async)
                    pushOfferToDriver(driverId, tripId, pickupLat, pickupLng);

                    // Wait for acceptance (blocking poll with timeout)
                    if (waitForAcceptance(driverId, tripId, OFFER_TIMEOUT_SECS)) {
                        return Optional.of(driverId);
                    }
                    // Driver declined or timed out — release lock, try next
                    redis.delete(lockKey);
                    redis.opsForValue().set("driver:status:" + driverId, "AVAILABLE");
                }
            }
        }
        return Optional.empty(); // No driver found
    }

    private boolean waitForAcceptance(String driverId, String tripId, int timeoutSecs) {
        String acceptKey = "offer:accepted:" + tripId + ":" + driverId;
        long deadline = System.currentTimeMillis() + (timeoutSecs * 1000L);
        while (System.currentTimeMillis() < deadline) {
            if (Boolean.TRUE.equals(redis.hasKey(acceptKey))) return true;
            LockSupport.parkNanos(Duration.ofMillis(250).toNanos());
        }
        return false;
    }

    private void pushOfferToDriver(String driverId, String tripId, double lat, double lng) {
        // WebSocket push to driver's active connection (implementation omitted)
    }
}

Java — Surge pricing recalculation with smoothing and Redis storage

@Scheduled(fixedDelay = 60_000)
public void recalculateSurge() {
    // Fetch all geohash-6 cells that have had activity in last 10 minutes
    Set<String> activeCells = supplyDemandStore.getActiveCells();

    for (String cell : activeCells) {
        int demand = supplyDemandStore.getDemand(cell);   // ride requests, last 5 min
        int supply = supplyDemandStore.getSupply(cell);   // available drivers in cell

        double ratio = (double) demand / Math.max(supply, 1);
        double newMultiplier = toMultiplier(ratio);

        // Smooth: cap step-up at 0.3x per cycle
        double current = getSurgeMultiplier(cell);
        double smoothed = Math.min(newMultiplier, current + 0.3);

        // Store in Redis hash — key: "surge", field: geohash6, value: multiplier
        redis.opsForHash().put("surge", cell, String.valueOf(smoothed));
    }
}

private double toMultiplier(double ratio) {
    if (ratio < 1.5) return 1.0;
    if (ratio < 2.0) return 1.2;
    if (ratio < 3.0) return 1.5;
    if (ratio < 4.0) return 2.0;
    return 2.5;  // hard cap
}

public double getSurgeMultiplier(String geohash6) {
    Object val = redis.opsForHash().get("surge", geohash6);
    return val != null ? Double.parseDouble(val.toString()) : 1.0;
}

// Fare Estimation API
public FareEstimate estimate(double pickupLat, double pickupLng,
                              double dropLat, double dropLng) {
    String cell = Geohash.encode(pickupLat, pickupLng, 6);
    double surge = getSurgeMultiplier(cell);
    double baseFare = calculateBaseFare(pickupLat, pickupLng, dropLat, dropLng);
    return new FareEstimate(baseFare * surge, surge);
}