" We solved the structural failure of unstructured public-content learning and low-completion course platforms by designing a dependency-locked skill-tree platform with server-graded active recall, an outbound-link content model, an asynchronous curriculum engine running graph and embedding algorithms over quota-aware YouTube metadata, and a SuperMemo-2 retention layer, resulting in a single-codebase, dependency-free, integrity-hardened architecture that delivers structured learning over free public resources without embedding, transcribing, or licensing any third-party content "
Overview
A free-to-learn skill-tree application for professional upskilling, built as a single Flutter codebase (web + Android) on a Supabase/PostgreSQL backend. The system organizes one job role at a time into a dependency-locked directed acyclic graph of concepts. Each concept pairs an AI-generated study summary with a curated outbound link to a public learning resource and a server-graded active-recall quiz. Learners cannot advance until they pass the quiz, and missed concepts are scheduled back into the practice stream via a spaced-repetition algorithm.
Problem Statement
The two most common ways an upskiller learns today — searching YouTube and enrolling in a course platform — both fail at the technical level in different ways:
YouTube fails as a learning system. It is a recommendation engine optimized for watch-time, not curriculum. There is no sequence, no enforced prerequisite ordering, no validation that a viewer understood anything, no mechanism to surface forgotten material, and no way to know whether a given 17-minute video covers the concept the learner actually needs or whether a 90-second segment of it does. The learner is asked to assemble a curriculum from a feed designed to keep them watching, with no feedback loop except their own subjective sense of progress.
Traditional course platforms fail at completion. They package learning as long-form linear video with low-frequency quizzes, no enforced active recall, and no spaced repetition. Completion rates in self-paced online courses are routinely under 10%, not because the content is bad but because the delivery mechanism offers neither short feedback cycles nor structural pressure to continue. The learner pays up front, watches a few hours, and drifts away.
The technical problem to solve was therefore: build a delivery system that combines the curatorial precision of a curriculum (sequencing, prerequisites, active recall) with the access economics of free public content (no expensive video production, no licensing) — without embedding or reproducing third-party content, and without making credential integrity hostage to AI errors.
Challenges
- Curriculum graph construction. Job roles do not come pre-decomposed into atomic, sequenced concepts. The engine had to accept an open-ended role string, decompose it into a directed acyclic graph of concepts, validate the graph for cycles, strip redundant prerequisite edges, and group concepts into difficulty tiers that read as a coherent learning order rather than an arbitrary topological flattening.
- Resource selection without consuming content. The system needed to choose the best public learning resource for each concept without downloading, embedding, transcribing, or storing the third-party content — a hard constraint imposed both by Terms of Service realities and by the goal of zero supplier dependency. Selection therefore had to operate on metadata and aggregate engagement signals only, while remaining honest about what those signals can and cannot tell you about content quality.
- API quota economics. The YouTube Data API v3 provides 10,000 quota units per day on the free tier, with search.list priced at 100 units per call. A naive implementation that searches per concept would exhaust the daily budget on a single 30-concept track, making iteration impossible. The integration had to be architected for quota efficiency — cheap endpoints over expensive ones, channel-first discovery over per-concept search, aggressive caching with TTLs tuned to how fast each signal actually drifts.
- Server-side trust boundary. Every learning system that issues a passable assessment has a tension between client UX (responsive quiz feedback) and integrity (the client cannot be trusted with the answer key, or the assessment is trivially bypassed by inspecting network traffic or app memory). Grading had to be exclusively server-side, with the client receiving only "correct/incorrect" results and never seeing answer payloads.
- Sequenced unlocking at two granularities. Learners benefit from both coarse-grained progression (sections and units that gate at meaningful milestones) and fine-grained dependencies (a specific concept that must precede another regardless of unit boundaries). The schema had to express both Unit-level and Concept-level prerequisites, with the unlock check ANDing both levels — neither cheap to retrofit if designed at one level only.
- Single-codebase delivery. Maintaining separate web and Android frontends would have doubled the implementation surface for a solo build. The same code had to compile to both targets, while the marketing and legal pages (where SEO and first-paint matter and Flutter web is weak) had to remain a separate, lightweight HTML surface.
- Authentication on India infrastructure. Phone-based OTP login via MSG91 with DLT-registered templates had to integrate cleanly with Supabase's session model, since Supabase's built-in phone auth uses different providers. The system had to mint Supabase sessions through a custom token exchange after MSG91 verified the OTP.
- Retention against forgetting. Active-recall quizzes are necessary but not sufficient — concepts missed today are likely to be missed again next week unless deliberately resurfaced. A spaced-repetition layer had to schedule missed concepts back into the daily stream at increasing intervals.
Solution
The platform was delivered as an AI-assisted certification and learning-path ecosystem built around dependency-driven curriculum management, secure credential issuance, intelligent content discovery, and adaptive learning progression.
- Dependency-Locked Skill Tree Architecture
Content is organized as a four-level hierarchy (Job Role → Section → Unit → Concept). Concept is the atomic learning unit containing study summaries, outbound resource links, and quiz items, with prerequisite-based unlocking enforced at both Unit and Concept levels. - Structured Learning Progression
Unlocking logic combines Unit-level and Concept-level prerequisite checks, ensuring learners follow a guided progression path and cannot skip foundational knowledge. - Asynchronous Curriculum Intelligence Engine
Curriculum generation operates outside request-serving workflows using graph-processing and ranking algorithms to validate dependencies, organize learning paths, remove redundant prerequisite relationships, and recommend relevant learning resources. - AI-Powered Resource Discovery
Candidate resources are matched to concepts using dense text embeddings and cosine similarity scoring. Near-duplicate detection and multi-factor quality scoring help surface relevant, credible, and diverse learning materials. - Automated Content Quality Assurance
Quiz items undergo automated validation including answer-key verification and distractor plausibility checks before publication, improving assessment reliability and content quality. - Human-Governed Publishing Workflow
All AI-generated curriculum content is written to a STAGING environment, requiring curator review and manual promotion to PRODUCTION before becoming visible to learners. - YouTube Metadata Discovery Integration
The platform integrates with YouTube discovery APIs for metadata-based content recommendations, while intentionally excluding captions, comments, embedded playback, and IFrame Player dependencies. - Quota-Aware Content Discovery
Discovery workflows include metadata caching, quota monitoring, channel credibility evaluation, and automated safeguards to prevent API quota exhaustion. - Server-Side Trust & Security Controls
Supabase Row-Level Security follows a deny-by-default model. Sensitive operations such as grading, credential issuance, payment verification, and administrative impersonation are restricted to audited server-side workflows. - Secure Credential Lifecycle Management
Credentials progress through a controlled state machine (LOCKED → ELIGIBLE → PAID → ASSESSMENT_STARTED → PASSED → ISSUED) enforced exclusively by backend services. - Certification & Retry Management
The assessment workflow supports controlled retry attempts through a re-payment model while maintaining certification integrity and auditability. - Adaptive Retention System
A SuperMemo-2–inspired spaced repetition engine automatically reintroduces incorrectly answered concepts at scheduled intervals, dynamically adjusting review frequency based on learner performance.
Architecture
Frontend: Flutter (Dart) compiled to web and Android from a single codebase; separate static HTML site (vanilla or lightweight static generator) for marketing, SEO, and legally-required pages.
Backend: Supabase managed PostgreSQL with row-level security, auto-generated REST under RLS, and Edge Functions (Deno/TypeScript) for OTP exchange, server-side quiz grading, credential state transitions, payment webhooks, coupon validation, the public verification endpoint, admin impersonation, and the asynchronous curriculum engine worker.
Authentication: MSG91 SMS OTP with DLT-registered templates for India compliance; custom Supabase session minting via JWT signed with the project secret after MSG91 verifies the OTP.
External data: YouTube Data API v3, scoped to search.list, videos.list, channels.list, and playlistItems.list. Public i.ytimg.com thumbnail CDN for UI imagery (zero quota cost).
Curriculum engine algorithms: Kahn's topological sort, transitive reduction, Coffman–Graham-style DAG tiering, cosine similarity over dense embeddings with near-duplicate dedup, multi-factor weighted quality scoring, Bayesian average for ratings, SuperMemo-2 variant for spaced repetition.
Schema model: four-level content hierarchy (Job Role → Section → Unit → Concept) with branch-ready Section columns dormant at launch; dual-level dependency locking; explicit credential state machine (LOCKED → ELIGIBLE → PAID → ASSESSMENT_STARTED → PASSED → ISSUED, with FAILED → ELIGIBLE for re-pay-on-retry, VOIDED on account deletion, REFUNDED on approved refund).
Security posture: Postgres RLS default-deny on every table; quiz answer keys isolated to server-only access; payment state moves only via verified webhooks (Razorpay signature, Play Developer API purchase verification); audit-logged admin impersonation; full personal-data deletion with anonymized minimum payment record retained for legal compliance.
