A Project Report on

“Match Winning Prediction”

Submitted in the Partial Fulfillment for the Award of degree for
Master Of Computer Application

Submitted By
Ramakanta Swain
2270269
UNDER THE GUIDANCE OF

Prof. Hemant Kumar Apat

SCHOOL OF COMPUTER APPLICATION

BHUBANESWAR, ODISHA – 751024

April-2024
 CERTIFICATE OF ORIGINALITY

This is to certify that the project report entitled “Match Winning

Prediction” submitted to School of Computer Application,
KIIT Deemed To Be University in partial fulfillment of the
requirement for the award of the degree of MASTER OF
COMPUTER APPLICATIONS (MCA) , is an authentic and
original work carried out by Mr. Ramakanta Swain bearing Roll
no. 2270269 and Regd. No. 21198179119 and RS Amaraprasad
Roll no. 2270260 and Regd. No. under my guidance.

The matter embodied in this project is genuine work done by the

student and has not been submitted whether to this University or to
any other University / Institute for the fulfillment of the
requirements of any course of study.

Ramakanta Swain Signature of the Guide

Date: Date:
 KIIT DEEMED TO BE UNIVERSITY
School of Computer Application Bhubaneswar, ODISHA 751024

CERTIFICATE
This certifies that the project entitled
“Match Winning Prediction“
submitted by

Ramakanta Swain

2270269

This is to certify that the project work entitled MATCH

WINNING PREDICTION by RAMAKANTA SWAIN of

MASTER OF COMPUTER APPLICATION bearing roll no.

2270269 is an authentic and original work.

Signature Signature
(Internal Examiner) (External Examiner)

Date.................. Date..................
 DECLARATION

I, Ramakanta Swain, 2270269 do hereby declare that the

project report entitled Match Winning Prediction

submitted to School of Computer Application, KIIT

University, Bhubaneswar for the award of the degree of

MASTER OF COMPUTER APPLICATION (MCA) ,

is an authentic and original work carried out by me from 1st

march 2024 to 21th March 2024 under the guidance of

Prof. Hemant ku. Apat.

Ramakanta Swain

Date:
 Acknowledgement

I am profoundly grateful to Prof. Hemant ku. Apat, my project

mentor for his expert guidance and continuous encouragement
throughout to see that this project rights its target since its
commencement to its completion.

I am also thankful to my team member for guiding and helping

me all the way during the working period.

Ramakanta Swain
(2270269)
 A BSTRACT
In the busy and fast-paced world of today, people want everything at
the click of a button. People are squeezed for time, where, they do
not even have the time to have proper meals. Eator is a web-based
food delivery application designed for a specific restaurant. . The
goal of the application is to provide a seamless and user-friendly
experience for customers who want to order food online from the
restaurant.

The application features a simple and intuitive user interface that

allows customers to browse the restaurant's menu, select items they
want to order, and submit their order for processing.

To ensure the security of customer data, the application employs

various security measures, including database encryption and user
authentication. The system also includes user profile creation and
access rights management features to control who can access
different parts of the application.

The project also includes extensive unit testing and integration

testing to ensure that the application functions correctly and is free
from errors.
Eator provides a reliable and efficient way for customers to order
food online from the specific restaurant. The application is designed
to be easily scalable, so it can handle an increasing number of
customers without any issues.

Eator provides a valuable solution for customers who want to order

food online from the restaurant, and for the restaurant itself, which
can increase its revenue by tapping into the online food delivery
market.
 Table of Contents
Sr. No Topic Page
No.
1 Introduction 9

2 System Analysis 10

2.1 Identification of Need 10

2.2 Feasibility Study
11
2.3 Software requirement specifications (SRS)
11
2.4
Software Engineering Paradigm applied 11
2.5
Data model, Control Flow diagrams, State 12
Diagrams/Sequence diagrams ERD’s/ Class
Diagrams/CRC Models/Collaboration
Diagrams/Use-case Diagrams/Activity Diagrams
depending upon your project requirements

3 System Design Details 20

3.1
Modularisation details 21

3.2
Data integrity and constraints 22
3.3
Database design/Procedural Design/Object Oriented 22
Design
3.4
User Interface Design

4 Coding 23
4.1 Comments and Description
24
 4.2Standardization of the coding /Code Efficiency
26

4.3Error handling

4.4 Parameters calling/passing 27

4.5 Validation checks

5 Testing 28
5.1 Testing techniques and Testing strategies used
along with the test case designs and test reports 28-29
5.2 Debugging and Code improvement
30

6 System Security measures (Implementation of 31

security for the project developed)
6.1 Database/data security

6.2 Creation of User profiles and access rights

7 Reports and screen (sample screen shots should be 32

included)

8 Future scope and further enhancement of the Project 32

9 Assumptions 33
1. INTRODUCTION :
Welcome to the Eator Food Ordering System - an online
platform that allows you to order delicious meals from the
comfort of your own home or office. Eator is a popular
restaurant known for its mouth-watering cuisine, and now
you can enjoy their delicious meals without ever leaving your
home or office.

With the Eator Food Ordering System, you can browse through
a variety of menu items, select your desired dishes, and have
them delivered right to your doorstep. The system is user-
friendly and easy to navigate, allowing you to place your
order quickly and efficiently.

Eator takes great pride in the quality of their food, and they use
only the freshest ingredients to ensure that every dish is both
healthy and delicious. Whether you're in the mood for a fresh
stater, a delicious Biriyani, or a mouth-watering Pizza, you
can find it all at Eator.

The Eator Food Ordering System is perfect for busy individuals

who want to enjoy a delicious meal without having to cook
or go out to a restaurant. Whether you're at home or at work,
you can easily order from Eator and have your food delivered
to you in no time.

So why wait? Visit the Eator Food Ordering System today and
experience the convenience of online food ordering for
yourself!
2. SYSTEM ANALYSIS :
2.1 Identification of Needs :

2.1.1. Convenience: People are increasingly looking for

convenient and efficient ways to order food, especially with
busy schedules and limited time for cooking or going out to
eat.

2.1.2. Variety: Consumers want access to a diverse selection

of dishes and cuisines, and are looking for food delivery
platforms that offer a wide range of options.

2.1.3. Safety and quality: With the increasing rate of

infections, people are more concerned about the safety and
hygiene of their food and the delivery process.

2.1.4. Timely delivery: Customers expect their orders to be

delivered quickly and on time, without any delays or
complications.

2.1.5. User-friendly technology: In today's digital age,

people want a user-friendly and accessible platform to place
their orders and track their deliveries.
2.2 Feasibility Study :

2.2.1. Technical feasibility:

The online ordering system project is technically feasible as
it involves developing a website or mobile application with
basic features like order placement, order confirmation, and
database integration. The technical requirements are not
complex, and there are many tools and platforms available to
develop such a system.

2.2.2. Economic feasibility:

The online ordering system project is economically feasible
as it can help the restaurant reduce overhead costs and
increase revenue. The restaurant can save on labor costs by
reducing the need for staff to take orders over the phone. It
can also increase revenue by attracting more customers who
prefer to order online.

2.2.3. Operational feasibility:

The online ordering system project is operationally feasible
as it can streamline the restaurant's order management
process. The restaurant can receive orders directly from
customers, reducing the chances of errors or
miscommunications. The system can also help the restaurant
manage inventory and track orders more efficiently.

2.2.4. Legal and regulatory feasibility:

The online ordering system project is legally and regulatory
feasible as it does not involve any sensitive customer data,
such as payment information. However, the restaurant should
ensure compliance with data protection regulations, such as
GDPR or CCPA.

2.3 Software Requirement Specification:

2.3.1. Introduction
The online ordering system is a web-based application that
allows customers to place orders for food items online. The
system should be simple, user-friendly, and easy to use. The
purpose of this document is to provide a detailed description
of the software requirements for the online ordering system.
2.3.2 Scope
The online ordering system include the following features:

- User registration and login

- Menu display
- Order placement
- Order confirmation
- Database integration

2.3.3. Functional Requirements

2.3.3.1 User Registration and Login

The system should allow customers to create an account by

providing their name, email address, and password. The user
should be able to log in using their email address and
password.

2.3.3.2. Menu Display

The system should display the restaurant's menu, including
the name and price of each item. The menu should be
categorized by food type (e.g., appetizers, entrees, desserts).
2.3.3.3 Order Placement

The system should allow customers to select items from the

menu and add them to their cart. The customer should be
able to specify any special instructions (e.g., no onions) for
each item. The system should calculate the total price of the
order and display it to the customer.

2.3.3.4 Order Confirmation

The system should display a confirmation page after the

customer submits their order. The confirmation page should
include the order details (e.g., items ordered, total price,
delivery time).

2.3.3.5 Database Integration

The system should integrate with the restaurant's existing

database to store order information. The database should
include the following fields:
- Customer name and email address
- Order details (e.g., items ordered, special instructions)
- Total price
- Delivery time

2.3.4. Non-Functional Requirements

2.3.4.1 Performance

The system should be able to handle a large number of

concurrent users without slowing down or crashing. The
response time for each page should be less than 3 seconds.

2.3.4.2 Security

The system should be secure and protect customer

information. The password should be encrypted and the
system should use SSL encryption to protect data in transit.

2.3.4.3 Usability

The system should be easy to use and navigate. The interface

should be intuitive and user-friendly.

2.3.5. Assumptions and Dependencies

- The restaurant has an existing website or mobile

application.
- The restaurant has a database that can be integrated with
the online ordering system.

2.3.6. Constraints

- The project budget is limited.

- The project timeline is tight.

2.3.7. Acceptance Criteria

- The system should allow customers to register and log in.

- The system should display the restaurant's menu.
- The system should allow customers to place orders and
specify special instructions.
- The system should display a confirmation page after the
customer submits their order.
- The system should integrate with the restaurant's existing
database.
- The system should be secure and protect customer
information.
- The system should be easy to use and navigate.

2.4 Software Engineering Paradigm Applied:

2.4.1. Market research: Conduct market research to identify

the current trends and demands for online ordering systems
in the restaurant industry. This can be done by analyzing
industry reports, conducting surveys and focus groups with
potential customers, and analyzing the websites of
competitors.

2.4.2. User requirements analysis: Conduct a user

requirements analysis to identify the specific needs and
expectations of the customers who will be using the online
ordering system. This can be done by conducting surveys
and interviews with potential customers and analyzing their
feedback.
2.4.3. Technical requirements analysis: Conduct a
technical requirements analysis to determine the technical
specifications and capabilities required for the online
ordering system. This can be done by consulting with
developers and technical experts and conducting research on
the latest technologies and tools available for developing
such a system.

2.4.4. Data collection: Collect data on the restaurant's menu,

pricing, and inventory. This data can be used to create the
database and menu display for the online ordering system.

2.4.5. Pilot testing: Conduct pilot testing of the online

ordering system to identify any technical issues or usability
problems. This can be done by selecting a small group of
customers to use the system and provide feedback.

2.5 Data Models:

A data model is a visual representation of how data is
organized and stored in a system. In the case of an online
food ordering system, the data model would include the
different entities (such as customers, orders, menus, etc.) and
the relationships between them. Here is a simplified example
of a data model for an online food ordering system:

2.4.1. Customers: This entity would include information

about the customers who use the online ordering system,
such as their name, email address, phone number, and
delivery address.

2.4.2. Orders: This entity would include information about

the orders placed by customers, such as the order ID, order
date, total price, and delivery status.

2.4.3. Menus: This entity would include information about

the menus offered by the restaurant, such as the menu ID,
menu name, and menu items.

2.4.4. Menu Items: This entity would include information

about the individual items on the restaurant's menu, such as
the item ID, item name, price, and description.
2.5.1. USE CASE DIAGRAM:
A use case diagram is a visual representation of the
interactions between actors (users) and a system. The purpose
of a use case diagram is to provide a clear and concise
overview of the functionality of a system and the actors who
interact with it.
A use case diagram typically consists of the following
elements:

i.Actors: An actor is a person, system, or external entity that

interacts with the system. Actors are represented as stick
figures on the diagram.
ii. Use Cases: A use case is a set of actions or steps that a
system performs to achieve a specific goal. Use cases are
represented as ovals on the diagram.
iii. Relationships: Relationships between actors and use
cases are represented as lines between the respective elements
on the diagram.

The use case diagram helps to clarify the requirements of a

system by breaking down its functionality into discrete use
cases that are easy to understand. It can also help to identify
gaps in the system's functionality by highlighting areas where
use cases are missing.
Use case diagrams are often used during the requirements
gathering phase of software development to ensure that all
stakeholders have a clear understanding of the system's
intended functionality. They can also be used to communicate
the system's functionality to developers, testers, and other
stakeholders throughout the software development process.

Use case diagrams can be used in conjunction with other

UML diagrams, such as sequence diagrams and class
diagrams, to provide a more complete picture of a system's
functionality and architecture.

In summary, a use case diagram is a valuable tool for

visualizing and communicating the interactions between
actors and a system. It helps to clarify requirements, identify
gaps in functionality, and provide a clear overview of the
system's intended functionality.
Fig. 2.5.1
The use case diagram shows the main interactions between
the system and its users. There are two main actors in the
system:

i. Customer: This actor represents the customers who use

the system to browse menus, place orders, and view order
confirmations.

ii. Administrator: This actor represents the system

administrator, who has access to all system functions and can
manage user accounts, menus, and orders.

There are several use cases in the system:

i.Customer Login/Logout : This use case allows restaurant
staff to manage customer accounts, by login to their account
and they can log out their account

ii. View Menu: This use case allows customers to view the
menus offered by the restaurant.

iii. Selected an item: This use case allows customer to select

any items and can add to the cart.
iv. View Total Bill: This use case allows customers to view
total bill of their of their order.

v. Confirm Order: This use case allows customer to view

their order.

2.5.2. CONTROL FLOW DIAGRAM:

A control flow diagram is a type of flowchart that is used to
represent the control flow or sequence of operations in a
system or process. It is a visual representation of the steps
involved in a process, along with the decision points and
branching logic that determine the flow of control.

In a control flow diagram, the steps in the process are

represented as rectangles, and the decision points or branches
are represented as diamonds. Arrows are used to show the
direction of control flow from one step to the next, and to
indicate the possible paths that the process may take based
on the decision points.

Control flow diagrams are commonly used in software

development and engineering to model the flow of control in
algorithms, programs, and systems. They can be used to
visualize complex processes, identify potential issues or
bottlenecks, and ensure that the system or process is robust
and reliable.

One of the key benefits of using control flow diagrams is that

they provide a clear and concise representation of the steps
involved in a process, making it easier to understand and
communicate the system or process to others. Control flow
diagrams can be used at different levels of detail, from high-
level overviews to more detailed specifications, depending
on the needs of the project.

Control flow diagrams can also be used to identify potential

errors or problems in a system or process, by highlighting
decision points where multiple paths are possible, or where
conditions may not be met. By visualizing the flow of
control and identifying potential issues early in the
development process, control flow diagrams can help to
ensure that the system or process is reliable and efficient.
Overall, control flow diagrams are an important tool for
software developers and engineers, as they provide a clear
and concise representation of the flow of control in a system
or process. By using control flow diagrams to model
complex processes and identify potential issues, developers
can ensure that the system or process is robust, reliable, and
efficient.

Fig 2.5.2
As shown in the diagram, the system has three main
processes:

i. Order Processing: This process begins when a customer

selects a menu item and places an order through the system.
The order details are captured and stored in the database, and
an order confirmation is sent to the customer.

ii. Menu Management: This process allows restaurant staff

to manage the menus that are available for customers to
order from. Menus can be created, edited, or deleted, and
changes are reflected in the database.

iii. Customer Management: This process allows restaurant

staff to manage customer accounts and order history.
Customer details are stored in the database, and staff can
view or modify orders placed by customers.

There are two data stores in the system:

i.Order Database: This stores information about customer

 orders, including order details, customer information, and
order status.
ii. Menu Database: This stores information about the
menus offered by the restaurant, including menu items and
prices.

The system has two types of external entities:

1. Customers: Customers interact with the system to browse

menus, place orders, and receive order confirmations.

2. Restaurant Staff: Restaurant staff interact with the

system to manage menus and customer orders.

Finally, there are two types of data flows in the system:

1. Order Data: This flow captures order details when a
customer places an order, and stores them in the Order
Database.

2. Menu Data: This flow allows restaurant staff to manage

menus, by adding, editing, or deleting menu items in the
Menu Database.
2.5.3. ACTIVITY DIAGRAM:
An activity diagram is a type of diagram in software
engineering that depicts the flow of activities, actions, and
transitions involved in a particular process or use case.
Activity diagrams are often used to visualize complex
business processes or software work flows.

In an activity diagram, each activity is represented by a

rectangular node, which is connected to other nodes by
arrows that show the sequence of actions. Activities can be
conditional, meaning that certain actions are only taken if
certain conditions are met, or they can be iterative, meaning
that they are repeated multiple times.

In addition to activities, activity diagrams can also include

decision points, represented by diamond-shaped nodes,
which allow for branching based on different conditions or
outcomes. And, like other UML diagrams, activity diagrams
can also include annotations, which provide additional
information about the actions and conditions depicted in the
diagram.
Overall, activity diagrams provide a high-level overview of a
system or process, helping to identify potential issues,
bottlenecks, or inefficiencies. They can be a valuable tool in
software development, as they allow developers to visualize
and refine their understanding of complex systems, making it
easier to identify areas for improvement or optimization.
 Fig. 2.5.3
As shown in the diagram, the process begins when a
customer login or sign up to their account .If the customer
has an existing account, they may also be prompted to log in
to their account to access their saved information and if the
user is new to the system, the user can create his account by
providing the information like Name, Email address and
Address.

The customer is then prompted to select the items they would

like to order from the restaurant's menu. Once the customer
has selected their items, they are prompted to the check out
option. If the customer selects the check out option then the
order details will reflect in the database and also in my
orders option.
At this point, the order process is complete and the customer
can exit the system.

2.5.4. SEQUENCE DIAGRAM:

A sequence diagram is a graphical representation of the
interaction between objects or components in a system over
time. It is used in software engineering to visualize how
objects collaborate to achieve a specific task. A sequence
diagram shows the flow of messages or actions between
objects, which helps in understanding the behavior of the
system.

Sequence diagrams are a part of Unified Modeling Language

(UML), which is a standard notation used in software
engineering for designing and modeling systems. Sequence
diagrams are useful in various stages of software
development, such as design, implementation, and testing.
They are particularly useful in the design phase as they help
in identifying potential design issues and communication
problems between objects.

A sequence diagram consists of actors, objects, messages,

and lifelines. Actors are external entities that interact with
the system, such as users or other systems. Objects are the
elements within the system, such as classes or components.
Messages are the interactions between objects or actors, such
as method calls or data exchanges. Lifelines are the vertical
lines that represent the lifespan of an object or actor in the
system.
The horizontal axis in a sequence diagram represents time,
while the vertical axis represents the objects or actors in the
system. The interaction between objects or actors is shown
using arrows or dashed lines with arrows. The order of
messages is shown by the vertical order of the arrows, which
represents the order in which the messages are sent and
received.

The sequence diagram is useful in various ways. Firstly, it

provides a visual representation of the interactions between
objects or actors, which is easier to understand than a textual
description. Secondly, it helps in identifying potential design
issues, such as message loops or redundant messages.
Thirdly, it helps in communicating the system behavior to
stakeholders, such as clients or developers.

To create a sequence diagram, first, the problem domain

must be analyzed, and the objects or actors involved in the
system must be identified. Then, the interactions between the
objects or actors must be identified, and messages or actions
between them must be defined. Finally, the sequence
diagram can be created using a tool, such as a UML
modeling tool or a drawing tool.

In conclusion, a sequence diagram is a useful tool for

modeling the interactions between objects or actors in a
system. It is used in software engineering for design,
implementation, and testing stages. It provides a visual
representation of the system behavior, identifies potential
design issues, and helps in communication between
stakeholders.

Creating a sequence diagram involves analyzing the problem

domain, identifying the objects or actors, defining their
interactions, and creating the diagram using a tool.
Fig 2.5.4
As shown in the diagram, the customer first selects the
"Place Order" option from the system's main menu. This
triggers a message to the system, which responds by sending
the customer a list of available menu items to choose from.

The customer then selects the items they would like to order
and submits the order to the system. The system validates the
order and sends a confirmation message to the customer,
which includes the order number and any relevant details.

Next, the system sends the order details to the restaurant

staff, who prepare the food and package it for delivery or
pickup. Once the order is ready, the staff update the system
with the order status, which triggers a message to the
customer that their order is on its way.

Finally, the customer receives their order and confirms its

delivery or pickup. At this point, the sequence is complete
and the system is updated with the final order status.
2.5.5. BLOCK DIAGRAM:
In software engineering, a block diagram is a graphical
representation of a software system or process that shows the
relationship between its components or modules. It is a
visual tool that is used to simplify complex systems by
breaking them down into smaller, more manageable pieces.

A block diagram typically consists of a set of interconnected

blocks or rectangles that represent different components or
modules of the system. Each block represents a specific
function or process within the system, and the lines
connecting the blocks represent the flow of data or control
between them. The blocks are usually labeled with the names
of the components they represent, and the lines are labeled
with the type of data or control being passed between them.

Block diagrams are used in software engineering for a

variety of purposes, including:

1. System design: Block diagrams are used during the system

design phase to break down complex software systems into
smaller, more manageable pieces. They help designers
understand how the different components of the system work
together and how data flows between them. This makes it
easier to design software systems that are scalable,
maintainable, and easy to understand.

2. System analysis: Block diagrams are also used during the

system analysis phase to identify potential problems and
bottlenecks in the software system. By analyzing the flow of
data or control between components, engineers can identify
areas where the system may be inefficient or where there
may be potential for errors or bugs.

3. Documentation: Block diagrams are an important part of

software documentation. They are used to document the
structure and organization of software systems, making it
easier for other engineers to understand and maintain the
software.

4. Communication: Block diagrams are also used to

communicate software designs and architectures to other
engineers, stakeholders, and customers. They provide a
visual representation of the software system that is easier to
understand than written descriptions.

In software engineering, there are two main types of block

diagrams: high-level block diagrams and detailed block
diagrams.
High-level block diagrams provide a high-level view of the
software system or process. They show the major
components or modules of the system and how they interact
with each other. High-level block diagrams are often used
during the early stages of system design and analysis to help
engineers understand the overall structure of the system.

Detailed block diagrams provide a more detailed view of the

software system or process. They show the individual
components or modules of the system and how they interact
with each other in more detail. Detailed block diagrams are
often used during the later stages of system design and
analysis to help engineers understand the details of how the
system works.

Block diagrams can be created using a variety of software

tools, including drawing software, modeling software, and
programming languages. Some popular software tools for
creating block diagrams in software engineering include
Microsoft Visio, Lucidchart, and UML modeling tools like
Rational Rose and Enterprise Architect.

In conclusion, block diagrams are a powerful tool in software

engineering that are used to simplify complex software
systems by breaking them down into smaller, more
manageable pieces. They are used during the system design
and analysis phases to help engineers understand the
structure and organization of software systems, identify
potential problems and bottlenecks, document software
designs, and communicate software architectures to
stakeholders and customers.
Fig 2.5.5
At a high level, the block diagram shows the different
components that make up the food delivery application for a
specific restaurant. These components include the user
device, the application server, and the database server.

The user device is where the user interacts with the

application. This could be a smartphone, tablet, laptop, or
any other device that can connect to the internet and make
HTTP/HTTPS requests.

The application server is responsible for processing these

requests and generating appropriate responses. It is built
using Node.js and React, two popular technologies for
building web applications. Node.js is a JavaScript runtime
that allows developers to build scalable, high-performance
applications on the server side. React is a JavaScript library
that simplifies the process of building user interfaces for
web applications.

The database server is where the application stores and

retrieves data. In this case, the database server is built using
MongoDB, a popular NoSQL database that is well-suited for
storing and managing large amounts of unstructured data.

The block diagram shows that communication between the

user device, the application server, and the database server
happens using HTTP/HTTPS requests and MongoDB
queries. This is a common architecture for web applications,
and it allows for flexible, scalable, and efficient
communication between the different components of the
system.

2.5.6. ENTITY-RELATIONSHIP DIAGRAM:

Entities:
- Customer: A person who uses the Eator application to
order food.
- Sign Up: The restaurant that provides the food delivery
service.
- Login: A specific food item that can be ordered by a user.
- Order: A user's order that includes one or more food items.
- Menu: The list of food items offered by the restaurant.

Relationships:
- A User can place zero or more Orders.
- An Order can include one or more Food Items.
- A Restaurant can offer many Food Items on its Menu.
- An Order is placed at a specific Restaurant.

Attributes:
- User: Name, Email, Password,Location
- Login: Name, Password
- Sign up: Name, Email, Password,Location
- Order: Name, Quantity, Size, Price
- Menu: Food Item, Price,Quantity, Size

Based on these entities, relationships, and attributes, an ER

diagram can be created that visually represents the structure
of the Eator application's database. The diagram will include
boxes representing entities, lines representing relationships,
and labels representing attributes.

For example, the ER diagram for the Eator application might

show a box labeled "Customer" with attributes for Name,
Email, and Password,location connected to a box labeled
"Login" with attributes for Name, Password .The Login box
might be connected to a box labeled "Menu" and it is
connected to Orders with attributes Name, Quantity, Size,
Price.

Overall, the ER diagram provides a clear and concise way to

understand the relationships between the various entities in
the Eator application's database, and can be used to guide the
design and implementation of the database.

Fig. 2.5.6.
3. SYSTEM DESIGN:

1. Architecture: The system is designed as a client-server

architecture, with a web-based front-end for customers and a
backend server that handles the ordering and processing of
orders.
2. User interface: The customer-facing user interface is
designed to be intuitive and easy to use, with a simple menu
and ordering system that allows customers to quickly select
their desired items and submit their order.
3. Database: The system utilizes a database to store and
manage all the data related to the ordering process, including
customer information, menu items, order details, and order
status.
4. Order processing: The system uses a series of algorithms
to process and validate each order, ensuring that all required
information is included and that the order can be fulfilled by
the restaurant staff.
5. Order fulfillment: Once an order has been validated, the
system communicates with the restaurant staff to initiate the
order fulfillment process, including preparing the food,
packaging it for delivery or pickup, and updating the order
status as needed.
6. Notifications: Throughout the ordering process, the system
sends notifications to both the customer and the restaurant
staff to keep them informed of the order status and any
updates or changes that may occur.
7. Security: The system is designed with security in mind,
utilizing encryption and secure authentication methods to
protect customer data and ensure the integrity of the ordering
process.

Overall, the system design for the online food ordering

system is focused on creating a streamlined and efficient
ordering process for customers while also ensuring that
restaurant staff can fulfill orders quickly and accurately. By
leveraging technology and automation, the system can
improve the overall customer experience and reduce the
potential for errors or delays in the ordering process.

3.1 Modularization Details:

1. User Interface Module: This module includes all the

user-facing components of the system, including the web-
based menu, ordering forms, and order confirmation pages.

2. Order Processing Module: This module is responsible

for processing and validating each customer order, ensuring
that all required information is included and that the order
can be fulfilled by the restaurant staff.

3. Database Module: This module is responsible for storing

and managing all the data related to the ordering process,
including customer information, menu items, order details,
and order status.

4. Order Fulfillment Module: This module is responsible

for initiating the order fulfillment process, including
preparing the food, packaging it for delivery or pickup, and
updating the order status as needed.

5. Security Module: This module is responsible for ensuring

the security and integrity of the ordering process, including
encrypting customer data and using secure authentication
methods to protect against unauthorized access.
Each of these modules can be developed and tested
independently, allowing for easier maintenance and updates
in the future. Additionally, modularization allows for a more
scalable system, as new features or components can be added
or removed as needed without affecting the entire system.
Overall, modularization is a key aspect of the system design
for the online food ordering system, helping to improve its
flexibility, scalability, and maintainability.

3.2Data Integrity and Constraints:

Data integrity refers to the accuracy and consistency of data

over its entire lifecycle. In the context of software
applications, it means that the data used by the application is
reliable, consistent, and free from errors. This is important
because inaccurate or inconsistent data can lead to incorrect
results, which can have serious consequences in certain
applications such as medical diagnosis or financial
forecasting.

1. Data Integrity: This refers to the accuracy, consistency,

and reliability of the data stored in the database. To ensure
data integrity in the online food ordering system, the
following measures can be implemented:

- Use data validation techniques to ensure that only valid

data is entered into the system.
- Implement referential integrity constraints to ensure that
data in related tables is consistent.
- Use transaction processing techniques to ensure that all
database operations are atomic, consistent, isolated, and
durable.
- Implement backup and recovery procedures to ensure that
data can be restored in case of a system failure.

2. Constraints: Constraints are rules that restrict the values

that can be entered into a database field. Here are some
examples of constraints that can be used in the online food
ordering system:

- Primary key constraints: Ensure that each record in the

database has a unique identifier.
- Foreign key constraints: Ensure that data in related tables is
consistent.
- Check constraints: Restrict the values that can be entered
into a field, for example, to ensure that a menu item price is a
positive value.
- Unique constraints: Ensure that each value in a field is
unique, for example, to ensure that each customer has a
unique email address.
By implementing data integrity measures and constraints, the
online food ordering system can ensure that the data stored in
the database is accurate, consistent, and reliable, reducing the
potential for errors and improving the overall quality of the
system.

3.3 Procedural Design

Procedural design is a process that involves breaking down

complex tasks into smaller, more manageable procedures or
steps. The goal of procedural design is to simplify the task by
dividing it into smaller parts that can be completed more
easily and efficiently. This process is commonly used in
software engineering, where complex tasks such as developing
software systems are divided into smaller tasks that can be
completed by individual programmers.
Procedural design involves analysing the problem, identifying
the key tasks or procedures, and defining the inputs, outputs,
and dependencies for each procedure. This helps to ensure that
the procedures are well-defined, modular, and reusable. The
procedures can then be implemented using a programming
language or other tool, and tested to ensure that they function
as expected.

Procedural design has several advantages over other design

methodologies, such as object-oriented design. For example,
procedural design is often simpler and more intuitive, making
it easier for novice programmers to learn and understand. It
also tends to be more efficient and less memory-intensive than
object-oriented design, since it does not require the use of
complex data structures and objects.

However, procedural design also has some limitations. For

example, it can be more difficult to maintain and update
procedural code as the size and complexity of the system
grows. It also tends to be less flexible and adaptable than
object-oriented design, which allows for greater modularity
and abstraction.

Overall, procedural design is a useful tool for breaking down

complex tasks into smaller, more manageable procedures. It
is particularly well-suited to tasks that are well-defined and
have a clear set of inputs and outputs. However, it may not
be the best approach for more complex systems that require
greater flexibility and modularity.

Here are some possible procedural designs for the online

food ordering system:

1. User Interface Procedure:

- Display the menu to the customer
- Allow the customer to select menu items and customize
their order
- Validate the customer's information and order details
- Send the order to the Order Processing Module

2. Order Processing Procedure:

- Validate the customer's order details
- Calculate the total cost of the order
- Store the order details in the Database Module
- Send a notification to the Notification Module

3. Database Procedure:
- Store customer information and order details in the
database
- Retrieve customer information and order details as needed
- Update the order status as it changes

4. Notification Procedure:
- Send a notification to the customer when the order is
received
- Send a notification to the restaurant staff when the order is
received
- Send a notification to the customer when the order status
changes

5. Order Fulfillment Procedure:

- Retrieve the order details from the Database Module
- Prepare the food according to the order details
- Package the food for delivery or pickup
- Update the order status as it changes
6. Security Procedure:
- Use secure authentication methods to protect against
unauthorized access
- Encrypt customer data to protect it from hackers and other
threats
- Implement access control measures to restrict access to
sensitive data

Each of these procedures can be implemented using

appropriate programming languages, frameworks, and
libraries, depending on the specific technology stack being
used. The procedural design should be tested thoroughly to
ensure that it is correct, efficient, and meets the requirements
of the online food ordering system.

3.4 USER INTERFACE DESIGN:

Introduction:
The aim of this report is to provide a comprehensive
overview of the user interface design for a food delivery
application for a specific restaurant. The application will be
developed using HTML, CSS, JavaScript, React, Node.js,
and MongoDB. The user interface design will focus on the
user experience and user interface elements that will enhance
the user's engagement with the application.
User Interface Design:

The user interface design will consist of a modern, user-

friendly, and responsive design that is optimized for both
desktop and mobile devices. The design will be consistent
throughout the application, ensuring that users can easily
navigate and use the application.

Homepage:

The homepage will be the first page that users see when they
open the application. The homepage will feature a search bar
where users can search for the restaurant they want to order
from. The homepage will also feature a section that
highlights the most popular dishes, new dishes, and any
promotions that the restaurant is offering.
Menu Page:

The menu page will display all the dishes available at the
restaurant. Users will be able to filter the dishes by category,
such as appetizers, entrees, desserts, etc. Users will also be
able to search for specific dishes using the search bar. Each
dish will have a picture, name, price, and a brief description.

Cart Page:

The cart page will display all the dishes that the user has
added to their cart. Users will be able to see the total cost of
their order, and they will be able to add or remove dishes
from their cart. The cart page will also feature a checkout
button that will take users to the payment page.

Checkout:

Checkout page will display the user's order number . After

the user placed the order, the order details will be reflected in
our database .
Conclusion:
In conclusion, the user interface design for the food delivery
application will be modern, user-friendly, and responsive.
The design will consist of a homepage, menu page, cart
page, checkout page. The design will be optimized for both
desktop and mobile devices, ensuring that users can easily
navigate and use the application. By following these design
principles, the food delivery application will provide users
with an excellent user experience, enhancing their
engagement with the application.

3.5. DATABASE DESIGN:

1. Customers table: This table would store information
about the customers, including their name, address, phone
number, and email address. Each customer would be
assigned a unique ID number.

2. Orders table: This table would store information about

the orders placed by customers, including the order ID,
customer ID, order date and time, order status (e.g.
"Received," "Preparing," "Ready for pickup," etc.), and total
cost.
3. Menu items table: This table would store information
about the menu items offered by the restaurant, including the
item ID, name, description, and price.

4. Order items table: This table would store information

about the items included in each order, including the order
ID, item ID, and any customizations or special requests.

4 . CODING:
4.1 Standardization of the coding /Code Efficiency
Introduction:
Standardized coding practices ensure that code is consistent,
easy to read and maintain, and can be easily understood by
other developers.

Coding Standards:

1. Code Structure: The code structure should be well-

organized and follow a standard directory structure. The
code should be broken down into smaller modules or
components for easy management and maintenance.
2. Indentation and Formatting: The code should be
properly indented and formatted to make it easier to read and
understand. The use of whitespace, line breaks, and
comments should be consistent throughout the codebase.

3. Naming Conventions: The naming conventions for

variables, functions, and files should follow a consistent and
descriptive naming convention. This helps to make the code
more understandable and easier to maintain.

4. Error Handling: Error handling should be consistent and

well-documented throughout the codebase. This includes
logging error messages, providing clear error messages, and
using standard error handling techniques.

5. Testing: Automated testing should be incorporated into

the development process to ensure that code is error-free and
meets the desired functionality. Standard testing frameworks
such as Jest can be used to ensure that the code is thoroughly
tested.
6. Security: The code should adhere to standard security
practices, such as using secure authentication and encryption
techniques to protect sensitive data. All data input should be
validated to prevent common security vulnerabilities such as
SQL injection and cross-site scripting.

7. Documentation: The code should be properly

documented to make it easy for other developers to
understand and work with the code. This includes providing
inline documentation for functions and modules, as well as
creating a comprehensive user manual.

Conclusion:

Standardization of coding practices is essential for any

software development project, including a food delivery
application. Following these standardized coding practices
ensures that code is consistent, easy to read and maintain,
and can be easily understood by other developers. By
adhering to these coding practices, the food delivery
application will be more secure, reliable, and easier to
maintain in the long term.
4.2 Error Handling:
Introduction:

Error handling is a critical aspect of software development

that ensures the application can handle unexpected events
and maintain a high level of reliability.

Error Handling Practices:

1. Use of Try-Catch Blocks: Try-catch blocks can be used

to handle exceptions and errors that occur during the
execution of the code. The try block contains the code that
may throw an error, while the catch block contains the code
that handles the error.

2. Logging: The application should log errors and exceptions

that occur during runtime. This helps developers to
understand what went wrong and how to fix it. Logs should
include a timestamp, a description of the error, and any
relevant data that can help identify the cause of the error.

3. User-Friendly Error Messages: When an error occurs,

the application should provide the user with a user-friendly
error message. The message should explain what went wrong
and provide instructions on how to fix the problem. The error
message should be clear and concise, using plain language
that is easy to understand.

4. Validation: All user input should be validated to ensure

that it is in the correct format and within acceptable limits.
This helps to prevent common security vulnerabilities such
as SQL injection and cross-site scripting.

5. Error Reporting: The application should have a

mechanism for users to report errors. This can be in the form
of a contact form or an error reporting button. Users should
be able to provide details about the error they encountered,
including a description of what they were doing when the
error occurred.
6. Monitoring: The application should be monitored to
detect and handle errors as they occur. This can be done
using automated monitoring tools or through manual
monitoring by developers. Monitoring helps to detect errors
before they impact users and can help developers to identify
areas for improvement in the application.
Conclusion:

Error handling is a critical aspect of software development,

and it is essential for the food delivery application to have
robust error handling practices in place. The application
should use try-catch blocks, logging, user-friendly error
messages, validation, error reporting, and monitoring to
ensure that errors are handled effectively. These practices
will help to maintain the reliability and security of the
application and ensure a positive user experience.

4.3 Parameters calling/passing

Introduction:
Effective parameter calling and passing practices ensure that
the application can perform its desired functionality and is
easy to maintain and modify.

Parameter Calling and Passing Practices:

1. Consistent Naming Conventions: All parameters should

follow a consistent naming convention. This helps to ensure
that the code is easily understandable, and parameters can be
easily located and modified.

2. Default Values: Default values should be used for

parameters where possible. This ensures that the application
continues to function even if the parameter is not passed.

3. Parameter Validation: All parameters should be

validated to ensure that they are in the correct format and
within acceptable limits. This helps to prevent common
security vulnerabilities such as SQL injection and cross-site
scripting.

4. Avoiding Magic Numbers: Magic numbers, which are

hard-coded numerical values used throughout the code,
should be avoided. Instead, they should be replaced with
named constants or variables. This makes the code more
readable and maintainable.

5. Avoiding Global Variables: Global variables should be

avoided as they can cause issues with parameter calling and
passing. Instead, local variables should be used within
functions or components to ensure that parameters are
correctly scoped and do not conflict with other parts of the
application.

6. Use of Callbacks and Promises: Callbacks and promises

should be used to handle asynchronous code and to pass
parameters between functions or components. This ensures
that the application can perform tasks in a non-blocking
manner, which can improve the application's performance.

Conclusion:

Effective parameter calling and passing practices are critical

for the food delivery application to function as intended and
to be easy to maintain and modify. The application should
follow consistent naming conventions, use default values,
validate parameters, avoid magic numbers and global
variables, and use callbacks and promises to handle
asynchronous code. By following these practices, the
application will be more secure, reliable, and maintainable in
the long term.
4.4 Validation Checks:
Introduction:
Validation checks ensure that user input is accurate and
within acceptable limits, helping to prevent security
vulnerabilities and maintain the reliability of the application.

Validation Checks:
1. Form Input Validation: All forms in the application should
be validated to ensure that users enter the correct data in the
correct format. This includes validating user input for
required fields, checking for the correct data type, and
validating data length and format.

2. Authentication and Authorization Validation: User

authentication and authorization should be validated to
ensure that users have the correct permissions to access the
application. User input should be validated for correct
usernames, passwords, and security tokens.

3. Data Validation: Data that is received or sent by the

application should be validated to ensure that it is in the
correct format and within acceptable limits. This includes
validating data types, data length, and data format.

Conclusion:
Validation checks are essential to ensure that user input is
accurate and within acceptable limits, preventing security
vulnerabilities and maintaining the reliability of the
application. The food delivery application should implement
validation checks for form input, authentication and
authorization, data. These checks should be implemented in
a secure and encrypted environment to protect user data and
ensure a positive user experience.

5. TESTING:
5.1. Test Units and Methods:
The testing process is divided basically into three major
components i.e., unit testing, integration testing and the
system testing. A test case is a document that describes an
input, action or event and an expected response to determine
if a feature of the application is working properly. For proper
functioning of the application these three levels of testing are
necessary. The basic units to be tested are:
5.1.1. Unit Testing:
1. User Interface: The user interface of the application can
be tested to ensure that it is responsive, user-friendly, and
visually appealing. This includes testing the layout, color
scheme, typography, and navigation.

2. Front-end Components: The front-end components of

the application, such as buttons, forms, and dropdown
menus, can be tested to ensure that they are working
correctly and responding to user input.

3. Back-end Components: The back-end components of the

application, such as the database queries and server-side
scripts, can be tested to ensure that they are processing data
correctly and returning the expected results.

4. User Authentication: The user authentication features of

the application can be tested to ensure that user accounts are
created and managed correctly, and that users are able to log
in and access their profile information.

5. Order Processing: The order processing features of the

application can be tested to ensure that orders are placed
correctly, stored in the database, and retrieved for processing
by the restaurant.

6. Search and Filtering: The search and filtering features of

the application can be tested to ensure that users are able to
search for menu items based on certain criteria, and that the
results are accurate and relevant.

7.Error Handling: The error handling features of the

application can be tested to ensure that error messages are
displayed correctly and that the application can recover from
errors gracefully.

5.1.2. Integration Testing:

Integration testing is performed to verify that the individual
units of the system are working together correctly.
1. Front-end and Back-end Integration: Verify that the
front-end components are integrated correctly with the back-
end components. For example, verify that the data entered
into a form on the front-end is correctly stored in the
database by the back-end.
2. User Authentication Integration: Verify that the user
authentication features are integrated correctly with the rest
of the system. For example, verify that a user's account
information is correctly retrieved from the database when
they log in.

3. Order Processing Integration: Verify that the order

processing features are integrated correctly with the rest of
the system. For example, verify that the restaurant receives
the correct order details when an order is placed by a user.

4. Search and Filtering Integration: Verify that the search

and filtering features are integrated correctly with the rest of
the system. For example, verify that the search results
displayed to the user are based on the correct criteria.

5. Error Handling Integration: Verify that the error

handling features are integrated correctly with the rest of the
system. For example, verify that error messages are
displayed correctly and that the system can recover
gracefully from errors.
6.Third-Party API Integration: If the system uses any
third-party APIs, such as a geolocation API to find nearby
restaurants, verify that the APIs are integrated correctly and
that the data returned is accurate.
5.1.3. Features to be Tested:
1. User registration and login: Test that users can register
for an account and log in to the system.
2. Menu display: Test that the restaurant's menu is displayed
correctly, including items, prices, and descriptions.
3. Item selection: Test that users can select items from the
menu and add them to their order.
4. Order submission: Test that users can submit their orders
for the selected items.
5. Order confirmation: Test that users receive confirmation
that their order has been received.
6. Order management: Test that the restaurant can manage
and process incoming orders, including updating order status
and confirming delivery details with the user.
7. Restaurant profile: Test that the restaurant's profile is
displayed correctly, including name, location, contact details,
and opening hours.
8. Search functionality: Test that users can search for
restaurants or specific menu items.

9. User feedback: Test that users can leave feedback on

their experience with the restaurant and the food delivery
application.

10. User profile management: Test that users can manage

their profile details, such as their name, email address, and
password.

11. Security: Test that user data is securely stored and

transmitted, and that the system is protected against common
security threats, such as SQL injection attacks.

5.2 Approach for Testing:

1. Manual testing: Manual testing is a traditional approach
that involves human testers executing test cases manually to
identify defects or bugs in the system. For the Eator food
delivery application, manual testing can be used to test the
user interface, the order processing, and the functionality of
the application.
2. Automated testing: Automated testing involves using
tools and scripts to execute test cases automatically.
Automated testing can help to speed up the testing process
and reduce the risk of human errors. For the Eator food
delivery application, automated testing can be used to test the
functionality of the application, including the order
processing, search and filtering, and user authentication.
3. Performance testing: Performance testing involves
testing the application's performance under different
conditions, such as high traffic, large amounts of data, and
multiple users. For the Eator food delivery application,
performance testing can be used to test the application's
response time, server load, and scalability.
4. Security testing: Security testing involves testing the
application's security features, such as encryption,
authentication, and access controls. For the Eator food
delivery application, security testing can be used to identify
vulnerabilities and ensure that the application is secure.
5. Usability testing: Usability testing involves testing the
application's user interface and user experience to ensure that
it is easy to use and meets the needs of the users. For the
Eator food delivery application, usability testing can be used
to identify any usability issues and to ensure that the
application is user-friendly.
6. Regression testing: Regression testing involves re-testing
the application after changes have been made to ensure that
no new defects or bugs have been introduced. For the Eator
food delivery application, regression testing can be used to
ensure that the application functions correctly after any
updates or changes have been made.

5.3 Testing techniques and Testing strategies used

along with the test case designs and test reports
There are several testing techniques and strategies that can
be used to test an online food ordering system. Here are
some of the most common ones:

1. Functional Testing: This technique involves testing each

feature of the system to ensure it works as intended. For
example, testing the ordering process, user registration, and
menu display. Test cases are designed to cover all possible
scenarios and edge cases.

2. Usability Testing: This technique involves testing the

system from a user's perspective to ensure it is easy to use
and navigate. This can be done by conducting user surveys
or by having a group of users test the system and provide
feedback.

3. Performance Testing: This technique involves testing the

system's ability to handle high volumes of traffic and data
processing. This is done by simulating peak loads and
measuring response times and resource utilization.

4. Security Testing: This technique involves testing the

system's security measures to ensure sensitive data is
protected from unauthorized access. This can include testing
authentication, data encryption, and network security.

5. Integration Testing: This technique involves testing how

different components of the system work together. This can
be done by testing how the ordering process integrates with
the payment gateway or how the database interacts with the
user interface.

Test case design is an important part of the testing process.

Test cases should be designed to cover all possible scenarios
and edge cases to ensure the system is thoroughly tested.
Test reports should also be generated to document the results
of the testing process, including any bugs or issues that were
identified and how they were resolved.

In addition to test case design and test reports, it is also

important to have a testing strategy in place. This includes
identifying the testing objectives, determining the testing
environment, and defining the roles and responsibilities of
the testing team. A good testing strategy will ensure that
testing is conducted effectively and efficiently, and that the
system meets the required quality standards.

6. System Security Measures:

6.1 Database Security:
6.1.1. Access Control: Access control is an essential part of
database security. It involves setting up user roles and
permissions, so that only authorized users can access the
database. This can be achieved by creating user accounts
with unique user names and passwords, and assigning
specific permissions to each account based on the user's role.
6.1.2. Encryption: Encryption is the process of converting
data into a code that cannot be easily read by unauthorized
users. Encrypting sensitive data such as passwords or
customer information can help prevent data breaches in case
the database is compromised. Encryption can be achieved
using technologies such as SSL, TLS, or AES.

6.1.3. Regular Backups: Regular backups are important for

database security because they ensure that data can be
restored in case of a data loss or database failure. It's
important to regularly backup the database to an off-site
location to prevent data loss due to disasters such as fires or
floods.

6.1.4. Regular Updates: Regularly updating the database

software can help prevent vulnerabilities and keep the
database secure. Updates may include bug fixes, security
patches, and new features that can improve database security.

6.1.5. Monitoring and Auditing: It's important to monitor

the database for any suspicious activity and audit the
database for compliance with security policies. This can be
achieved by setting up database logs and monitoring tools to
track user activity, data access, and other database events.

6.2Creation of User profiles and access rights:

6.2.1. Define User Roles: The first step is to define user
roles, such as customer, restaurant owner, and administrator.
Each role will have different access rights and privileges.

6.2.2. Collect User Information: For each user role, collect

the relevant information needed for their user profile. For
customers, this may include their name, address, phone
number, and email address. For restaurant owners, this may
include their business name, address, phone number, and
email address.

6.2.3. Set Up User Accounts: Create user accounts for each

user role, using the information collected in step 2. Each user
account should have a unique username and password.

6.2.4. Assign Access Rights: Assign access rights to each

user role based on their responsibilities in the application.
For example, customers should have access to their order
history and profile information, while restaurant owners
should have access to their restaurant menu and order
history.

6.2.5. Test User Profiles and Access Rights: Test the user
profiles and access rights to ensure that each user role can
access the appropriate features and information.
7. REPORTS AND SCREENSHOTS:
7.1. Home Page:
7.2. Create User:
7.3. Login Homepage:
7.4. MENU PAGE:
7.5. CART:
 8. FURTHER ENHANCEMENT AND
FUTURE SCOPE :

i. Ratings and reviews:

While the project does not currently include a ratings and
reviews feature, adding this functionality could enhance the
user experience by allowing users to rate and review
restaurants and menu items. This could also help improve the
overall quality of the platform by promoting higher quality
restaurants and incentivizing restaurants to maintain high
standards.

ii. Mobile applications:

Considering developing mobile applications for iOS and
Android platforms, to make it easier for users to order food
on-the-go. This would also increase the platform's
accessibility and reach a wider audience.

iii.Loyalty programs:
Introducing loyalty programs, discount codes, and
 promotional offers can encourage repeat business and help
in customer retention. Considering developing a rewards
program where users earn points for placing orders that can
be redeemed for discounts or free meals.

iv. Advanced search and filtering:

Implementing advanced search and filtering options could
help users find restaurants and menu items more easily
based on their specific preferences. These advanced filters
could include options such as dietary restrictions (e.g.
vegetarian, gluten-free), price range, delivery time, etc.

v. Order tracking:
Adding a real-time order tracking feature can help customers
track their orders in real-time and provide them with regular
updates on the status of their orders. This could also help
increase trust and transparency between the platform and the
customers.

vi. Chatbot integration:

Integrating a chatbot feature can provide users with instant
customer support and assistance with placing orders. This
can help in providing an efficient and user-friendly
experience to the customer.

9. Assumptions:
1. The application does not have a payment option: It can
be assumed that the food delivery application does not have
any payment options integrated, which means that payment
will be handled separately from the application. Customers
will have to pay the restaurant directly, using a payment
method of their choice.

2. The application does not have delivery tracking: It can

be assumed that the food delivery application does not have
any delivery tracking features integrated, which means that
customers will not be able to track the status of their
delivery in real-time. They will have to rely on
communication from the restaurant or delivery person to
know when their food will arrive.

3. The application has a basic ordering system: It can be

assumed that the food delivery application has a basic
ordering system, where customers can browse the restaurant
menu, select the items they want, and place an order. The
restaurant will receive the order and prepare the food for
delivery or pickup.

4. The application has user authentication: It can be

assumed that the food delivery application has user
authentication features, which means that customers and
restaurant owners will have to create an account and log in
to use the application. This will allow the application to
store and retrieve user information, such as order history,
menu items, and restaurant information.

5. The application has basic search and filtering features:

It can be assumed that the food delivery application has
basic search and filtering features, which will allow
customers to search for restaurants or menu items based on
certain criteria, such as location, cuisine, or price range.