Veridian

Veridian turns classroom mistakes into structured data, making the learning process visible. Instead of grading outputs, teachers and students alike see thinking, gaps, and growth in real time.

Comment

Inspiration

Education is entering an AI arms race.

Students feel constant pressure to ``keep up.'' Some use AI to skip hard thinking and get answers instantly. Others don’t have the same access and feel like they’re falling behind anyway. Everyone is afraid of being wrong. Teachers are left grading final outputs while the real learning process stays invisible.

That’s the fracture Veridian was built for.

Classrooms already generate massive learning signal: drafts, crossed-out steps, partial reasoning, misconceptions, and recovery attempts. Today, most of that disappears. Teachers get snapshots. Students get scores. Nobody gets a true diagnostic of how learning happened.

Veridian starts with one question:

What if every mistake became structured data?

We’re building an AI-native classroom runtime where errors are not failures to hide, but the highest-value signal in the room.

What Veridian Does

Veridian is a full-stack EdTech platform with symmetric teacher and student surfaces. It outperforms existing edtech platforms like Canvas and Google Classroom by unifying the full assignment workflow—creation tech stack, including writing/completion, and submission—into a single AI-powered, data-driven platform Veridian includes AI driven learning insights from student data, seamless digital notebook integrations for easy assignment submission, and AI assisted notetaking autocomplete plus correction within digital homework notebooks.

Teacher Side

  • Create classrooms students can join
  • Upload a course corpus per classroom (PDFs, TeX, lecture notes, reference material)
  • Generate auto-formatted assignments delivered directly to students
  • Configure runtime policies (for example: when analysis runs, whether chat is allowed, and how much guidance students receive)
  • Review submissions, mistake patterns, and classroom-level analytics

Student Side

  • Work inside a digital canvas for notes and problem-solving
  • Get AI-assisted writing/autocomplete with mistake tracking, when enabled by the teacher
  • Receive real-time mistake analysis during work, based on teacher-defined classroom settings
  • Use Socratic chat guidance when teacher-enabled
  • Operate under teacher-defined runtime policy via resolved_config (the effective classroom configuration applied to each student session)

At its core, Veridian converts raw student work into structured mistake intelligence, giving students better feedback loops and giving teachers visibility into learning that used to happen behind closed doors.

How We Built It

We built Veridian as a mirrored system by design:

  • teacher/backend (Flask)
  • teacher/frontend (Expo React)
  • student/backend (Flask)
  • student/frontend (Expo React)
  • supabase/ (shared schema + migrations)

This symmetry is intentional: one platform, two operating surfaces, one source of truth.

Backend

  • Flask APIs for teacher and student runtimes
  • JWT auth with strict membership gating (401 / 403)
  • Supabase as the shared persistence layer
  • Config-driven student runtime via GET /assignments/:id, returning teacher-controlled resolved_config

Frontend

  • Expo React apps for both teacher and student
  • Shared design tokens and reusable UI primitives (src/components/ui/)
  • Canvas-first student workspace
  • AI analysis trigger modes:
    • auto_idle
    • auto_page_change
    • manual_only
    • passive

We enforced hard boundaries between:

  • Auth
  • Classroom logic
  • Assignment configuration
  • AI runtime behavior

Challenges We Ran Into

1. Runtime policy enforcement at the edge

Teacher intent had to survive all the way to the student session. That required strict backend contracts and disciplined frontend state orchestration.

2. Hard role separation

We enforced single-role identity (Teacher or Student). It made permissioning safer, but raised the bar for membership and access flows.

3. Multi-layer state sync

Assignments, submissions, and AI feedback had to stay coherent across Supabase, Flask APIs, and Expo client state in near real time.

4. Automation vs pedagogy

Choosing when AI should intervene (auto_idle) versus when students should drive (manual_only) was a product and learning-design challenge, not just an engineering one.

Accomplishments We’re Proud Of

  • AI-assisted handwritten note completion inside the student canvas, so students can keep working without losing momentum
  • AI mistake localization with red-dot markers and suggestion captions that pinpoint exactly where an error occurs for instant correction and review Symmetric architecture that scales without chaos
  • Teacher-governed, config-driven student runtime
  • Fully gated endpoints with role-based access control
  • AI mistake analysis embedded directly in the workflow
  • Repeatable end-to-end classroom demo path
  • Supabase migrations that cleanly separate teacher/student concerns

Most importantly: Veridian behaves like infrastructure, not a prototype.

What We Learned

  • AI in classrooms must be policy-driven, not always-on.
  • Mistake analysis is strongest inside the workflow, not after the fact.
  • Architectural symmetry lowers team cognitive load and speeds iteration.
  • Strong backend contracts prevent frontend state blowups.
  • In education, teacher trust is the adoption curve.

What’s Next For Veridian

  • Longitudinal mistake trajectories across assignments
  • Teacher-side misconception heatmaps
  • Adaptive assignment branching based on error patterns
  • Fine-grained error distribution analytics
  • Agentic reasoning over a student’s full historical mistake profile
  • Institutional deployment model for district and campus rollout

Our long-term vision:

Veridian becomes the mistake intelligence layer for modern classrooms.

Share this project:

Updates