How EduGenius's AI Grading Feature Drafts Feedback — But Not From the Grading Inbox
EduGenius's Submissions page is a real grading inbox: a teacher pastes in a student's answer or bulk-uploads .txt files, runs AI grading against Gemini, and gets back a first-pass score and a few sentences of written feedback per student — genuinely useful grunt-work automation, not a mockup. It's a paid-plan feature, rate-limited, and the draft it produces is visible to the teacher the moment grading finishes.
What that page cannot do is send the draft on to the student. Not because publishing doesn't exist in EduGenius — it does, and it's wired to a real backend endpoint — but because the control for it isn't on the Submissions page at all. It lives on a separate teacher surface, reachable from a different item in the main navigation.
Quick Answer: On
/submissions, a teacher pastes a response or bulk-uploads up to 10.txtfiles per batch, then runs AI grading — a paid-plan-gated call (403PAID_PLAN_REQUIREDon a free plan) to Geminigemini-3.1-flash-lite, rate-limited to 5 requests a minute, that drafts a 0–100 score and 2–5 sentences of feedback per submission. That draft shows up in a read-only "AI feedback" panel on the same page, alongside real stats (average score, on-time %) and a wrong-answer cluster list. The Submissions page itself has no publish control — verified directly inapp/submissions/page.js, where the only per-row actions are Rename and Delete. Publishing to the student is real, but it's a separate action on a separate page, the Assignments workspace at/assignments/[id], confirmed incomponents/assignments/AssignmentWorkspace.jsand the backend lifecycle inlib/feedback-server.js.
This piece walks through what the grading inbox actually does end to end — intake, the AI call itself, what a teacher sees back, the reporting layer on top of it — and then states plainly, with the code cited, exactly where the publish step lives instead and why that split matters in practice. It's a mechanics piece about one specific feature, not a workflow tutorial on writing quizzes; how a quiz becomes a gradable assignment in the first place is its own, separate story.
What the Submissions Inbox Actually Is
Submissions is the page where student work a teacher already has — pasted from an email, copied out of a paper packet, exported from another tool — gets into EduGenius so it can be scored and read alongside everything a class turns in through an assignment link.
Two Real Intake Paths, Not One
A teacher can add a response two ways, and both are live, working paths rather than a UI sketch:
- Manual paste — an "Add submission" form takes a student name, an optional roll number or ID, and a pasted free-response answer, then submits it through the same public endpoint an assignment link uses.
- Bulk
.txtupload — up to 10.txtfiles at once, each file's name becoming the student's name and its contents becoming the response, capped at 20,000 characters per file.
The page states its own current limit directly in the UI, next to the upload button: "Up to 10 .txt files at once. PDF, Word and image uploads arrive in a later pass." That's a real, honestly stated constraint today, not a hidden one a teacher discovers by trial and error.
Every Assignment Gets Its Own Expandable Row
The page lists every assignment a teacher owns as a collapsible row — title, submission count, average score, open-or-closed status. Opening a row loads that assignment's full report inline: stats, the ingestion toolbar, and a table of every submission received so far, each one carrying a status of unread or read.
Where This Data Actually Lives
Every submission, whether it arrived by link, QR code, paste, or upload, lands in the same Firestore location: users/{uid}/assignments/{assignmentId}/submissions/{submissionId}. Manual and bulk intake aren't a side channel — they write through the identical public submission endpoint a student uses, just triggered by the teacher instead.
Running AI Grading: The Real Mechanics
Once submissions exist, a "Generate Feedback" button in the toolbar triggers grading for everything ungraded in that assignment — or the app runs it automatically right after a manual add or bulk upload finishes, for a teacher who's entitled to use it.
The Model, the Prompt, and the Output Shape
Each ungraded submission gets one call to Gemini, model gemini-3.1-flash-lite, with a system prompt instructing it to grade strictly against the assignment's own details, the teacher's grading instruction, and an attached rubric when one exists. The response comes back as a single JSON object:
| Field | Constraint |
|---|---|
score | Integer, clamped 0–100 |
feedback | 2–5 sentences, addressed directly to the student |
Requests run with a low temperature (0.2) for consistent grading rather than creative variation, and the server defensively parses the model's output — falling back to extracting the first balanced JSON object from raw text if the strict parser fails — so a slightly malformed response still usually resolves to a usable score and comment instead of silently failing.
Batching and Concurrency
A single grading call handles up to 20 submissions, processed through a small worker pool of 4 concurrent requests rather than one at a time — fast enough for a full class, gentle enough not to hammer the API on a large batch. Grading a class of 20 short-answer responses, for instance, is one click and one request, not twenty.
The Paid-Plan Gate Is Real and Server-Enforced
AI grading checks a teacher's subscription plan on the server before it does anything else. A free-plan account gets back a 403 with the error PAID_PLAN_REQUIRED — not a UI suggestion that a determined user could route around, an actual gate checked against the plan ID stored on the user's account. The Submissions page surfaces this as a plain locked notice: "AI grading is part of paid plans," linking to the pricing page.
The Rate Limit Is Also Real
Grading requests are capped at 5 per minute, per teacher, regardless of plan tier. Hit the limit and the server responds with a 429 and a plain message asking the teacher to wait a minute before trying again — a real, checkable constraint, not a soft suggestion.
Two gates, two different jobs: the plan check decides whether a teacher can use AI grading at all; the rate limit decides how fast they can fire requests once they're allowed to. Both are enforced in the same route, independently of each other.
What a Teacher Actually Sees Back
Once grading finishes, the results land in two places on the same page: on the individual submission, and in the assignment's aggregate stats.
A Read-Only Feedback Panel, Per Submission
Each graded submission gets an expandable "AI feedback" panel — an ordinary <details>/<summary> disclosure — showing the drafted score as a small badge and the written comment underneath. It's read-only on this page: there's no edit box, no approve button, and, as the next section covers, no publish button either. A teacher opens it, reads it, and that's the extent of what the page lets them do with it directly.
The Stats and Wrong-Answer Cluster Layer
Above the submission list, four figures summarize the whole assignment: total submissions, average score, on-time percentage, and average time spent. Underneath, a "Where the class struggled" panel lists any objective questions with wrong answers, ranked by how many students missed each one.
- Computed server-side from every submission's
scoreDetail.perQuestionarray - Ranked from most-missed down, capped at the 10 worst questions
- Useful specifically for spotting a shared misconception across dozens of responses, not just one student's grade
Managing the List: Rename and Delete
Two real actions sit behind a per-row menu: Rename, for fixing a typo or a mismatched name from a bulk upload, and Delete, which permanently removes a submission and adjusts the assignment's stats to match. A lightweight duplicate check also flags rows sharing a normalized name so a teacher can catch an accidental double-paste before it skews the average.
Confirmed directly in
app/api/assignments/[assignmentId]/report/route.js: the POST handler on this route accepts exactly three actions —read,delete,rename— nothing else.publishis not one of them.
The Honest Limitation: Drafted, Read, and Stuck on This One Page
Here's the part worth stating precisely, because the app's own backend already anticipated it and built around it — this isn't an oversight so much as a feature that's half-connected.
The Backend Already Has a Full Publish Lifecycle
lib/feedback-server.js defines a genuine four-stage lifecycle for a submission's feedback — ai_drafted → teacher_edited → approved → published — with a server function, applyTeacherFeedback, that handles edit, setScore, approve, and publish as real actions against a real API route: POST /api/assignments/[assignmentId]/submissions/[subId]/feedback. A score is never visible to the student until the publish action runs.
But the Submissions Page Never Calls It
A repository search for every place that calls that feedback route, or shows a UI element labeled "publish" in connection with submissions, turns up exactly one component: components/assignments/AssignmentWorkspace.js. The Submissions grading inbox (app/submissions/page.js) is not among them — its only submission-level actions are the rename and delete calls described above, both hitting the report route, not the feedback route.
In practice: a teacher who does all their intake and AI grading from the Submissions inbox — pastes responses, uploads
.txtfiles, clicks Generate Feedback, reads the drafted comment — never sees a button that sends any of it to the student. Not because the button was never built. Because it wasn't built here.
Where Publish Actually Lives
The real publish control sits inside a separate teacher surface: the Assignments workspace, opened either at /assignments/[id] directly or by clicking into an assignment card from the /assignments list — a page reachable from the "Assignments" item in the main navigation, distinct from "Submissions." Its Feedback tab states its own mechanism plainly, in the app's own copy:
"AI drafts feedback into a single record. Edit, then publish — the learner sees the score and message only after you publish."
A row-level Publish button there calls the real feedback route with action: "publish". It is not demo-gated — for a real, non-demo assignment, clicking it flips the submission's feedback.status to "published" in Firestore. From that point, the score and comment are picked up by GET /api/learner/submissions, which returns a student's own submissions with only published feedback (lib/feedback-server.js's toLearnerFeedback returns null for anything not yet published), and rendered on the student's Results page by components/learner/TeacherFeedback.js. The loop genuinely closes — once a teacher uses the right page to close it.
A Second, Narrower Wrinkle Inside That Same Workspace
There's one more honest detail worth naming, because it sits right next to the real Publish button and is easy to mistake for an extension of it. Clicking a student's name inside the Assignments workspace opens a richer per-question review drawer — individual notes, emoji tags, an "accept AI suggestion" action, a message composer, and its own "Publish sheet" button.
None of those actions call the server. Every one of them — the per-question note, the AI-suggestion accept, the message, and that drawer's own Publish button — only ever updates local component state in components/assignments/AssignmentWorkspace.js, for a real assignment exactly as much as for a demo one. Reload the page and the notes are gone; nothing was ever written to Firestore.
| Control | Where it lives | Does it reach the server on a real assignment? |
|---|---|---|
| Rename / Delete a submission | Submissions inbox (/submissions) | Yes — report route |
| Run AI grading | Submissions inbox and Assignments workspace | Yes — grade route |
| Read the AI draft | Submissions inbox (read-only panel) | N/A — display only |
| Row-level Publish (score + comment) | Assignments workspace, AI Review / Feedback tabs | Yes — feedback route, action: "publish" |
| Per-question notes, AI-suggestion accept, "Publish sheet" | Assignments workspace, per-question review drawer | No — local state only, on any assignment |
So the accurate shape of the gap is narrower than "AI grading has no way to reach the student." It's this: the page where a teacher actually does the grading has no publish control at all, the page that does have one is a different surface with different navigation, and one more control sitting inside that second surface — the one that looks the most polished — doesn't persist anywhere yet either.
Why the Delivery Step, Specifically, Is the Part That Matters
None of this is EduGenius-specific, but it's the reason a drafted score sitting unread by the student isn't really "feedback" yet in the sense the education research means.
Feedback's Effect Depends on It Actually Being Received
In their widely cited review of the classroom-feedback literature, Hattie and Timperley (2007) found feedback among the more powerful single influences on achievement of anything they examined — but built that finding entirely on feedback that reached a student and was acted on, not on feedback that existed only as a draft in a teacher's own view of it.
Formative Assessment Requires the Loop to Close
Black and Wiliam's foundational review reached a related conclusion from a different angle: assessment produces measurable gains specifically when the information "comes back" to the student and gets used to adjust what happens next — a score sitting in a teacher's inbox, ungraded of delivery, doesn't function as formative assessment no matter how accurate the score is (Black & Wiliam, 1998).
A drafted AI comment a teacher has read is real work saved. It isn't yet feedback in the sense either body of research is describing — that step only starts once a student sees it.
Pro Tips
- If you graded from Submissions, finish the job in Assignments. The draft you read on the grading inbox page won't reach the student on its own — open the same assignment from
/assignmentsand use the Feedback tab's Publish button to actually send it. - Treat the per-question review drawer as a note-taking scratchpad, not a saved record. Its notes, emoji tags, and "Publish sheet" button don't persist anywhere yet — write anything you want to keep somewhere durable instead, at least for now.
- Use the wrong-answer cluster list before rereading every submission individually. It's computed from the same data as the per-submission scores and tells you exactly which question tripped up the group, in one glance.
- Rename bulk-uploaded files before they land in the inbox. Since a
.txtfile's name becomes the student's name automatically, a clear filename convention saves a round of manual renaming afterward. - Pair AI grading with a rubric attached in the Assignments workspace — the model grades against it directly when one's attached, which narrows how much a draft score needs adjusting before you publish it.
What to Avoid
- Don't assume reading the AI draft is the same as the student having seen it. The read-only panel on the Submissions page is exactly that — read-only — with no path from there to the student's Results page.
- Don't expect a free plan to run AI grading at all. It's a real, server-checked gate; a free-plan attempt returns
PAID_PLAN_REQUIRED, not a soft warning that can be clicked through. - Don't fire off more than 5 grading requests a minute expecting them all to succeed. The limit is enforced server-side with a 429 response, not a client-side courtesy.
- Don't rely on the per-question review drawer's notes surviving a page reload. They're local component state only, on a real assignment exactly as much as a demo one.
- Don't upload anything other than
.txtfiles expecting the bulk uploader to handle it. PDF, Word, and image uploads are explicitly stated as not yet supported, right in the upload toolbar's own helper text. - Don't hunt for a publish button on the Submissions page. It isn't there by design of the current build — the control you want is one page over, in the Assignments workspace.
Key Takeaways
- The Submissions inbox is a real, working grading tool: manual paste and bulk
.txtupload (up to 10 files at once) both feed into the same Firestore path a live assignment link uses. - AI grading is genuinely useful automation, not a stub: one Gemini
gemini-3.1-flash-litecall per submission drafts a 0–100 score and 2–5 sentences of feedback, batched up to 20 at a time. - Two real, server-enforced gates apply: a paid-plan check (
PAID_PLAN_REQUIREDon a free plan) and a 5-requests-per-minute rate limit, independent of each other. - The drafted feedback is visible to the teacher immediately, in a read-only expandable panel, alongside real average-score, on-time, and wrong-answer-cluster stats.
- The Submissions page itself has no publish control — verified directly in the route code, where its only submission-level actions are rename and delete.
- Publishing is real, but it's a different page's job: the Assignments workspace (
/assignments/[id]) has a working Publish button that writes to the same backend lifecycle and genuinely reaches the student's Results page once used. - A closely related control inside that same workspace — the per-question review drawer's "Publish sheet" — doesn't persist anywhere yet, on a real assignment or a demo one, which is worth knowing before relying on it.
Frequently Asked Questions
Can I get AI-drafted feedback to a student directly from the Submissions page?
No. The Submissions page shows the AI draft in a read-only panel and lets you rename or delete a submission, but it has no publish action. Sending the score and comment to the student requires opening the same assignment in the Assignments workspace (/assignments/[id]) and using its Publish control instead.
Is AI grading free?
No. It requires a paid plan; a free-plan account attempting it gets a real PAID_PLAN_REQUIRED 403 response. Manually pasting or uploading submissions, and reading them, costs nothing on any plan.
What model actually grades the submissions?
Gemini gemini-3.1-flash-lite, called once per ungraded submission with the assignment's details, the teacher's grading instruction, and any attached rubric, returning a clamped 0–100 score and a short written comment.
How many submissions can I grade at once?
Up to 20 per grading request, processed with 4 requests running concurrently. Requests themselves are capped at 5 per minute per teacher.
Once I do publish feedback from the Assignments workspace, does the student actually see it?
Yes, verifiably. A published submission's score and comment are returned by /api/learner/submissions — which explicitly filters to published-only feedback — and rendered on the student's own Results page. The loop closes once the publish action runs from the right page.
What about the notes I write in the per-question review drawer?
Those don't persist on the server today, for a real assignment or a demo one — they live only in that browser tab's local state. Treat them as a scratchpad rather than a saved record until that changes.
Can I upload PDF or Word files of student work instead of .txt?
Not yet. The bulk uploader currently accepts .txt files only, up to 10 per batch — the app states this limit directly in its own interface rather than failing silently on an unsupported file type.
Related Reading
- How EduGenius's Assign Feature Turns a Generated Quiz Into a Gradable Assignment
- How EduGenius's Insights Dashboard Tracks Bloom's-Level Mastery Over Time
- What Are Teaching Spaces in EduGenius? Organizing Classes, Sections, and Rosters
- How EduGenius's Content History Helps Teachers Find Past Generations Again
- How to Create ESL Quizzes With AI