Building a Personal Learning Tool

Translate the target learner journey into testable multi-user MVP use cases.

Define acceptance criteria for course intake, syllabus creation, resource curation, lesson study, exercises, and mentoring.

Draw the end-to-end data flow from learner intake through course generation and study.

Separate synchronous user interactions from long-running generation tasks in the system design.

Identify trust boundaries among users, the application, model providers, and external websites.

Select free-tier or open-source components using explicit capability, cost, and operational criteria.

Organize the codebase into frontend, API, worker, and shared-contract boundaries.

Model users, learner profiles, courses, syllabus versions, lessons, resources, exercises, attempts, progress, and conversations in a relational schema.

Create database migrations for the initial domain model.

Configure an identity provider with a free tier or self-hosted option.

Validate authenticated user identity in FastAPI endpoints.

Enforce ownership checks when users access courses, lessons, and conversations.

Define typed request and response contracts shared between the frontend and API.

Implement a minimal course CRUD API for authenticated users.

Build a frontend application shell that preserves authenticated session state.

Define the learner facts required to personalize a course without collecting unnecessary personal data.

Represent learner goals, prior knowledge, constraints, preferences, and study time in a validated schema.

Design an intake conversation state machine that distinguishes known, missing, and conflicting information.

Prompt a language model to extract structured learner facts from a chat turn.

Generate one targeted follow-up question from the missing learner facts.

Require learner confirmation before locking the intake profile.

Persist intake messages and profile revisions under the authenticated user.

Test the intake flow with incomplete, contradictory, and off-topic responses.

Write assessable learning outcomes that each fit within a short lesson.

Apply prerequisite ordering to a set of learning outcomes.

Define a structured schema for modules, learning outcomes, and syllabus metadata.

Prompt a model to generate a syllabus constrained by the confirmed learner profile.

Validate generated syllabi for schema limits, duplication, and missing prerequisites.

Score a syllabus against goal alignment, learner level, time budget, and practical emphasis.

Implement chat-driven syllabus revision without losing unaffected content.

Represent draft, reviewed, and finalized syllabus states as immutable versions.

Generate focused web-search queries from a single lesson outcome.

Implement a provider-neutral search adapter that can use a free-tier search service.

Filter search results by accessibility, supported content type, and basic domain rules.

Check site policies and retrieval constraints before fetching a resource.

Fetch a permitted web resource with timeouts, size limits, and content-type validation.

Extract readable text and metadata from an HTML resource.

Canonicalize resource URLs and remove duplicate search results.

Store source provenance, retrieval time, and content fingerprints for each resource.

Define a resource-quality rubric covering relevance, authority, clarity, accessibility, and freshness.

Estimate semantic relevance between a lesson outcome and a candidate resource.

Combine rubric signals into an explainable resource ranking.

Select a complementary set of resources rather than redundant top results.

Identify the specific sections or timestamps needed from a selected resource.

Generate lesson instructions that connect each resource segment to the lesson outcome.

Estimate lesson duration from assigned reading, viewing, and practice.

Create a lesson context pack containing approved source excerpts, metadata, and citations.

Choose an exercise format that directly assesses a lesson outcome.

Generate a structured exercise using only the approved lesson context.

Create an answer key or scoring rubric with source-backed reasoning.

Grade deterministic exercise types without a language model.

Score a short free-text answer against an explicit rubric.

Generate feedback that identifies the learner's misconception without revealing the full answer prematurely.

Adjust the next exercise difficulty using prior attempt evidence.

Persist exercise attempts, scores, feedback, and completion state.

Define what information the lesson mentor may use and what it must exclude.

Chunk approved lesson context for retrieval without separating claims from their citations.

Create embeddings for lesson-context chunks using a replaceable embedding provider.

Store and retrieve vectors with course, lesson, and user access filters.

Construct a mentor prompt from the current lesson, retrieved evidence, and learner question.

Require the mentor to cite evidence or state when the lesson context is insufficient.

Summarize older conversation turns without discarding unresolved learner questions.

Test mentor answers for grounding, citation accuracy, and cross-user isolation.

Represent course generation as explicit stages with durable status transitions.

Move resource discovery and content generation into background jobs.

Make a generation job idempotent under duplicate delivery.

Apply bounded retries to transient model, search, and fetch failures.

Expose stage-level progress and failure details to the frontend.

Resume a partially completed course build from the last valid stage.

Apply per-user quotas and rate limits to expensive operations.

Cache reusable model or retrieval results without leaking data across users.

Create a small evaluation dataset spanning different learner goals and experience levels.

Measure syllabus quality with prerequisite, relevance, atomicity, and personalization checks.

Measure resource curation quality using a manually judged reference set.

Measure exercise-answer faithfulness to approved lesson sources.

Detect prompt-injection patterns in retrieved web content before model use.

Prevent server-side request forgery in the resource fetcher.

Redact sensitive learner data from model prompts and application logs.

Set model usage budgets and record cost or token consumption per course build.

Build a chat interface that clearly communicates intake progress and requests confirmation.

Build a syllabus workspace for reviewing modules and submitting revision requests.

Build a lesson view that presents outcomes, curated resources, instructions, and citations.

Integrate exercises into the lesson flow with attempt and feedback states.

Embed the context-aware mentor in the active lesson without obscuring study materials.

Calculate course and lesson progress from completed learning activities.

Display recoverable generation failures with safe retry actions.

Verify keyboard navigation and responsive behavior across the core learner journey.

Containerize the API, worker, and frontend with reproducible development settings.

Manage application secrets separately from source code and container images.

Create a continuous-integration workflow for linting, tests, and database migration checks.

Deploy the multi-user MVP using free-tier-friendly infrastructure.

Run database migrations safely during deployment.

Implement structured logs with request, user-safe, course, and job correlation identifiers.

Define service indicators and alerts for API errors, job failures, and model-provider latency.

Run an end-to-end acceptance test from new-user signup through a completed mentored lesson.