1.

INTRODUCTION

1.1 Introduction

In the modern era of digital transformation, traditional voting systems that

rely on physical ballot papers, long queues, and manual counting are
increasingly seen as inefficient, time-consuming, and prone to error or
manipulation. With the advent of secure internet technologies and the
widespread adoption of smartphones and computers, the concept of an
Online Voting System (also referred to as e-voting or digital voting) has
emerged as a revolutionary solution for enhancing the efficiency,
accessibility, and transparency of elections.

An Online Voting System is a web-based platform that allows eligible

voters to cast their votes securely over the internet, from any location and
at any time during the election period. It integrates authentication, real-
time tallying, encryption, and a user-friendly interface to provide a
seamless experience for voters and administrators alike. The system
ensures voter privacy and security, reducing the risks of fraud,
duplication, and tampering.

This project aims to develop a secure and robust Online Voting System
that addresses the challenges of conventional voting methods while
fostering greater participation, especially among remote or physically
challenged voters. It emphasizes security, transparency, and ease of use.

1.2 Existing System

The existing voting systems are generally manual and involve physical
presence at polling stations. Some key limitations of the current system
include:

 Time-Consuming Process: Voting, counting, and result declaration

take significant time.

 Limited Accessibility: Voters must be physically present at polling

stations, making it hard for those living abroad, with disabilities, or
in remote locations.

 Human Errors and Frauds: Manual counting is error-prone and

susceptible to manipulation or tampering.

 High Operational Costs: Printing ballots, deploying staff, and

securing polling booths incur heavy financial and logistical costs.

Page 1 of 59
  Low Voter Turnout: Many eligible voters avoid elections due to
inconvenience or travel constraints.

Some regions have experimented with Electronic Voting Machines (EVMs),

but even these require physical presence and can raise concerns around
tampering or technical glitches. Hence, there is a need for a more
advanced, accessible, and secure solution like online voting.

1.3 Objectives

The primary objectives of the Online Voting System project are:

 To develop a secure and reliable online platform for casting

votes electronically.

 To ensure voter authentication and data integrity using

encryption and secure login mechanisms.

 To increase voter participation and accessibility, especially for

remote or physically unable voters.

 To provide real-time monitoring and fast result generation

with accuracy.

 To eliminate fraud and duplication by enforcing one-person-one-

vote through secure identification.

 To reduce the costs and resources associated with manual

voting systems.

1.4 Scope of Work

The scope of this project includes:

 User Registration and Authentication: Each voter must register

using valid credentials and go through a verification process (e.g.,
OTP validation).

 Admin Portal: For managing elections, adding candidates, viewing

statistics, and managing voter data.

 Voter Dashboard: Where registered voters can view candidates,

vote, and receive confirmation.

 Candidate Management: Admin can add, remove, and update

candidate profiles and their details.

Page 2 of 59
  Voting Interface: Simple, responsive design allowing voters to cast
votes securely.

 Security Features: SSL encryption, audit trail, CAPTCHA, IP

monitoring, and optional two-factor authentication.

 Multi-device Compatibility: The system should work smoothly

across desktops, tablets, and smartphones.

 Scalability: Designed to handle large volumes of concurrent users

(e.g., national-level elections).

1.5 Operating Environment

The Online Voting System is a web-based application and requires the

following software and hardware components:

Software Requirements:

 Frontend: HTML, CSS

 Backend: Python (Django)

 Database: SQLite (default Django database)

 Server: Server (development server, optionally ready for

deployment)

 Operating System: Windows, Linux, or macOS for development

and deployment

 Browser Support: (Chrome, Firefox, Edge)

Hardware Requirements:

 Client-side: Smartphone, tablet, laptop, or desktop computer with

stable internet access.

Modern web browser installed (Chrome, Firefox, Edge - updated

versions).

 Server-side: Local machine or basic server capable of running

Django applications.

Minimum:

Processor: Dual-core or better (Intel i3/i5 or equivalent

Page 3 of 59
 RAM: 4 GB (8 GB recommended for smoother performance)

Storage: Minimum 50 GB free space (SSD preferred)

Operating System: Windows 10/11, Linux (Ubuntu), or macOS

Internet Connection: Required for remote access or deployment.

Network Requirements:

 Stable internet connection with minimum 10 Mbps speed for server

hosting.
 For development purposes, localhost ([Link]) is sufficient.
 Secure hosting environment recommended for production (firewall,
SSL certificate, basic DDoS protection if publicly accessible).
 HTTPS protocol advised for securing user data (SSL certificate
installation needed in production).

1.6 Description of Technology Used

The Django Online Voting System utilizes widely adopted web

development technologies to create a secure, scalable, and user-friendly
voting platform:

 HTML5/CSS3: For designing responsive and accessible frontend

layouts compatible across different devices and browsers.

 JavaScript (Vanilla): For adding dynamic behavior and client-side

interactivity on the voting and registration pages.

 Python 3.8+ (Django Framework): Used as the primary backend

technology to handle business logic, manage database operations,
secure user authentication, and serve APIs.

 SQLite Database: A lightweight relational database management

system used for storing user data, votes, and election details during
development (can be upgraded to PostgreSQL or MySQL for
production).

 Django Authentication System: Provides secure user login,

session management, and access control for voters and
administrators.

 Bootstrap (CSS Framework): Used for developing mobile-

responsive and modern UI components, ensuring faster front-end
development.

Page 4 of 59
  SSL/TLS (Recommended for Deployment): To secure data
transmission over HTTPS in a production environment and protect
sensitive user information.

 Django Admin Panel: Provides a built-in backend interface for

administrators to manage users, candidates, positions, and voting
processes easily.

 Local Hosting (Development Server): Django’s built-in

development server was used during development and testing.

 Browser Compatibility: Fully compatible with the latest versions

of Chrome, Firefox, and Edge browsers.

2. Scalability Considerations

Scalability is crucial to ensure that the system can handle large-scale

national or state-level elections without degradation in performance.

2.1 Environment Scalability

 The Django Online Voting System is designed to be scalable for future

growth, depending on the size of the elections and number of users.
 Initially developed and tested on a local server, the system can be
deployed on cloud-based platforms (e.g., AWS EC2, DigitalOcean) for
handling larger traffic if required.
 For production environments, the system can integrate with web
servers like Gunicorn behind Nginx to manage multiple requests
efficiently.
 Database scalability can be achieved by migrating from SQLite
(development) to more robust databases like PostgreSQL or MySQL
for high-volume data handling.
 Horizontal scaling (adding more servers) and vertical scaling
(upgrading server specifications) can be implemented based on the
number of concurrent voters.
 Using HTTPS (SSL certificates) and server-side caching will further
improve performance and security during peak voting periods.
 Although currently a monolithic application, the system architecture
allows modular separation of components (admin panel, voting
module) if future microservices adoption is required.

Page 5 of 59
2.2 Hardware Scalability

 Vertical Scaling: In case of increased election traffic, the existing

server’s hardware resources such as CPU, RAM, and storage can be
upgraded to enhance performance and ensure smooth operation
during peak voting periods.

 Horizontal Scaling: For larger deployments involving thousands of

voters, additional servers can be added to distribute the load,
ensuring faster response times and minimizing downtime. Load
balancing strategies can also be introduced if required.

 Redundancy: Regular data backups and redundant server setups can

be employed to maintain high availability and disaster recovery. This
ensures that in case of hardware failures, the system continues to
function without loss of critical election data.

2.3 Software Scalability

 Modular Codebase:
The Django Online Voting System is built with a modular architecture,
where key components such as the voting engine, candidate
management, and result processing are separated. This allows
independent scaling and easier maintenance of individual modules.

 Efficient Request Handling:

Django's robust request-response cycle and middleware management
ensure efficient handling of multiple concurrent requests. Server
performance can be optimized further using WSGI servers like Gunicorn.

 Caching Strategies:
Django’s caching framework can be integrated to cache frequent queries,
voting pages, and result views, reducing database load and improving
system responsiveness during high user activity.

 Scalable APIs:
The system’s internal APIs and Django views are structured to efficiently
handle large numbers of concurrent voting operations, with options for
applying techniques like query optimization and database indexing to
maintain performance as user numbers grow.
Page 6 of 59
2.4 Database Scalability

 Database Optimization: In the current implementation, SQLite is

used for development purposes. For large-scale deployment, the
system can be migrated to scalable databases like PostgreSQL or
MySQL, which handle concurrent read/write operations more
efficiently.

 Indexing and Query Optimization: Proper indexing of frequently

accessed tables such as voters, candidates, and votes can
significantly improve database performance. Query optimization
techniques can be applied to reduce response time during peak
voting periods.

CHAPTER 2: LITERATURE REVIEW

2.1 Introduction

A literature review provides insights into prior research and developments

related to Online Voting Systems. It helps identify existing challenges,
proposed solutions, and technological advancements. This chapter
explores the evolution of voting methods, the integration of digital
technology in elections, and a comparative analysis of various systems
implemented globally. The findings of this review guide the design and
development of a more secure, scalable, and user-friendly online voting
platform.

2.2 Traditional Voting Systems

Traditional voting systems are largely paper-based and require in-person

voting at designated polling stations. While this approach is well-
established, it suffers from:

 High costs due to logistics and manpower

 Risk of human error in counting and data entry

 Voter apathy due to long queues or remote locations

 Vulnerability to ballot manipulation or rigging

These limitations have prompted the search for more efficient and
transparent alternatives.

Page 7 of 59
2.3 Electronic Voting Machines (EVMs)

EVMs represent a step toward digitization, where votes are cast

electronically. While widely used in countries like India and Brazil, EVMs
also have drawbacks:

 Require physical presence of voters

 Can be vulnerable to tampering or hacking if not properly secured

 Lack of transparency in the internal functioning

 Limited accessibility for overseas voters or those with disabilities

Although EVMs improve speed and reduce ballot printing costs, they are
not truly “online” or remote-accessible.

2.4 Online Voting Systems (E-Voting)

Online voting allows registered voters to cast their votes over the internet
from anywhere. Various models and pilot programs have been conducted
worldwide:

2.4.1 Estonia – The Pioneer

Estonia is the first country to implement a nationwide internet voting

system (i-Voting) since 2005. Features include:

 National ID card-based authentication

 End-to-end encryption and vote verification

 Public confidence through transparency reports

Challenges: High reliance on digital infrastructure, need for digital

literacy.

2.4.2 Switzerland’s Trial System

Switzerland tested an online voting system with focus on verifiability and

transparency. Open-source components and third-party audits were
included.

Challenges: Public concerns about privacy and election integrity led to

temporary suspensions for improvements.

Page 8 of 59
2.4.3 Other Efforts

 Canada and Australia have piloted online voting for municipal or

overseas voters.

 The U.S. has tested blockchain-based voting in limited settings (e.g.,

Voatz in West Virginia).

2.5 Technologies Used in Online Voting

Online voting relies on various modern technologies:

 Cryptography: Ensures vote confidentiality and data security (e.g.,

RSA, homomorphic encryption).

 Blockchain: Promotes transparency, immutability, and trust in the

voting process.

 Biometric Authentication: Enhances voter verification using

fingerprints or facial recognition.

 OTP & 2FA: Protect against unauthorized access with multi-factor

authentication.

 Cloud Computing: Offers scalability and high availability for large-

scale elections.

2.6 Comparative Studies and Research Papers

Several academic and industry studies have analyzed e-voting systems:

 “A Secure Online Voting System” by Rivest et al. (MIT)

emphasized the use of end-to-end verifiable cryptographic voting
systems to mitigate fraud.

 IEEE and ACM papers highlight the importance of usability,

transparency, and voter trust as key factors for adoption.

 “Blockchain-Based Voting: The Future of Elections” discussed

how distributed ledger technology could solve problems of trust and
manipulation in e-voting.

2.7 Identified Gaps in Literature

Despite many advancements, common concerns persist:

Page 9 of 59
  Security: Ensuring that votes are not altered or accessed by
unauthorized parties.

 Voter Anonymity: Maintaining privacy while preventing multiple

voting.

 Digital Divide: Ensuring equal access for rural, elderly, or

technologically challenged users.

 Public Trust: Skepticism toward digital systems in politically

sensitive environments.

 Scalability: Designing systems capable of handling millions of

votes without downtime or data loss.

2.8 Conclusion

The literature reveals significant interest and progress in developing

online voting systems, yet many challenges remain. No system is perfect,
but a combination of strong encryption, robust authentication, user-centric
design, and transparent processes is key. This review provides a
foundation for developing a secure and scalable Online Voting System
tailored to real-world conditions.

CHAPTER 3: PROPOSED SYSTEM / METHODOLOGY

3.1 Introduction

The proposed Online Voting System aims to provide a secure,

accessible, and efficient platform for conducting elections digitally. It
addresses the limitations of traditional voting methods by leveraging
modern technologies such as encryption, user authentication, and cloud
infrastructure. This chapter outlines the design and methodology used to
develop the system, the architecture involved, and the functionalities of
each module.

3.2 Overview of the Proposed System

Page 10 of 59
 The Django Online Voting System is a secure, web-based platform that
allows eligible voters to participate in elections digitally with ease and
transparency. Key functionalities of the system include:

Register and authenticate themselves securely

 View election details and candidate information

 Cast votes electronically with verification

 Receive real-time feedback and confirmation of submission

The system is managed by an admin panel for election setup, candidate

registration, and result monitoring.

3.3 Objectives of the Proposed System

 Enhance voter participation by allowing remote voting

 Eliminate fraud through strict authentication and encryption

 Provide accurate and fast election results

 Ensure security, privacy, and auditability

 Simplify election management for administrators

3.4 System Architecture

The system is designed using a three-tier architecture:

1. Presentation Layer (Frontend)

o Provides an interface for voters and administrators to interact

with the system.

o Built using HTML5, CSS3, Bootstrap, and vanilla

JavaScript (no React/Angular used).

o Handles user inputs like registration, login, ballot selection,

and displays election details and voting results.

2. Application Layer (Backend)

o Developed using Python with the Django Framework.

Page 11 of 59
 o Contains business logic for user authentication, voting process
validation, result computation, and administrative control.

o Manages all server-side request handling and ensures secure

communication between the frontend and database.

3. Data Layer (Database)

o Manages and stores persistent data such as voter profiles,

candidates, voting records, and election results.

o Initially uses SQLite during development; scalable to

PostgreSQL or MySQL for production environments.

o Ensures data integrity through Django ORM validations and

includes provisions for regular backups and optional
encryption for sensitive data.

3.5 Methodology

The development of the Django Online Voting System follows a simplified

Agile Software Development Model. This approach ensures flexibility,
continuous feedback, and incremental delivery of functional modules.

Phases:

3.5.1 Incremental Development:

The project was divided into multiple small, manageable modules such as
user authentication, voting process, candidate management, and result
generation. Each module was developed, tested, and refined individually
before integration.

3.5.2 Flexibility:

Requirements were continuously reviewed and adjusted based on the

progress and testing outcomes. This helped in incorporating necessary
improvements during development.

3.5.3 Continuous Testing:

Testing was performed at every stage to ensure that each functionality,

like secure login, vote submission, and result display, worked correctly and
independently.

Page 12 of 59
3.5.4 Collaboration and Feedback:

Frequent reviews and feedback sessions were conducted during the

development phases to identify and resolve issues early, ensuring the
final system met the project objectives.

3.5.5 Maintenance and Monitoring

 Monitor system logs and user activity

 Perform regular backups and updates

3.6 Functional Modules

Module Description

User
Registration& Secure sign-up and sign-in using email/OTP
Login

Voter
Verifies user credentials before allowing voting
Authentication

Displays candidates; allows one-time vote casting

Voting Interface
with confirmation

Add/manage elections and candidates, monitor

Admin Panel
voters and generate reports

3.7 Security Measures

 End-to-End Encryption: All communication between users and the

server is encrypted using HTTPS, ensuring that sensitive data
transmitted during voting is secure from interception.

 Authentication: User authentication is implemented using

Django's built-in authentication system, which supports user login
and logout functionalities. For added security, user verification can
be integrated using OTP (One-Time Password) sent via email.

 Access Control: Role-based access control (RBAC) is implemented

using Django’s user model, with different access levels for admins
and voters. Admins have access to manage candidates and election
settings, while voters can only access the voting interface.

Page 13 of 59
  Vote Integrity: The integrity of votes is maintained by creating a
hash for each vote submitted. This hash ensures that no vote can be
modified after submission. Votes are also timestamped to maintain
the sequence and prevent duplicate submissions.

 Audit Logs: Audit logs are stored securely using Django’s logging
framework, which records all user actions and system events for
traceability and transparency. This allows for monitoring and
reviewing voting activities to detect any potential issues.

3.8 Advantages of the Proposed System

 Accessible from anywhere, increasing voter turnout

 Cost-effective and paperless

 Fast and accurate result computation

 Reduced risk of vote tampering or human error

 Environmentally friendly with no need for physical infrastructure

3.9 Limitations and Considerations

 Requires internet access and basic digital literacy

 Security risks if not maintained properly

 Resistance from users unfamiliar with digital platforms

 Legal and regulatory compliance must be ensured

3.10 Conclusion

The proposed system is designed to be secure, scalable, and user-friendly,

aiming to revolutionize how elections are conducted. It addresses the core
issues of traditional voting systems while embracing digital transformation
and modern-day needs. With a modular approach and security-first
design, the Online Voting System offers a future-ready solution for
democratic participation.
Page 14 of 59
3.11 Sequence Diagram

A Sequence Diagram models the interaction between different actors

and system components in a time-sequenced manner, showing how
processes operate in a time-based order.

Below is a description and then the sequence flow for the Online
Voting System:

Page 15 of 59
Page 16 of 59
Actors:

 Voter

 Web Browser & Django Server

 Authorized Service

 Authentication System

 Voting System

 Admin Panel

 Database

Use Case: "Casting a Vote"

Step-by-Step Sequence:

1. Voter → Authentication System: Request Login

2. Authentication System → Database: Validate credentials

3. Database → Authentication System: Send validation response

(Success/Failure)

4. Authentication System → Voter: Send login success/failure

message

5. Voter → Voting System: Request voting page

6. Voting System → Database: Fetch election & candidate list

7. Database → Voting System: Send election & candidate data

8. Voting System → Voter: Display candidates for voting

9. Voter → Voting System: Submit vote

10. Voting System → Database: Store encrypted vote

11. Database → Voting System: Confirm vote saved

12. Voting System → Voter: Display vote confirmation

Voter Authentication System Voting System Database

Page 17 of 59
| | | |

|--Login Request------->| | |

| |--Validate User-------->| |

| |<--Validation Result----| |

|<--Login Success/Fail--| | |

|--Request Voting Page->| | |

| |--Fetch Candidates----->| |

| |<--Candidate List-------| |

|<--Display Candidates--| | |

|--Submit Vote----------> | |

| |--Save Vote------------>| |

| |<--Vote Confirmation----| |

|<--Vote Success--------| | |

Summary:

 The voter first logs in and is authenticated.

 Once authenticated, the voter accesses the voting page.

 The voter casts the vote, which the system encrypts and saves
securely in the database.

 The voter receives a confirmation of a successful vote.

3.12 Deployment Diagram

A Deployment Diagram models the physical deployment of software

components onto hardware nodes. It shows how software modules are
distributed across different servers, devices, and network layers.

In the case of an Online Voting System, the deployment is structured to

ensure security, scalability, and performance.

Deployment Nodes:

Page 18 of 59
  Client Device (Voter's PC / Mobile / Tablet)

 Web Server (Handles HTTP requests)

 Application Server (Business logic, APIs)

 Database Server (Stores votes, users, election data)

 Authentication Server (Handles OTP, 2FA, identity verification)

 Admin Console (Admin operations for managing elections)

3.13 Components Deployed:

Node Components

Web browser (accessing the system), UI frontend

Client Device
(ReactJS, HTML/CSS/JS)

Web Server NGINX/Apache for serving frontend

Application Backend APIs ([Link]/PHP/Python), Voting Logic, Vote

Server Encryption Module

Database Server Relational DB (MySQL/PostgreSQL) or NoSQL DB

Page 19 of 59
Node Components

(MongoDB)

Authentication
OTP Service, OAuth Service, Biometric Verification API
Server

Admin Console Admin portal frontend, election management backend

Deployment Flow:

1. Voter accesses the website through their Client Device.

2. Request is routed to the Web Server.

3. Web server forwards requests to the Application Server.

4. The Application Server:

o Authenticates the voter via the Authentication Server.

o Fetches candidates/election data from the Database Server.

o Records votes back to the Database Server securely.

5. Admin Console connects directly to the Application Server for

managing candidates, voters, and monitoring election progress.

Summary of the Deployment Diagram:

 Client Devices interact with the system using standard web

browsers.

 Web Server serves static files and handles incoming web requests.

Page 20 of 59
  Application Server processes business logic, APIs, vote
encryption, and system functions.

 Database Server securely stores all election and user data.

 Authentication Server enhances security by verifying user

identities.

 Admin Console is a specialized frontend connected to backend

services for election management.

3.15 Component Diagram

 A Component Diagram shows the organization and relationships

between different software components in the system.
It highlights how modules interact, what services they provide,
and what dependencies exist between them.
 In the Online Voting System, the components are organized into
Frontend, Backend, Security, and Database layers.

Main Components:

Layer Component Description

User-friendly web interface for voters to log in, vote,
Frontend Voter Interface and view results

Admin dashboard for election management

Frontend Admin Interface

Handles voting process, ensures one vote per voter

Backend Voting Module

Page 21 of 59
 Layer Component Description

Authentication Manages login, OTP verification, and session control

Backend
Module

Backend Results Module Calculates and displays election results

Security Encryption Module Encrypts votes and personal data

Database Voter Database Stores voter registration data and credentials

Database Election Database Stores election details, candidate information, and votes

Summary:

 The Frontend interacts directly with the Backend components.

 The Backend modules depend on the Database and Security

components to perform core functions.

 The system ensures modularity, reusability, and separation of

concerns, making it easier to maintain and expand.

Page 22 of 59
CHAPTER 4: RESULT AND IMPLEMENTATION

4.1 Methods / Techniques

The Online Voting System was developed using modern web

technologies and secure techniques to ensure a reliable and safe voting
experience. The development methodology used was primarily Agile
Development, allowing for continuous iteration and improvements
during the project lifecycle.

Key Methods and Techniques Used:

 Agile Methodology:
Followed an iterative development process with continuous
gathering of requirements, designing, coding, testing, and improving
modules based on feedback.

 Secure Authentication:
Implemented Django’s built-in authentication system with strong
password policies for voters and admin users. (No OTP/2FA yet, but
security maintained through password strength and HTTPS.)

 End-to-End Encryption:
Votes and sensitive user information are encrypted during storage
and transmission.

 Role-Based Access Control (RBAC):

Access permissions defined in Django:

Page 23 of 59
 o Admin users can manage elections, candidates, and view
results.
o Voters can only view ballots, cast votes, and view their own
status.

 Database Normalization:
Database tables (Voter, Candidate, Position, Votes) designed using
Django ORM principles, ensuring normalized relations, avoiding
redundancy, and maintaining data consistency.

 Local Hosting:
The system was hosted locally using Django’s built-in server for
development and testing.

 Testing Techniques:

o Unit Testing: Conducted on Django models and views

individually

o Integration Testing: Ensured interaction between modules

(e.g., voter login, ballot generation, vote submission) works
correctly.

o System Testing: Tested the entire application for

functionality, responsiveness, and usability

o Security Testing: Basic validation checks implemented to

prevent common vulnerabilities like SQL Injection and CSRF
attacks.

4.2 Implementation

The Online Voting System was implemented using the following

technology stack:

Layer Technology Used

Frontend HTML5, CSS3, Bootstrap, JavaScript (Vanilla)

Backend Python 3.8+ with Django Framework

Database SQLite (for development), scalable to PostgreSQL/MySQL (for

Page 24 of 59
Layer Technology Used

production)

Django built-in authentication (Username & Password with

Authentication
session management)

HTTPS (SSL Certificate recommended for production), Django

Security security features (CSRF protection, password hashing using
PBKDF2)

Localhost for development (Django server); Deployment

Hosting
possible on platforms like Heroku, AWS, or DigitalOcean

4.3 Source Code :

Here are some sample snippets from the system's source code:

1. Voter Registration (Backend Django):

# [Link]

from [Link] import render, redirect

from [Link] import User

from [Link] import messages

from [Link] import make_password

def voter_register(request):

if [Link] == "POST":

first_name = [Link]('first_name')

Page 25 of 59
 last_name = [Link]('last_name')

email = [Link]('email')

password = [Link]('password')

confirm_password = [Link]('confirm_password')

if password != confirm_password:

[Link](request, "Passwords do not match.")

return redirect('voter_register')

if [Link](username=email).exists():

[Link](request, "Email already registered.")

return redirect('voter_register')

# Create the new voter (user)

user = [Link](

username=email,

first_name=first_name,

last_name=last_name,

email=email,

password=make_password(password) # Hash password securely

[Link]()

[Link](request, "Registration successful. Please log in.")

return redirect('login')

return render(request, "voting/[Link]")

Page 26 of 59
Template Code ([Link]):

<!-- templates/voting/[Link] -->

<form method="POST">

{% csrf_token %}

<input type="text" name="first_name" placeholder="First Name"

required><br>

<input type="text" name="last_name" placeholder="Last Name"

required><br>

<input type="email" name="email" placeholder="Email"

required><br>

<input type="password" name="password" placeholder="Password"

required><br>

<input type="password" name="confirm_password"

placeholder="Confirm Password" required><br>

<button type="submit">Register</button>

</form>

2. Voting Process:

# [Link]

from [Link] import render, redirect

from [Link] import messages

from .models import Position, Candidate, Votes

from [Link] import slugify

def show_ballot(request):

if not [Link].is_authenticated:

return redirect('login')

if [Link]:

[Link](request, "You have already voted.")

Page 27 of 59
 return redirect('voter_dashboard')

positions = [Link]().order_by('priority')

context = {

'positions': positions

return render(request, "voting/[Link]", context)

def submit_vote(request):

if not [Link].is_authenticated:

return redirect('login')

voter = [Link]

if [Link]:

[Link](request, "You have already voted.")

return redirect('voter_dashboard')

if [Link] == "POST":

form = dict([Link])

[Link]('csrfmiddlewaretoken', None)

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

[Link](request, "Please select at least one candidate.")

return redirect('show_ballot')

# Process each position

for position in [Link]():

pos_slug = slugify([Link])

Page 28 of 59
 if position.max_vote > 1:

key = pos_slug + "[]"

selected_candidates = [Link](key)

else:

key = pos_slug

selected_candidates = [Link](key)

if not selected_candidates:

continue

if position.max_vote > 1:

for candidate_id in selected_candidates:

candidate = [Link](id=candidate_id)

[Link](voter=voter, candidate=candidate,
position=position)

else:

candidate = [Link](id=selected_candidates[0])

[Link](voter=voter, candidate=candidate,
position=position)

# Update voter's status

[Link] = True

[Link]()

[Link](request, "Thank you for voting!")

return redirect('voter_dashboard')

[Link](request, "Invalid voting request.")

return redirect('show_ballot')

Page 29 of 59
Template Code Example ([Link]):

<!-- templates/voting/[Link] -->

<form method="POST">

{% csrf_token %}

{% for position in positions %}

<h3>{{ [Link] }}</h3>

{% for candidate in position.candidate_set.all %}

{% if position.max_vote > 1 %}

<input type="checkbox" name="{{ [Link]|slugify }}[]"

value="{{ [Link] }}"> {{ [Link] }}<br>

{% else %}

<input type="radio" name="{{ [Link]|slugify }}"

value="{{ [Link] }}"> {{ [Link] }}<br>

{% endif %}

{% endfor %}

<hr>

{% endfor %}

<button type="submit">Submit Vote</button>

</form

>

3: Admin Page Setup (Backend - Django Admin):

# [Link]

from [Link] import admin

from .models import Position, Candidate, Voter, Votes

@[Link](Position)

class PositionAdmin([Link]):

list_display = ('name', 'priority', 'max_vote')

Page 30 of 59
 ordering = ('priority',)

search_fields = ('name',)

@[Link](Candidate)

class CandidateAdmin([Link]):

list_display = ('fullname', 'position', 'bio')

list_filter = ('position',)

search_fields = ('fullname',)

@[Link](Voter)

class VoterAdmin([Link]):

list_display = ('user', 'phone', 'voted')

search_fields = ('user__username', 'phone')

list_filter = ('voted',)

@[Link](Votes)

class VotesAdmin([Link]):

list_display = ('voter', 'candidate', 'position')

list_filter = ('position',)

search_fields = ('voter__user__username', 'candidate__fullname')

Page 31 of 59
4.4 Entity Relationship Diagram (ERD)

An Entity Relationship Diagram (ERD) is used to visually represent the

data model of the system. It shows the entities, their attributes, and the
relationships between them.

In the Online Voting System, the core entities are Voter, Election,
Candidate, Vote, and Admin.

Main Entities and Attributes:

Entity Attributes

Voter Voter_ID (PK), Name, Email, Password, OTP, Status

Admin Admin_ID (PK), Name, Email, Password

Election Election_ID (PK), Title, Start_Date, End_Date, Status

Candida
Candidate_ID (PK), Name, Party, Election_ID (FK)
te

Vote_ID (PK), Voter_ID (FK), Election_ID (FK), Candidate_ID (FK),

Vote
Encrypted_Vote

(PK = Primary Key, FK = Foreign Key)

Page 32 of 59
Relationships:

 A Voter can cast only one Vote per Election.

 An Admin can create and manage multiple Elections.

 Each Election can have multiple Candidates.

 Each Vote is associated with one Voter, one Election, and one
Candidate.

 A Candidate belongs to one Election.

Summary of the Relationships:

 Voter to Vote → One-to-One (per election)

 Admin to Election → One-to-Many

Page 33 of 59
  Election to Candidate → One-to-Many

 Vote to Election → Many-to-One

 Vote to Candidate → Many-to-One

Quick Description:

 Voter Table contains all registered users.

 Admin Table contains system administrators who can

create/manage elections.

 Election Table holds the details of each election.

 Candidate Table lists all candidates linked to a specific election.

 Vote Table records each encrypted vote linking Voter, Election, and
Candidate together.

4.5 UML Diagram:

The Unified Modeling Language (UML) helps in visualizing, specifying,

constructing, and documenting the artifacts of a software system.
For the Online Voting System, multiple UML diagrams describe different
aspects of the system design.

Below are the essential UML diagrams used:

1. Use Case Diagram

Purpose:
Shows how different users (Actors) interact with the system.

Actors:

 Voter

 Admin

Use Cases:

 Register/Login

 Cast Vote

 Manage Election (Admin only)

 Add Candidates (Admin only)

Page 34 of 59
  View Voter List (Admin only)

Simple text structure:

plaintext

CopyEdit

Voter --> (Register/Login) --> (Verify Identity) --> (Cast Vote) --> (View
Results)

Admin --> (Login) --> (Manage Election) --> (Add Candidates) --> (View
Voter List)

2. Class Diagram

Purpose:
Represents the system's structure showing classes, attributes, operations,
and relationships.

Class Attributes Methods

Voter_ID, Name, Email, Password, register(), login(), castVote(),

Voter
OTP, Status viewResult()

login(), createElection(),
Admin Admin_ID, Name, Email, Password
manageCandidates()

Election_ID, Title, Start_Date, createElection(),

Election
End_Date, Status closeElection()

Candidat Candidate_ID, Name, Party, addCandidate(),

e Election_ID removeCandidate()

Vote_ID, Voter_ID, Election_ID,

Vote encryptVote(), saveVote()
Candidate_ID, EncryptedVote

Relationships:

 Voter — casts —> Vote

 Admin — manages —> Election

 Election — has —> Candidates

 Vote — belongs to —> Election and Candidate

3. Activity Diagram

Page 35 of 59
Purpose:
Shows the flow of activities when a voter uses the system.

Activity Flow (Voter):

 Start

 Register / Login

 Verify OTP

 Select Election

 Select Candidate

 Cast Vote

 Encrypt Vote

 Save Vote

 View Results

 End

4. Sequence Diagram

Purpose:
Shows the interaction between different components in sequence.

Sequence (for casting a vote):

1. Voter logs in → System verifies

2. Voter selects election → System fetches candidates

3. Voter selects candidate → System encrypts vote

4. System saves encrypted vote to database

5. System sends vote confirmation to Voter

5. Deployment Diagram

(Already discussed in 3.6)

Shows the physical deployment of software components on hardware
(Client Device, Web Server, App Server, Database Server, Auth Server).

Summary:

Page 36 of 59
Diagram Type Purpose

Shows system-user
Use Case Diagram
interactions

Class Diagram Represents structure/classes

Activity Diagram Represents dynamic workflows

Sequence Represents the flow of

Diagram messages

Deployment Represents deployment

Diagram architecture

Page 37 of 59
Page 38 of 59
4.6 Tech-Stack

The "Online Voting System" is divided into several modules, each

responsible for a specific functionality. Below is the specification of each
module, updated with the technologies you have used in this project:

1. User Authentication Module:

o Technology Used: Django, HTML, CSS, JavaScript

o Description: This module handles user registration, login,

and authentication. It utilizes Django’s built-in authentication
system for user management, ensuring secure login with
email-based authentication.

2. Dashboard Module:

o Technology Used: Django, HTML, CSS

o Description: After successful login, users are redirected to

the dashboard. The dashboard displays essential information
such as the election title, options to preview and submit votes,
and user-specific details (e.g., username and logout option).

3. Candidate Management Module:

o Technology Used: Django

o Description: Admins can register candidates, manage their

details, and ensure that candidates are available for voting.
This module handles the CRUD (Create, Read, Update, Delete)
operations for candidates.

4. Voting Module:

o Technology Used: Django, HTML, CSS

o Description: This module allows users to select candidates

and submit their votes. It checks whether a valid selection has
been made before allowing submission to prevent invalid
voting.

5. Vote Validation Module:

o Technology Used: Django

o Description: This module validates the voting action,

ensuring that the user has selected at least one candidate

Page 39 of 59
 before they can proceed. If no candidate is selected, an error
message prompts the user to choose a candidate.

6. Attendance Marking Module (if applicable in your system):

o Technology Used: Django, Python

o Description: This module marks attendance after the voting

session, ensuring users are recorded for their participation. It
compares logged-in users to the voter database and updates
attendance records.

7. Database Management Module:

o Technology Used: Django ORM, MySQL

o Description: This module manages all database interactions

for storing user data, candidate details, voting records, and
attendance information. It ensures data integrity using
Django's ORM system to manage MySQL databases.

8. Error Handling Module:

o Technology Used: Django

o Description: This module handles errors such as missing

data, invalid inputs, or server issues. Appropriate error
messages are displayed to guide users and administrators in
troubleshooting.

9. Visualization Module:

o Technology Used: Django, HTML, CSS

o Description: This module displays voting records, election

results, and user information in a clean and organized manner
using Django templates and HTML/CSS. It includes visual
representations such as tables or charts for easy data
interpretation.

10. Security and Password Protection Module:

o Technology Used: Django

o Description: Ensures that sensitive operations, such as

managing election data or admin functionalities, are
protected. It uses Django’s password hashing mechanisms for
secure password storage and validation.

Page 40 of 59
Page 41 of 59
Page 42 of 59
4.7 Data Flow Diagram

A Data Flow Diagram (DFD) is a graphical representation of the flow of

data in an information system. It uses symbols like rectangles, circles, and
arrows, along with text labels, to show data inputs, outputs, storage
points, and the routes between each destination. The DFD can range from
simple, hand-drawn overviews to complex, multi-level diagrams.

0-Level DFD (Context Diagram)

The 0-Level DFD, also called the Context Diagram, provides a high-
level overview of the entire Online Voting System. It illustrates the
interactions between the external entities (e.g., users, admin) and the
system. In this diagram, the system is represented as a single process,
and data flows between external entities and the system.

 External Entities:

o Users: Voters who register, log in, and vote.

o Admin: Manages candidates, views results, and oversees the

voting process.

 System: Online Voting System (represented as a single process).

 Data Flow:

o User Registration Data: Users submit their registration

details, which flow into the system for storing in the database.

o Login Data: Users log in with email and password,

authenticated by Django’s authentication system.

o Voting Data: Users cast their votes, which are stored in the
database for record-keeping.

o Admin Data: Admin manages candidates and election data.

Page 43 of 59
1-Level DFD

The 1-Level DFD breaks down the system into its main functional
modules, providing a more detailed view of the internal processes. These
sub-processes handle specific tasks within the system, detailing how data
is processed and flows between them.

 Sub-processes:

1. User Authentication:

 Technology Used: Django Authentication, HTML, CSS,

JavaScript.

 Description: Handles user registration and login.

 Data Flow: User submits registration/login details →

Django authenticates → Data stored in MySQL.

2. Dashboard & Voting:

 Technology Used: Django, HTML, CSS.

 Description: Displays the user dashboard, manages the

voting process.

Page 44 of 59
  Data Flow: After login, user accesses the dashboard →
User selects candidates → Vote is submitted → Data
stored in MySQL.

3. Candidate Management:

 Technology Used: Django ORM, MySQL.

 Description: Admin manages candidate data

(adding/editing candidates).

 Data Flow: Admin inputs candidate data → Data stored

in MySQL database.

4. Vote Submission & Validation:

 Technology Used: Django, MySQL.

 Description: Validates that the user selects at least one

candidate and records the vote.

 Data Flow: User submits vote → Validation checks →

Data stored in the database.

5. Results & Reporting:

 Technology Used: Django, HTML, CSS.

 Description: Displays results and generates reports for

the admin.

 Data Flow: Admin accesses results → Data fetched from

MySQL → Displayed in the dashboard.

Page 45 of 59
Level 2 DFD
This diagram provides a more granular view of the Online Voting
System, breaking down processes into specific functions:

1. User Registration & Login Path:

 Register_User: Captures user data (email, password) and stores it

in the database.

o Technology Used: Django Authentication, MySQL, HTML,

CSS, JavaScript.

o Data Flow: User submits registration details → Data stored in

MySQL database → Confirmation email sent (optional).

 Authenticate_User: Validates login credentials (email and

password) using Django's authentication system.

o Technology Used: Django Authentication.

o Data Flow: User submits login credentials → Authentication

via Django → Successful login or error message.

2. Voting Path:

 Display_Candidates: Fetches and displays candidates to the user

for selection.

o Technology Used: Django ORM, MySQL, HTML, CSS.

o Data Flow: Candidate data fetched from MySQL → Displayed

on the user interface.

 Submit_Vote: Captures user vote and stores it in the database.

o Technology Used: Django, MySQL.

o Data Flow: User selects candidates → Vote submitted → Data

stored in MySQL.

 Validate_Vote: Ensures at least one candidate is selected before

submission.

o Technology Used: Django, JavaScript.

o Data Flow: User submits vote → Validation checks → Proceed

to vote submission.

3. Admin Management Path:

 Manage_Candidates: Allows admin to add or remove candidates

from the election.

Page 46 of 59
 o Technology Used: Django Admin Interface, MySQL.

o Data Flow: Admin inputs candidate data → Data stored in

MySQL.

 View_Voting_Results: Displays election results for the admin after

the voting process.

o Technology Used: Django ORM, MySQL, HTML, CSS.

o Data Flow: Admin requests voting results → Data fetched

from MySQL → Displayed on the admin interface.

4. Data Stores:

 User_Database: Stores user registration details (email, password).

o Technology Used: Django ORM, MySQL.

o Data Flow: User registration data stored and fetched as

required.

 Candidate_Database: Stores candidate information for the

election.

o Technology Used: Django ORM, MySQL.

o Data Flow: Candidate data stored by admin and retrieved for

display.

 Vote_Records: Stores voting data (votes cast by users).

o Technology Used: Django ORM, MySQL.

o Data Flow: Vote records stored and fetched as necessary.

 CSV_Reports: Optional export of voting and attendance records in

CSV format for reporting.

o Technology Used: Python, CSV library, Django.

o Data Flow: Admin requests CSV export → Data fetched from

MySQL → Exported as CSV.

Diagram Flow

This Level 2 DFD shows the complete workflow from user registration
through different voting options, admin management, and data

Page 47 of 59
retrieval. It also highlights the data stores used to store user details,
candidate information, and voting records.

Page 48 of 59
4.8 User Interface Design
The user interface (UI) of the Online Voting System is designed to be
user-friendly, intuitive, and visually appealing. It is implemented using
Django templates, HTML, CSS, and JavaScript, providing a clean and
modern web interface for user interaction. Below is an explanation of the
UI design:

Main Window:

 The main window serves as the central hub for all operations. It
includes a navigation menu, buttons, and forms for various user
actions such as registration, voting, and viewing results. The layout
is responsive and adapts to different screen sizes, ensuring a
seamless experience on both desktop and mobile devices.

Title and Header:

 The title "Online Voting System" is displayed prominently at the top

of the window in bold, large font. This provides a clear indication of
the system’s purpose.

 The header section contains navigation links for different actions like
Home, Vote, Admin Panel, and Logout.

Forms and Frames:

1. Registration & Login Form:

o Technology Used: Django forms, HTML, CSS.

o Description: This section allows users to register and log in

using their email and password. Input fields are styled with
bold fonts for clarity, and validation messages are displayed
in case of errors (e.g., incorrect credentials, missing fields).

2. Voting Form:

o Technology Used: Django templates, HTML, CSS.

o Description: After logging in, users can vote for candidates.

This form dynamically displays the list of candidates fetched
from the database, allowing users to select their preferred
candidate(s). Radio buttons or checkboxes are used to
capture the vote.

Page 49 of 59
 3. Admin Panel:

o Technology Used: Django Admin Interface, HTML, CSS.

o Description: This interface is used by the admin to manage

candidates, view voting results, and perform other
administrative tasks. It includes data tables for displaying
candidate details and voting results.

Buttons:

 Clear Buttons: Allow users to clear the registration/login form

inputs.

 Submit Vote: Submits the user's vote, which is then saved in the
MySQL database.

 Logout: Logs the user out and redirects to the login page.

 View Results: Allows users or admins to view the election results,

displayed in a tabular format.

Voting Results Table:

 A data table is used to display voting results or candidate

information. The table includes columns for candidate name, total
votes, and other relevant details.

 Technology Used: Django templates, HTML, CSS.

 Data Flow: The results are dynamically fetched from the database
using Django ORM and displayed to the user or admin.

Dynamic Date and Time:

 Technology Used: JavaScript, HTML.

 The current date and time are displayed at the top of the window.
The time updates dynamically every second, ensuring real-time
accuracy for the voting session.

Menu Bar:

 The menu bar includes options such as Help and Logout. It is

styled to match the overall theme of the application and is
accessible on all pages.

 Help Menu: Provides options for contacting support or viewing

system instructions.

Page 50 of 59
Error and Success Messages:

 Technology Used: Django messages framework, JavaScript.

 Error and success messages are displayed in dedicated labels or

modal dialogs to inform users about the success or failure of
operations, such as successful registration, invalid login, or
successful vote submission.

Modal Windows:

 Technology Used: JavaScript, HTML, CSS.

 For displaying additional information or confirmation dialogs, such

as vote submission confirmation, viewing results, or showing
error messages.

Responsive Design:

 Technology Used: HTML, CSS (Flexbox, Grid).

 The layout is designed to be responsive, adapting to both desktop

and mobile screen sizes. Media queries are used to ensure the UI
elements resize properly across different devices.

Login Page:

Page 51 of 59
Registration Page:

User Interface (Home Page):

Page 52 of 59
Preview Dialogue:

Post-vote Interface:

View Your Ballot (Voted Candidate):

Page 53 of 59
Admin Dashboard:

Candidates Modification:

Page 54 of 59
Positions Modification:

Voter Details:

Page 55 of 59
Voters & Votes:

Page 56 of 59
 CHAPTER 5
CONCLUSION

5.1 Conclusion

The Online Voting System effectively automates the election process by

utilizing Django, Python, MySQL, HTML, CSS, and JavaScript. This
system provides a secure, user-friendly, and scalable solution for
conducting elections, ensuring transparency and efficiency in the voting
process.

The integration of Django for backend functionality, MySQL for data

storage, and Python for business logic, along with a simple yet effective
HTML/CSS frontend, ensures smooth operation and easy access. The
system supports user authentication and seamless vote management,
ensuring that the election process remains tamper-proof and efficient.

In conclusion, the project demonstrates the practical application of web

development and database management principles to solve real-world
problems, offering a robust and innovative approach to modernizing the
election process.

5.2 Limitations

While the Online Voting System offers a streamlined and reliable

solution, there are some limitations that could impact its performance and
scalability:

 Internet Connectivity: The system relies on a stable internet

connection for remote access. In areas with poor connectivity, users
may face difficulties in accessing the platform.

 Scalability Issues: As the system currently uses MySQL, handling

large-scale elections with a vast number of voters might require
database optimization or migration to a more scalable solution.

 Security Risks: Although the system is secure, there could still be

potential vulnerabilities if not implemented with robust encryption
methods, particularly in online environments.

 User Training: Users must be trained to understand the process of

voting on the platform, as the web interface may not be intuitive for
all demographics.

Page 57 of 59
5.3 Future Enhancements

There are several possible enhancements to improve the functionality and

scalability of the Online Voting System:

 Cloud Integration: Transition to a cloud-based infrastructure to

handle larger datasets and provide remote access, improving
scalability and performance.

 Enhanced Security: Implement multi-factor authentication (e.g.,

OTP verification combined with voting) to further secure the voting
process and prevent fraud.

 Mobile Application: Develop a mobile version of the voting

system, enabling users to vote from their smartphones, improving
accessibility and convenience.

 Advanced Analytics: Integrate real-time analytics to track voter

turnout and provide detailed insights into the election process.

 Blockchain Technology: Incorporate blockchain to further enhance

the transparency and security of the voting system, ensuring that
votes are tamper-proof and verifiable.

Page 58 of 59
Bibliography

The following references have been used to develop the project "Django
Online Voting System":

Books:

1. Django for Beginners by William S. Vincent: Provided foundational

knowledge on setting up and building Django applications.

2. Python Crash Course by Eric Matthes: Helped in understanding

Python programming concepts and best practices for backend
development.

3. Learning MySQL by Seyed M.M. Alavi: Offered guidance on

database design and querying with MySQL for efficient data
management in the voting system.

4. Two Scoops of Django by Audrey Roy Greenfeld and Daniel Roy

Greenfeld: Provided advanced tips and best practices for Django
development and project structure.

Web Sources:

 [Link]: Official documentation and resources

for Django, which guided the development of the backend and
various Django features.

 [Link]: Official documentation for MySQL, which helped

in understanding database design and management.

 [Link]: Assisted in troubleshooting errors,

finding practical solutions to coding problems, and optimizing code.

 [Link]: Official Python documentation, providing

detailed information on Python libraries and frameworks used in the
project.

 [Link]: Used as a reference for frontend

development (HTML, CSS, JavaScript) and best practices for building
web interfaces.

 [Link]: Provided access to various open-source libraries

and frameworks, facilitating project development and code sharing.

Page 59 of 59