Eduquest

Gemini-powered quiz marking and parent reporting for independent tutors — auditable, fail-closed, and human-reviewed when it matters.

Comment

A note on what's new here

Eduquest is a tutoring platform I built and launched in February 2026, before this competition opened on May 19, 2026. From February through May it was a non-AI administrative system: attendance records, invoicing, timetables, and posting learning material for independent tutors and their learners. It did not mark work, generate memos, or use any AI provider.

What I'm entering into this competition is the new, AI-native assessment operations layer built on top of that foundation during the competition period — private exam ingestion, Gemini-based question structuring, answer-key generation, queued and auditable AI marking with human fail-safes, and AI-assisted parent reporting. The pre-existing LMS provides identity, scheduling, and billing infrastructure around it; it did not provide any of the assessment intelligence described below.

Inspiration

I run a small tutoring business, and marking is the part that doesn't scale. A tutor with twenty learners across five subjects spends hours each week marking short-answer scripts by hand, writing memos from scratch when a question paper doesn't come with one, and producing parent progress reports that read like they were assembled at 11pm — because they were. I wanted the AI to do the tedious, mechanical parts of that job — reading a question paper, producing a defensible memo, marking against it fairly — while keeping a human in the loop for anything the model isn't confident about, and keeping every AI decision auditable after the fact.

What it does

A tutor uploads a question paper (a memo is optional). Eduquest parses it, uses Gemini to structure each question into a strict, validated schema, and generates an answer key — from the tutor's memo if one was supplied, or from the model's own CAPS-aligned subject knowledge if it wasn't. The tutor reviews and publishes. Learners submit answers, which are queued for marking: multiple-choice and numeric answers are marked deterministically, free-text answers go to Gemini against the memo. If Gemini (or its fallback) can't produce a response that passes strict schema validation, the submission is never guessed at — it's marked needs_review and a human tutor finishes it. Verified results stay private until the tutor releases them, at which point learners and linked parents are notified. Parents also get AI-written progress reports — strengths, weaknesses, and an action plan — instead of a static template, unless the tutor has opted for fully human-written reports.

Every one of those choices — which AI provider, or none at all — is a per-tutor setting, because not every tutor trusts the same provider, and some don't want AI touching marking at all.

How we built it

The core routing decision was Gemini-first with DeepSeek as an interchangeable, auditable fallback — never a silent retry, only a fallback that's recorded as such. A response only counts as accepted after it passes a strict JSON schema specific to its use case (question structure, answer key, marking result, or report narrative); anything that fails validation is treated exactly like a provider failure, including from the primary provider, so a syntactically-valid-but-wrong response can't slip through.

Gemini itself runs through a small, purpose-built Cloud Run gateway (Python, Google Gen AI SDK, Vertex AI) that the PHP application calls with HMAC-signed, timestamped requests — not a bare API key sitting in application config. Every execution — provider requested, provider used, model, latency, token count, Cloud Run revision, fallback status — is written to a privacy-safe execution ledger. Prompts, memos, and learner answers are deliberately never logged; only the operational metadata needed to prove what happened and audit it later.

The hardest part wasn't the AI integration itself — it was making the switch and the reports feature reach production, not just a clean staging environment. Production runs an older, self-contained version of the marking pipeline that had drifted from the newer codebase over time. Rather than replace it wholesale — a real risk to learners' actual marked work — I patched each diverged production file individually, preserving its existing fallback behavior, and verified every deployment byte-for-byte before treating it as live. Along the way I found and fixed a live production bug — a missing class file that was silently breaking any code path that touched the shared AI service — that had nothing to do with the new feature but was blocking it regardless.

Challenges we ran into

Keeping "fail closed, never guess" honest under real failure conditions was harder than building the happy path: a missing memo, an unavailable ledger, or an invalid model response all had to reliably escalate to a human rather than silently degrade to a lower-quality automatic mark. Shared cPanel hosting also meant no persistent worker processes — every AI job runs through a bounded, retryable database queue rather than a long-running service, so the architecture had to be durable across process restarts by default, not as an afterthought.

Accomplishments that we're proud of

A tutor can now generate a full quiz, have it marked, and see a real Gemini-written parent report, end to end, in production — not a demo environment. Every AI decision in that path is schema-validated and auditable, and a provider outage degrades to a fallback or a human, never to a wrong answer presented as a right one.

What we learned

That the hard part of shipping AI into a real, already-live product isn't the model call — it's everything around it: schema validation strict enough to trust, a privacy-safe audit trail, and a fail path that never guesses.

What's next

Extending Gemini's grounding to real textbook/web search for memo-less marking (currently model knowledge only), and building out the tutor-facing evidence dashboard so provider attribution is visible in-product, not just in the database.

Built With

Share this project:

Updates

Submission history