Lets Build Uber Eats Clone App 2024


I am preparing a playlist to showcase full stake Production-ready application, Uber eats is a food ordering platform for restaurants and end-user who are ordering food

Let's think about what all we can build in this app using our own stack and technology

Let's think about architecture we can follow to build services

{% youtube i1jcSwxUfdk %}

Building an Uber Eats clone app involves several components and functionalities. Here's a general outline of the steps you can follow to create a basic version of an Uber Eats clone:

  1. Design and Wireframing: Start by designing the user interface (UI) and creating wireframes for the app. This step helps in visualizing the app's structure and user flow. Consider the key features of Uber Eats, such as restaurant listings, menu items, shopping cart, order tracking, and user authentication.

  2. Setup React Native Project: Create a new React Native project using a tool like Expo or React Native CLI. Set up the necessary dependencies and configure the development environment.

  3. Build Authentication: Implement user authentication features like sign-up, login, and logout using a service like Firebase Authentication. Allow users to create accounts, log in with their credentials, and manage their profiles.

  4. Restaurant Listings: Create a screen to display a list of restaurants using components like FlatList or ScrollView. Fetch restaurant data from an API and render it in the app. Include details like restaurant name, cuisine type, ratings, and images.

  5. Menu Items: Implement a screen to display the menu items for a selected restaurant. Fetch menu data from an API and show details such as item name, description, price, and images. Allow users to add items to their shopping cart.

  6. Shopping Cart: Develop a shopping cart functionality where users can add or remove items, adjust quantities, and view the total cost. Implement features like item quantity selection, order subtotal calculation, and clearing the cart.

  7. Order Placement: Allow users to place an order by providing delivery details like address, contact information, and payment method. Handle order submission to an API and display a confirmation screen with the order summary.

  8. Order Tracking: Implement a real-time order tracking feature using technologies like WebSocket or Firebase Realtime Database. Show the progress of the order and provide updates to the user.

  9. User Profile: Create a user profile screen where users can view and edit their personal information, order history, and preferences.

  10. Testing and Refinement: Test the app thoroughly for bugs and usability issues. Gather feedback from users and make necessary refinements to enhance the user experience and performance.

  11. Deployment: Prepare the app for deployment to the desired platforms (Android, iOS). Follow the platform-specific guidelines for building and publishing the app to the respective app stores.

It's important to note that building a complete and fully functional Uber Eats clone involves more complexity and additional features like geolocation, real-time delivery tracking, payment integration, and more. Consider the scalability and extensibility requirements for future enhancements.

🍔 Welcome to our YouTube channel! Join us in this comprehensive tutorial where we guide you through the process of building your own Uber Eats application from scratch.

📋 Overview:

  • Setting Up: We'll start by setting up our development environment and laying the groundwork for our application.
  • User Authentication: Learn how to implement secure user authentication to manage customer accounts.
  • Restaurant Listings: Discover how to create and manage restaurant listings, including menus and details.
  • Order Placement and Tracking: Dive into the process of allowing users to place orders and track their delivery in real-time.
  • Payment Integration: Explore how to integrate payment gateways to facilitate secure transactions.
  • Rating and Review System: Implement a rating and review system to gather feedback from customers.
  • Admin Dashboard: Learn how to build an admin dashboard for restaurant owners to manage their listings and orders.
  • Delivery Management: Understand the process of managing deliveries and assigning delivery personnel.
  • Responsive Design: Ensure your application is responsive and provides a seamless experience across devices.

🔧 Technologies Used:

  • Frontend: HTML, CSS, JavaScript, React.js
  • Backend: Node.js, Express.js
  • Database: MongoDB

🎥 Don't forget to subscribe to our channel for more tutorials on web development and software engineering!


  • FE for UI we can use simple React
  • BE for API and service development we can use Node JS with different SQL and no SQL Databases
  • The interface between UI and APIs can be REST or graphql based

As we are doing this in a Microservice way, we can build different services that can be consumed by the UI layer.

UI layer will talk to the centralized gateway for any kind of request and API gateway will forward this request to the right set of services, a simple gateway based microservice architecture

In our case, we can decide if we want REST-based services or graphql based services

GitHub Link 🔗 https://github.com/tkssharma/uber-eats-clone-app

Welcome to Uber Eats clone App development Let's build the Ubereats Clone App Tools and technologies we are going to use

  • Architecture discussion
  • different types of architecture
  • Designing different microservices
  • Defining Deployment stack for application and services
  • Application setup with Monorepo solutions
  • Lerna/Nx for monorepo
  • AWS CDK for deploying application
  • github action for CI/CD
  • exploring sveltekit for dashboard app
  • exploring Next JS 13 for UI apps
  • React JS with latest features from end user application
  • Nest JS Microservices for API development
  • next js for end user application
  • svelte kit for managing SSR using SvelteKit
  • React and next js
  • Nests with Node JS
  • SQS and Kafka
  • Twillio and sendGrid
  • Microservices and service communication
  • Express with Node JS and typescript
  • Prisma and TypeORM for services
  • Docker and containerization
  • Mysql and Postgres with MongoDB

Github : 🔗 https://github.com/tkssharma/uber-eats-clone-app

Our Flow will be simple

UI layer to the gateway and from that to microservice, for authentication and authorization we will be using a simple auth service built in Node JS, and API gateway will also be a simple gateway in node js

Our Simple Requirements — based on a simple food ordering system

  1. Restaurants can register themselves.
  2. Users can create, update, delete, get their profiles.
  3. Users can search for the restaurant using a restaurant name, city name.
  4. Restaurants can add, update the food menu.
  5. Users can add remove food items from the cart
  6. Users can order food and can get the right communication and can also cancel the order in a pre-defined time.
  7. Users can track the delivery.
  8. Users should be able to make payments.
  9. Delivery boy can get all the deliveries made by him using his Id.
  10. Users can get the status of food anytime with all tracks.

Let's think in terms of services and Model Designing

Restaurant Service

  • This service will deal with restaurant data only and will expose data for user search from UI, it like we can expose this data from elastic search
  • We need basic APIs from this service like adding a new menu item for restaurant Users or updating menu items.
  • Customers can search for menu items based on different search filters like item name or item name in a city
  • The restaurant owner can add new menu items to decide the price.

User Service

  • User service to provide base authentication feature based on mobile no and OTP token
  • Post Login for new users we will allow to update Profile
  • For Users Mob No will be unique and the main profile identifier for authentication
  • Post Login user can update the profile and can populate User Profile data like location and set of addresses
  • Users can have multiple addresses where order delivery can happen with GPS location Coordinates.

Food Menu Service

  • This looks like the same service as Restaurant but this has totally different business, it will land the information on UI when the user selects a particular restaurant and wants to see all menu items from that restaurant
  • Users can see all menu items provided by the restaurant
  • This service will be used by Admin and Customers as Admin can manage menu items and customer can search the menu items
  • admin can add more menu items or update existing menu items

Cart Service

  • This service will manage the adding and removing items from the cart by the user
  • This service will talk to the food Menu service to fetch the details about the items ordered by the user.
  • Users can add and remove items before placing the order.

Order Service

  • This service will manage orders and will expose to the customers and Admin of the system.
  • Customers can place or cancel orders
  • Admin can search for the order
  • Customers can see their order history for a restaurant
  • Customers can see their all order history

Similarly, we are building a Payment and delivery service

The most important aspect of this whole system is domain level isolation so we don’t mix things in different services and there should be no too much decoupling of services

  • Managing authorization in services
  • Managing User sessions across different services
  • Providing Async Communication between services using messaging queues so we don’t lose any order due to some failure and provide retry mechanism
  • This will be an event-driven design as I can see lots of events as we can across different services and based on those events subscriber service can react like assigning a delivery partner, sending updates to customers, provide tracking real-time to the user.

Next Part of this is design ERD and define Models for all these different services

I will keep adding all these videos in my YouTube playlist as I can’t explain and we can’t write whole complex things here in this Blog

The most challenging part of this whole design is —

  • Data synchronization and communication between services
  • Decoupled services where service A should know as less as possible about service B
  • Async communication to avoid any real-time failure using messaging bus platform (SQS, SNS, KAFKA, RABBIT MQ)
  • Build delivery guy assignment tooling based on GPS real-time.
  • Provider real-time tracking for customers (good to have).