ITINERARY PLANNER:
EXPLORING HIDDEN GEMS
A PROJECT REPORT
Submitted by
DIVYE BATWARA [RA24110051010017]
VIRAJ DEGLURKAR [RA24110051010021]
ADHYAYAN MALGURI [RA24110051010022]
SOUMIL MEHROTRA [RA2411051010023]
Under the Guidance of
[Link]
(Assistant Professor,Department of Data Science And Business Systems)
in partial fulfillment of the requirements for the degree of
BACHELOR OF TECHNOLOGY
in
COMPUTER SCIENCE ENGINEERING
(CSE w/s GAMING TECHNOLOGY)
DEPARTMENT OF
DATA SCIENCE AND BUSINESS SYSTEMS
COLLEGE OF ENGINEERING AND TECHNOLOGY SRM INSTITUTE
OF SCIENCE AND TECHNOLOGY
KATTANKULATHUR- 603 203
NOVEMBER 2025
SRM INSTITUTE OF SCIENCE AND TECHNOLOGY
KATTANKULATHUR – 603 203
BONAFIDE CERTIFICATE
Certified that 21CSC203P – Advanced Programming Practice [Project
Report] titled “ITINERARY PLANNER:EXPLORING HIDDEN GEMS” is
the bonafide work of “DIVYE BATWARA [RA24110051010017], VIRAJ
DEGLURKAR [RA24110051010021], ADHYAYAN MALGURI [RA24110051010022],
SOUMIL MEHROTRA [RA2411051010023]” who carried out the project work
under my supervision.
SIGNATURE SIGNATURE
Dr. S VENKATESH Dr. V. Kavitha
Assistant Professor Professor & HOD
Department of Data Science and Business Systems Department of Data Science and Business Systems
ABSTRACT
Tourism across South India offers a unique combination of natural beauty, cultural
heritage, and regional diversity. However, most tourists tend to focus on popular
destinations such as Ooty, Mysore, and Chennai, while numerous hidden gems like
Kodaikanal, Munnar, Coorg, Alappuzha, Varkala, and Araku Valley remain
underexplored. The South India Itinerary Planner – Exploring Hidden Gems project
seeks to address this imbalance by developing an intelligent, interactive trip planning
platform that uncovers and promotes these lesser-known destinations.
The system is designed to generate personalized travel itineraries based on user inputs
such as preferred state and duration of travel. It features a web-based frontend built
with HTML/CSS and
JavaScript, ensuring a visually appealing, simple, and responsive interface for users to
interact with. The backend is developed using Java, integrated with a MySQL database
through JDBC for efficient data storage, retrieval, and management of user itineraries.
This architecture provides both scalability and maintainability, ensuring smooth
functionality and data integrity throughout the planning process.
The Itinerary Planner offers functionalities including user authentication (login and
signup), destination search by state, and a rule-based itinerary generator that
dynamically composes travel routes and suggestions. The system’s modular design
promotes easy feature expansion in future versions, such as AI-driven
recommendation systems, integration with navigation maps, and hotel or transport
booking services.
By encouraging exploration of less-commercialized destinations, the project contributes
to sustainable tourism, regional economic growth, and the promotion of local
cultures. It aligns with Sustainable Development Goals (SDG 8 — Decent Work and
Economic Growth) and (SDG 11 — Sustainable Cities and Communities) by
fostering balanced tourism development.
In conclusion, the South India Itinerary Planner stands as an innovative approach to
redefining travel planning through digital empowerment. It provides travelers with
authentic and diverse experiences while supporting the preservation of South India’s
cultural and environmental richness. The project demonstrates the practical application
of full-stack development principles and highlights the potential of technology in
promoting responsible and inclusive tourism.
TABLE OF CONTENTS
CHAPTER NO. TITLE PAGE NO.
ABSTRACT iii
TABLE OF CONTENTS iv
1 INTRODUCTION 1
2 SYSTEM REQUIREMENTS 2
3 SYSTEM DESIGN 3
4 MODULE DESCRIPTION 6
5 CONCLUSION 13
REFERENCES 14
APPENDIX A: CODING 15
CHAPTER 1
INTRODUCTION
1.1 GENERAL
The South India Itinerary Planner is designed to provide travelers with a convenient and
intelligent way to explore the hidden treasures of South India. Most travel applications and
websites focus on mainstream tourist destinations, often overlooking equally mesmerizing but
less-crowded locations. This project introduces a rule-based itinerary generator that helps
users discover offbeat places based on their chosen state and duration of travel.
1.2 MOTIVATION
Tourists often miss out on South India’s cultural and natural diversity due to the absence of
personalized and intelligent planning tools. While mainstream attractions are heavily
commercialized, serene and unique destinations such as Coorg, Alappuzha, Araku Valley,
and Varkala remain relatively undiscovered. This project is motivated by the need to promote
sustainable tourism and enhance travel diversity by providing users with curated itineraries
that highlight hidden gems tailored to their interests.
1.3 OBJECTIVES
● To design an interactive itinerary planner highlighting hidden destinations in South India.
● To enable personalized itinerary generation based on user inputs (state and travel duration).
● To develop a web-based interface using HTML and CSS for user-friendly interaction.
● To implement a Java backend with JDBC for efficient database connectivity and to store
and manage user itineraries securely in a MySQL database.
1.4 SCOPE
● Covers five South Indian states: Karnataka, Tamil Nadu, Kerala, Andhra Pradesh, and
Telangana.
● Provides destination recommendations and dynamic itinerary creation.
● Allows itinerary saving and retrieval through integrated database management.
● Supports scalability for AI-based recommendations, map integration, and booking
features in the future.
1.5 SUSTAINABLE DEVELOPMENT GOAL
SDG 8 — Decent Work and Economic Growth and SDG 11 — Sustainable Cities and Communities
The project supports sustainable tourism by promoting lesser-known destinations, thereby
contributing to local economies while reducing pressure on overcrowded tourist hubs. It aligns
with global efforts to make travel more inclusive, culturally enriching, and environmentally
responsible.
CHAPTER 2
SYSTEM REQUIREMENTS
2.1 HARDWARE REQUIREMENTS
Requirement Minimum Recommended
Processor Dual-core 2.0 GHz Quad-core 2.5+ GHz
RAM 8 GB 16 GB
Storage 256 GB HDD/SSD 512 GB SSD
Display Standard HD Full HD or above
Internet Basic broadband Stable high-speed connection
Table 2.1 Hardware
2.2 SOFTWARE REQUIREMENTS
Component Specification
Operating System Windows / macOS / Linux
Programming Language Java 17+ , JavaScript
Backend Framework Java and JDBC
Database MySQL 8.x
Front-End Stack HTML, CSS, JavaScript
IDE / Tools IntelliJ IDEA / VS Code / Eclipse
Browser Chrome / Edge / Safari
Build Tool Maven
Server Embedded Tomcat (via Java)
Table 2.2 Software
CHAPTER 3
SYSTEM DESIGN
3.1 SYSTEM ARCHITECTURE DIAGRAM
Fig 3.1 System Architecture
3.2 USE CASE DIAGRAM
Fig 3.2 Use Case Diagram
3.3 CLASS DIAGRAM
Fig 3.3 Class Diagram
CHAPTER 4
MODULE DESCRIPTION
The South India Itinerary Planner system is composed of multiple interconnected modules, each
responsible for a specific function within the overall application workflow. These modules
collectively handle user authentication, itinerary generation, destination management, and
database connectivity, providing a seamless and engaging travel planning experience.
4.1 USER AUTHENTICATION MODULE
This module manages user registration and login functionality to ensure secure access to the platform.
It allows users to create accounts and store their credentials safely within the database. Users provide
basic details such as name, email, and password, which are validated and securely stored in the MySQL
database. During login, the system verifies credentials using backend logic implemented in Java. After
successful authentication, the user is redirected to the itinerary generation dashboard.
Key Functions:
● User registration and login authentication
● Secure password handling
● Database integration for user credential storage
● Access restriction for unauthorized users
4.2 HOMEPAGE & NAVIGATION MODULE
The homepage acts as the main entry point for users. It provides easy access to features like destination
exploration, itinerary creation, and saved itinerary [Link] using HTML and CSS, the
interface offers a clean and intuitive layout that guides users through the process of building their travel
plan.
Key Functions:
● Display project title and introduction
● Navigation menu to major modules
● Buttons/links for itinerary creation, destination search, and user login ● Responsive web design
for user convenience
4.3 DESTINATION SEARCH MODULE
This module allows users to search for tourist destinations based on the selected state within South
India. It emphasizes hidden gems and lesser-known attractions, ensuring diversity and novelty in travel
[Link] a user selects a state, the system fetches corresponding destinations from the database,
displaying relevant details such as attraction names, highlights, and best travel seasons.
Key Functions:
● Retrieve destinations by state (Karnataka, Tamil Nadu, Kerala, Andhra Pradesh, Telangana)
● Display destination details dynamically
● Filter out mainstream tourist locations and promote underexplored travel spots
4.4 ITINERARY GENERATOR MODULE
The Itinerary Generator is the core of the system. It creates personalized itineraries based on the
user’s selected state and duration of travel. The logic is rule-based — meaning it follows predefined
conditions to assign destinations and travel sequences. The backend, implemented in Java and
JavaScript, processes the inputs, applies the logic, and returns the itinerary to be displayed on the
HTML frontend.
Key Functions:
● Accept state and duration as input
● Apply rule-based logic for itinerary generation
● Output structured daily itineraries
● Handle multiple destinations and travel sequences
4.5 ITINERARY STORAGE & RETRIEVAL MODULE
This module allows users to save their generated itineraries and access them later through their account.
Each saved itinerary is linked to a user ID and stored in the database for personalized
[Link] can revisit their travel plans, make edits, or generate new itineraries without re-
entering all details.
Key Functions:
● Save user-generated itineraries
● Retrieve and display stored itineraries
● Link itineraries to authenticated users
● Support for future expansion (e.g., exporting to PDF)
4.6 DATABASE MANAGEMENT MODULE
This module is responsible for maintaining all persistent data, including user details, destination lists,
and saved itineraries. It uses MySQL for reliable data storage and JDBC for communication between
the Java backend and the [Link] data is organized in tables with proper relational mappings,
ensuring integrity and fast retrieval.
Key Functions:
● Store and retrieve user credentials
● Maintain records of destinations and itineraries
● Ensure secure and efficient data handling
4.7 RESULT
Fig. 4.1 Homepage
Fig. 4.2 Login Page
Fig. 4.3 Register Page
Fig. 4.4 Destination Search Page
Fig. 4.5 Itinerary Generation Output
Fig. 4.6 My Itineraries
Fig.4.7 Information Page
CHAPTER 5
CONCLUSION
The South India Itinerary Planner – Exploring Hidden Gems project successfully demonstrates the
development of a dynamic and user-friendly web-based travel planning system that promotes lesser-
known tourist destinations across South India. By integrating a responsive HTML/CSS frontend with
a robust Java backend and a MySQL/PostgreSQL database, the system provides a comprehensive
solution for generating, saving, and managing personalized itineraries.
The project effectively bridges the gap between conventional travel planners and the need for a
platform that emphasizes sustainable and inclusive tourism. Through intelligent rule-based itinerary
generation and database connectivity, users can explore offbeat destinations in states such as
Karnataka, Tamil Nadu, Kerala, Andhra Pradesh, and Telangana, encouraging them to move beyond
traditional tourist routes.
From a technical perspective, the project highlights key concepts such as frontend–backend integration,
database management, user authentication, and rule-based logic implementation. The modular system
design ensures scalability, allowing for future enhancements such as AI-driven personalized
recommendations, map-based navigation integration, hotel and transport booking modules, and offline
access for remote travel planning.
Beyond its technical achievements, this project contributes to the Sustainable Development Goals
(SDG 8 — Decent Work and Economic Growth) and (SDG 11 — Sustainable Cities and Communities)
by supporting local economies and promoting eco-friendly tourism practices. It provides a platform
that not only enhances user convenience but also encourages cultural appreciation and balanced
regional development.
In conclusion, the South India Itinerary Planner serves as a practical example of how modern web
technologies and database-driven systems can be utilized to promote responsible tourism. It showcases
the power of technology in enhancing travel experiences while preserving the rich cultural and natural
heritage of South India.
REFERENCES
[1] Ministry of Tourism, Government of India. Incredible India: South India Tourism Overview.
Available at:
[Link]
[2] MySQL Documentation. MySQL 8.0 Developer Guide. Available at:
[Link]
[3] Baeldung. JDBC and Java Database Integration Guides.
Available at: [Link]
[4] W3Schools. Web Development Tutorials for HTML, CSS, and Java. Available at:
[Link]
[5] Oracle Corporation. Java Platform Standard Edition Documentation. Available at:
[Link]
[6] GeeksforGeeks. Java JDBC and Database Connectivity Tutorials. Available at:
[Link]
[7] Mozilla Developer Network (MDN). HTML, CSS, and JavaScript Reference. Available at:
[Link]
[8] UNWTO. Sustainable Tourism and Development Goals. Available at:
[Link]
[9] Stack Overflow. Developer Community for Technical Q&A.
Available at:[Link]
[10] Pressman, R. S. (2010). Software Engineering: A Practitioner’s Approach. McGraw-Hill
Education.
[11] Sommerville, I. (2015). Software Engineering (10th ed.). Pearson Education
[12] Fowler, M. (2003). Patterns of Enterprise Application Architecture. Addison-Wesley.
APPENDIX A
CODING
Database Connectivity
package backend;
import [Link];
import [Link];
public class DBConnection {
private static final String URL =
"jdbc:mysql://localhost:3306/south_india_travel";
private static final String USER = "root";
private static final String PASSWORD = "daredevil";
public static Connection getConnection() {
Connection connection = null;
try {
[Link]("[Link]");
connection = [Link](URL, USER, PASSWORD);
} catch (Exception e) {
[Link]();
}
return connection;
}
}
Generate Itinerary
package backend;
import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link].*;
import [Link].*;
import [Link];
import [Link];
import [Link].*;
import [Link].*;
public class GenerateItinerary extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse
response)
throws ServletException, IOException {
HttpSession session = [Link](false);
if (session == null || [Link]("user") == null) {
[Link](HttpServletResponse.SC_UNAUTHORIZED);
return;
}
String state = [Link]("state");
int days = [Link]([Link]("days"));
[Link]("application/json");
PrintWriter out = [Link]();
Gson gson = new Gson();
List<Destination> destinations = new ArrayList<>();
try (Connection con = [Link]()) {
String query = "SELECT * FROM destinations WHERE state = ?";
PreparedStatement ps = [Link](query);
[Link](1, state);
ResultSet rs = [Link]();
while ([Link]()) {
[Link](new Destination(
[Link]("dest_id"),
[Link]("name"),
[Link]("state"),
[Link]("category"),
[Link]("description"),
[Link]("days_required"),
[Link]("rating"),
[Link]("image_url")
));
}
List<Destination> itinerary =
[Link](destinations, days);
[Link]([Link](itinerary));
} catch (Exception e) {
[Link]();
[Link](HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
[Link]("{\"error\": \"Failed to generate itinerary\"}");
}
}
}
User Register
package backend;
import [Link].*;
import [Link].*;
import [Link].*;
import [Link].*;
import [Link].*;
public class RegisterUser extends HttpServlet {
static class Req {
String username;
String password;
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
[Link]("application/json");
PrintWriter out = [Link]();
try (BufferedReader br = [Link]()) {
Req body = new Gson().fromJson(br, [Link]);
if (body == null || [Link] == null || [Link] == null ||
[Link]() || [Link]()) {
[Link](HttpServletResponse.SC_BAD_REQUEST);
[Link]("{\"error\":\"Invalid input\"}");
return;
}
try (Connection con = [Link]()) {
String sql = "INSERT INTO users (username, password) VALUES (?,
?)";
try (PreparedStatement ps = [Link](sql)) {
[Link](1, [Link]());
[Link](2, [Link]());
[Link]();
}
} catch (SQLIntegrityConstraintViolationException dup) {
[Link](HttpServletResponse.SC_CONFLICT);
[Link]("{\"error\":\"Username already exists\"}");
return;
}
[Link](HttpServletResponse.SC_OK);
[Link]("{\"ok\":true}");
} catch (Exception e) {
[Link]();
[Link](HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
[Link]("{\"error\":\"Server error\"}");
}
}
}
Frontend(Login)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Login - South India Itinerary Planner</title>
<link rel="stylesheet" href="styles/[Link]?v=3">
<link
href="[Link]
isplay=swap" rel="stylesheet">
<script>window.API_BASE_URL =
'[Link]
<script defer src="script/[Link]"></script>
</head>
<body class="auth-body">
<div class="login-card">
<div class="login-header">
<h1>Welcome Back 🌿</h1>
<p>Login to plan your next South India adventure</p>
</div>
<form id="loginForm" class="login-form">
<label>
<span>Username</span>
<input type="text" id="username" placeholder="Enter your username"
required />
</label>
<label>
<span>Password</span>
<input type="password" id="password" placeholder="Enter your
password" required />
</label>
<button type="submit" class="btn btn-primary
full-width">Login</button>
<p class="register-link">
Don’t have an account?
<a href="[Link]">Register here</a>
</p>
</form>
<p id="loginMessage" class="form-message"></p>
</div>
</body>
</html>