Project Criteria:

Project Criteria:​
—----------------------------------------------------------------------------------
1.​ Instead of recreating code that has been built countless times before, we
encourage students to work on problems that require engineering, enabling them
to tackle any project confidently when they start their professional careers.
2.​ Teams can have up to 3 students; individual projects are also encouraged.
3.​ The projects will be built over the guidance of your seniors, this is limited to
students from 4th sem (sec A) which are mapped to 6th sem (sec D), these
students what we think are our best students. At max one senior can guide 2
projects.
4.​ GitHub commit history will be monitored to ensure consistent progress.
5.​ Project file will contain​
Page1: Cover page, project certificate, table of content, project
introduction.​
Page2: Github repo link, and screenshot of contributors page can be found
over (your project -> Insights -> Contributors), ask your respective mentors for
help.​
Page3: Flow charts of important flows how to code is working. (can be covered
in multiple pages)​
Page4: List of tech stack used, and why you choose over other tech.​
Page5: Testing strategies used.​
Page6: Project code.
Page7: Screenshots of project.​
Page8: Pick any one case study and prepare, viva questions will also be
from that.

6.​ Only projects under this initiative or ongoing Automation Cell projects are
allowed; no external projects apart from these.
7.​ Any tech stack can be used, but you must justify why it was chosen over others.
8.​ Each project can be at max allocated to 2 groups, the intended groups will come to the
project coordinator to get the projects assignment to them, this will be on FIFS basis.
9.​ Proper documentation, including requirement analysis, testing, and deployment,
is mandatory.
10.​To prevent plagiarism, we will set up MOSH (by Stanford University).
11.​WeCode classes each week and project progress review & mentorship by
WeCode members during WeCode classes.
VIVA Questions:
—----------------------------------------------------------------------------------
1.​ Time Complexity Analysis of Algorithms​
Study and analyze algorithm complexities like O(n), O(log n), and O(n^2), and
their real-world performance. Deliverables: complexity analysis, examples, and a
report on time efficiency in algorithm design.
2.​ Graph Theory and Shortest Path Algorithms​
Explore graph theory and shortest path algorithms like Dijkstra’s and
Bellman-Ford. Deliverables: code implementation, performance comparison, and
a report on graph traversal techniques.
3.​ Cryptography and Encryption Algorithms​
Study encryption techniques like RSA, AES, and hashing algorithms, exploring
their role in data security. Deliverables: encryption/decryption tool, example data,
and a report on cryptography in secure communications.
4.​ Operating System Process Management​
Learn about process scheduling algorithms (e.g., FCFS, SJF, Round Robin).
Deliverables: implementation of scheduling algorithms, process simulation, and a
report on OS process management techniques.
5.​ NP-Completeness and Approximation Algorithms​
Study NP-complete problems like TSP and implement approximation algorithms.
Deliverables: algorithm implementation, performance analysis, and a report on
approximation techniques.
6.​ Cloud Computing and Virtualization​
Understand cloud computing models (IaaS, PaaS, SaaS), virtualization
technologies, and their applications. Deliverables: comparison of cloud platforms,
virtualization setup, and a report on cloud infrastructure.
7.​ Software Engineering and Agile Methodologies​
Study SDLC, Agile methodologies (Scrum, Kanban), and iterative development.
Deliverables: Agile project simulation, task management using Scrum, and a
report on Agile processes in software development.
8.​ Any question from Data structures taught over the class, any algorithm or other
concepts.
Case studies:
—----------------------------------------------------------------------------------
1.​ Dynamic Programming for Optimization Problems​
Explore dynamic programming techniques for solving optimization problems like
Knapsack, LCS, and Matrix Chain Multiplication. Deliverables: algorithm
implementations, time complexity analysis, and a report on DP applications.
2.​ Traffic Light Optimization Using Algorithms​
Study traffic light optimization algorithms to improve flow. Implement a simulation
to optimize timings with real-time traffic data. Focus on greedy algorithms, queue
management, and real-time processing. Deliverable: Algorithm design,
performance comparison before and after optimization.
3.​ Real-Time Chat System Using Message Queues​
Build a real-time chat application using message queues (e.g., Kafka) to manage
messages in distributed systems. Focus on architecture, low latency, and
scalability. Deliverable: A chat system with performance analysis and scalability
testing.
4.​ Implementing a Distributed File Storage System​
Create a distributed file storage system ensuring high availability and fault
tolerance. Focus on data replication and retrieval optimization. Deliverable: File
system design, performance analysis under load, and comparison with
centralized systems.
5.​ Content Delivery Network (CDN) for Static Websites​
Build a CDN for delivering static content by distributing files across multiple
servers. Focus on load balancing, caching, and replication. Deliverable:
Simulation of CDN, caching strategies, and performance benchmarks.
6.​ Social Media Feed Ranking Algorithm​
Implement a ranking algorithm for social media posts based on user
engagement. Focus on sorting, recommendation systems, and real-time data
processing. Deliverable: Ranking algorithm implementation, performance
comparison, and engagement evaluation.
7.​ Pathfinding in a Maze Using AI Algorithms​
Implement AI-based pathfinding algorithms like A* or BFS to find the shortest
path in a maze. Focus on search algorithms and path optimization. Deliverable:
Algorithm implementation, performance comparison, and visualization.
Projects:
—----------------------------------------------------------------------------------
1. Chrome Extension

Build a Chrome Extension using JavaScript, defining permissions and entry

points through a manifest.json file. Implement content scripts to modify web
pages, background scripts for persistent tasks, and a popup UI for user
interaction.

●​ Frontend: HTML, CSS, JavaScript

●​ Backend: JavaScript (for background scripts)
●​ Tools: Chrome Extensions API

2. Pytest

Set up automated testing for Python applications using Pytest. Write reusable
unit tests with fixtures, implement parameterized testing for multiple scenarios,
and integrate mocking for simulating external APIs or databases.

●​ Programming Language: Python

●​ Testing Framework: Pytest
●​ Tools: Mocking (unittest.mock), Fixtures
●​ Libraries: pytest-mock, pytest-cov

3. Digital Signature Verifier

Create a tool to generate and verify digital signatures using cryptographic

algorithms. Include functionality to sign and verify PDF or text documents to
ensure secure authentication.

●​ Programming Language: Python/Java

●​ Libraries: PyCryptoDome (Python) or Bouncy Castle (Java)
●​ Cryptography: RSA, SHA-256
●​ Tools: PyPDF2 for PDF signing and verification (Python)
5. Dynamic Student Grouping System

Create a system to dynamically form student groups based on academic

performance, interests, and other relevant factors. This ensures balanced and
efficient team composition for academic projects, activities, or competitions. This
student's data to be uploaded via csv file.

​ •​ Performance-Based Grouping: Divide students based on marks, and

other factors, ensuring a balance of high, medium, and low performers in
each group.

​ •​ Email: first time it should send an email of update to all students, but from
2nd time only send the updated section to students whose section gets
changed.

6. Live Traffic Heatmap

Simulate traffic to visualize live traffic heatmap, generate fake traffic and then
visualize the traffic on a UI just like google map, you have to use some form of
graph algorithm to represent the roads.
Dynamically generate randomly traffic density, weather, and time variations for
real-time visualization.​

7. Dynamic Sudoku Generator and Solver

Build an interactive Sudoku solver that solves NxN puzzles using a backtracking
algorithm. Implement an interactive interface where users can input puzzles
manually, and the program provides step-by-step visualization of how the
solver works. For optimization, you can use Constraint Propagation and Branch
and Bound algorithms for faster solving.

●​ Programming Language: Python

●​ Libraries: Tkinter (for GUI), NumPy
●​ Algorithms: Backtracking, Constraint Propagation, Branch and Bound
8. Custom File Compression Tool

Implement a file compression tool using algorithms like Huffman coding or LZW.
Develop a GUI for users to interactively compress and decompress files with
ease.

●​ Programming Language: Python

●​ Algorithms: Huffman Coding, LZW Compression
●​ Libraries: Tkinter for GUI
●​ Tools: zlib for compression

9. Augmented Reality Object Placement

Build an AR application allowing users to place virtual 3D objects, such as

furniture or shapes, into live camera feeds. Use OpenCV for camera calibration
and object positioning.

●​ Programming Language: Python (for OpenCV)

●​ Libraries: OpenCV, ARCore/ARKit (for mobile)
●​ Tools: Vuforia or AR.js
●​ Frameworks: Unity (optional for 3D objects)

10. Optimized Task Scheduling System with Web Integration

Create a web-based task scheduling application that efficiently assigns tasks to

workers based on resource availability, priority, deadlines, and dependencies.
The system will use Priority Queues to manage task prioritization, Greedy
Algorithms for optimal task assignment, and Graph Theory (Topological Sorting)
to handle task dependencies. This web app will have a user interface for adding,
viewing, and updating tasks, as well as visualizing the schedule in real time. It
will be designed to handle a large dataset, optimize resources, and provide an
intuitive dashboard for administrators to track the progress of tasks.

●​ Frontend: HTML, CSS, JavaScript (React)

●​ Backend: Node.js, Express.js
●​ Database: MongoDB/PostgreSQL
●​ Algorithms: Priority Queues, Greedy Algorithms, Topological Sorting
●​ Libraries: React, D3.js (for visualization)
12. Document Plagiarism Checker​
Develop a plagiarism detection system for text documents. The system will
compare and analyze two or more documents using Suffix Trees/Arrays or
Rolling Hashing to check for similarities and plagiarized content. This project can
also implement Longest Common Subsequence (LCS) to find the highest
matching text segments.

●​ Programming Language: Python

●​ Algorithms: Suffix Trees, Rolling Hashing, Longest Common
Subsequence
●​ Libraries: NLTK, difflib
●​ Tools: Tkinter (optional for GUI)

13. Resume ATS checker:

●​ Develop a resume ATS check algorithm that automates the process of

evaluating resumes based on Applicant Tracking Systems (ATS) used by
recruiters. This system will analyze resumes to ensure they are
ATS-friendly. Additionally, it will offer feedback on how to optimize resumes
for better compatibility with ATS.
●​ Programming Language: Python or any other.
●​ Libraries: Scikit-learn (for matching algorithms), SpaCy (for NLP)
●​ Tools: Flask/Django for backend, React for frontend
●​ Database: PostgreSQL/MySQL
●​ Algorithms: Text similarity, Resume parsing

14. Personal Finance Tracker

GEHU is unable to manage their daily expenses, can you help them to design a
web application to help users track expenses, set budgets, and visualize
spending habits. Include features for data import/export and detailed analysis by
categories.

●​ Frontend: React/Angular
●​ Backend: Node.js
●​ Database: MongoDB
●​ Libraries: Chart.js (for visualizations)
●​ Tools: Bootstrap for UI design​
15. Book My Show Reservation System

Create a CLI based algorithm that creates the ticket spot reservations, allowing
users to book parking spots in real-time. The system should have the capability
to book slots, cancel tickets after then it should be available to other people,
update the seat number, or change the date of the show.

●​ Frontend: React.js
●​ Backend: Node.js, Express.js
●​ Database: MongoDB
●​ Algorithms: Heaps, Graph Theory
●​ Tools: Google Maps API for location services

17. Time Zone Scheduling Assistant

A tool to schedule meetings with users across multiple time zones.Automatically

converts time zones, provides a visual calendar, and suggests optimal meeting
times considering all participants' time zones.

●​ Frontend: React.js
●​ Backend: Node.js, Express.js
●​ Libraries: Moment.js (for time handling), FullCalendar (for calendar view)
●​ Database: MongoDB

18. Secure Delivery Data Transformation System

Currently all the information on the parcel package is written in the delivery box,
this information contains someone's name, phone, address etc. Design a system
to encrypt customer data into QR codes that only authorized delivery agents can
access. Track and log all access attempts to ensure data security.​
Tech Stack:

●​ Frontend: HTML, CSS, JavaScript

●​ Backend: Python with Flask
●​ Database: SQLite or Firebase​
Key Features:
●​ Encrypted QR code generation
●​ Role-based access and decryption
●​ Log tracking for security
19. Traffic Flow Optimization Simulator

Traffic pattern simulation is a computational technique used to replicate

real-world traffic dynamics in a virtual environment. By adjusting variables such
as signal timing or lane configurations, planners can observe their effects on
congestion, travel times, and overall efficiency of traffic systems. This approach
helps to make data-driven decisions for improving urban mobility and reducing
negative impacts like delays, fuel consumption, and emissions.

Tech Stack:

●​ Frontend: HTML, CSS, D3.js for visualization

●​ Backend: Flask
●​ Simulation Tools: NumPy, Matplotlib​
Key Features:
●​ Real-time traffic simulation
●​ Adjustable variables (signal timing, lane configuration)
●​ Visual representation of traffic flow
23. Smart Feed Scheduler for Livestock

Farmers are struggling with overfeeding and underfeeding their livestock, wasting
feed and affecting animal health. They want to adopt a system, which uses
sensors and machine learning to track individual animal needs. The system
automates feeding schedules, optimizes feed quantities, and minimizes waste.

Develop a system that optimizes feeding schedules for livestock based on health,
growth, and activity data, enhancing efficiency and minimizing feed waste.

Tech Stack:

●​ Frontend: React.js or Angular

●​ Backend: Flask or Django
●​ Database: PostgreSQL or MySQL
●​ IoT Devices: Smart feeders, activity trackers
●​ ML Model: Regression models for feeding optimization

Key Features:

●​ Track growth, weight, and activity levels of each animal.

●​ Use machine learning to determine ideal feed types and amounts.
●​ Integrate with smart feeders for precise feeding times.
●​ Monitor feed consumption to minimize waste.
●​ Adjust feeding based on the animal’s health and growth stage.

24. Moonlander Algorithm

Wonder what algorithm chandrayaan-3 must have, to implement and analyze the
Moonlander algorithm for lunar landing simulations, and make the most
optimized algorithm, make it so that our other space programs for MARS, or Titan
this algorithm can be inherited and made modifications.
Aim: To understand and optimize the landing process using algorithms.
Other Aspects:
​ •​ Simulating lunar landing scenarios
​ •​ Analyzing algorithm performance
​ •​ Optimizing landing strategies
25. Red-Green Game

To develop an engaging and interactive game inspired by the “Red Light, Green
Light” game from Squid Game.
Aim: To enhance machine learning algorithms and solve a challenge where you
could find new algorithms on Computer Vision (CNN), Reinforcement
Learning (DQN) or others like RNNs, Isolation Forest or other machine
learning techniques.

Other Aspects:
​ •​ Implementing game mechanics and rules.
​ •​ Developing an intuitive user interface.
​ •​ Ensuring a far accuracy of 90%, when working with 100 moving objects.
​ •​ Ensuring smooth performance and responsiveness.

26. Haircut Recommendations According to Face Cut

Your face cut decides what haircut will suit you, to develop an AI-based
application for personalized haircut recommendations.
Aim: To provide users with tailored haircut suggestions based on their facial
features.
Other Aspects:
​ •​ Implementing facial recognition and analysis
​ •​ Integrating a recommendation engine
​ •​ Ensuring a user-friendly interface