Inspiration
Every student learns at a different pace, but most classrooms and most edtech tools are built like they don't. We've watched students get left behind not because they aren't capable, but because nobody caught the exact moment they started struggling. At the same time, teachers are stretched too thin to give each student that kind of individual attention. We wanted to build something that could sit between the two: an AI that actually pays attention to how a student learns, adapts to them, and gives teachers the visibility they need to step in before a student falls behind not after.
That's how DROP was born: an AI-powered learning companion that never stops teaching, and never stops adapting.
What it does
DROP tracks how each student actually performs where they get quiz questions wrong, which lessons they rush through, which topics they keep avoiding and adjusts in real time. Instead of a one-size-fits-all curriculum, every student gets a personal AI tutor that meets them where they are.
- Adaptive quizzes and an AI tutor that respond to each student's pace and weak spots
- Progress tracking and revision tools that give students an honest picture of what's working
- Auto-graded assignments that turn feedback into forward motion instead of just a score
- Classroom analytics for teachers so they can see exactly which students need help before it becomes a bigger problem
The goal isn't just to digitize a classroom it's to create a genuine feedback loop between student, AI, and teacher, where every quiz and every question a student asks makes the learning path a little smarter.
How we built it
DROP is built as a single-file Flask application (by design, to keep the project easy to reason about and deploy), with:
-Flask + Flask-Login for the core app and auth -HTML, CSS, and JavaScript for a fully web-based, responsive frontend -SQLAlchemy + PostgreSQL for data classrooms, students, assignments, quizzes, progress
- Groq API powering the AI tutor, adaptive quizzes, and auto-grading
- Deployed on Render
We chose Groq for speed and because it let us iterate on the AI-tutor and auto-grading logic without worrying about cost while building on a tight budget.
Challenges we ran into
The biggest challenges weren't in the app logic they were in the constraints of building this as a self-funded project:
- Groq's model quality and token limits. Groq is fast and cheap, which made it possible to build DROP in the first place, but it isn't a substitute for a frontier model. It has a tighter minimum token input than we'd like, and its reasoning quality falls short of models like Claude, GPT, or Gemini especially for nuanced tasks like grading open-ended answers or generating genuinely adaptive lesson content. Right now DROP proves the concept works; with funding to move to a stronger model, the tutor and grading engine could get meaningfully smarter.
- Render's free tier. The app runs on Render's free instance, which spins down after inactivity. That means the first request after idle time is slow not the experience we want a student or teacher to have. A paid tier would fix this instantly.
- Database headroom. The free-tier Postgres database is enough to prove DROP works, but it isn't built for real classroom-scale data years of quiz history, assignment submissions, and analytics per student. Scaling this to real schools means investing in proper database infrastructure.
None of these are architecture problems they're funding problems. The system is designed to scale; it just needs the resources to do it.
Accomplishments that we're proud of
- Building a working, end-to-end adaptive learning loop quizzes, tutor, grading, and analytics all feeding into one another as a lean, self-funded project
- Getting an AI tutor and auto-grading system live and usable despite the real constraints of a free-tier AI API and free-tier hosting
- Designing DROP so teachers get real, actionable visibility into student performance, not just another dashboard
- Proving that the core idea an AI that adapts to how a student learns, not just what they got wrong actually works in practice
What we learned
Building DROP taught us a lot about the gap between "AI that answers questions" and "AI that actually teaches." A chatbot bolted onto a classroom doesn't move the needle what matters is the feedback loop: capturing signal from every quiz and lesson, feeding it back into what the student sees next, and giving teachers visibility into the whole picture. We also learned a lot about working within real infrastructure constraints building something that behaves well even on a free-tier API and a free-tier host, while keeping an eye on what it could become with real resources behind it.
What's next for Drop
The potential impact here is bigger than one classroom. Machine learning and adaptive AI can genuinely change how students learn not by replacing teachers, but by giving every student the kind of individual attention a great tutor gives, at a scale no single teacher could manage alone. For teachers, it means finally being able to see, clearly, who needs help and when instead of finding out at exam time.
With funding, the next steps are clear:
- Upgrade the AI engine from Groq to a frontier model (Claude, GPT, or Gemini) for sharper grading, richer adaptive content, and better tutoring conversations.
- Move off Render's free tier so the app is always instantly available no cold starts, no waiting.
- Invest in a production-grade database built to hold real classroom-scale history and power deeper analytics for teachers.
DROP already proves the idea works. The next stage is giving it the resources to reach every student who needs it.
