-
-
brief snippet
About the Project
College students often receive syllabuses, assignments, and exam dates but struggle to convert them into a practical daily study plan. The problem is not only understanding what needs to be studied; it is deciding what to study first, how much time to allocate, and how to recover after missing a task.
As a student balancing academics and limited time, I wanted to build a focused tool that would turn an unstructured syllabus into a clear next action. This led to CampusPilot, an academic-action agent designed around planning and replanning rather than simple chat.
What it does
CampusPilot helps students create and adapt study plans.
The student provides:
Syllabus text.
An upcoming exam date.
The number of hours available for study each day.
CampusPilot then:
Extracts study topics from the syllabus.
Assigns planning priorities.
Generates a day-by-day study plan.
Shows estimated time for each task.
Tracks completed and missed topics.
Creates a revised plan based on the student’s progress.
The key behavior is adaptive replanning. If a student misses a task, CampusPilot does not leave them with an outdated schedule. It uses the updated progress to prioritize unfinished topics and create a new actionable plan.
How I built it CampusPilot was built as a solo project using a Python FastAPI backend and a browser-based frontend.
The frontend uses:
HTML.
CSS.
JavaScript.
The JavaScript fetch API for communicating with the backend.
The backend uses:
Python.
FastAPI.
Uvicorn.
Pydantic models for request and response validation.
The application exposes three main endpoints:
/extract processes syllabus text and returns structured topics.
/plan generates an initial study plan.
/replan creates a revised plan using completed and missed topics.
The internal workflow is separated into three stages: Syllabus input ↓ Topic extraction ↓ Plan generation ↓ Progress update ↓ Adaptive replanning
The current prototype uses structured and deterministic planning logic to keep the demonstration reliable and reproducible. This architecture allows a model-backed extraction and planning layer to be added in a future version without changing the main user workflow.
Challenges I ran into
The biggest challenge was building and connecting the frontend and backend within a limited academic schedule as a solo participant.
Some of the challenges included:
Setting up the Python virtual environment.
Installing and managing the backend dependencies.
Understanding how Uvicorn loads the FastAPI application using main:app.
Resolving module and file-structure issues.
Connecting a frontend running on one local port to a backend running on another port.
Handling CORS during browser-to-backend communication.
Making sure the frontend request fields matched the Pydantic models in the backend.
Designing a replanning workflow that was simple enough to demonstrate but still showed meaningful adaptation.
Time management was also an important constraint. Instead of attempting authentication, databases, PDF processing, and calendar integrations all at once, I focused on one complete workflow that could be tested end to end.
Accomplishments that I'm proud of
Built a working end-to-end prototype as a solo participant. Connected a browser frontend to a Python FastAPI backend. Implemented separate extraction, planning, and replanning stages. Created a workflow that adapts when tasks are completed or missed. Added estimated study duration and priority information to generated tasks. Made the application runnable locally with a simple setup. Focused on a real student problem rather than creating a generic chatbot. Completed the project while continuing regular academic work. The accomplishment I am most proud of is the progress feedback loop: Syllabus → Plan → Student progress → Revised plan
What we all learn from this
This project taught us that building a useful AI product involves more than generating text. The system must connect a real user problem to an actionable workflow.
We learned:
How to structure a FastAPI application.
How to define and validate API requests with Pydantic.
How a frontend communicates with backend endpoints using JSON.
How to use Uvicorn to run a local ASGI application.
How to debug import, port, CORS, and connection problems.
How to design a small but complete MVP.
Why reliable and explainable behavior is important in an agent workflow.
How to use AI-assisted development responsibly for scaffolding, debugging, documentation, and implementation support.
We also learned the importance of being realistic about scope. A smaller workflow that works and can be explained is more valuable than a larger collection of incomplete features.
What's next for CampusPilot
Future versions of CampusPilot could include:
PDF syllabus and assignment uploads.
Retrieval from lecture notes and course materials.
LLM-backed syllabus understanding and personalized planning.
Quiz and flashcard generation.
Persistent user accounts and progress history. Calendar integration. Notifications and reminders. Tamil-English language support. Analytics showing weak topics and study consistency. Personalized replanning based on exam weightage, past performance, and learning speed.
The long-term goal is for CampusPilot to become a practical academic assistant that helps students plan, study, track progress, and recover from setbacks without creating additional complexity.
Log in or sign up for Devpost to join the conversation.