QUESTORIAA

Inspiration

Students often have plenty of learning material but very little guidance on how to study it effectively. Notes, textbooks, presentations, and PDFs contain the information, but they do not tell a learner what concepts they have mastered, what they are struggling with, what they should revise next, or how different topics depend on each other.

We wanted to build something that goes beyond simply chatting with an AI or summarizing a document.

That idea became Questoriaa — an adaptive learning platform that converts course material into an interactive learning journey where every learner can follow a personalized path, test their understanding, improve weak concepts, and receive explanations grounded in their own study material.

What it does

Questoriaa allows a learner to upload course material such as PDFs and presentation files and automatically converts that material into a structured learning experience.

The platform:

extracts and organizes educational content into chapters, topics, and concepts
identifies relationships and prerequisites between concepts
creates an interactive visual course map
generates adaptive assessments based on the learner’s current concept and mastery level
supports multiple challenge formats including MCQs, short answers, numerical questions, matching, and sequence-based questions
evaluates answers and provides feedback and misconception guidance
tracks concept mastery over time using a learner model
recommends whether the learner should continue, review, remediate, or advance
awards XP and progression through a gamified learning system
provides an AI tutor that retrieves relevant course material before answering
shows source references so learners can trace explanations back to their uploaded material

Instead of giving every student the same sequence of questions, Questoriaa adapts the learning path according to each learner’s performance.

How we built it

Questoriaa uses a modular architecture with a Next.js and React frontend connected to a FastAPI backend.

The frontend is built using Next.js, React, TypeScript, and Tailwind CSS. Clerk is used for the user-facing authentication flow, while the application interface contains the dashboard, course library, learning map, adaptive quests, mastery tracking, and AI tutor.

The backend is written in Python using FastAPI, Pydantic, SQLAlchemy, and Alembic.

Uploaded PDF and PowerPoint material is processed into source-aware chunks while preserving references such as page or slide information. The extracted knowledge is organized into a hierarchy of courses, chapters, topics, concepts, and prerequisite relationships.

For semantic retrieval, Questoriaa uses Qwen3-Embedding-0.6B to generate 1024-dimensional embeddings. These embeddings are stored and searched using PostgreSQL with pgvector on Neon.

For generation and reasoning, we use the open-weight Qwen2.5 7B model through an OpenAI-compatible Ollama endpoint. Retrieval is performed before tutor and assessment generation so that answers remain grounded in the learner’s uploaded course material.

The adaptive learning engine is implemented separately from the generative model. AI generates questions, explanations, and interpretations, while deterministic application code controls grading, mastery updates, progression, XP, and learner state.

We use a Bayesian Knowledge Tracing-inspired mastery model to update a learner’s probability of mastering each concept after assessments.

Background processing is handled by a persistent processing-job system and worker so document analysis can run asynchronously without blocking the web application.

The complete application is deployed using Railway, with Neon PostgreSQL providing the persistent database and a Railway volume storing uploaded course files.

Challenges we ran into

One of the biggest challenges was integrating AI-generated content with deterministic learning behavior.

It would have been easy to let the language model decide everything, including whether an answer was correct or how much progress a learner should receive. Instead, we designed Questoriaa so that AI is responsible for content generation and interpretation while application code owns state, grading rules, mastery updates, and game progression.

Another challenge was preserving source grounding. Generated explanations are useful only if learners can trust them, so we built a retrieval pipeline that associates generated answers and assessments with the original document chunks and their source references.

We also had to coordinate document processing, embeddings, background jobs, adaptive assessments, the frontend, the database, and model inference as one integrated system.

Deployment introduced another challenge because our AI models run through an external GPU-backed Ollama endpoint while the application itself is hosted on Railway. We added timeout handling and graceful failure states so temporary inference unavailability does not corrupt learner data or leave processing jobs stuck indefinitely.

Accomplishments that we’re proud of

We are especially proud that Questoriaa is not just an interface placed on top of a chatbot.

We built a complete learning pipeline:

course material → document processing → knowledge structure → embeddings → retrieval → adaptive assessment → mastery update → progression → grounded AI tutoring

The platform supports five assessment modes and maintains learner mastery and game progression independently of the language model.

Our tutor can retrieve source material and return references alongside its explanation rather than responding only from general model knowledge.

We also created a persistent processing workflow, vector retrieval system, course map, mastery system, adaptive quest engine, and gamified progression system that all share the same backend state.

Reliability was also an important focus. The backend currently passes 184 automated tests, along with frontend linting, production builds, integration tests, and static code checks.

During retrieval evaluation, our knowledge pipeline achieved full retrieval within the top three to five results on our evaluation sets, helping us validate that relevant source context was consistently being surfaced.

Finally, we successfully deployed the complete web application and backend as an integrated cloud prototype.

What we learned

The biggest lesson we learned was that building an AI product is very different from simply calling a language model.

A useful adaptive learning system needs reliable data models, source tracking, retrieval, deterministic application logic, error handling, learner-state management, and evaluation in addition to generative AI.

We also learned the importance of separating responsibilities between AI and traditional software.

Language models are excellent at generating questions, interpreting natural-language answers, and explaining difficult concepts. However, deterministic code is much better suited for maintaining user state, grading structured questions, calculating mastery, preventing duplicate attempts, and controlling progression.

Working on Questoriaa also gave us practical experience with vector databases, retrieval-augmented generation, open-weight language models, asynchronous processing, cloud deployment, frontend-backend integration, and building AI systems as a team.

What’s next for Questoriaa

Our next goal is to make Questoriaa capable of understanding even richer learning material.

We plan to add support for diagrams, images, lecture videos, audio, and OCR so that visual and spoken information can become part of the same adaptive knowledge graph.

We also want to improve the learner model using longer-term learning history, spaced repetition, forgetting curves, revision scheduling, and more detailed misconception tracking.

Future versions could generate personalized study plans based on deadlines, available study time, concept mastery, and prerequisite relationships.

We also plan to move model inference to a persistent production GPU infrastructure, expand multilingual tutoring, improve educator analytics, and allow instructors to create shared adaptive courses for entire classrooms.

Ultimately, our goal for Questoriaa is to turn static educational content into a continuously adapting learning experience that understands not only what a student is studying, but what that individual student should learn next.