Vellum

The LMS that learns the student back. Adaptive AI tutor inside every lesson, built end-to-end on MeDo.

Comment

Inspiration

Every LMS we have ever used is a content container with a quiz layer bolted on. The student does the work; the platform does the recording. We wanted to build the opposite — a learning system that watches what each learner does, remembers what they missed, and adapts the next lesson to them. The hackathon prompt asked us to build something creative with MeDo. The most creative thing we could think of was to bend a no-code conversational platform into producing a multi-tenant adaptive LMS — the category MeDo’s showcase does not yet have.

What it does — the problem we solved

Vellum is an end-to-end K-12 learning management system with an adaptive AI tutor named VEL embedded in every lesson. A judge lands on the splash, clicks "Try the demo as Priya (8th-grade math student)", and is signed in via a magic-link callback as Priya Patel at Lakeline ISD. From there they walk a complete learner journey:

  • A personalized dashboard ("Good afternoon, Priya. Day 4 of your learning journey") with streak, due-soon assignments, today’s goal, enrolled courses with module progress, and a recent-activity feed (mastered lessons, instructor notes, XP earned).
  • An enrolled course (Equivalent Fractions and Number Sense, taught by Mr. Devon Park) with eight modules and a real lesson body for Module 2 / Lesson 1 — Visual model for equivalent fractions.
  • Inside the lesson: lesson text, a four-question Quick Check, navigation to Modules / Grades / VEL Tutor / Notes / People / Syllabus, and a live VEL conversation panel on the right where the tutor adapts to the learner’s last answer. Confidence and Mastery indicators track the session.
  • Cross-cutting surfaces for Achievements and Messages so the demo reads as a real product, not a tech demo.

The full Vellum platform — multi-tenant, white-label, with admin and instructor consoles — lives in our production codebase. What is deployed on MeDo is the Learner Edition slice we built specifically to demonstrate the adaptive-tutor pattern inside the hackathon window.

How we built it — MeDo conversation structure

We treated MeDo’s Deep Build as a co-engineer rather than a generator. Our prompt strategy followed a five-arc pattern:

  1. Schema-first arc. Described the data model in a single conversation — organizations → courses → modules → lessons → users → enrollments → progress → quiz_attempts → messages → notes — and let MeDo provision Supabase Postgres tables, row-level-security policies scoped to app_metadata.org_id, and the auth flow that signs Priya in with org_id: org_lakeline and role: student via OTP magic-link.
  2. Seed-data arc. Aidan built a synthetic Lakeline ISD cohort: one district, one course, eight modules, a real eighth-grade math lesson, four quiz items, instructor Mr. Devon Park, learner Priya Patel with four days of streak history and three mastered lessons. Fed to MeDo as structured JSON inside the same conversation.
  3. Surface-by-surface arc. Each route — /dashboard, /courses, /lesson/:id, /achievements, /messages — got its own arc with explicit interaction requirements ("a streak card that pulses when the streak is at risk," "a Quick Check whose feedback drives the right-panel tutor turn").
  4. VEL tutor arc. The adaptive tutor is the project’s spine. We prompted MeDo to build a chat panel that reads the learner’s last quiz answer and produces three turn types — explain, example, quiz — each grounded in the lesson body. The tutor surfaces Confidence and Mastery indicators tied to learner state.
  5. Accessibility + brand arc. Ended with WCAG AA contrast, focus rings, keyboard navigation, screen-reader labels, and the dark/gold visual identity. The "WCAG AA accessible" pill on the splash is earned, not aspirational.

Total: roughly two dozen MeDo Deep Build turns, captured prompt-by-prompt for the writeup.

Impressive features and code

  • VEL adaptive tutor with three turn types and live state. The right-rail tutor in every lesson is not a chatbot bolted on. It reads the learner’s last interaction and produces an explain / example / quiz turn that targets the specific concept they missed. Confidence and Mastery indicators reflect that state in the UI.
  • Multi-tenant from row zero. Every record in Vellum is scoped by org_id. The JWT app metadata carries the org binding. Switch the org and Lakeline ISD disappears cleanly. This is the foundation the full platform’s white-label and admin consoles sit on top of.
  • Production-grade learner journey. Dashboard, course, module, lesson, quick check, tutor panel, achievements, messages, instructor notes, XP system, streak tracking — all wired together as a single learner walk-through with realistic content.
  • WCAG AA throughout. Contrast ratios verified across the dark theme; every interactive element has accessible labels; the splash announces "WCAG AA accessible" because we earned it.
  • Magic-link OTP auth. Clicking "Try the demo as Priya" routes through Supabase’s OTP flow with a pre-baked token, so judges sign in without seeing a credentials gate.

Plugins and APIs used

For v1 we leaned on MeDo’s Deep Build for full-stack generation — auth, Postgres, RLS, UI, deploy — and intentionally did not pull in the four Kling plugins (Image Gen, Image Gen Lite, Video Gen Omni, Video Gen Advanced). We want every line that the judges see to be answerable by the MeDo conversation transcript. A Kling Image Generation arc is prepared for v2 (illustrated lesson manipulatives — drag-and-drop fraction strips, rectangle-cut visuals) and can ship inside the submission window if a category lift is helpful.

Challenges we ran into

  • Holding the LMS scope inside the hackathon window. Drivia, our production company, ships an enterprise LMS with multi-tenant admin and instructor consoles. We deliberately cut Vellum to a Learner Edition slice so the submission is honest about what is deployed on MeDo versus what lives in the production codebase. The splash names that distinction directly.
  • Designing the VEL turn types so they feel adaptive, not scripted. We landed on three turn types tied to learner state. The right-rail conversation visible in the lesson screenshot ("scrolled past the rectangle diagram twice — want me to walk through it step by step?") is what the pattern produces in practice.
  • WCAG AA at speed. Most hackathon submissions skip accessibility. We treated it as a final-arc gate. The contrast and focus work is real.

Accomplishments that we’re proud of

  • Built a complete learner-side LMS — splash, dashboard, courses, lessons with adaptive tutor, achievements, messages — on MeDo in nine days, single primary builder.
  • Differentiated the submission. The MeDo Education showcase as of May 10 was twelve student-facing study tools. Vellum is the only LMS in the category, the only multi-tenant architecture in the category, and the only WCAG AA submission we are aware of in the category.
  • Earned the Lakeline ISD synthetic cohort treatment that lets a judge walk a real learner journey rather than a tech demo.

What we learned

MeDo’s Deep Build is best treated as a co-engineer, not a generator. Prompt strategy matters more than plugin orchestration. Schema-first, seed-data-second, surface-by-surface, accessibility-last is the arc that produces something a judge can actually use end-to-end.

What’s next for Vellum

  • Open the source under an OSI license once the hackathon judging window closes. The "Open source coming" pill on the splash is a commitment.
  • Ship the v2 Kling Image Generation arc — illustrated manipulatives for fraction lessons.
  • Surface the admin and instructor consoles from the production codebase as a v3 once Vellum graduates from hackathon demo into a public deployment Drivia institutional customers can pilot.

Built for the Build with MeDo Hackathon · May 2026 · drivia.consulting

Built With

Share this project:

Updates