GOVERNMENT POLYTE CHNIC, AMBAD

DEPARTMENT OF INFORMATION
TECHNOLOGY

ACADEMIC YEAR- 2025-26

COURSE & CODE:- (SPI) (315003)

A SEMINAR-PROJECT OF
“SEMINAR AND PROJECT INITIATION”

A SEMINAR-PROJECT ON
LEETCODE-Online DSA Problem Solving and Coding
Learning Platform
(INFORMATION TECHNOLOGY ENGINEERING 5-K)

UNDER THE GUIDANCE OF

PROF. [Link]

SUBMITTED BY
ROLL NO ENROLLMENT
[Link] NO NAME OF STUDENT SIGN

01 IF5K 16 23510280540 GORADE VIJAY RAMESH

02 IF5K 03 23510280524 BORDE PRANAY DILIP

03 IF5K 09 23510280532 CHANDODE VAISHNAVI VISHNU

04 IF5K 44 23510280586 WAGHMARE PRUTHA KIRAN

 GOVERNMENT POLYTECHNIC, AMBAD
DEPARTMENT OF INFORMATION TECHNOLOGY

COURSE & CODE:- (SPI) (315003)

CERTIFICATE
This is to certify that the Seminar-project entitled Leetcode
-Online DSA Problem Solving and coding Learning media
platform being submitted here with for the award of DIPLOMA
IN IF ENGINEERING of MAHARASHTRA STATE BOARD &
TECHNICAL EDUCATION
(MSBTE) is the result of seminar-project work completed
by ........... under the supervision and guidance of Prof.
[Link] It is to the best of my knowledge and belief that
the work embodied in this seminar project has not formed earlier
the basis for the award of any degree or diploma of this or any
other Board or examining body.

Academic Year: 2025-2026 Semester: FIFTH(5TH)

Place :- Ambad
Date :-

seminar-project Guide HOD Principle

Prof. [Link] [Link] [Link]

 ACKNOWLEDGEMENTS

We have great pleasure to express my immense gratitude towards a dynamic

person and my INFORMATION TECHNOLGY ENGINEERING Government project guidance,
Prof. [Link] Department of Polytechnic, Ambad for giving me an opportunity to
work on an interesting topic over first semester. The work presented here could not have
been accomplished without his most competent and inspiring guidance, incessant
encouragement, constructive criticism and constant motivation during all phases of our
group seminar-project work. I am highly indebted to him.

We are very much thankful to Prof. Y. B. SANAP, Head Department of

INFORMATION TECHNOLGY ENGINEERING, all HODs of various departments and Prof. B. S.

PAWAR Sir, The Principal of Government Polytechnic, Ambad for his encouragement
and providing me a motivating environment and project facilities in the Institute
to carry out experiments and complete this seminar-project work.

I would like to extend my thanks to all our professors, staff members and all
our friends who extended their co-operation to complete the project.

I am indeed indebted to my parents and other family members for their

immense help at all levels with moral, social & financial support, care and support
throughout my studies without which my work would not have seen light of the
day.

With warm regards,

Yours Sincerely,

Place: Ambad

Date:
LEETCODE-Online DSA Problem Solving and Coding
Learning Platform

Introduction – LEETCODE Website

In the modern era of software engineering, problem-solving and DSA

(Data Structures and Algorithms) are considered the soul of coding
excellence.
While platforms like LeetCode, HackerRank, and Codeforces exist, most
are either paid, complex, or lack personalized learning assistance.
To bridge this gap, this project introduces “LEETCODE – Online DSA
Problem Solving and Coding Learning Platform”, built using the MERN
Stack (MongoDB, [Link], [Link], [Link]) and powered by
Judge0 API for real-time code execution.
The highlight of this project is the integration of an AI-based Chatbot
that acts like a virtual coding mentor — guiding users when they are
stuck, explaining DSA concepts, suggesting optimized solutions, and
even motivating them to improve their performance.
This is not just a coding platform —
it’s a revolutionary learning ecosystem, designed for self-growth,
guidance, and intelligent practice.
Amazon, Flipkart, and other top tech companies prioritize DSA
problem-solving skills because it directly reflects a candidate’s ability
to think critically, code efficiently, and solve real-world problems.
LeetCode and similar platforms provide a proven and structured way
to develop these skills, which is why they are widely used by both
students preparing for placements and companies evaluating top
talent.
Using platforms like LeetCode is not just about solving problems; it is
about developing critical thinking, coding efficiency, and algorithmic
mastery.
It provides a structured, interactive, and guided learning environment,
preparing learners for technical interviews, competitive programming,
and real-world software development challenges.
The modular structure ensures each component is independent,
scalable, and maintainable.
Together, these modules form a complete, modern, interactive, and
intelligent coding platform.
The system is not just a practice environment but also a learning
mentor with AI guidance, real-time code execution, and detailed
analytics.
 Objectives

1) To develop an intelligent and modern web-based platform for Data

Structures and Algorithms (DSA) problem-solving using the MERN stack.

2) To simplify the process of learning and practicing DSA by providing a clean

, responsive, and interactive coding environment.

3) To integrate the Judge0 API for real-time code compilation and execution
in multiple programming languages such as C, C++, Java, Python, and JavaScript.

4) To implement an AI-powered chatbot assistant provides hints,

algorithmic explanations, and conceptual guidance to users during
problem-solving.

5) To provide personalized learning recommendations based on user performance,

accuracy, and level of experience.

6) To create a self-paced and independent learning environment that

helps students improve coding logic without external help.

7) To design a visually appealing and mobile-friendly interface using [Link]

and Tailwind CSS for seamless user experience across all devices.

8) To ensure data privacy and security by implementing user authentication

and encryption techniques using JWT and bcrypt.

9) To store and manage user profiles, coding problems, and submissions

securely in MongoDB with efficient data models.

10) To develop an admin dashboard that allows administrators to add, edit,

and manage coding problems and test cases dynamically.
Problem Definition

• In today’s rapidly evolving software industry, the ability to solve

problems efficiently using Data Structures and Algorithms (DSA)
has become one of the most essential skills for programmers.
Despite the availability of several online platforms like LeetCode,
HackerRank, and Codeforces, most of them have certain
limitations such as complex interfaces, limited free access, lack
of personalized assistance, and no real-time mentoring support.
• As a result, many students, especially beginners, struggle to
understand DSA concepts and fail to develop strong problem-
solving skills. They often encounter difficulties such as:
• Not knowing how to start solving a problem.
• Lack of real-time guidance or hint systems.
• Difficulty in debugging code and understanding logic errors.
• Overwhelming user interfaces that distract rather than help.
• Absence of emotional or motivational support during continuous
failures.
• To overcome these challenges, there is a need for an interactive,
intelligent, and beginner-friendly coding platform that provides
both practical problem-solving experience and conceptual
understanding.
• The proposed project, “LEETCODE – Online DSA Problem
Solving and Coding Learning Platform”, aims to bridge this gap
by offering a complete coding ecosystem where students can:
• Practice DSA problems online.
• Execute their code in real time using Judge0 API.
• Learn concepts through an AI-powered chatbot that provides
hints, explanations, and motivational support.
 System Design

1. System Overview

The system aims to provide an intelligent, modern, and user-friendly

platform for learning and practicing Data Structures and Algorithms (DSA)
online.
It allows users to solve problems, run code in real-time, and get AI-powered
guidance whenever they are stuck.
The system is divided into several interconnected modules that work
together seamlessly to provide a smooth experience:

1. User Interface (UI): The front-end through which users interact with the
system.
2. Application Server: Handles all user requests and controls business logic.
3. Storage Layer: Stores user information, problems, submissions, and
performance data.
4. Code Execution Service: Executes user-submitted code in a secure sandbox
environment.
5. AI Assistant Service: Provides hints, explanations, and learning support to
users.
6. Admin Module: Manages problems, users, and system configurations.
7. Monitoring & Logging Module: Tracks system performance, user activity,
and logs for analysis.
 2. High-Level Architecture

The overall data flow and architecture can be summarized as follows:

1. The user opens the platform, views the problem list, and selects a problem
to solve.
2. The user writes code in the online editor and submits it for execution.
3. The Application Server receives the request and sends the code to the Code
Execution Service for safe execution.
4. The Execution Service compiles and runs the code securely, returning
results such as output, runtime, and errors.
5. If the user is stuck or requests help, the AI Assistant Service provides
relevant hints or explains the concept.
6. All user interactions, submissions, and performance statistics are saved in
the Storage Layer.
7. The Admin Module allows moderators or instructors to add new problems,
test cases, and monitor the system.
8. The Monitoring Module ensures the platform is running efficiently and
securely.
 3. Component Design and Responsibilities

• Displays problem lists, problem descriptions, and an online code editor.

• Shows live output and execution results.
• Contains a chatbot interface for AI-assisted learning and help.
• Tracks progress through dashboards and submission history.
• Ensures responsive design and smooth user interaction.
Manages all requests from the front-end.
• Handles user authentication and authorization securely.
• Sends submitted code to the Code Execution Service and returns the result.
• Communicates with the AI Assistant for intelligent hint generation.
• Processes all data transactions between the client and database.
• Ensures business logic execution and error handling.
• Provides APIs for admin operations like adding/editing problems and users.
• User Data: Stores registration details, login credentials (securely hashed),
and learning progress.
• Problems Database: Contains all problem statements, constraints, and test
cases.
• Submissions Database: Saves code submissions, results, timestamps, and
performance metrics.
• Chat History: Keeps records of AI chats for context-based responses.
• Analytics: Tracks accuracy, problem difficulty levels, and user improvement
trends.

.
4. Admin Module

• Allows administrators to manage problems, test cases, users, and system

configurations.
• Provides analytical dashboards to track user engagement and system
performance.
• Helps in maintaining platform quality and adding new challenges regularly

5. AI Assistant Service

• An intelligent component that analyzes user queries and provides context-

aware responses.
• Offers hints, algorithmic explanations, and learning suggestions rather than
direct answers.
• Detects when a user is repeatedly failing a problem and provides
motivational guidance.
• Integrates problem context (title, tags, topic) to provide precise help.
• Improves user engagement and reduces frustration during learning.
• Works like a personal mentor or virtual tutor within the system.

6. Monitoring & Logging Module

• Collects logs for all system events like user submissions, server errors, and
code execution statistics.
• Monitors server uptime, response times, and error rates.
• Provides detailed analytics for debugging, optimization, and scaling
decisions.
• Ensures system reliability and helps developers maintain performance.
4. Data Flow Summary
1. The user interacts through the front-end UI.
2. The request travels to the Application Server.
3. The server processes logic and connects with other modules (Execution, AI,
Storage).
4. The output or AI response is returned to the user.
5. Data gets stored or updated in the database for progress tracking.
.

5. Key Design Goals

• Secure and isolated code execution.

• Intelligent, adaptive learning experience.

• Seamless communication between components.

• Scalability for multiple users solving problems simultaneously.

• Reliability, low latency, and real-time response.

• Engaging design with built-in virtual guidance.

Technology Stack (Tech Stack)
The proposed project “LEETCODE – Online DSA Problem Solving and Coding
Learning Platform” is developed using the MERN stack (MongoDB, [Link],
[Link], and [Link]) along with additional third-party APIs and AI services.
The selection of each technology is based on scalability, performance, and
modern web development standards.
Below is a detailed explanation of each layer and its role in the system.

1. Front-End (Client Side)

Technology Used: [Link], HTML5, CSS3, JavaScript, Tailwind CSS
Description:
• The front-end of the platform is designed using [Link], a powerful
JavaScript library for building interactive and component-based user
interfaces.
• React Hooks such as useState, useEffect, and useReducer are used to
handle state management efficiently.
• Tailwind CSS provides a modern and mobile-first design approach, ensuring
responsiveness on all devices.
• Dynamic Routing is implemented using React Router for smooth navigation
between problems, submissions, and profile pages.
• The Code Editor on the front-end is integrated using open-source libraries
(like Monaco Editor or CodeMirror) to provide syntax highlighting, code
formatting, and real-time error checking.
• The Chatbot Interface is implemented on the client side to enable real-time
user-AI communication.
Key Features of the Front-End:
• Responsive and user-friendly layout.
• Problem listing and filtering interface.
• Integrated code editor with run/test functionality.
• Real-time chatbot section for instant help.
• Dashboard to track progress and submission history.
2. Back-End (Server Side)

Technology Used: [Link], [Link]

Description:
• The back-end is developed using [Link] with [Link] framework to
handle APIs and server-side logic efficiently.
• All user requests (problem loading, code submission, authentication,
AI chat requests) are processed through this layer.
• The back-end acts as the bridge between the client, the Judge0 API, and
the database.
• The system ensures secure communication through token-based
authentication (JWT).
• RESTful APIs are designed for modular and scalable development.

Responsibilities:
• Handle user registration, login, and session management.
• Manage CRUD operations for problems and submissions.
• Forward code execution requests to Judge0 API and process results.
• Connect to the AI Assistant API for intelligent help and explanation.
• Validate data and ensure proper error handling.
3. Database Layer
Technology Used: MongoDB (NoSQL Database)
Description:
• MongoDB is chosen for its flexibility and scalability in storing unstructured
and semi-structured data.
• Collections include:
o Users: stores user credentials, roles, and progress.
o Problems: holds problem statements, difficulty levels, and tags.
o Submissions: stores each user’s submission, code, and results.
o Chats: logs user-chatbot interactions for context-based responses.
• MongoDB’s document-based model allows fast retrieval of problem data
and analytics.

4. Code Execution Layer

Technology Used: Judge0 API (Third-Party API)
Description:
• Judge0 API is an open-source online code execution engine used to compile
and run user-submitted programs safely in a sandbox environment.
• The platform sends code, selected language, and input to the Judge0 API
and receives the output, runtime, and error details.
• The sandbox ensures system safety from malicious code.
• Multiple programming languages are supported (C, C++, Java, Python,
JavaScript, etc.).
Advantages:
• Real-time code execution.
• Language flexibility.
• Secure and isolated environment.
• Accurate runtime and memory feedback.
5. AI Assistant Layer
Technology Used: OpenAI API / Custom NLP Model
Description:
• This layer integrates an AI-powered chatbot that acts as a personal mentor
for the user.
• When a user gets stuck, the chatbot analyzes the problem context and
provides:
o Relevant hints.
o Step-by-step logic guidance.
o Algorithmic insights and concept explanations.
o Motivational messages to encourage continued learning.
• The AI assistant uses natural language processing (NLP) to understand user
queries.
• Context-awareness is maintained through chat history stored in MongoDB.

6. Additional Tools & Libraries

• Axios / Fetch API – For communication between client and server.
• JWT (JSON Web Token) – For secure user authentication.
• dotenv – For environment configuration.
• Nodemon – For automatic server restart during development.
• [Link] – For password hashing.
• CORS Middleware – For secure cross-origin requests.
• Mongoose – For MongoDB object data modeling.

7. Hosting and Deployment

• Front-End: Deployed on Vercel or Netlify.
• Back-End: Hosted on Render or AWS EC2 instance.
• Database: Managed via MongoDB Atlas (Cloud Database).
• Judge0 API: Used via its public endpoint or hosted privately.
8. Reasons for Choosing MERN Stack
1. Single language (JavaScript) for both client and server simplifies
development.
2. Highly scalable and well-suited for real-time web applications.
3. Strong community support and abundant libraries.
4. Excellent performance for modern, data-driven applications.
5. Ideal for full-stack development with quick prototyping and deployment.
 Implementation
1. User Authentication and Profile Management Module
Purpose: Securely manage user accounts and profiles.
Details:
• Users can register, login, and manage their accounts.

• Passwords are securely hashed and stored.

• Session management is implemented to keep users logged in securely.

• Users can view their progress, solved problems, and performance

analytics.
• Role-based access: regular users and admin users have different

permissions.
Features:
• Secure registration/login.

• Profile management and dashboard.

• View problem-solving stats.

• Reset password feature.

2. Problem Management Module

Purpose: Manage and display coding problems to users.
Details:
• Admins can add, edit, or remove problems.

• Problems are categorized by topic and difficulty (Easy, Medium, Hard).

• Problem details include description, input/output format, sample and

hidden test cases.

• Users can filter and search problems by tags, difficulty, and topics.

Features:
• Dynamic problem list.

• Topic-wise and difficulty-wise filtering.

• Problem details with sample test cases.

• Pagination for smooth navigation.

 3. Online Code Editor and Execution Module
Purpose: Allow users to write and run code in real-time.
Details:
• Provides an interactive code editor with syntax highlighting and auto-
indentation.
• Multi-language support: C, C++, Java, Python, JavaScript, etc.
• Submissions are sent to Judge0 API for secure execution.
• Users receive execution results including output, errors, runtime, and
memory usage.
Features:
• Secure code execution in sandbox.

• Run code with custom inputs.

• Multi-language support.

• Real-time output console.

4. Submission and Evaluation Module

Purpose: Automatically evaluate user submissions.
Details:
• Compares output with predefined test cases.

• Provides feedback: Accepted, Wrong Answer, Runtime Error, or Time

Limit Exceeded.
• Stores submission history for tracking progress.

• Evaluates code efficiency (runtime, memory).

Features:
• Automatic result evaluation.

• Real-time feedback to users.

• Submission history and statistics tracking.

5. AI Chatbot Assistance Module

Purpose: Provide hints, explanations, and guidance.
Details:
• Acts as an intelligent virtual mentor.

• Gives problem-solving tips and step-by-step logic.

• Motivates users when stuck.

• Uses chat history for context-aware responses.

Features:
• Interactive chat interface.

• Context-based hints and explanations.

• Personalized learning support.

• Encourages self-learning.

6. User Progress and Analytics Module

Purpose: Track and visualize user learning progress.
Details:
• Records all solved, attempted, and pending problems.

• Shows progress dashboards with charts and stats.

• Provides topic-wise performance analysis.

• Helps users identify weak areas and improve skills.

Features:
• Progress dashboard.

• Graphical analytics for user performance.

• Topic-wise strengths and weaknesses.

• Continuous improvement tracking.

7. Admin Management Module

Purpose: Enable admins to manage platform data.
Details:
• Admins add/edit/delete problems and test cases.

• Can monitor user activity and submissions.

• Manage chatbot responses and AI database.

• View system usage reports.

Features:
• Admin dashboard.

• CRUD operations on problems.

• Monitoring and reporting.

• AI chatbot management.
 8. Notification and Feedback Module
Purpose: Engage users and collect suggestions.
Details:
• Sends notifications for milestones, achievements, and new problems.
• Users can submit feedback about problems or platform issues.
• Feedback improves AI guidance and platform features.
Features:
• Achievement notifications.
• Feedback form.
• Platform improvement suggestions.

9. Security and Monitoring Module

Purpose: Ensure safety and stability.
Details:
• Implements secure authentication and data encryption.

• Monitors system performance, server health, and error logs.

• Ensures sandboxed code execution for user safety.

• Detects unusual activity and prevents misuse.

Features:
• Encrypted credentials.

• Continuous monitoring.

• Error and system logs.

• Secure and isolated code execution.

 Testing Tools

Testing is a crucial phase in the development of the platform to ensure

functionality, reliability, security, and performance. For this project,
the following testing tools and approaches are used:

1. Postman
• Purpose: To test all RESTful APIs developed in the [Link] backend.

• Usage:

o Validate API endpoints for user registration, login,

problem fetching, and code submission.

o Check response status, data correctness, and error handling.

• Benefit: Ensures APIs work correctly before integration with the

front-end.

2. Jest
• Purpose: To perform unit testing on JavaScript functions, React

components, and backend logic.

• Usage:

o Test utility functions for code execution results, problem

sorting/filtering, and analytics calculations.

o Validate React components render correctly with expected

props.
• Benefit: Detects logic errors early and ensures reliable front-end

and back-end functionality.

3. Cypress
• Purpose: For end-to-end testing of the platform.
• Usage:
o Simulate real user interactions: login, solve problems, submit code,

and receive results.

o Test chat interface and AI responses.

• Benefit: Verifies that the complete system works as expected from a user
perspective.
 4. ESLint

• Purpose: To maintain code quality and consistency.

• Usage:
o Detects syntax errors, potential bugs, and enforces

coding standards in JavaScript/React code.

• Benefit: Reduces runtime errors and improves maintainability.

5. Browser Developer Tools

• Purpose: For manual testing and debugging of the front-end.
• Usage:
o Inspect elements, monitor network requests, and check console

for errors.
o Test responsiveness and UI performance across different devices.

• Benefit: Ensures a smooth and bug-free user interface.

6. MongoDB Compass
• Purpose: To test database operations.
• Usage:
o Verify CRUD operations for Users, Problems, Submissions,

and Chats.
o Check data integrity and correct storage of submissions and AI

chat logs.
• Benefit: Ensures database is consistent, reliable, and properly linked with
backend APIs.
 7. Load Testing Tools (Optional)
• Tools: Apache JMeter or Postman Collection Runner
• Purpose: To test platform performance under high user load.
• Usage:
o Simulate multiple users submitting code simultaneously.

o Check API response time, server stability, and database handling.

• Benefit: Ensures the platform is scalable and can handle real-world

usage
Why Top Tech Companies Like Amazon and Flipkart Use /
Value LeetCode & DSA Skills

1. Recruitment and Interview Preparation

• Companies like Amazon, Flipkart, Google, Microsoft hire software
engineers through coding interviews.
• These interviews primarily focus on Data Structures and Algorithms
(DSA).
• Platforms like LeetCode provide industry-standard problems similar
• to those asked in interviews.
• Practicing on such platforms prepares candidates for real interview
scenarios.

2. Assess Problem-Solving Skills

• Top companies need engineers who can solve complex problems
efficiently.
• DSA problems test logical thinking, analytical ability, and algorithmic
efficiency.
• LeetCode problems help candidates practice optimization techniques
such as time and space complexity analysis.
• This ensures that new hires can write scalable and efficient code
for real-world systems.
 3. Standardized Benchmark for Candidates
• LeetCode and similar platforms standardize the skill evaluation

process.
• By solving these problems, candidates demonstrate their ability

to tackle unseen problems.

• Recruiters use these platforms as a benchmark to identify

high-performing candidates who can adapt to challenging tasks.

4. Real-World Software Engineering Simulation

• Many LeetCode problems are inspired by real-world software
are challenges:
o Optimizing search and retrieval operations

o Efficiently handling large datasets

o Designing algorithms for scalability and concurrency.

5. Continuous Learning and Upskilling

• Top tech companies encourage employees to upskill regularly.

• LeetCode is often used internally for competitive coding contests

and skill improvement sessions.

• It fosters a culture of continuous learning, problem-solving,

and innovation.
7. Preparing for Leadership in Tech
• Employees who master DSA are better at designing complex systems,

mentoring juniors, and making architecture decisions.

• This is why tech giants use DSA platforms as part of their

• technical assessment and growth framework.

 Conclusion

The LEETCODE – Online DSA Problem Solving Platform is a modern,

interactive system designed to help learners master Data Structures and
Algorithms efficiently.
The platform includes:
• AI-powered chatbot for hints and step-by-step guidance.
• Real-time code execution using Judge0 API.
• Responsive UI built with [Link] and Tailwind CSS.
• Progress tracking and analytics to monitor performance.

This project provides a safe, structured, and scalable learning environment,

bridging the gap between theory and practical coding.
It equips students with problem-solving skills, coding efficiency, and
interview readiness, making it both educational and professional-grade.
Amazon, Flipkart, and other top tech companies prioritize DSA
problem-solving skills because it directly reflects a candidate’s ability
to think critically, code efficiently, and solve real-world problems.
LeetCode and similar platforms provide a proven and structured way
to develop these skills, which is why they are widely used by both
students preparing for placements and companies evaluating top
talent.
Using platforms like LeetCode is not just about solving problems; it is
about developing critical thinking, coding efficiency, and algorithmic
mastery.
It provides a structured, interactive, and guided learning environment,
preparing learners for technical interviews, competitive programming,
and real-world software development challenges.
The modular structure ensures each component is independent,
scalable, and maintainable.
Together, these modules form a complete, modern, interactive, and
intelligent coding platform.
The system is not just a practice environment but also a learning
mentor with AI guidance, real-time code execution, and detailed
analytics.
References (Links and Platform Names)
1. LeetCode – [Link]
2. GeeksforGeeks – [Link]
3. Judge0 API – [Link]
4. [Link] Documentation – [Link]
[Link]
5. [Link] Documentation – [Link]
6. MongoDB Documentation – [Link]
7. OpenAI API – [Link]
8. Tailwind CSS Documentation – [Link]