Project Info

graider

This project did not submit a demo video on Devpost.

Inspiration

We realized that grading papers is time-consuming and repetitive, often lacking meaningful feedback for students. This inspired us to create a solution that automates grading and enhances student feedback.

What it does

Graider grades essays, assignments, and exams based on a provided rubric or one generated from the exam sheet. It also includes a feedback section for both students and graders, making the process more efficient and insightful.

How we built it

We built the platform entirely using Python, leveraging Reflex to develop both the frontend and backend seamlessly. We also utilized the Groq LLM library to handle the complexities of grading papers accurately and efficiently

Challenges we ran into

Working with Reflex, a new technology, was challenging. As we adapted to it, we faced a steep learning curve in scaling our project quickly using only our knowledge of Python.

Accomplishments we're proud of

We’re proud of building an entire system using Python (thanks to Reflex). Additionally, we explored new tools provided by our sponsors—VAPI, Groq, and Fetch AI—which helped us enhance the project by integrating advanced AI capabilities.

What we learned

We gained a deep understanding of Reflex and how to build frontend applications entirely in Python. We also explored different LLM models, refining our approach to achieve optimal latency rates suitable for the project’s needs.

What's next

We plan to add a chatbot feature that allows graders to adjust student grades via voice commands. Additionally, we aim to incorporate image scanning to grade handwritten papers automatically. Our goal is to scale Graider to educational institutions across the country.

Graider

Graider helps teachers turn assignments into structured questions, prepare reference answers and rubrics, grade student submissions, and review the results before exporting them.

Live demo · Docker image · Documentation

The demo runs on a sleeping free service; the first visit can be slow. Use sample student data.

Features

Create assignments from text, TXT files or PDFs, with editable questions and mark allocations.
Generate reference answers and rubrics with AI, or write them manually.
Import submissions individually, from files or through CSV.
Grade with AI against the saved reference answer and every rubric criterion; review and edit criterion scores and feedback with calculated totals.
Run AI actions in persistent background jobs, with progress, cancellation, controlled retries and recovery after restart.
Publish each student's complete result independently while other students continue grading.
Sign in with passwords or Google, explicitly connect accounts, and manage profile and credentials.
Keep uploads private and enforce teacher access, upload limits and AI usage quotas.
Explore the automatically generated API through Swagger UI at /api/docs/.

Engineering results

A production 10-student × 10-question grading run finished in 1 minute 54 seconds, including answer mapping and 110 real OpenAI calls, on Render's 0.1-CPU / 512-MB Free service; sampled peak memory was 313.8 MiB.
Container restart preserved 100 question results, 200 criterion breakdowns and 110 successful usage records, without repeating provider calls.
Process-death and connection-loss checks cover checkpoint recovery, atomic publication, concurrent workers and uncertain billing.
GitHub Actions verifies the repository, publishes Docker images for Intel/AMD and Apple Silicon, and triggers Render with the passing commit image.

The production benchmark uses short synthetic arithmetic answers, real GPT-6 Luna and Neon PostgreSQL; setup and startup are outside its timer. Local concurrency and process-failure experiments use simulated calls. See benchmarks and their limits.

Tech stack

Layer	Technology
Frontend	React, TypeScript, Vite, Tailwind CSS
Backend	Django, Django REST Framework, Gunicorn, WhiteNoise
Identity and API docs	django-allauth, Google OIDC, drf-spectacular
Persistence	Neon PostgreSQL and private S3-compatible Object Storage; SQLite/local files for development
AI	OpenAI SDK, task-specific model and reasoning configuration
Delivery	Docker, Docker Hub, GitHub Actions, Render

Documentation

Page	Contents
Architecture	System and data diagrams, component boundaries, security and design decisions
Grading workflow	Assignment preparation, answer mapping, criterion scoring, concurrency, recovery and teacher review
Benchmarks	Current and historical grading timings, test conditions, recovery evidence and reproduction
Setup and deployment	Docker quickstart, source development, environment settings, accounts, Render and maintenance
Issues and roadmap	Unresolved limitations, upcoming features and proposed improvements
Production grading report	Real-provider timings, resource samples, usage and restart evidence
Raw grading benchmarks	Concurrency experiments, isolated grading measurements and runtime image ID
Earlier capacity report	Historical full-workflow, startup and restart measurements

These pages describe this checkout; the deployed demo and published latest image may lag it.

Start with the Docker quickstart to use the app, or source development to change it.

Analysis

Compare with all teams

View

Metric

No commits on this project resolved to a GitHub account.

Technology

Found in codeClaimed only

CSSIn code
DjangoIn code
HTMLIn code
JavaScriptIn code
OpenAIIn code
PythonIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
Google GeminiClaimed

9 of 10 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

313 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Feature verification

8 Verified6 Claimed only

Add student submissions manually or by CSVVerified
Add student submissions manually or by CSV
Claimed on readmehigh confidence
- backend/apps/grading/views.py:309 — SubmissionListCreateView handles manual/file submission creation
- backend/apps/grading/services/submission_io.py:15 — import_submissions_from_csv parses CSV rows into StudentSubmission objects, matching the documented CSV format
AI grading pass on submissionsVerified
Run an AI grading pass
Claimed on readmehigh confidence
- backend/apps/grading/views.py:378 — SubmissionGradeView and AssignmentGradeAllView call run_grading_pipeline
- backend/apps/grading/services/grading_pipeline.py:10 — Grading pipeline uses OpenAI models (gpt-5.4-mini) to map answers and produce scores/feedback
AI-generated questions, reference answers, and rubric from an LLMVerified
Generate questions, reference answers, and rubric criteria with an OpenAI LLM (or Groq per Devpost)
Claimed on readmehigh confidence
- backend/apps/assignments/views.py:107 — QuestionGenerateView calls generate_question_parts and persists QuestionPart rows
- backend/apps/grading/views.py:163 — ReferenceAnswerGenerateView and RubricGenerateView call generate_reference_answer/generate_rubric_criteria
- backend/apps/grading/services/openai_client.py:29 — OpenAIChatService wraps openai.OpenAI client.chat.completions.parse for structured generation
Create assignment from pasted text, .txt, or .pdfVerified
Create an assignment from pasted text, .txt, or .pdf
Claimed on readmehigh confidence
- backend/apps/assignments/services.py:75 — extract_text_from_uploaded_file handles .txt and .pdf extraction (via pypdf) with normalization
- backend/apps/assignments/models.py:32 — Assignment model stores raw_assignment_text and source_file
Finalize results and export CSVVerified
Finalize results and export a CSV
Claimed on readmehigh confidence
- backend/apps/grading/views.py:441 — SubmissionFinalizeView and AssignmentExportCsvView implement finalize and export endpoints
- backend/apps/grading/services/submission_io.py:65 — build_assignment_results_csv_response writes a CSV with per-question scores/feedback, matching the documented export endpoint GET /api/assignments/:id/export.csv
Review and edit scores and feedback (personalized feedback for students and graders)Verified
Review and edit scores and feedback; includes a feedback section for both students and graders
Claimed on readmehigh confidence
- backend/apps/grading/views.py:428 — GradingResultDetailView.patch lets a teacher override ai_score/ai_feedback via save_grading_review
- backend/apps/grading/models.py:150 — GradingResult stores separate ai_feedback and final_feedback fields, and needs_review flag
- frontend/src/pages/SubmissionReviewPage.tsx — Dedicated review page exists for editing grading results
Rubric-based or auto-generated-from-exam-sheet gradingVerified
Grades essays, assignments, and exams based on a provided rubric or one generated from the exam sheet
Claimed on Devposthigh confidence
- backend/apps/grading/views.py:214 — RubricListCreateView allows manual rubric criteria; RubricGenerateView auto-generates rubric criteria from the reference answer/question
Teacher registration and loginVerified
Register and sign in as a teacher
Claimed on readmehigh confidence
- backend/apps/accounts/views.py:11 — RegisterView and LoginView implement session-based registration and login, wired to serializers
- frontend/src/pages/LoginPage.tsx — Frontend login page exists and calls the auth API
Built with Groq LLM libraryClaimed only
Utilized the Groq LLM library to handle grading
Claimed on Devposthigh confidence
Built with Reflex frameworkClaimed only
Built the platform entirely using Python, leveraging Reflex for frontend and backend
Claimed on Devposthigh confidence
Fetch AI integrationClaimed only
Explored Fetch AI to enhance the project with advanced AI capabilities
Claimed on Devposthigh confidence
Handwritten paper image scanningClaimed only
Aim to incorporate image scanning to grade handwritten papers automatically
Claimed on Devposthigh confidence
VAPI voice integrationClaimed only
Explored VAPI to enhance the project with advanced AI capabilities
Claimed on Devposthigh confidence
Voice-command chatbot for adjusting gradesClaimed only
Plan to add a chatbot feature that allows graders to adjust student grades via voice commands
Claimed on Devposthigh confidence

An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.