Codemia | Master System Design Interviews Through Active Practice

My Solution for Design a Food Delivery Service

by nectar4678

System requirements

Functional:

User can search different restaurant based on his/her location
User can select a restaurant
User can see the menu of selected restraunt
Restraunt can change the menu any time
User selects restraunt and add different food items from the menu
User orders the food by selecting different online payment modes
User can track the order in real time
The restaurant process the orders by preparing the meal and packaging the orders.
The restaurant contacts the delivery service or their personnel delivery staff to deliver.

Non-Functional:

No. of orders = 10,000 orders per minute
No. of cities and towns operational = 500
Total number of restraunts listed on the application = 140,000
Total active delivery partners = 2,00000
Total number of order cancellations = 1,500 daily
System should be highly scalable and available.
User should be able to get all features with minimal latency.

Capacity estimation

Traffic Estimates

System is expecting 10,000 orders per minute. So, order requests per second will be:

10, 000 orders per minute/60 = ~ 167 Orders /Second

Storage Estimates

Since we are expecting 10,000 orders per minute so, per day will be:

Orders per day = 10, 000 orders/minute * 60 * 24 = 14,400,000 orders/day

Total expected orders in 5 years = 14,400,000 orders/day * 12 Months * 5 Years = 864,000,000

Lets assume the size of object = 500 bytes

Total storage in 5 years = 432 GB

Food delivery system can be devided into three major components:

Customer's Application
Delivery guy's application
Admin Panel

Customer's Application

Selection of city and listing of restraunts
Searching menu: Allow users to search for different restaurants, cafes, pubs, and bars by location and cuisines. Users can go through the menus and choose an item from using the search filter; users can easily find their favorite eating places.
Order placement/Cancellation: The user can place an order of selected dishes and food with just a few simple taps on the screen. User can cancel order with a given allowed time.
Tracking Drivers: Users can check how much time a driver will take to reach their food parcel.
Payment gateway integration: It will be required for the payment by users. It will have multiple options of payment.

Delivery guy's application

Driver's profile - Driver can update his profile details like his name, email, address, phone number, photos, or any other details.
Notification for orders: Through push notifications, drivers can get constant updates & alerts for new food orders online. It will help in the accurate delivery service of your restaurant.
Map for the delivery route: Integrate Google Map or Waze and allow drivers to choose the shortest and fastest routes to reach the location.

Admin Panel

Restaurant management: Being on the admin panel, one can directly manage all the restaurants by adding, updating, and removing any eating joint from the list. He can also check active restaurant status and also menu pricing.
Analytics & report generation: Using the analysis and report feature, you can get real-time insights of reports and other accounting information, which helps you to identify the growth and opportunities to expand reach.
Monitoring every action: Monitor all the drivers, changes in the menu, deliveries, ratings & reviews of drivers, canceled orders, and other important data related to the driver’s performance.
Payment and commission management: Allow owners to set payment and commission rates and manage it directly from the panel with every single partner and make payments.

API design

Customer's Application APIs

List Restaurants by Location

GET /restaurants
Params: city, cuisine, rating
Response:
{
  "restaurants": [
    {"id": "123", "name": "Pizza Place", "cuisine": "Italian", "rating": 4.5},
    {"id": "124", "name": "Sushi Bar", "cuisine": "Japanese", "rating": 4.8}
  ]
}

Get Restaurant Menu

GET /restaurants/{restaurantId}/menu
Response:
{
  "menuItems": [
    {"id": "501", "name": "Margherita Pizza", "price": 15.00},
    {"id": "502", "name": "Veggie Pizza", "price": 13.50}
  ]
}

Place Order

POST /orders
Body:
{
  "userId": "90210",
  "restaurantId": "123",
  "items": [{"itemId": "501", "quantity": 2}],
  "paymentMethodId": "3456"
}
Response:
{"orderId": "1001", "status": "processing"}

Track Order

GET /orders/{orderId}/track
Response:
{"orderId": "1001", "status": "en route", "estimatedDeliveryTime": "15 mins"}

Delivery Personnel's Application APIs

Driver Order Notification

GET /driver/{driverId}/orders
Response:
{
  "orders": [
    {"orderId": "1001", "restaurant": "Pizza Place", "destination": "123 Main St"}
  ]
}

Update Driver Status

POST /driver/{driverId}/status
Body:
{"status": "available"}
Response:
{"success": true}

Admin Panel APIs

Update Restaurant Menu

POST /admin/restaurants/{restaurantId}/menu`
Body:
{"menuItems": [{"name": "Cheese Pizza", "price": 12.00}]}
Response:
{"success": true}

Restaurant Performance Report

GET /admin/reports/{restaurantId}
Response:
{"ordersToday": 150, "revenueToday": 1400.00}

Database design

We need to design a data model that efficiently handles the interactions between customers, restaurants, orders, and drivers. Let’s begin with an Entity-Relationship (ER) diagram to illustrate the relationships between different entities.

Entities and Relationships

Users: Represents both customers and drivers with their respective details.

Restaurants: Stores information about restaurant partners.

Menu Items: Represents the dishes available at each restaurant.

Orders: Details of customer orders, including which items were ordered, from which restaurant, by which customer, and their delivery status.

Payments: Tracks payment details associated with each order.

High-level design

Frontend Applications: Customer app and driver app.

Backend Services:

User Service: Manages user registration, login, and profiles.
Restaurant Service: Manages restaurant listings, menus, and availability.
Order Service: Handles order placement, tracking, and status updates.
Payment Service: Processes payments and manages payment methods.
Delivery Service: Assigns orders to drivers and tracks delivery status.

Data Stores: Databases for users, restaurants, orders, etc.

External Integrations:

Payment Gateway: For processing payments.
Mapping Service: For navigation and optimal route calculation.

Request flows

I'll describe the request flow for a common scenario: a customer placing an order, which is then processed and delivered.

Customer Places an Order
The customer opens the customer app and selects their city and restaurant.
The customer browses the menu and adds items to their cart.
The customer proceeds to checkout, enters payment details, and submits the order.
The order details are sent to the backend order service.
The order service validates the order, interacts with the restaurant service to confirm the order with the restaurant, and reserves inventory.
The payment service processes the payment and confirms the transaction.
The order service updates the order status to "Confirmed" and notifies the customer via the frontend application.
Order Preparation and Pickup
The restaurant prepares the order. Once ready, the restaurant updates the order status via the restaurant management interface.
The delivery service assigns the order to a nearby driver, who is notified via the driver app.
The driver accepts the order and updates their status to "en route to restaurant".
Delivery to Customer
The driver picks up the order and updates the status to "en route to customer".
The customer can track the driver’s progress via the tracking feature in the customer app.
Upon arrival, the driver updates the order status to "delivered".
The customer confirms receipt of the order through the app, which triggers the order service to close the order and process any necessary payments to the restaurant.

Detailed component design

User Service

Scalability: The User Service is built on a microservices architecture, allowing it to scale independently based on demand. This service can be horizontally scaled by adding more instances as the number of users grows. Load balancers distribute incoming requests across these instances to ensure even load distribution and high availability.