VIMALA CENTRAL SCHOOL

KARAMCODU P.O, CHATHANNOOR, KOLLAM,

KERALA-691579
AFFILIATED TO CENTRAL BOARD OF SECONDARY EDUCATION NEW
DELHI
[Link]. -930331

In partial fulfilment of the requirement for the second year of Senior Secondary
Certificate Examination, 2025-‘26

DEPARTMENT OF COMPUTER SCIENCE

“SELF-ORDER SYSTEM”

DONE BY
Name : SALIHA FATHIMA.K
Class : XII-B
Register no. :
Admission no. : 984
Year of study : 2025-2026
Teacher in charge : BINCY B.S

Examiners: Principal:

1
 ACKNOWLEDGEMENT
First of all I would like to express my sincere concern and regards to our most
respected [Link] Samuel Pazhavooradickal and Principal [Link] Mathew for
giving me ample support and encouragement for completing this project. This project
was done under the guidance of teacher, Mrs. Bincy B.S,department of Computer
Science Vimala Central School.

I have great indebtedness to them, and I express my wholehearted gratitude for their
valuable guidance. I would also extent my faithful thanks to my friends and my family
for their valuable help and advice during the course of project.

At last, not the least I am thanking his guidance,

‘’THE ALMIGHTY GOD”

2
 CERTIFICATE

This is to certify that this project entitled as “Self-order system” is a bona fide work
done by SALIHA FATHIMA K of class XII B under the guidance and supervision of
[Link] B.S, teacher in charge of Department of Computer Science.

PRINCIPAL

ABSTRACT
3
The manual and traditional methods of taking orders in restaurants, cafés, or food
courts often suffer from inefficiencies such as human errors, delays, and a high
workload on staff during peak hours. This project addresses these shortcomings by
designing and implementing a modern, user-friendly Self-Order System. The system is
built using Python, leveraging MySQL for database management, to create an efficient
and reliable digital platform for customer ordering.
The primary objective of this project is to streamline the ordering process, thereby
reducing waiting times for customers and minimizing operational errors for the
business. The system consists of three main modules: a customer interface for
browsing the menu and placing orders, a kitchen module for receiving and managing
orders, and an admin module for menu and inventory management. The customer-
facing module provides an intuitive graphical user interface (GUI) where users can
view the digital menu, select items, and finalize their order. This order is then
immediately reflected in the kitchen module, allowing for faster processing.
The database, implemented in MySQL, is structured to store and manage critical
information, including menu items, pricing, inventory levels, and transaction records.
This connectivity between Python and MySQL ensures real-time updates and data
integrity. Key functionalities include:
 A user-friendly menu display.

 The ability to add, update, and remove items from a cart.

 Calculation of the total bill.

 Generation of a final order receipt.

 A secure and robust backend for managing all operations.

Ultimately, this Self-Order System aims to provide a proof-of-concept for how

technology can be used to improve customer satisfaction and increase the operational
efficiency of a service-oriented business. The project showcases fundamental
programming and database management skills, aligning with the CBSE Class 12
Computer Science curriculum.

4
 CONTENT

SI NO: TOPIC PAGE NO:

1 INTRODUCTION 6
2 MODULES 7
3 SURVEY OF 8
TECHNOLOGIES
4 SOFTWARE & 11
HARDWARE
REQUIREMENTS
5 SOURCE CODE 12
6 OUTPUT SCREEN 26
7 CONCLUSION 29
8 BIBLIOGRAPHY 30

INTRODUCTION
The Restaurant Self-Order System is a user-friendly and efficient digital platform
designed to streamline the ordering process in restaurants. Leveraging Python as the
primary programming language, SQL for database management, and SQL Connector

5
for seamless database interaction, this project aims to enhance customer experience
and optimize restaurant operations.

Key Features:

1. Intuitive User Interface: A simple and intuitive interface allows customers to easily
browse menus, select items, and place orders.
2. Real-time Order Management: The system updates orders in real-time, ensuring that
kitchen staff and management have access to accurate and timely information.
3. Database Integration: SQL database management ensures secure and efficient
storage of menu items, orders, and customer information.
4. Streamlined Operations: The system automates order processing, reducing errors
and increasing efficiency.

Objectives:
1. Improve customer satisfaction through a user-friendly ordering process.
2. Enhance operational efficiency by reducing manual errors and streamlining order
management.
3. Provide valuable insights into customer preferences and ordering trends.

Technologies Used:

1. Python: Primary programming language for developing the system's logic and
functionality.
2. SQL: Database management system for storing and retrieving menu items, orders,
and customer information.
3. SQL Connector: Enables seamless interaction between the Python application and
SQL database.

Expected Outcomes:

The Restaurant Self-Order System aims to revolutionize the dining experience by

providing a convenient, efficient, and user-friendly platform for customers to order
their favourite dishes. By leveraging Python, SQL, and SQL Connector, this project
demonstrates the potential for technology to enhance the restaurant industry and
improve customer satisfaction.

Modules
In this project we need to import the module sqlite3 in order to connect our Python
script to MySQL database.

6
The sqlite3 module in Python provides a lightweight, serverless, and self-contained
relational database management system. Since it is part of Python's standard library, it
can be used without installing any external dependencies.
The sqlite3 module is ideal for s maller-scale applications, data storage, and
prototyping because:
 It operates entirely within the host application process, so there's no need to
manage a separate database server.

 An entire SQLite database is stored in a single cross-platform file, which makes

it easy to move, copy, or back up.

import sqlite3

SURVEY OF TECHNOLOGIES
The following software is used in the project for the development of STUDENT
MANAGEMENT SYSTEM.

7
 PYTHON: Python is an interpreted, high-level, general purpose programming
language developed by Guido van Rossum in 1991. Python is dynamically typed
and garbage-collected. It supports multiple programming paradigms,
including procedural, object-oriented, and functional programming. Python is often
described as a "Batteries Included" language due to its comprehensive standard
library.
There are two major Python versions - Python 2 and Python 3. The version used for
this project is PYTHON 3.9.5
MY SQL: My SQL is an open-source relational database management
system (RDBMS). My SQL is free and open-source software under the terms of
the GNU General Public License. It is the world’s most popular open-source database.
With its proven performance, reliability, and ease-of-use, My SQL has become the
leading database choice for web-based applications, used by high profile web
properties including Face book, Twitter, YouTube etc.

My SQL-Connector-Python: Python needs a My SQL driver to access the My SQL

database. This is a driver "My SQL Connector" used to connect python and MySQL
databases. We can install this connector using command: pip install my sql-
connector-python
Python is a high-level, interpreted, interactive and object-oriented scripting language.
Python is designed to be highly readable. It uses English keywords frequently where
as other languages use punctuation, and it has fewer syntactical constructions than
other languages.
[Link] is Interpreted Python is processed at runtime by the interpreter. You do not
need to compile your program before executing it. This is similar to PERL and PHP.
[Link] is Interactive - You can actually sit at a Python prompt and interact with the
interpreter directly to write your programs.
[Link] is Object-Oriented- Python supports Object-Oriented style or technique of
programming that encapsulates code within objects.

8
[Link] is a Beginner's Language - Python is a great language for the beginner-level
programmers and supports the development of a wide range of applications from
simple text processing to WWW browsers to games.
History of Python: Python was developed by Guido van Rossum in the late eighties
and early nineties at the National Research Institute. for Mathematics and Computer
Science in the Netherlands.
Python is derived from many other languages, including ABC, Modula-3, C, C++,
Algol-68, Smalltalk, and Unix shell and other scripting languages.
Python is copyrighted. Like Perl, Python source code snow available under the GNU
General Public License (GPL).
Python is now maintained by a core development team at the institute, although Guido
van Rossum still holds a vital role in directing its progress.
Python Features:
[Link]-to-learn- Python has few keywords, simple structure, and a clearly defined
syntax. This allows the student to pick up the language quickly.
[Link]-to-read - Python code is more clearly defined and visible to the eyes.
[Link]-to-maintain - Python's source code is fairly easy-to-maintain.
4.A broad standard library - Python's bulk of the library is very portable and cross-
platform compatible on UNIX, Windows, and Macintosh.
[Link] Mode - Python has support for an interactive mode which allows
interactive testing and debugging of snippets of code.
[Link]- Python can run on a wide variety of hardware platforms and has the same
interface on all platforms.
[Link]- You can add low-level modules to the Python interpreter. These
modules enable programmers to add to or customize their tools to be more efficient.
[Link]-Python provides interfaces to all major commercial databases.
[Link] Programming - Python supports GUI applications that can be created and
ported to many system calls, libraries and windows systems, such as Windows MFC,
Macintosh, and the X Window system of Unix.
9
[Link]- Python provides a better structure and support for large programs than
shell scripting.

10
 SOFTWARE & HARDWARE REQUIREMENTS

HARDWARE SPECIFICATIONS:

⮚ PROCESSOR : ANY MODERN DUAL-CORE PROCESSOR

⮚ RAM : 4 GB RAM
⮚ HARD DISK : 1 TB
⮚ MONITOR : 14’’ LED or Above
⮚ KEYBOARD : 104 KEYS
⮚ MOUSE : OPTICAL MOUSE
⮚ PRINTER : 24 Pin DOTMATRIX or above

SOFTWARE SPECIFICATIONS:
⮚ OPERATING SYSTEM: WINDOWS 10 or Later
macOS 13 or Later
LINUX
⮚ DATABASE : SQlite3
⮚ FRONT END: Python 3 or Above & TK Inter Library
⮚ MIDDLEWARE: Python-MySQL Connector
⮚ BACKEND: MySQL

11
 SOURCE CODE
import sqlite3

import random

from datetime import datetime

DATABASE_NAME = '[Link]'

def create_and_seed_database():

"""Create the SQLite database and populate it with initial data."""

conn = [Link](DATABASE_NAME)

cursor = [Link]()

[Link]("""

CREATE TABLE IF NOT EXISTS Restaurants (

RestaurantID INTEGER PRIMARY KEY AUTOINCREMENT,

Name TEXT NOT NULL

);

""")

[Link]("""

12
 CREATE TABLE IF NOT EXISTS MenuCategories (

CategoryID INTEGER PRIMARY KEY,

CategoryName TEXT NOT NULL

);

""")

[Link]("""

CREATE TABLE IF NOT EXISTS Menu (

ItemID INTEGER PRIMARY KEY,

CategoryID INTEGER,

MenuItemName TEXT NOT NULL,

Price REAL NOT NULL,

FOREIGN KEY (CategoryID) REFERENCES MenuCategories(CategoryID)

);

""")

[Link]("""

CREATE TABLE IF NOT EXISTS Orders (

OrderID INTEGER PRIMARY KEY AUTOINCREMENT,

OrderDate TEXT NOT NULL,

TotalAmount REAL NOT NULL,

OrderStatus TEXT NOT NULL

13
 );

""")

[Link]("""

CREATE TABLE IF NOT EXISTS OrderItems (

OrderItemID INTEGER PRIMARY KEY AUTOINCREMENT,

OrderID INTEGER,

ItemID INTEGER,

Quantity INTEGER NOT NULL,

PriceAtOrder REAL NOT NULL,

FOREIGN KEY (OrderID) REFERENCES Orders(OrderID),

FOREIGN KEY (ItemID) REFERENCES Menu(ItemID)

);

""")

[Link]("""

CREATE TABLE IF NOT EXISTS Payments (

PaymentID INTEGER PRIMARY KEY AUTOINCREMENT,

OrderID INTEGER NOT NULL,

PaymentMethod TEXT NOT NULL,

PaymentDate TEXT NOT NULL,

AmountPaid REAL NOT NULL,

14
 FOREIGN KEY (OrderID) REFERENCES Orders(OrderID)

);

""")

[Link]("SELECT COUNT(*) FROM Restaurants")

if [Link]()[0] == 0:

[Link]("INSERT INTO Restaurants (Name) VALUES (?)", ('Celeste

Kitchen',))

categories = [

(1, 'Starters / Small Plates'),

(2, 'Soups & Salads'),

(3, 'Global Classics'),

(4, 'Indian Signatures'),

(5, 'Seafood & Meats'),

(6, 'Vegetarian Delights'),

(7, "Chef's Specials"),

(8, 'Desserts'),

(9, 'Beverages')

15
 [Link]("INSERT INTO MenuCategories (CategoryID,

CategoryName) VALUES (?, ?)", categories)

menu_items = [

(101, 1, 'Celeste Bites', [Link](8.0, 12.0)),

(102, 1, 'First Flavors', [Link](8.0, 12.0)),

(103, 1, 'Appetizers & Tapas', [Link](8.0, 12.0)),

(201, 2, 'Garden & Broth', [Link](6.0, 9.0)),

(202, 2, 'Fresh Harvest', [Link](6.0, 9.0)),

(203, 2, 'Greens & Warm Bowls', [Link](6.0, 9.0)),

(301, 3, 'Italian Pastas & Pizzas', [Link](14.0, 22.0)),

(302, 3, 'Continental Grills & Steaks', [Link](18.0, 28.0)),

(303, 3, 'Asian Noodles & Stir-Fries', [Link](12.0, 18.0)),

(401, 4, 'Royal Curries & Biryanis', [Link](15.0, 25.0)),

(402, 4, 'Regional Specialties', [Link](14.0, 24.0)),

(501, 5, 'From the Ocean', [Link](19.0, 32.0)),

(502, 5, 'Prime Cuts & Grills', [Link](22.0, 35.0)),

(601, 6, 'Earth’s Table', [Link](14.0, 20.0)),

(602, 6, 'Gourmet Veg Plates', [Link](16.0, 22.0)),

(701, 7, 'Fusion Creations', [Link](25.0, 40.0)),

(702, 7, 'Seasonal Highlights', [Link](25.0, 40.0)),

(801, 8, 'Sweet Finale', [Link](7.0, 11.0)),

16
 (802, 8, 'Celeste Indulgence', [Link](7.0, 11.0)),

(901, 9, 'Mocktails & Fresh Juices', [Link](5.0, 8.0)),

(902, 9, 'Artisanal Teas & Coffees', [Link](4.0, 7.0))

[Link]("INSERT INTO Menu (ItemID, CategoryID,

MenuItemName, Price) VALUES (?, ?, ?, ?)", menu_items)

[Link]()

[Link]()

def connect_to_database():

"""Establishes and returns a connection to the SQLite database."""

try:

conn = [Link](DATABASE_NAME)

return conn

except [Link] as ex:

print(f"Error connecting to database: {ex}")

return None

def get_restaurant_name(connection):

"""Retrieves and prints the restaurant name from the database."""

cursor = [Link]()

17
 try:

[Link]("SELECT Name FROM Restaurants LIMIT 1")

result = [Link]()

if result:

restaurant_name = result[0]

print(f"--- Welcome to {restaurant_name}! ---\n")

else:

print("Welcome to Our Restaurant!\n")

except [Link] as ex:

print(f"Error retrieving restaurant name: {ex}")

finally:

[Link]()

def print_menu(connection):

"""Retrieves and prints the restaurant menu with categories."""

cursor = [Link]()

[Link]("SELECT CategoryID, CategoryName FROM MenuCategories

ORDER BY CategoryID")

categories = [Link]()

menu_dict = {}

if not categories:

18
 print("Menu is currently unavailable.")

return menu_dict

print("--- Menu ---")

for category_id, category_name in categories:

print(f"\n[{category_name}]")

[Link]("SELECT ItemID, MenuItemName, Price FROM Menu WHERE

CategoryID = ? ORDER BY ItemID", (category_id,))

items = [Link]()

for item_id, name, price in items:

print(f"{item_id}. {name} - ${price:.2f}")

menu_dict[item_id] = (name, price)

print("------------")

[Link]()

return menu_dict

def place_order_in_db(order_cart, total_bill, connection, menu_items,

payment_method):

"""Inserts a new order and its items into the database, along with payment details,

using a transaction."""

cursor = [Link]()

try:

19
 [Link]("BEGIN IMMEDIATE")

order_date = [Link]().strftime("%Y-%m-%d %H:%M:%S")

order_status = "Pending"

[Link]("INSERT INTO Orders (OrderDate, TotalAmount, OrderStatus)

VALUES (?, ?, ?)",

(order_date, total_bill, order_status))

order_id = [Link]

order_items_data = []

for item_id, quantity in order_cart.items():

_, item_price = menu_items[item_id]

price_at_order = item_price

order_items_data.append((order_id, item_id, quantity, price_at_order))

[Link]("INSERT INTO OrderItems (OrderID, ItemID, Quantity,

PriceAtOrder) VALUES (?, ?, ?, ?)",

order_items_data)

20
 [Link]("INSERT INTO Payments (OrderID, PaymentMethod,

PaymentDate, AmountPaid) VALUES (?, ?, ?, ?)",

(order_id, payment_method, order_date, total_bill))

[Link]()

except [Link] as ex:

print(f"Error placing order in database: {ex}")

[Link]()

finally:

[Link]()

def take_order(available_menu, connection):

"""Handles the user's order selection and payment."""

if not available_menu:

print("Cannot take order: menu is empty.")

return

order_cart = {}

total_bill = 0.0

while True:

21
 try:

selection = input("\nEnter item number to add (or 'done' to finish): ").lower()

if selection == 'done':

break

item_id = int(selection)

if item_id in available_menu:

item_name, item_price = available_menu[item_id]

quantity = int(input(f"How many {item_name}s? "))

if quantity > 0:

order_cart[item_id] = order_cart.get(item_id, 0) + quantity

total_bill += item_price * quantity

print(f"Added {quantity} x {item_name} to your order. Total: $

{total_bill:.2f}")

else:

print("Quantity must be positive.")

else:

print("Invalid menu item number.")

except ValueError:

print("Invalid input. Please enter a number or 'done'.")

if order_cart:

22
 print("\n--- Final Order Summary ---")

for item_id, quantity in order_cart.items():

item_name, item_price = available_menu[item_id]

print(f"{item_name} x {quantity} = ${item_price * quantity:.2f}")

print(f"Total Bill: ${total_bill:.2f}")

while True:

payment_method = input("Enter payment method ('Card' or 'Cash'): ").lower()

if payment_method in ['card', 'cash']:

if payment_method == 'card':

while True:

card_number = input("Please enter your card number: ")

if len(card_number) >= 13 and len(card_number) <= 19 and

card_number.isdigit():

print("Processing card transaction...")

break

else:

print("Invalid card number. Please try again.")

break

else:

23
 print("Invalid payment method. Please choose 'Card' or 'Cash'.")

confirm = input("Confirm and place order? (yes/no): ").lower()

if confirm == 'yes':

place_order_in_db(order_cart, total_bill, connection, available_menu,

payment_method)

print("Order placed successfully! Thank you.")

else:

print("Order cancelled.")

else:

print("No items were added to the order.")

def main():

"""Main function to run the self-order system."""

create_and_seed_database()

conn = connect_to_database()

if conn:

get_restaurant_name(conn)

menu = print_menu(conn)

take_order(menu, conn)

[Link]()

24
if __name__ == "__main__":

main()

OUTPUT SCREEN

--- Welcome to Celeste Kitchen! ---

--- Menu -

[Starters / Small Plates]

101. Celeste Bites - $11.69

102. First Flavors - $9.72

103. Appetizers & Tapas - $9.46

[Soups & Salads]

201. Garden & Broth - $6.91

25
202. Fresh Harvest - $6.95

203. Greens & Warm Bowls - $6.73

[Global Classics]

301. Italian Pastas & Pizzas - $17.84

302. Continental Grills & Steaks - $27.36

303. Asian Noodles & Stir-Fries - $15.99

[Indian Signatures]

401. Royal Curries & Biryanis - $24.30

402. Regional Specialties - $23.60

[Seafood & Meats]

501. From the Ocean - $30.27

502. Prime Cuts & Grills - $26.65

[Vegetarian Delights]

601. Earth’s Table - $18.94

602. Gourmet Veg Plates - $19.75

[Chef's Specials]

701. Fusion Creations - $30.63

702. Seasonal Highlights - $30.73

26
[Desserts]

801. Sweet Finale - $7.43

802. Celeste Indulgence - $7.72

[Beverages]

901. Mocktails & Fresh Juices - $7.46

902. Artisanal Teas & Coffees - $4.53

------------

Enter item number to add (or 'done' to finish): 901

How many Mocktails & Fresh Juicess? 2

Added 2 x Mocktails & Fresh Juices to your order. Total: $14.91

Enter item number to add (or 'done' to finish): done

--- Final Order Summary ---

Mocktails & Fresh Juices x 2 = $14.91

Total Bill: $14.91

Enter payment method ('Card' or 'Cash'): card

Please enter your card number: 2345646778899042

Processing card transaction...

Confirm and place order? (yes/no): yes

27
Order placed successfully! Thank you.

CONCLUSION

The Restaurant Self-Order System project has successfully demonstrated the potential
of technology to revolutionize the dining experience. By leveraging Python, SQL, and
SQL Connector, we have developed a user-friendly and efficient digital platform that
streamlines the ordering process, reduces errors, and enhances customer satisfaction.

The project's key features, including intuitive user interface, real-time order
management, and database integration, have been successfully implemented and
tested. The system's ability to automate order processing and provide valuable insights
into customer preferences and ordering trends makes it an attractive solution for
restaurants looking to improve their operations.

28
 BIBLIOGRAPHY
[Link]
[Link]
search engine
[Link]
[Link]

29