Inspiration
University professors often struggle to identify which students are at risk early in the semester. By the time midterm exams arrive, it’s often too late to provide timely help students who could have succeeded may already be falling behind. At the same time, professors receive fragmented signals: quiz results in one place, assignment scores in another, and attendance records elsewhere. Without a unified view, it’s hard to see patterns and intervene early. We created ClassPulse to act as a real-time heartbeat monitor for the classroom: Just like a pulse tells doctors about a patient’s health, ClassPulse helps professors track the academic pulse of their class. By analyzing quizzes, assignments, and attendance before midterms, ClassPulse highlights students who may need support. For example: In a class of 40 students, a professor might spend hours going through assignments, quizzes, and attendance records. With ClassPulse, this analysis is done automatically — and the professor receives a clear breakdown: 6 students at High Risk 10 students at Medium Risk 24 students at Low Risk
What it does
ClassPulse is designed as a professor-only early warning system that converts raw student data into actionable insights. Professors begin by uploading a CSV file containing quizzes, assignments, attendance, and midterm scores. The platform then handles the heavy lifting in the background performing data cleaning, normalization, and pattern detection before applying a custom risk-classification algorithm. Within seconds, ClassPulse categorizes students into high, medium, or low risk groups and generates individual dashboards for each student. These dashboards allow professors to deep dive into performance breakdowns, identifying whether attendance, quizzes, or assignments are the main issues. Importantly, the data and analysis remain accessible only to professors, ensuring privacy while empowering them to take timely, targeted interventions.
How we built it
We built the UI/UX using react and mui library. backend is the python FAST API, Uvicorn, mysql, celery, Alembic. for the AI driven development we used pandas, numpy, random forest classifier, scikit-learn, Joblib.We built this project using a modern, decoupled full-stack architecture to ensure scalability and a seamless user experience. The frontend is a dynamic single-page application developed with React and the MUI component library, providing a polished and responsive user interface with data visualizations powered by Chart.js. The backend is a high-performance asynchronous API built with Python and FastAPI, which handles data ingestion and exposes processed insights. To prevent the user from waiting, all heavy-lifting—such as parsing uploaded CSV files and running our AI risk-assessment models—is offloaded to a Celery task queue managed by Redis. This allows for immediate user feedback while the data is processed in the background and stored in a robust MySQL database, making the entire system efficient, powerful, and ready for real-world application. Our solution is engineered with a decoupled, service-oriented architecture to separate concerns and maximize performance.On the frontend, we developed a responsive and interactive dashboard using React. We leveraged the MUI component library to rapidly build a professional, themeable user interface that mirrors familiar educational platforms. For data visualization, we integrated Chart.js to render clear and dynamic performance charts for individual students.The backend is a high-performance, asynchronous API built on Python with the FastAPI framework. It serves as the central hub for data management and logic, using SQLAlchemy as an ORM to communicate with our MySQL database and Pydantic for robust data validation. The core of our system's efficiency lies in its asynchronous task processing. To ensure the user interface remains fast and responsive, we integrated Celery with a Redis message broker. When a professor uploads a large CSV file, the API immediately accepts it and delegates the time-consuming parsing and AI analysis to a background Celery worker. This worker processes the data, calculates risk scores, and populates the database without ever blocking the user, creating a truly seamless experience.
Challenges we ran into
Ideation was a challenge to produce whil learning FAST API and using it for the first time Used AI concepts to predict the risk level of the students based on the quiz, assignments and midterm. like bridging the python model with the proffessor dashboard in a web browser, and missing values like if a student misses a test or the assignment. The assignment of risk on based with the overall performance score which was difficult to determine as each course has different distribution of score percentage.
Accomplishments that we're proud of
Smart Feature Engineering: Instead of relying on raw scores, we engineered a custom metric, the Overall Performance Score. This score gave Quizzes a high weighting (x2) and the Midterm a lower weighting (x0.5), injecting expert logic that prioritizes consistent engagement over high-stakes exams. This created the clean, labeled data (Green, Yellow, Red) the AI needed to learn. Predictive Core: We trained a Random Forest Classifier (Scikit-learn) to reliably predict the student's risk level based on the weighted performance score. This "AI brain" was saved using Joblib for fast deployment. Actionable Backend: We created a high-performance FastAPI server that runs the prediction model. When a professor uploads a new CSV file, the work is immediately passed to a Celery background worker. This worker not only runs the AI but also performs a Root Cause Analysis on the student's data, identifying their single weakest area (e.g., "Assignments") to generate a personalized Intervention Suggestion.
What we learned
The core lesson learned in building the ClassPulse AI Agent was that project success hinges on smart feature engineering and robust architectural integration, not algorithm complexity. We realized the AI's predictive power came from creating a custom metric, the Overall Performance Score, which strategically assigns quizzes a higher weight (x2) than assignments or midterms, explicitly teaching the Random Forest Classifier what student engagement looks like. Architecturally, we learned the necessity of bridging the Python AI core with the web frontend using a high-performance FastAPI server and Celery background workers; this setup prevents the dashboard from freezing during processing and enables dynamic, real-time prediction. Finally, we learned that operational hurdles—like configuring Alembic and SQLAlchemy to properly connect to a secured MySQL database—are often the most challenging aspects, confirming that robust security and server management are critical prerequisites for deploying any AI-powered web service.
What's next for ClassPulse
1)Real-time Data Integration Connect with LMS platforms (e.g., Canvas, Blackboard, Moodle) and gradebooks to fetch attendance, assignments, and quiz scores automatically instead of manual CSV uploads. 2)Advanced AI Models 3)Move beyond Random Forest to deep learning (e.g., LSTMs, Transformers) for time-series prediction of student performance trends. 4)Incorporate explainable AI (XAI) for more transparent insights into why a student is flagged as at-risk.
Log in or sign up for Devpost to join the conversation.