Class Objectives Tracker (goaltracker)

Contents:

• FERPA and Legal Compliance

Overview

This project turns a semester’s worth of course syllabi into a single, personal checklist. Each class breaks down into a syllabus-derived tree of learning objectives (“goals”), and a Django web application (goaltracker) lets a student check them off as they master them, track progress per course, and build one running project plan across every class they’re taking.

The data starts life in pbj.db, a small SQLite database that holds five course syllabi (Computer Science I, Data Structures, Database Management Systems, Fullstack I, and Operating Systems) broken into 175 hierarchical topics – things like “Imperatives,” “Decisions,” and “Iterations/Loops” nested under a parent objective such as “Understanding and having a strong ability to use the core features of a procedural programming language.” A Django management command (import_pbj) reads that file and imports it into the tracker’s database, preserving the parent/child structure so a broad objective and its specific sub-skills both show up as separate, checkable items.

How It Works

Data Model

The Django app (tracker) is built around a small set of models:

Course

A class, with its syllabus metadata (title, course code, credit hours, term).

Goal

A single learning objective. Goals are global, not tied to one course – if two classes share an objective (e.g. both a database class and a fullstack class expect basic SQL), completing it once satisfies it everywhere it’s required. Goals may nest under a parent goal to preserve the syllabus’s own grouping.

CourseRequirement

Links a Goal to a Course and marks whether it’s required or optional for that class.

GoalCompletion

The single source of truth for whether a student has finished a goal. Keyed on the student and the goal only – never per-course – so progress made before ever “using” a course still counts the moment that course requires the same goal.

Enrollment / CourseCompletion / ProjectPlanItem / PlanMilestone

Support enrolled-course dashboards, an automatically-derived “you finished every requirement” badge per course, and a drag-and-reordered personal project plan built from goals the student has pulled in.

Application

The web application has three main views:

• All Goals – every objective across every course, each tagged with the course(s) it counts toward, with a search box to jump straight to one by name or by course.

• My Plan – a single, ongoing, drag-to-reorder list of goals the student is actively working through, framed as a running project timeline rather than a per-class assignment list.

• My Courses – the student’s enrolled courses, each with a progress bar and full checklist of its required (and optional) goals.

Checking a goal off in any of the three views updates it everywhere else instantly, in every open browser tab, via a WebSocket connection (Django Channels + Redis) – no page reload required. The whole stack (the Django app, PostgreSQL, and Redis) runs together via Docker Compose.

Use Cases

Tracking mastery, not just grades

A letter grade says a class is “done.” It doesn’t say which of the 40+ specific skills a syllabus promised were actually absorbed. This tool lets a student see, at a glance, exactly which objectives from a class they’ve genuinely covered versus which ones are still open – useful for identifying gaps before a final, a technical interview, or a follow-on course that assumes the earlier material.

Reusing shared skills across courses

Because a Goal isn’t owned by a single course, an objective like “Integrate a SQL database” that shows up in both a database class and a fullstack class only has to be completed once. A student who learns it early (in an internship, a personal project, or an earlier class) walks into the second course already partway done.

Building one ongoing portfolio/project plan

The “My Plan” view isn’t scoped to a single semester or class – it’s meant to hold the actual project(s) a student is building, with goals pulled in from whatever courses are relevant, reordered to match real build order. It turns scattered syllabus objectives into one coherent to-do list for a real piece of work.

Self-directed review and planning ahead

Because goal completion isn’t gated by enrollment, a student can browse and check off objectives from a class they haven’t registered for yet – useful for getting a head start over a break or confirming prerequisite knowledge before registration.

Why It Helps

• Turns a syllabus into something actionable. A PDF syllabus is a list of promises; this tool turns it into a checklist that changes as the student actually learns.

• Makes gaps visible early. Per-course progress bars and an all-goals view surface exactly which objectives are still incomplete, rather than discovering the gap on an exam or in a job interview.

• Rewards a small amount of daily upkeep with a persistent record of everything mastered so far, instead of relying on memory or scattered notes across multiple classes.

• Encourages connecting coursework to a real project, since the plan view is framed around one ongoing body of work rather than disconnected homework lists.

• Costs almost nothing to maintain. New syllabi can be dropped in by re-running the same import against an updated pbj.db, and the whole stack runs locally with Docker Compose – no external service dependency.