ClassLoop

Close the loop on every class.

Comment

ClassLoop

Close the loop on every class.

🧠 Inspiration

Every teacher knows the moment. Class ends, the energy fades, and somewhere between packing up and walking out the door — the follow-up dies.

Not because teachers don't care. They care deeply. But follow-up is invisible labor: the recap email that never got sent, the student who needed extra support but didn't ask, the action item that got lost in a group chat. The research backs this up — the forgetting curve, first modeled by Hermann Ebbinghaus in 1885, shows that without reinforcement, students forget roughly 70% of new information within 24 hours:

$$R(t) = e^{-t/S}$$

where $R$ is memory retention, $t$ is time elapsed since learning, and $S$ is the stability of the memory trace. Structured follow-up directly intervenes in this decay — but today, it happens inconsistently, manually, and at the cost of teacher burnout.

We built ClassLoop because we've seen this problem firsthand — in classrooms, in tutoring sessions, in club meetings, in office hours. The gap between what was taught and what students actually carry forward is real, measurable, and fixable.

🔍 What It Does

ClassLoop is an AI-assisted classroom follow-up platform that turns raw class records into a structured, student-personalized follow-up workflow — in seconds.

Here's the loop:

  1. Import — The teacher pastes a transcript, notes, or session summary.
  2. Generate — ClassLoop's AI parses the session and produces a structured review: recaps, per-student action items, flagged quiet students, and curated resources.
  3. Review — The teacher edits and approves before anything reaches students. Full control, always.
  4. Publish — Students receive a personalized dashboard: their recap, tasks, due dates, resources, and a completion check-in.
  5. Track — The teacher sees private analytics: who completed what, who's falling behind, who hasn't opened their follow-up yet. The full experience runs as a native desktop application (Electron + React + TypeScript), with a clean, education-focused interface built for trust.

⚙️ How We Built It

Layer Technology
Framework React 18
Language TypeScript 5
Desktop Shell Electron 41
Build Tool Vite 6
Icons Lucide React
Styling CSS
Package Manager npm

The architecture is deliberately straightforward. Electron wraps a Vite-compiled React frontend into a native desktop window, giving us cross-platform reach (macOS, Windows, Linux) from a single codebase. TypeScript across the stack kept the data models consistent between the teacher-side session flows and student-facing dashboards.

The AI parsing layer ingests unstructured text — transcripts, notes, bullet points — and outputs a structured JSON session object that drives every downstream UI component: the teacher review draft, student follow-up cards, and analytics signals. This separation of concerns (parse once, render everywhere) is also what makes the platform architecturally scalable.

🚧 Challenges We Faced

Designing for trust, not just function. Teachers won't hand student data to a tool they don't trust. Every design decision — the approval gate before publish, the privacy panel, the "teacher stays in control" framing — was deliberate. The hardest UX challenge wasn't building features; it was building confidence.

The before/after moment. The core value proposition of ClassLoop lives in one transformation: raw, messy notes → clean, structured student follow-up. Making that moment feel magical in the UI — not just functional — required multiple iterations on the import and review flows.

Scoping ruthlessly. A platform like this could grow in fifty directions simultaneously (LMS integrations, parent dashboards, AI-generated quizzes, attendance tracking). Staying focused on the MVP loop — import, generate, review, publish, track — while building extensible architecture for future features was a constant discipline.

📚 What We Learned

  • AI is most powerful at the interface between structure and chaos. The input to ClassLoop is messy (raw notes, voice transcripts, bullet dumps). The output is clean, structured, and actionable. That transformation gap is exactly where language models add the most value.
  • Desktop-first isn't dead. For teachers and tutors managing sensitive student data, a desktop app offers meaningful trust signals that a web app doesn't — no accounts to remember, no data in the cloud by default, no browser security warnings.

- Personalization at scale is a product moat. Sending every student the same recap is easy. Sending each student their recap — their action items, their flagged moments, their due dates — is hard. And it's hard in a way that creates real retention.

📈 Scalability

ClassLoop's architecture is built to scale along two axes simultaneously: user volume and institution complexity.

Technical Scalability

The current desktop build is a proof-of-concept container. The underlying architecture — a React frontend consuming a structured session API, with AI parsing as a stateless microservice — maps directly to a cloud-native deployment:

[Teacher Client] ──► [Session API] ──► [AI Parser Service]
                                  └──► [Student Delivery Service]
                                  └──► [Analytics Service]

Each service is independently scalable. The AI parser is stateless and horizontally scalable. The student delivery service can handle fan-out to thousands of students per session via async queuing. The analytics service is append-only, making it trivially distributable.

At institutional scale, the platform supports a natural hierarchy:

$$\text{Platform} \supset \text{Schools} \supset \text{Departments} \supset \text{Teachers} \supset \text{Classes} \supset \text{Students}$$

Each layer adds organizational controls (admin dashboards, roster sync, privacy policies) without changing the core follow-up loop.

Market Scalability

The total addressable market is substantial. In the United States alone:

  • ~3.8 million K–12 teachers
  • ~1.5 million post-secondary instructors
  • ~1.2 million private tutors (IBIS World, 2024)
  • ~$7.5 billion global tutoring software market (projected 2027) ClassLoop's initial target — independent tutors and small private schools — represents a low-friction entry point with high willingness to pay and minimal procurement friction. Expansion to public school districts, higher education, and corporate L&D follows the same product with progressively deeper institutional integrations.

💰 Profitability

ClassLoop operates on a SaaS freemium model with three tiers designed to capture value at every stage of the educator journey.

Pricing Architecture

Tier Target Price Key Features
Free Individual teachers, hobbyists $0/mo 3 sessions/month, basic AI recap, student view
Pro Active tutors, small schools $12/mo per teacher Unlimited sessions, full AI parsing, analytics, exports
Institution Schools, districts, L&D teams Custom Admin dashboard, LMS sync, roster management, SSO, SLA

Revenue Model

Let $T$ be the number of active teacher accounts, $p_f$ the proportion on the free tier, $p_p$ the proportion on Pro, and $p_i$ the proportion on Institution at average revenue $r_i$ per seat:

$$\text{MRR} = T \cdot \left( p_p \cdot \$12 + p_i \cdot r_i \right)$$

With a conservative 8% free-to-paid conversion (in line with B2B SaaS benchmarks) and an average institution contract of $4,000/year for a 50-seat school:

Milestone Active Teachers MRR ARR
Launch 500 $480 $5,760
6 months 2,000 $1,920 $23,040
12 months 8,000 $12,480 $149,760
18 months 25,000 + 10 institutions $24,000 + $40,000 ~$768,000

Unit Economics

  • Customer Acquisition Cost (CAC): Estimated $18–$35 for individual teachers (content marketing, educator communities, word-of-mouth). Institutions acquired through direct sales at $200–$800 CAC.
  • Lifetime Value (LTV): Pro teachers at 18-month average retention → $216 LTV. LTV:CAC ratio of ~8:1 at scale.
  • Gross Margin: AI inference costs (OpenAI/Anthropic API) estimated at $0.04–$0.12 per session at current token pricing, yielding >85% gross margin on Pro tier. ### Why This Works

EdTech SaaS compounds well because of habit loops. A teacher who uses ClassLoop for one semester is structurally unlikely to stop — their session history, student data, and analytics baseline are all inside the platform. Churn is naturally suppressed by workflow lock-in, not artificial friction.

The institution tier is the long-term value driver. A single district contract (500 teachers, $6,000/year) equals the annual revenue of ~41 individual Pro subscribers. As ClassLoop proves ROI in small schools, district-level deals become the natural expansion motion.

🔮 What's Next

  • LMS integrations (Google Classroom, Canvas, Schoology) for roster sync and grade passback
  • Mobile student app for iOS and Android
  • Voice transcript ingestion — record class, skip the paste step entirely
  • Parent visibility layer — optional summaries sent home for K–12

- Completion analytics benchmarks — how does my class compare to similar classes?

🏗️ Built With

TypeScript React Electron Vite CSS

ClassLoop — Close the loop on every class.

Share this project:

Updates