diff --git a/drizzle/0007_learning_platform.sql b/drizzle/0007_learning_platform.sql
new file mode 100644
index 0000000..f88ade8
--- /dev/null
+++ b/drizzle/0007_learning_platform.sql
@@ -0,0 +1,110 @@
+CREATE TABLE IF NOT EXISTS "learning_tracks" (
+	"id" text PRIMARY KEY NOT NULL,
+	"slug" text NOT NULL,
+	"title" text NOT NULL,
+	"description" text NOT NULL,
+	"difficulty" text DEFAULT 'beginner' NOT NULL,
+	"estimated_hours" integer DEFAULT 10 NOT NULL,
+	"is_published" boolean DEFAULT false NOT NULL,
+	"prerequisites" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"objectives" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"order_index" integer DEFAULT 0 NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "learning_tracks_slug_unique" UNIQUE("slug")
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "learning_modules" (
+	"id" text PRIMARY KEY NOT NULL,
+	"track_id" text NOT NULL REFERENCES "learning_tracks"("id") ON DELETE cascade,
+	"slug" text NOT NULL,
+	"title" text NOT NULL,
+	"description" text NOT NULL,
+	"order_index" integer DEFAULT 0 NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "learning_lessons" (
+	"id" text PRIMARY KEY NOT NULL,
+	"module_id" text NOT NULL REFERENCES "learning_modules"("id") ON DELETE cascade,
+	"slug" text NOT NULL,
+	"title" text NOT NULL,
+	"content" text NOT NULL,
+	"estimated_minutes" integer DEFAULT 15 NOT NULL,
+	"order_index" integer DEFAULT 0 NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "learning_enrollments" (
+	"id" text PRIMARY KEY NOT NULL,
+	"user_id" text NOT NULL REFERENCES "users"("id") ON DELETE cascade,
+	"track_id" text NOT NULL REFERENCES "learning_tracks"("id") ON DELETE cascade,
+	"status" text DEFAULT 'enrolled' NOT NULL,
+	"enrolled_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"completed_at" timestamp with time zone,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "lesson_progress" (
+	"id" text PRIMARY KEY NOT NULL,
+	"user_id" text NOT NULL REFERENCES "users"("id") ON DELETE cascade,
+	"lesson_id" text NOT NULL REFERENCES "learning_lessons"("id") ON DELETE cascade,
+	"completed" boolean DEFAULT true NOT NULL,
+	"completed_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "learning_assignments" (
+	"id" text PRIMARY KEY NOT NULL,
+	"lesson_id" text NOT NULL REFERENCES "learning_lessons"("id") ON DELETE cascade,
+	"title" text NOT NULL,
+	"description" text NOT NULL,
+	"acceptance_criteria" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"submission_type" text DEFAULT 'text_submission' NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "assignment_submissions" (
+	"id" text PRIMARY KEY NOT NULL,
+	"assignment_id" text NOT NULL REFERENCES "learning_assignments"("id") ON DELETE cascade,
+	"user_id" text NOT NULL REFERENCES "users"("id") ON DELETE cascade,
+	"content" text NOT NULL,
+	"status" text DEFAULT 'submitted' NOT NULL,
+	"reviewed_by" text REFERENCES "users"("id"),
+	"feedback" text,
+	"submitted_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"reviewed_at" timestamp with time zone
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "learning_tracks_slug_idx" ON "learning_tracks" ("slug");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_tracks_is_published_idx" ON "learning_tracks" ("is_published");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_modules_track_id_idx" ON "learning_modules" ("track_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_modules_order_idx" ON "learning_modules" ("track_id", "order_index");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_lessons_module_id_idx" ON "learning_lessons" ("module_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_lessons_order_idx" ON "learning_lessons" ("module_id", "order_index");
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "learning_enrollments_user_track_idx" ON "learning_enrollments" ("user_id", "track_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_enrollments_user_id_idx" ON "learning_enrollments" ("user_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_enrollments_track_id_idx" ON "learning_enrollments" ("track_id");
+--> statement-breakpoint
+CREATE UNIQUE INDEX IF NOT EXISTS "lesson_progress_user_lesson_idx" ON "lesson_progress" ("user_id", "lesson_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "lesson_progress_user_id_idx" ON "lesson_progress" ("user_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "lesson_progress_lesson_id_idx" ON "lesson_progress" ("lesson_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "learning_assignments_lesson_id_idx" ON "learning_assignments" ("lesson_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "assignment_submissions_user_idx" ON "assignment_submissions" ("user_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "assignment_submissions_assignment_idx" ON "assignment_submissions" ("assignment_id");
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "assignment_submissions_status_idx" ON "assignment_submissions" ("status");
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index c52be88..18c99d9 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -50,6 +50,13 @@
       "when": 1793326000000,
       "tag": "0006_privacy_and_governance",
       "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "7",
+      "when": 1793327000000,
+      "tag": "0007_learning_platform",
+      "breakpoints": true
     }
   ]
 }
diff --git a/src/app/api/learn/assignments/[id]/submit/route.ts b/src/app/api/learn/assignments/[id]/submit/route.ts
new file mode 100644
index 0000000..f4ce59d
--- /dev/null
+++ b/src/app/api/learn/assignments/[id]/submit/route.ts
@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { submitAssignment } from "@/lib/learning/service";
+
+const submissionSchema = z.object({
+  content: z.string().min(1, "Submission content is required"),
+});
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const token = request.cookies.get(COOKIE_NAME)?.value;
+  if (!token) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const sessionUser = await verifySessionToken(token);
+  if (!sessionUser) {
+    return NextResponse.json({ error: "Invalid session" }, { status: 401 });
+  }
+
+  try {
+    const { id: assignmentId } = await params;
+    const body = await request.json();
+    const { content } = submissionSchema.parse(body);
+
+    const submission = await submitAssignment(
+      sessionUser.id,
+      assignmentId,
+      content
+    );
+
+    return NextResponse.json({ success: true, submission });
+  } catch (error: any) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: "Invalid request data", details: error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    return NextResponse.json(
+      { error: error.message || "Failed to submit assignment" },
+      { status: 400 }
+    );
+  }
+}
diff --git a/src/app/api/learn/enroll/route.ts b/src/app/api/learn/enroll/route.ts
new file mode 100644
index 0000000..9c84f59
--- /dev/null
+++ b/src/app/api/learn/enroll/route.ts
@@ -0,0 +1,41 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { enrollInTrack } from "@/lib/learning/service";
+
+const enrollSchema = z.object({
+  trackId: z.string().min(1, "Track ID is required"),
+});
+
+export async function POST(request: NextRequest) {
+  const token = request.cookies.get(COOKIE_NAME)?.value;
+  if (!token) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const sessionUser = await verifySessionToken(token);
+  if (!sessionUser) {
+    return NextResponse.json({ error: "Invalid session" }, { status: 401 });
+  }
+
+  try {
+    const body = await request.json();
+    const { trackId } = enrollSchema.parse(body);
+
+    const enrollment = await enrollInTrack(sessionUser.id, trackId);
+    return NextResponse.json({ success: true, enrollment });
+  } catch (error: any) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: "Invalid request data", details: error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    console.error("Failed to enroll in track:", error);
+    return NextResponse.json(
+      { error: error.message || "Failed to enroll in track" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/src/app/api/learn/lessons/[id]/progress/route.ts b/src/app/api/learn/lessons/[id]/progress/route.ts
new file mode 100644
index 0000000..f4964aa
--- /dev/null
+++ b/src/app/api/learn/lessons/[id]/progress/route.ts
@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { toggleLessonProgress } from "@/lib/learning/service";
+
+const progressSchema = z.object({
+  completed: z.boolean(),
+});
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const token = request.cookies.get(COOKIE_NAME)?.value;
+  if (!token) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const sessionUser = await verifySessionToken(token);
+  if (!sessionUser) {
+    return NextResponse.json({ error: "Invalid session" }, { status: 401 });
+  }
+
+  try {
+    const { id: lessonId } = await params;
+    const body = await request.json();
+    const { completed } = progressSchema.parse(body);
+
+    const result = await toggleLessonProgress(
+      sessionUser.id,
+      lessonId,
+      completed
+    );
+
+    return NextResponse.json({ success: true, ...result });
+  } catch (error: any) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: "Invalid request data", details: error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    console.error("Failed to update lesson progress:", error);
+    return NextResponse.json(
+      { error: error.message || "Failed to update lesson progress" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/src/app/api/learn/routes.test.ts b/src/app/api/learn/routes.test.ts
new file mode 100644
index 0000000..52aecd3
--- /dev/null
+++ b/src/app/api/learn/routes.test.ts
@@ -0,0 +1,170 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { NextRequest } from "next/server";
+import { getDb, schema } from "@/lib/db";
+import { runMigrations } from "@/lib/db/migrate";
+import { createSessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { eq } from "drizzle-orm";
+import { GET as getTracksHandler } from "./tracks/route";
+import { POST as enrollHandler } from "./enroll/route";
+import { POST as progressHandler } from "./lessons/[id]/progress/route";
+import { POST as submitAssignmentHandler } from "./assignments/[id]/submit/route";
+import { getTrackBySlug } from "@/lib/learning/service";
+
+describe("Learning Platform API Routes", () => {
+  let db: any;
+  const testUserId = `usr_api_student_${Date.now()}`;
+  let sessionCookie: string;
+
+  beforeAll(async () => {
+    db = await getDb();
+    await runMigrations();
+
+    await db.insert(schema.users).values({
+      id: testUserId,
+      githubId: Math.floor(Math.random() * 1000000),
+      githubUsername: "apistudent",
+      email: "apistudent@technexus.org",
+      role: "contributor",
+    });
+
+    const token = await createSessionToken({
+      id: testUserId,
+      githubId: 123456,
+      githubUsername: "apistudent",
+      displayName: "API Student",
+      email: "apistudent@technexus.org",
+      avatarUrl: null,
+      role: "contributor",
+      level: "explorer",
+      isOnboarded: true,
+      foundingNumber: null,
+    });
+
+    sessionCookie = `${COOKIE_NAME}=${token}`;
+  });
+
+  it("GET /api/learn/tracks returns published tracks", async () => {
+    const req = new NextRequest("http://localhost:3000/api/learn/tracks", {
+      headers: { cookie: sessionCookie },
+    });
+
+    const res = await getTracksHandler(req);
+    expect(res.status).toBe(200);
+
+    const data = await res.json();
+    expect(data.tracks).toBeDefined();
+    expect(data.tracks.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("POST /api/learn/enroll enrolls logged-in student in track", async () => {
+    const track = await getTrackBySlug("linux-fundamentals", testUserId, db);
+    expect(track).toBeDefined();
+
+    // Unauthorized without cookie
+    const unauthReq = new NextRequest("http://localhost:3000/api/learn/enroll", {
+      method: "POST",
+      body: JSON.stringify({ trackId: track!.id }),
+    });
+    const unauthRes = await enrollHandler(unauthReq);
+    expect(unauthRes.status).toBe(401);
+
+    // Authorized enrollment
+    const authReq = new NextRequest("http://localhost:3000/api/learn/enroll", {
+      method: "POST",
+      headers: {
+        cookie: sessionCookie,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ trackId: track!.id }),
+    });
+
+    const authRes = await enrollHandler(authReq);
+    expect(authRes.status).toBe(200);
+    const data = await authRes.json();
+    expect(data.success).toBe(true);
+    expect(data.enrollment.trackId).toBe(track!.id);
+  });
+
+  it("POST /api/learn/lessons/[id]/progress updates completion status", async () => {
+    const track = await getTrackBySlug("linux-fundamentals", testUserId, db);
+    const lesson = track!.modules[0].lessons[0];
+
+    const req = new NextRequest(
+      `http://localhost:3000/api/learn/lessons/${lesson.id}/progress`,
+      {
+        method: "POST",
+        headers: {
+          cookie: sessionCookie,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ completed: true }),
+      }
+    );
+
+    const res = await progressHandler(req, {
+      params: Promise.resolve({ id: lesson.id }),
+    });
+
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.success).toBe(true);
+    expect(data.completed).toBe(true);
+    expect(data.completedLessons).toBeGreaterThanOrEqual(1);
+  });
+
+  it("POST /api/learn/assignments/[id]/submit handles submissions with validation", async () => {
+    const track = await getTrackBySlug("git-open-source", testUserId, db);
+    const lastModule = track!.modules[track!.modules.length - 1];
+    const lastLesson = lastModule.lessons[lastModule.lessons.length - 1];
+
+    const [assignment] = await db
+      .select()
+      .from(schema.learningAssignments)
+      .where(eq(schema.learningAssignments.lessonId, lastLesson.id));
+
+    expect(assignment).toBeDefined();
+
+    // Invalid PR URL should return 400
+    const invalidReq = new NextRequest(
+      `http://localhost:3000/api/learn/assignments/${assignment.id}/submit`,
+      {
+        method: "POST",
+        headers: {
+          cookie: sessionCookie,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ content: "not-a-pr-url" }),
+      }
+    );
+
+    const invalidRes = await submitAssignmentHandler(invalidReq, {
+      params: Promise.resolve({ id: assignment.id }),
+    });
+    expect(invalidRes.status).toBe(400);
+
+    // Valid PR URL should return 200
+    const validReq = new NextRequest(
+      `http://localhost:3000/api/learn/assignments/${assignment.id}/submit`,
+      {
+        method: "POST",
+        headers: {
+          cookie: sessionCookie,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          content: "https://github.com/TechNexusOrg/platform/pull/15",
+        }),
+      }
+    );
+
+    const validRes = await submitAssignmentHandler(validReq, {
+      params: Promise.resolve({ id: assignment.id }),
+    });
+    expect(validRes.status).toBe(200);
+    const validData = await validRes.json();
+    expect(validData.success).toBe(true);
+    expect(validData.submission.content).toBe(
+      "https://github.com/TechNexusOrg/platform/pull/15"
+    );
+  });
+});
diff --git a/src/app/api/learn/tracks/route.ts b/src/app/api/learn/tracks/route.ts
new file mode 100644
index 0000000..ad9832f
--- /dev/null
+++ b/src/app/api/learn/tracks/route.ts
@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { listTracks } from "@/lib/learning/service";
+
+export async function GET(request: NextRequest) {
+  try {
+    const token = request.cookies.get(COOKIE_NAME)?.value;
+    let userId: string | undefined;
+
+    if (token) {
+      const sessionUser = await verifySessionToken(token);
+      if (sessionUser) {
+        userId = sessionUser.id;
+      }
+    }
+
+    const tracks = await listTracks({ userId, publishedOnly: true });
+    return NextResponse.json({ tracks });
+  } catch (error: any) {
+    console.error("Failed to list learning tracks:", error);
+    return NextResponse.json(
+      { error: "Failed to list learning tracks", details: error.message },
+      { status: 500 }
+    );
+  }
+}
diff --git a/src/app/learn/[trackSlug]/[lessonSlug]/LessonViewer.tsx b/src/app/learn/[trackSlug]/[lessonSlug]/LessonViewer.tsx
new file mode 100644
index 0000000..6b5f45c
--- /dev/null
+++ b/src/app/learn/[trackSlug]/[lessonSlug]/LessonViewer.tsx
@@ -0,0 +1,305 @@
+"use client";
+
+import React, { useState } from "react";
+import Link from "next/link";
+import { MarkdownRenderer } from "@/components/MarkdownRenderer";
+import type { DetailedLesson } from "@/lib/learning/service";
+
+interface LessonViewerProps {
+  lesson: DetailedLesson;
+  isLoggedIn: boolean;
+}
+
+export function LessonViewer({ lesson, isLoggedIn }: LessonViewerProps) {
+  const [isCompleted, setIsCompleted] = useState(lesson.isCompleted);
+  const [isToggling, setIsToggling] = useState(false);
+
+  // Assignment states
+  const [submissionContent, setSubmissionContent] = useState(
+    lesson.assignment?.userSubmission?.content || ""
+  );
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [submissionStatus, setSubmissionStatus] = useState<string | null>(
+    lesson.assignment?.userSubmission?.status || null
+  );
+  const [submissionMessage, setSubmissionMessage] = useState<string | null>(
+    null
+  );
+  const [submissionError, setSubmissionError] = useState<string | null>(null);
+
+  const handleToggleCompletion = async () => {
+    if (!isLoggedIn) {
+      window.location.href = "/join";
+      return;
+    }
+
+    setIsToggling(true);
+    try {
+      const res = await fetch(`/api/learn/lessons/${lesson.id}/progress`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ completed: !isCompleted }),
+      });
+
+      if (!res.ok) {
+        const errorData = await res.json();
+        throw new Error(errorData.error || "Failed to update progress");
+      }
+
+      setIsCompleted(!isCompleted);
+    } catch (err: any) {
+      console.error(err);
+      alert(err.message || "Failed to update progress");
+    } finally {
+      setIsToggling(false);
+    }
+  };
+
+  const handleAssignmentSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!lesson.assignment) return;
+
+    if (!isLoggedIn) {
+      window.location.href = "/join";
+      return;
+    }
+
+    if (!submissionContent.trim()) {
+      setSubmissionError("Please provide submission content");
+      return;
+    }
+
+    setIsSubmitting(true);
+    setSubmissionError(null);
+    setSubmissionMessage(null);
+
+    try {
+      const res = await fetch(
+        `/api/learn/assignments/${lesson.assignment.id}/submit`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ content: submissionContent.trim() }),
+        }
+      );
+
+      const data = await res.json();
+      if (!res.ok) {
+        throw new Error(data.error || "Failed to submit assignment");
+      }
+
+      setSubmissionStatus("submitted");
+      setSubmissionMessage("Assignment submitted successfully for review!");
+    } catch (err: any) {
+      setSubmissionError(err.message || "Failed to submit assignment");
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <div className="mx-auto max-w-4xl px-4 sm:px-6 lg:px-8 py-8">
+      {/* Top Breadcrumb & Metadata */}
+      <nav className="flex flex-wrap items-center gap-2 text-xs font-mono text-slate-400 mb-6">
+        <Link href="/learn" className="hover:text-emerald-400 transition-colors">
+          Tracks
+        </Link>
+        <span>/</span>
+        <Link
+          href={`/learn/${lesson.track.slug}`}
+          className="hover:text-emerald-400 transition-colors"
+        >
+          {lesson.track.title}
+        </Link>
+        <span>/</span>
+        <span className="text-slate-500">{lesson.module.title}</span>
+      </nav>
+
+      {/* Lesson Header Banner */}
+      <div className="rounded-xl border border-slate-800 bg-slate-900/40 p-6 backdrop-blur-sm mb-8">
+        <div className="flex flex-wrap items-center justify-between gap-4">
+          <div>
+            <div className="flex items-center gap-2 mb-2">
+              <span className="px-2 py-0.5 rounded text-[11px] font-mono bg-emerald-500/10 text-emerald-400 border border-emerald-500/20">
+                {lesson.module.title}
+              </span>
+              <span className="text-xs font-mono text-slate-400">
+                ⏱ {lesson.estimatedMinutes} minutes
+              </span>
+            </div>
+            <h1 className="text-2xl sm:text-3xl font-bold font-mono text-white tracking-tight">
+              {lesson.title}
+            </h1>
+          </div>
+
+          {/* Completion Toggle */}
+          <button
+            type="button"
+            onClick={handleToggleCompletion}
+            disabled={isToggling}
+            className={`inline-flex items-center gap-2 rounded-lg px-4 py-2 text-xs sm:text-sm font-semibold font-mono transition-all ${
+              isCompleted
+                ? "bg-emerald-500/20 text-emerald-400 border border-emerald-500/50 hover:bg-emerald-500/30"
+                : "bg-slate-800 text-slate-300 border border-slate-700 hover:bg-slate-700 hover:text-white"
+            }`}
+          >
+            {isCompleted ? (
+              <>
+                <span>✓</span> Completed
+              </>
+            ) : (
+              <>
+                <span className="h-3.5 w-3.5 rounded-full border border-slate-400 inline-block" />
+                Mark as Complete
+              </>
+            )}
+          </button>
+        </div>
+      </div>
+
+      {/* Lesson Content */}
+      <article className="prose prose-invert max-w-none rounded-xl border border-slate-800/80 bg-slate-900/20 p-6 sm:p-8">
+        <MarkdownRenderer content={lesson.content} />
+      </article>
+
+      {/* Practical Assignment Section */}
+      {lesson.assignment && (
+        <section className="mt-10 rounded-xl border border-purple-500/30 bg-purple-950/10 p-6 sm:p-8">
+          <div className="flex items-center gap-2 mb-2">
+            <span className="px-2 py-0.5 rounded text-[10px] font-mono uppercase tracking-wider bg-purple-500/20 text-purple-300 border border-purple-500/30">
+              Capstone Assignment
+            </span>
+            {submissionStatus && (
+              <span
+                className={`px-2 py-0.5 rounded text-[10px] font-mono uppercase tracking-wider ${
+                  submissionStatus === "approved"
+                    ? "bg-emerald-500/20 text-emerald-300 border border-emerald-500/30"
+                    : submissionStatus === "needs_revision"
+                    ? "bg-amber-500/20 text-amber-300 border border-amber-500/30"
+                    : "bg-sky-500/20 text-sky-300 border border-sky-500/30"
+                }`}
+              >
+                Status: {submissionStatus.replace("_", " ")}
+              </span>
+            )}
+          </div>
+
+          <h2 className="text-xl font-bold font-mono text-white mb-2">
+            {lesson.assignment.title}
+          </h2>
+
+          <p className="text-sm text-slate-300 mb-4 leading-relaxed">
+            {lesson.assignment.description}
+          </p>
+
+          {/* Acceptance Criteria */}
+          {lesson.assignment.acceptanceCriteria.length > 0 && (
+            <div className="mb-6 rounded-lg border border-slate-800 bg-slate-900/60 p-4">
+              <h3 className="text-xs font-mono font-semibold uppercase tracking-wider text-purple-300 mb-2">
+                Acceptance Criteria
+              </h3>
+              <ul className="text-xs text-slate-300 space-y-1.5">
+                {lesson.assignment.acceptanceCriteria.map((criterion, idx) => (
+                  <li key={idx} className="flex items-start gap-2">
+                    <span className="text-purple-400 font-bold">•</span>
+                    <span>{criterion}</span>
+                  </li>
+                ))}
+              </ul>
+            </div>
+          )}
+
+          {/* Submission Form */}
+          <form onSubmit={handleAssignmentSubmit} className="space-y-4">
+            <div>
+              <label className="block text-xs font-mono font-medium text-slate-300 mb-1.5">
+                {lesson.assignment.submissionType === "github_pr"
+                  ? "Pull Request URL (e.g. https://github.com/owner/repo/pull/12)"
+                  : "Terminal Output / Verification Logs"}
+              </label>
+
+              {lesson.assignment.submissionType === "github_pr" ? (
+                <input
+                  type="url"
+                  placeholder="https://github.com/TechNexusOrg/platform/pull/..."
+                  value={submissionContent}
+                  onChange={(e) => setSubmissionContent(e.target.value)}
+                  className="w-full rounded-lg border border-slate-700 bg-slate-900 px-3.5 py-2.5 text-sm text-white placeholder-slate-500 focus:border-purple-500 focus:outline-none focus:ring-1 focus:ring-purple-500 font-mono"
+                  required
+                />
+              ) : (
+                <textarea
+                  rows={6}
+                  placeholder="Paste terminal command output verifying systemd service status and journal logs..."
+                  value={submissionContent}
+                  onChange={(e) => setSubmissionContent(e.target.value)}
+                  className="w-full rounded-lg border border-slate-700 bg-slate-900 px-3.5 py-2.5 text-xs text-emerald-400 placeholder-slate-500 focus:border-purple-500 focus:outline-none focus:ring-1 focus:ring-purple-500 font-mono"
+                  required
+                />
+              )}
+            </div>
+
+            {submissionError && (
+              <p className="text-xs font-mono text-red-400">{submissionError}</p>
+            )}
+
+            {submissionMessage && (
+              <p className="text-xs font-mono text-emerald-400">
+                {submissionMessage}
+              </p>
+            )}
+
+            {lesson.assignment.userSubmission?.feedback && (
+              <div className="rounded-lg border border-amber-500/30 bg-amber-950/20 p-3 text-xs text-amber-200">
+                <span className="font-semibold font-mono">Mentor Feedback: </span>
+                {lesson.assignment.userSubmission.feedback}
+              </div>
+            )}
+
+            <button
+              type="submit"
+              disabled={isSubmitting}
+              className="inline-flex items-center justify-center rounded-lg bg-purple-600 px-4 py-2 text-xs sm:text-sm font-semibold font-mono text-white shadow-sm hover:bg-purple-500 transition-all disabled:opacity-50"
+            >
+              {isSubmitting
+                ? "Submitting..."
+                : submissionStatus
+                ? "Update Submission"
+                : "Submit Assignment for Review"}
+            </button>
+          </form>
+        </section>
+      )}
+
+      {/* Bottom Navigation */}
+      <div className="mt-10 flex items-center justify-between border-t border-slate-800 pt-6">
+        {lesson.previousLesson ? (
+          <Link
+            href={`/learn/${lesson.track.slug}/${lesson.previousLesson.slug}`}
+            className="inline-flex items-center gap-2 rounded-lg border border-slate-800 bg-slate-900/50 px-4 py-2 text-xs sm:text-sm font-mono text-slate-300 hover:border-slate-700 hover:text-white transition-colors"
+          >
+            ← {lesson.previousLesson.title}
+          </Link>
+        ) : (
+          <div />
+        )}
+
+        {lesson.nextLesson ? (
+          <Link
+            href={`/learn/${lesson.track.slug}/${lesson.nextLesson.slug}`}
+            className="inline-flex items-center gap-2 rounded-lg bg-emerald-600 px-4 py-2 text-xs sm:text-sm font-semibold font-mono text-white hover:bg-emerald-500 transition-colors shadow-sm"
+          >
+            {lesson.nextLesson.title} →
+          </Link>
+        ) : (
+          <Link
+            href={`/learn/${lesson.track.slug}`}
+            className="inline-flex items-center gap-2 rounded-lg bg-emerald-600 px-4 py-2 text-xs sm:text-sm font-semibold font-mono text-white hover:bg-emerald-500 transition-colors shadow-sm"
+          >
+            Back to Syllabus ✓
+          </Link>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/app/learn/[trackSlug]/[lessonSlug]/page.tsx b/src/app/learn/[trackSlug]/[lessonSlug]/page.tsx
new file mode 100644
index 0000000..5c8217c
--- /dev/null
+++ b/src/app/learn/[trackSlug]/[lessonSlug]/page.tsx
@@ -0,0 +1,48 @@
+import { notFound } from "next/navigation";
+import { cookies } from "next/headers";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { getLesson } from "@/lib/learning/service";
+import { Navbar } from "@/components/Navbar";
+import { LessonViewer } from "./LessonViewer";
+
+interface LessonPageProps {
+  params: Promise<{
+    trackSlug: string;
+    lessonSlug: string;
+  }>;
+}
+
+export const dynamic = "force-dynamic";
+
+export async function generateMetadata({ params }: LessonPageProps) {
+  const { trackSlug, lessonSlug } = await params;
+  const lesson = await getLesson(trackSlug, lessonSlug);
+  if (!lesson) return { title: "Lesson Not Found — TechNexusOrg" };
+
+  return {
+    title: `${lesson.title} — ${lesson.track.title} | TechNexusOrg`,
+    description: `Learn ${lesson.title} in the ${lesson.track.title} learning track on TechNexusOrg.`,
+  };
+}
+
+export default async function LessonPage({ params }: LessonPageProps) {
+  const { trackSlug, lessonSlug } = await params;
+  const cookieStore = await cookies();
+  const token = cookieStore.get(COOKIE_NAME)?.value;
+  const user = token ? await verifySessionToken(token) : null;
+
+  const lesson = await getLesson(trackSlug, lessonSlug, user?.id);
+
+  if (!lesson) {
+    notFound();
+  }
+
+  return (
+    <div className="min-h-screen bg-[#07090e] text-slate-100">
+      <Navbar />
+      <main>
+        <LessonViewer lesson={lesson} isLoggedIn={!!user} />
+      </main>
+    </div>
+  );
+}
diff --git a/src/app/learn/[trackSlug]/page.tsx b/src/app/learn/[trackSlug]/page.tsx
new file mode 100644
index 0000000..0472ffc
--- /dev/null
+++ b/src/app/learn/[trackSlug]/page.tsx
@@ -0,0 +1,235 @@
+import Link from "next/link";
+import { notFound } from "next/navigation";
+import { cookies } from "next/headers";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { getTrackBySlug } from "@/lib/learning/service";
+import { Navbar } from "@/components/Navbar";
+
+interface TrackPageProps {
+  params: Promise<{
+    trackSlug: string;
+  }>;
+}
+
+export const dynamic = "force-dynamic";
+
+export async function generateMetadata({ params }: TrackPageProps) {
+  const { trackSlug } = await params;
+  const track = await getTrackBySlug(trackSlug);
+  if (!track) return { title: "Track Not Found — TechNexusOrg" };
+
+  return {
+    title: `${track.title} — TechNexusOrg Learning`,
+    description: track.description,
+  };
+}
+
+export default async function TrackDetailPage({ params }: TrackPageProps) {
+  const { trackSlug } = await params;
+  const cookieStore = await cookies();
+  const token = cookieStore.get(COOKIE_NAME)?.value;
+  const user = token ? await verifySessionToken(token) : null;
+
+  const track = await getTrackBySlug(trackSlug, user?.id);
+
+  if (!track) {
+    notFound();
+  }
+
+  // Find the first uncompleted lesson for "Continue" button
+  let firstIncompleteLessonSlug = track.modules[0]?.lessons[0]?.slug;
+  for (const mod of track.modules) {
+    const uncompleted = mod.lessons.find((l) => !l.isCompleted);
+    if (uncompleted) {
+      firstIncompleteLessonSlug = uncompleted.slug;
+      break;
+    }
+  }
+
+  return (
+    <div className="min-h-screen bg-[#07090e] text-slate-100">
+      <Navbar />
+
+      <main className="mx-auto max-w-5xl px-4 sm:px-6 lg:px-8 py-10">
+        {/* Breadcrumb */}
+        <nav className="flex items-center gap-2 text-xs font-mono text-slate-400 mb-6">
+          <Link href="/learn" className="hover:text-emerald-400 transition-colors">
+            Tracks
+          </Link>
+          <span>/</span>
+          <span className="text-slate-200">{track.title}</span>
+        </nav>
+
+        {/* Track Header Card */}
+        <div className="rounded-xl border border-slate-800 bg-slate-900/40 p-6 sm:p-8 backdrop-blur-sm">
+          <div className="flex flex-wrap items-center gap-2 mb-3">
+            <span
+              className={`px-2.5 py-0.5 rounded text-xs font-mono font-medium uppercase tracking-wider ${
+                track.difficulty === "beginner"
+                  ? "bg-emerald-500/10 text-emerald-400 border border-emerald-500/30"
+                  : track.difficulty === "intermediate"
+                  ? "bg-sky-500/10 text-sky-400 border border-sky-500/30"
+                  : "bg-purple-500/10 text-purple-400 border border-purple-500/30"
+              }`}
+            >
+              {track.difficulty}
+            </span>
+            <span className="px-2.5 py-0.5 rounded text-xs font-mono text-slate-400 bg-slate-800/60 border border-slate-700/50">
+              ⏱ {track.estimatedHours} Hours
+            </span>
+            <span className="px-2.5 py-0.5 rounded text-xs font-mono text-slate-400 bg-slate-800/60 border border-slate-700/50">
+              📚 {track.moduleCount} Modules • {track.lessonCount} Lessons
+            </span>
+          </div>
+
+          <h1 className="text-2xl sm:text-3xl font-bold tracking-tight text-white font-mono">
+            {track.title}
+          </h1>
+
+          <p className="mt-3 text-base text-slate-300 leading-relaxed max-w-3xl">
+            {track.description}
+          </p>
+
+          {/* User Progress Bar */}
+          {user && (
+            <div className="mt-6 pt-6 border-t border-slate-800/80">
+              <div className="flex items-center justify-between text-xs font-mono mb-2">
+                <span className="text-slate-400">
+                  {track.completedLessonsCount} of {track.lessonCount} lessons completed
+                </span>
+                <span className="font-semibold text-emerald-400">
+                  {track.progressPercentage}%
+                </span>
+              </div>
+              <div className="h-2.5 w-full rounded-full bg-slate-800 overflow-hidden">
+                <div
+                  className="h-full bg-emerald-500 transition-all duration-500"
+                  style={{ width: `${track.progressPercentage}%` }}
+                />
+              </div>
+            </div>
+          )}
+
+          {/* Action CTA */}
+          <div className="mt-6 flex flex-wrap gap-4">
+            {firstIncompleteLessonSlug && (
+              <Link
+                href={`/learn/${track.slug}/${firstIncompleteLessonSlug}`}
+                className="inline-flex items-center justify-center rounded-lg bg-emerald-600 px-5 py-2.5 text-sm font-semibold text-white shadow-sm hover:bg-emerald-500 transition-all font-mono"
+              >
+                {track.progressPercentage && track.progressPercentage > 0
+                  ? "Resume Track →"
+                  : "Start Learning →"}
+              </Link>
+            )}
+          </div>
+        </div>
+
+        {/* Learning Objectives & Prerequisites */}
+        <div className="mt-8 grid grid-cols-1 md:grid-cols-2 gap-6">
+          <div className="rounded-xl border border-slate-800/80 bg-slate-900/30 p-5">
+            <h3 className="text-sm font-mono font-semibold uppercase tracking-wider text-emerald-400 mb-3">
+              Learning Objectives
+            </h3>
+            <ul className="text-xs sm:text-sm text-slate-300 space-y-2">
+              {track.objectives.map((obj, idx) => (
+                <li key={idx} className="flex items-start gap-2">
+                  <span className="text-emerald-400 font-bold mt-0.5">✓</span>
+                  <span>{obj}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+
+          <div className="rounded-xl border border-slate-800/80 bg-slate-900/30 p-5">
+            <h3 className="text-sm font-mono font-semibold uppercase tracking-wider text-sky-400 mb-3">
+              Prerequisites
+            </h3>
+            <ul className="text-xs sm:text-sm text-slate-300 space-y-2">
+              {track.prerequisites.map((prereq, idx) => (
+                <li key={idx} className="flex items-start gap-2">
+                  <span className="text-sky-400 font-bold mt-0.5">•</span>
+                  <span>{prereq}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+        </div>
+
+        {/* Modules & Syllabus */}
+        <div className="mt-10">
+          <h2 className="text-xl font-bold font-mono text-white mb-6">
+            Curriculum Syllabus
+          </h2>
+
+          <div className="space-y-6">
+            {track.modules.map((module, modIdx) => (
+              <div
+                key={module.id}
+                className="rounded-xl border border-slate-800 bg-slate-900/40 overflow-hidden"
+              >
+                <div className="p-5 border-b border-slate-800/80 bg-slate-900/60 flex items-start justify-between gap-4">
+                  <div>
+                    <span className="text-xs font-mono uppercase tracking-wider text-emerald-400">
+                      Module {modIdx + 1}
+                    </span>
+                    <h3 className="text-lg font-semibold text-white mt-1">
+                      {module.title}
+                    </h3>
+                    <p className="text-xs sm:text-sm text-slate-400 mt-1">
+                      {module.description}
+                    </p>
+                  </div>
+                  <span className="text-xs font-mono text-slate-500 whitespace-nowrap">
+                    {module.lessons.length} lessons
+                  </span>
+                </div>
+
+                <div className="divide-y divide-slate-800/50">
+                  {module.lessons.map((lesson, lesIdx) => (
+                    <Link
+                      key={lesson.id}
+                      href={`/learn/${track.slug}/${lesson.slug}`}
+                      className="group flex items-center justify-between p-4 sm:px-6 hover:bg-slate-800/40 transition-colors"
+                    >
+                      <div className="flex items-center gap-3">
+                        <div
+                          className={`flex h-6 w-6 shrink-0 items-center justify-center rounded-full text-xs font-mono font-medium ${
+                            lesson.isCompleted
+                              ? "bg-emerald-500/20 text-emerald-400 border border-emerald-500/40"
+                              : "bg-slate-800 text-slate-400 border border-slate-700"
+                          }`}
+                        >
+                          {lesson.isCompleted ? "✓" : lesIdx + 1}
+                        </div>
+                        <div>
+                          <p className="text-sm font-medium text-slate-200 group-hover:text-emerald-400 transition-colors">
+                            {lesson.title}
+                          </p>
+                          <div className="flex items-center gap-2 mt-0.5">
+                            <span className="text-xs font-mono text-slate-500">
+                              ⏱ {lesson.estimatedMinutes} min
+                            </span>
+                            {lesson.hasAssignment && (
+                              <span className="inline-flex items-center px-1.5 py-0.5 rounded text-[10px] font-mono bg-purple-500/10 text-purple-400 border border-purple-500/30">
+                                Practical Assignment
+                              </span>
+                            )}
+                          </div>
+                        </div>
+                      </div>
+
+                      <span className="text-xs font-mono text-slate-500 group-hover:text-emerald-400 transition-colors">
+                        Start →
+                      </span>
+                    </Link>
+                  ))}
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      </main>
+    </div>
+  );
+}
diff --git a/src/app/learn/page.tsx b/src/app/learn/page.tsx
new file mode 100644
index 0000000..063cd17
--- /dev/null
+++ b/src/app/learn/page.tsx
@@ -0,0 +1,149 @@
+import Link from "next/link";
+import { cookies } from "next/headers";
+import { verifySessionToken, COOKIE_NAME } from "@/lib/auth/session";
+import { listTracks } from "@/lib/learning/service";
+import { Navbar } from "@/components/Navbar";
+
+export const metadata = {
+  title: "Learning Tracks — TechNexusOrg",
+  description:
+    "Structured, self-paced technical learning tracks designed to prepare students for real-world engineering and open-source contributions.",
+};
+
+export const dynamic = "force-dynamic";
+
+export default async function LearnPage() {
+  const cookieStore = await cookies();
+  const token = cookieStore.get(COOKIE_NAME)?.value;
+  const user = token ? await verifySessionToken(token) : null;
+
+  const tracks = await listTracks({ userId: user?.id, publishedOnly: true });
+
+  return (
+    <div className="min-h-screen bg-[#07090e] text-slate-100">
+      <Navbar />
+
+      <main className="mx-auto max-w-7xl px-4 sm:px-6 lg:px-8 py-12">
+        {/* Header section */}
+        <div className="max-w-3xl">
+          <div className="inline-flex items-center gap-2 px-2.5 py-1 rounded-full text-xs font-mono font-medium bg-emerald-500/10 text-emerald-400 border border-emerald-500/20 mb-4">
+            <span className="h-1.5 w-1.5 rounded-full bg-emerald-400 animate-pulse" />
+            Curriculum Pilot
+          </div>
+          <h1 className="text-3xl sm:text-4xl font-bold tracking-tight text-white font-mono">
+            Structured Learning Tracks
+          </h1>
+          <p className="mt-3 text-base sm:text-lg text-slate-400 leading-relaxed">
+            Bridge academic theory and production software engineering. Each track contains
+            hands-on terminal exercises, internal architecture deep-dives, and verifiable capstone assignments.
+          </p>
+        </div>
+
+        {/* Tracks Grid */}
+        <div className="mt-10 grid grid-cols-1 md:grid-cols-2 gap-6 lg:gap-8">
+          {tracks.map((track) => {
+            const isCompleted = track.enrollmentStatus === "completed";
+            const isInProgress = track.enrollmentStatus === "in_progress";
+
+            return (
+              <div
+                key={track.id}
+                className="flex flex-col justify-between rounded-xl border border-slate-800/80 bg-slate-900/40 p-6 sm:p-8 backdrop-blur-sm transition-all hover:border-slate-700 hover:shadow-xl hover:shadow-emerald-950/10"
+              >
+                <div>
+                  {/* Badges */}
+                  <div className="flex flex-wrap items-center gap-2 mb-4">
+                    <span
+                      className={`px-2.5 py-0.5 rounded text-xs font-mono font-medium uppercase tracking-wider ${
+                        track.difficulty === "beginner"
+                          ? "bg-emerald-500/10 text-emerald-400 border border-emerald-500/30"
+                          : track.difficulty === "intermediate"
+                          ? "bg-sky-500/10 text-sky-400 border border-sky-500/30"
+                          : "bg-purple-500/10 text-purple-400 border border-purple-500/30"
+                      }`}
+                    >
+                      {track.difficulty}
+                    </span>
+                    <span className="px-2.5 py-0.5 rounded text-xs font-mono text-slate-400 bg-slate-800/60 border border-slate-700/50">
+                      ⏱ {track.estimatedHours} hrs
+                    </span>
+                    <span className="px-2.5 py-0.5 rounded text-xs font-mono text-slate-400 bg-slate-800/60 border border-slate-700/50">
+                      📚 {track.moduleCount} modules • {track.lessonCount} lessons
+                    </span>
+                  </div>
+
+                  <h2 className="text-xl sm:text-2xl font-semibold text-white tracking-tight">
+                    <Link
+                      href={`/learn/${track.slug}`}
+                      className="hover:text-emerald-400 transition-colors"
+                    >
+                      {track.title}
+                    </Link>
+                  </h2>
+
+                  <p className="mt-3 text-sm text-slate-400 leading-relaxed">
+                    {track.description}
+                  </p>
+
+                  {/* Prerequisites Preview */}
+                  {track.prerequisites.length > 0 && (
+                    <div className="mt-4 pt-4 border-t border-slate-800/60">
+                      <p className="text-xs font-mono uppercase tracking-wider text-slate-500 mb-2">
+                        Prerequisites
+                      </p>
+                      <ul className="text-xs text-slate-400 space-y-1">
+                        {track.prerequisites.map((prereq, idx) => (
+                          <li key={idx} className="flex items-start gap-1.5">
+                            <span className="text-slate-600">•</span>
+                            <span>{prereq}</span>
+                          </li>
+                        ))}
+                      </ul>
+                    </div>
+                  )}
+                </div>
+
+                {/* Progress & CTA */}
+                <div className="mt-6 pt-6 border-t border-slate-800/80">
+                  {user && track.enrollmentStatus ? (
+                    <div className="mb-4">
+                      <div className="flex items-center justify-between text-xs font-mono mb-1.5">
+                        <span className="text-slate-400">
+                          {isCompleted
+                            ? "Track Completed"
+                            : `${track.completedLessonsCount || 0} of ${track.lessonCount} lessons completed`}
+                        </span>
+                        <span className="font-semibold text-emerald-400">
+                          {track.progressPercentage}%
+                        </span>
+                      </div>
+                      <div className="h-2 w-full rounded-full bg-slate-800 overflow-hidden">
+                        <div
+                          className={`h-full transition-all duration-500 ${
+                            isCompleted ? "bg-emerald-400" : "bg-sky-400"
+                          }`}
+                          style={{ width: `${track.progressPercentage}%` }}
+                        />
+                      </div>
+                    </div>
+                  ) : null}
+
+                  <Link
+                    href={`/learn/${track.slug}`}
+                    className="inline-flex w-full items-center justify-center rounded-lg bg-emerald-600 px-4 py-2.5 text-sm font-semibold text-white shadow-sm hover:bg-emerald-500 transition-all focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-emerald-600 font-mono"
+                  >
+                    {isCompleted
+                      ? "Review Track Syllabus →"
+                      : isInProgress
+                      ? "Continue Learning →"
+                      : "Explore Syllabus →"}
+                  </Link>
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      </main>
+    </div>
+  );
+}
diff --git a/src/components/MarkdownRenderer.tsx b/src/components/MarkdownRenderer.tsx
new file mode 100644
index 0000000..c7b6e8b
--- /dev/null
+++ b/src/components/MarkdownRenderer.tsx
@@ -0,0 +1,223 @@
+"use client";
+
+import React from "react";
+
+interface MarkdownRendererProps {
+  content: string;
+}
+
+export function MarkdownRenderer({ content }: MarkdownRendererProps) {
+  const lines = content.split("\n");
+  const elements: React.ReactNode[] = [];
+  let inCodeBlock = false;
+  let codeBlockContent: string[] = [];
+  let codeLanguage = "";
+  let listItems: string[] = [];
+  let listType: "ul" | "ol" | null = null;
+
+  const flushList = () => {
+    if (listItems.length > 0 && listType) {
+      if (listType === "ul") {
+        elements.push(
+          <ul
+            key={`list-${elements.length}`}
+            className="my-3 space-y-1.5 list-disc list-inside text-slate-300 text-sm leading-relaxed"
+          >
+            {listItems.map((item, idx) => (
+              <li key={idx} className="text-slate-300">
+                {renderInline(item)}
+              </li>
+            ))}
+          </ul>
+        );
+      } else {
+        elements.push(
+          <ol
+            key={`list-${elements.length}`}
+            className="my-3 space-y-1.5 list-decimal list-inside text-slate-300 text-sm leading-relaxed"
+          >
+            {listItems.map((item, idx) => (
+              <li key={idx} className="text-slate-300">
+                {renderInline(item)}
+              </li>
+            ))}
+          </ol>
+        );
+      }
+      listItems = [];
+      listType = null;
+    }
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Fenced Code Block start/end
+    if (line.trim().startsWith("```")) {
+      flushList();
+      if (inCodeBlock) {
+        // End code block
+        const codeText = codeBlockContent.join("\n");
+        elements.push(
+          <div
+            key={`code-${elements.length}`}
+            className="my-4 rounded-lg border border-slate-800 bg-[#06080d] p-4 font-mono text-xs text-emerald-400 overflow-x-auto shadow-inner"
+          >
+            {codeLanguage && (
+              <div className="text-[10px] uppercase tracking-wider text-slate-500 mb-2 border-b border-slate-800 pb-1">
+                {codeLanguage}
+              </div>
+            )}
+            <pre className="font-mono leading-relaxed">{codeText}</pre>
+          </div>
+        );
+        inCodeBlock = false;
+        codeBlockContent = [];
+        codeLanguage = "";
+      } else {
+        // Start code block
+        inCodeBlock = true;
+        codeLanguage = line.trim().replace(/^```/, "");
+        codeBlockContent = [];
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeBlockContent.push(line);
+      continue;
+    }
+
+    // Dividers
+    if (line.trim() === "---" || line.trim() === "***") {
+      flushList();
+      elements.push(
+        <hr
+          key={`hr-${elements.length}`}
+          className="my-6 border-slate-800"
+        />
+      );
+      continue;
+    }
+
+    // Headings
+    if (line.startsWith("### ")) {
+      flushList();
+      elements.push(
+        <h3
+          key={`h3-${elements.length}`}
+          className="mt-6 mb-2 text-base font-semibold text-white font-mono"
+        >
+          {renderInline(line.replace("### ", ""))}
+        </h3>
+      );
+      continue;
+    }
+
+    if (line.startsWith("## ")) {
+      flushList();
+      elements.push(
+        <h2
+          key={`h2-${elements.length}`}
+          className="mt-8 mb-3 text-lg sm:text-xl font-bold text-white font-mono border-b border-slate-800/80 pb-2"
+        >
+          {renderInline(line.replace("## ", ""))}
+        </h2>
+      );
+      continue;
+    }
+
+    if (line.startsWith("# ")) {
+      flushList();
+      elements.push(
+        <h1
+          key={`h1-${elements.length}`}
+          className="mt-6 mb-4 text-2xl font-bold text-white font-mono"
+        >
+          {renderInline(line.replace("# ", ""))}
+        </h1>
+      );
+      continue;
+    }
+
+    // Unordered lists
+    if (line.trim().startsWith("- ") || line.trim().startsWith("* ")) {
+      if (listType === "ol") flushList();
+      listType = "ul";
+      listItems.push(line.trim().replace(/^[-*]\s+/, ""));
+      continue;
+    }
+
+    // Ordered lists
+    const numMatch = line.trim().match(/^(\d+)\.\s+(.*)$/);
+    if (numMatch) {
+      if (listType === "ul") flushList();
+      listType = "ol";
+      listItems.push(numMatch[2]);
+      continue;
+    }
+
+    // Normal paragraph or empty line
+    flushList();
+    if (line.trim().length === 0) {
+      continue;
+    }
+
+    elements.push(
+      <p
+        key={`p-${elements.length}`}
+        className="my-3 text-sm sm:text-base leading-relaxed text-slate-300"
+      >
+        {renderInline(line)}
+      </p>
+    );
+  }
+
+  flushList();
+
+  return <div className="space-y-1">{elements}</div>;
+}
+
+/**
+ * Parses inline bold, code, and links.
+ */
+function renderInline(text: string): React.ReactNode {
+  // Regex to match `code`, **bold**, or [text](url)
+  const regex = /(`[^`]+`|\*\*[^*]+\*\*|\[[^\]]+\]\([^)]+\))/g;
+  const parts = text.split(regex);
+
+  return parts.map((part, i) => {
+    if (part.startsWith("`") && part.endsWith("`")) {
+      return (
+        <code
+          key={i}
+          className="rounded bg-slate-800/80 px-1.5 py-0.5 font-mono text-xs text-emerald-300 border border-slate-700/60"
+        >
+          {part.slice(1, -1)}
+        </code>
+      );
+    }
+    if (part.startsWith("**") && part.endsWith("**")) {
+      return (
+        <strong key={i} className="font-semibold text-white">
+          {part.slice(2, -2)}
+        </strong>
+      );
+    }
+    const linkMatch = part.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+    if (linkMatch) {
+      return (
+        <a
+          key={i}
+          href={linkMatch[2]}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="text-emerald-400 underline hover:text-emerald-300 transition-colors"
+        >
+          {linkMatch[1]}
+        </a>
+      );
+    }
+    return part;
+  });
+}
diff --git a/src/components/Navbar.tsx b/src/components/Navbar.tsx
index 8c6922c..178d488 100644
--- a/src/components/Navbar.tsx
+++ b/src/components/Navbar.tsx
@@ -22,6 +22,9 @@ export async function Navbar() {
           </Link>
 
           <nav className="hidden md:flex items-center gap-6 text-sm font-medium text-slate-400">
+            <Link href="/learn" className="hover:text-white transition-colors">
+              Learn
+            </Link>
             <Link href="/issues" className="hover:text-white transition-colors">
               Issues
             </Link>
diff --git a/src/lib/db/schema.ts b/src/lib/db/schema.ts
index ee9c261..9e838c3 100644
--- a/src/lib/db/schema.ts
+++ b/src/lib/db/schema.ts
@@ -511,3 +511,187 @@ export const mentorRequests = pgTable(
     index("mentor_requests_status_idx").on(table.status),
   ]
 );
+
+// --- LEARNING TRACKS ---
+export const learningTracks = pgTable(
+  "learning_tracks",
+  {
+    id: text("id").primaryKey(),
+    slug: text("slug").notNull().unique(),
+    title: text("title").notNull(),
+    description: text("description").notNull(),
+    difficulty: text("difficulty", { enum: ["beginner", "intermediate", "advanced"] })
+      .default("beginner")
+      .notNull(),
+    estimatedHours: integer("estimated_hours").default(10).notNull(),
+    isPublished: boolean("is_published").default(false).notNull(),
+    prerequisites: jsonb("prerequisites").$type<string[]>().default([]).notNull(),
+    objectives: jsonb("objectives").$type<string[]>().default([]).notNull(),
+    orderIndex: integer("order_index").default(0).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    uniqueIndex("learning_tracks_slug_idx").on(table.slug),
+    index("learning_tracks_is_published_idx").on(table.isPublished),
+  ]
+);
+
+// --- LEARNING MODULES ---
+export const learningModules = pgTable(
+  "learning_modules",
+  {
+    id: text("id").primaryKey(),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => learningTracks.id, { onDelete: "cascade" }),
+    slug: text("slug").notNull(),
+    title: text("title").notNull(),
+    description: text("description").notNull(),
+    orderIndex: integer("order_index").default(0).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    index("learning_modules_track_id_idx").on(table.trackId),
+    index("learning_modules_order_idx").on(table.trackId, table.orderIndex),
+  ]
+);
+
+// --- LEARNING LESSONS ---
+export const learningLessons = pgTable(
+  "learning_lessons",
+  {
+    id: text("id").primaryKey(),
+    moduleId: text("module_id")
+      .notNull()
+      .references(() => learningModules.id, { onDelete: "cascade" }),
+    slug: text("slug").notNull(),
+    title: text("title").notNull(),
+    content: text("content").notNull(), // Markdown formatted
+    estimatedMinutes: integer("estimated_minutes").default(15).notNull(),
+    orderIndex: integer("order_index").default(0).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    index("learning_lessons_module_id_idx").on(table.moduleId),
+    index("learning_lessons_order_idx").on(table.moduleId, table.orderIndex),
+  ]
+);
+
+// --- LEARNING ENROLLMENTS ---
+export const learningEnrollments = pgTable(
+  "learning_enrollments",
+  {
+    id: text("id").primaryKey(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => learningTracks.id, { onDelete: "cascade" }),
+    status: text("status", { enum: ["enrolled", "in_progress", "completed"] })
+      .default("enrolled")
+      .notNull(),
+    enrolledAt: timestamp("enrolled_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    uniqueIndex("learning_enrollments_user_track_idx").on(table.userId, table.trackId),
+    index("learning_enrollments_user_id_idx").on(table.userId),
+    index("learning_enrollments_track_id_idx").on(table.trackId),
+  ]
+);
+
+// --- LESSON PROGRESS ---
+export const lessonProgress = pgTable(
+  "lesson_progress",
+  {
+    id: text("id").primaryKey(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    lessonId: text("lesson_id")
+      .notNull()
+      .references(() => learningLessons.id, { onDelete: "cascade" }),
+    completed: boolean("completed").default(true).notNull(),
+    completedAt: timestamp("completed_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [
+    uniqueIndex("lesson_progress_user_lesson_idx").on(table.userId, table.lessonId),
+    index("lesson_progress_user_id_idx").on(table.userId),
+    index("lesson_progress_lesson_id_idx").on(table.lessonId),
+  ]
+);
+
+// --- LEARNING ASSIGNMENTS ---
+export const learningAssignments = pgTable(
+  "learning_assignments",
+  {
+    id: text("id").primaryKey(),
+    lessonId: text("lesson_id")
+      .notNull()
+      .references(() => learningLessons.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    description: text("description").notNull(),
+    acceptanceCriteria: jsonb("acceptance_criteria").$type<string[]>().default([]).notNull(),
+    submissionType: text("submission_type", {
+      enum: ["github_pr", "text_submission", "terminal_output"],
+    })
+      .default("text_submission")
+      .notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => [index("learning_assignments_lesson_id_idx").on(table.lessonId)]
+);
+
+// --- ASSIGNMENT SUBMISSIONS ---
+export const assignmentSubmissions = pgTable(
+  "assignment_submissions",
+  {
+    id: text("id").primaryKey(),
+    assignmentId: text("assignment_id")
+      .notNull()
+      .references(() => learningAssignments.id, { onDelete: "cascade" }),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id, { onDelete: "cascade" }),
+    content: text("content").notNull(),
+    status: text("status", { enum: ["submitted", "approved", "needs_revision"] })
+      .default("submitted")
+      .notNull(),
+    reviewedBy: text("reviewed_by").references(() => users.id),
+    feedback: text("feedback"),
+    submittedAt: timestamp("submitted_at", { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    reviewedAt: timestamp("reviewed_at", { withTimezone: true }),
+  },
+  (table) => [
+    index("assignment_submissions_user_idx").on(table.userId),
+    index("assignment_submissions_assignment_idx").on(table.assignmentId),
+    index("assignment_submissions_status_idx").on(table.status),
+  ]
+);
diff --git a/src/lib/learning/content.ts b/src/lib/learning/content.ts
new file mode 100644
index 0000000..c54d8f3
--- /dev/null
+++ b/src/lib/learning/content.ts
@@ -0,0 +1,819 @@
+export interface LessonSeed {
+  slug: string;
+  title: string;
+  estimatedMinutes: number;
+  orderIndex: number;
+  content: string;
+  assignment?: {
+    title: string;
+    description: string;
+    acceptanceCriteria: string[];
+    submissionType: "github_pr" | "text_submission" | "terminal_output";
+  };
+}
+
+export interface ModuleSeed {
+  slug: string;
+  title: string;
+  description: string;
+  orderIndex: number;
+  lessons: LessonSeed[];
+}
+
+export interface TrackSeed {
+  slug: string;
+  title: string;
+  description: string;
+  difficulty: "beginner" | "intermediate" | "advanced";
+  estimatedHours: number;
+  isPublished: boolean;
+  orderIndex: number;
+  prerequisites: string[];
+  objectives: string[];
+  modules: ModuleSeed[];
+}
+
+export const PILOT_LEARNING_TRACKS: TrackSeed[] = [
+  {
+    slug: "linux-fundamentals",
+    title: "Linux Fundamentals and Administration",
+    description:
+      "Master POSIX system architecture, shell navigation, process management, storage operations, and systemd service administration through practical hands-on exercises.",
+    difficulty: "beginner",
+    estimatedHours: 12,
+    isPublished: true,
+    orderIndex: 1,
+    prerequisites: [
+      "Basic terminal familiarity",
+      "Access to a modern Linux distribution (Ubuntu 22.04+, Debian, Fedora) or WSL2",
+    ],
+    objectives: [
+      "Understand the POSIX filesystem hierarchy and execute standard shell operations with pipes and streams",
+      "Manage Linux file permissions (rwx), ownership, and special security bits (SUID, SGID, Sticky bit)",
+      "Inspect, monitor, and signal processes using ps, top, htop, and kill",
+      "Work with block devices, filesystems, and persistent mounts via /etc/fstab",
+      "Perform network diagnostics and configure hardened SSH key-based access",
+      "Write, manage, and debug systemd services, timers, and inspect system journals",
+    ],
+    modules: [
+      {
+        slug: "sys-navigation-basics",
+        title: "System Navigation & Shell Basics",
+        description:
+          "Explore the Linux Filesystem Hierarchy Standard, standard I/O redirection, pipeline mechanics, and file inspection tools.",
+        orderIndex: 1,
+        lessons: [
+          {
+            slug: "posix-shell-hierarchy",
+            title: "Introduction to POSIX Shell & File Hierarchy",
+            estimatedMinutes: 20,
+            orderIndex: 1,
+            content: `## 1. The POSIX Shell Environment
+
+The POSIX shell is the unified interface between the developer and the operating system kernel. Unlike graphical interfaces that obscure internal system state, the shell gives you direct control over process execution, input/output streams, and system configuration.
+
+### Standard I/O Streams
+Every Linux process starts with three default file descriptors:
+- **\`stdin\` (Descriptor 0)**: Standard input (default: keyboard)
+- **\`stdout\` (Descriptor 1)**: Standard output (default: terminal screen)
+- **\`stderr\` (Descriptor 2)**: Standard error (default: terminal screen)
+
+#### Redirection & Pipelines
+- \`command > file.txt\`: Redirect stdout, overwriting file.txt
+- \`command >> file.txt\`: Redirect stdout, appending to file.txt
+- \`command 2> error.log\`: Redirect stderr only
+- \`command > output.log 2>&1\`: Redirect both stdout and stderr to the same file
+- \`cmd1 | cmd2\`: Connect stdout of cmd1 directly to stdin of cmd2 via an anonymous kernel buffer
+
+\`\`\`bash
+# Example: Filter active SSH listening sockets and count them
+ss -tulpn | grep ":22" | wc -l
+\`\`\`
+
+---
+
+## 2. The Filesystem Hierarchy Standard (FHS)
+
+Linux treats everything as a file (or byte stream). The directory structure follows the standardized FHS:
+- \`/bin\`, \`/sbin\`: Essential binaries for all users and system administration (often symlinked to \`/usr/bin\`)
+- \`/etc\`: System-wide configuration files (plain text, human editable)
+- \`/home\`: User home directories containing personal configs and projects
+- \`/var\`: Variable data such as logs (\`/var/log\`), spools, and databases
+- \`/proc\`: Virtual filesystem exposing live kernel and process data (e.g., \`/proc/cpuinfo\`, \`/proc/[pid]/\`)
+- \`/sys\`: Virtual filesystem representing kernel subsystems, hardware, and device drivers
+- \`/tmp\`: Temporary files, often cleared on reboot
+
+---
+
+## 3. Essential Navigation & Search Commands
+
+\`\`\`bash
+# List directory contents with permissions, sizes in human-readable format
+ls -lah /var/log
+
+# Create nested directory trees
+mkdir -p ~/projects/technexus/pilot
+
+# Fast searching by file name in directory tree
+find /etc -name "*.conf" -type f 2>/dev/null
+
+# Search inside file contents recursively with line numbers
+grep -rn "ListenAddress" /etc/ssh/
+\`\`\`
+
+---
+
+## Hands-On Exercise
+1. In your terminal, inspect your kernel version and architecture using \`uname -a\`.
+2. Find all \`.conf\` files inside \`/etc/systemd/\` and count the total number using a single piped command:
+   \`\`\`bash
+   find /etc/systemd -name "*.conf" | wc -l
+   \`\`\`
+3. Verify that your standard streams work as expected by redirecting a directory listing to \`/tmp/test_fhs.log\`.`,
+          },
+          {
+            slug: "file-permissions-security",
+            title: "File Permissions, Ownership, and Security",
+            estimatedMinutes: 25,
+            orderIndex: 2,
+            content: `## 1. The Linux Permission Model
+
+Linux enforces multi-user access security through discretionary access control (DAC). Every file and directory has an **Owner**, a **Group**, and an **Others** category.
+
+### The Permission Bits
+- **Read (\`r\` / \`4\`)**: View file contents or list directory contents.
+- **Write (\`w\` / \`2\`)**: Modify file contents or create/delete files in a directory.
+- **Execute (\`x\` / \`1\`)**: Run file as binary/script or traverse (\`cd\`) into a directory.
+
+\`\`\`
+- rwx r-x r-- 1 alice developers 4096 Oct 30 10:00 deploy.sh
+  ^^^ ^^^ ^^^   ^^^^^ ^^^^^^^^^^
+   |   |   |      |       |
+   |   |   |      |       +-- Group ownership
+   |   |   |      +---------- User ownership
+   |   |   +----------------- Others permissions (4 = read-only)
+   |   +--------------------- Group permissions (5 = read + execute)
+   +------------------------- User permissions (7 = read + write + execute)
+\`\`\`
+
+---
+
+## 2. Modifying Permissions & Ownership
+
+### Symbolic vs Octal Notation
+\`\`\`bash
+# Octal mode: 755 (User: rwx, Group: rx, Others: rx)
+chmod 755 deploy.sh
+
+# Symbolic mode: Add execute for user only
+chmod u+x build.sh
+
+# Restrict sensitive configuration file to owner read/write only
+chmod 600 ~/.ssh/id_ed25519
+
+# Change owner and group recursively
+sudo chown -R alice:developers /opt/apps/backend
+\`\`\`
+
+---
+
+## 3. Special Permissions: SUID, SGID, and Sticky Bit
+
+1. **SUID (Set User ID - \`4000\`)**: The executable runs with the privileges of the file owner, not the caller (e.g., \`/usr/bin/passwd\`).
+2. **SGID (Set Group ID - \`2000\`)**:
+   - On files: runs with group privileges.
+   - On directories: newly created files inherit the parent directory's group instead of the creator's primary group.
+3. **Sticky Bit (\`1000\`)**:
+   - On directories: only the file owner or root can delete or rename files within it (e.g., \`/tmp\`).
+
+\`\`\`bash
+# Setting SGID on a shared project directory
+chmod 2775 /var/www/shared
+
+# Setting Sticky bit on a shared scratch directory
+chmod 1777 /tmp/scratch
+\`\`\`
+
+---
+
+## Hands-On Exercise
+1. Create a directory \`/tmp/perm_test\` and set permissions such that only your user can read and write files inside it (\`chmod 700\`).
+2. Verify that creating a file inside it inherits proper default permissions derived from your \`umask\`.`,
+          },
+        ],
+      },
+      {
+        slug: "process-and-storage",
+        title: "Process Management & Storage",
+        description:
+          "Monitor running workloads, manage process signals, inspect storage devices, and configure persistent filesystem mounts.",
+        orderIndex: 2,
+        lessons: [
+          {
+            slug: "processes-signals-monitoring",
+            title: "Processes, Signals, and System Monitoring",
+            estimatedMinutes: 25,
+            orderIndex: 1,
+            content: `## 1. Process Lifecycle and States
+
+Every task running in Linux is a process identified by a unique **Process ID (PID)**. Every process (except \`systemd\` at PID 1) is spawned by a **Parent Process (PPID)** via the \`fork()\` and \`exec()\` system calls.
+
+### Primary Process States
+- **R (Running / Runnable)**: Actively computing or in the CPU scheduler queue.
+- **S (Interruptible Sleep)**: Waiting for an event or I/O operation.
+- **D (Uninterruptible Sleep)**: Waiting for device I/O (cannot be killed with signals).
+- **Z (Zombie)**: Terminated, but parent has not yet read exit status via \`wait()\`.
+- **T (Stopped)**: Paused by job control signal (\`SIGTSTP\` / \`Ctrl+Z\`).
+
+---
+
+## 2. Inspecting and Monitoring Workloads
+
+\`\`\`bash
+# Standard snapshot of all running processes with user attribution
+ps aux | head -n 15
+
+# View tree representation of parent-child hierarchy
+pstree -p
+
+# Real-time process monitor
+top -b -n 1 | head -n 20
+\`\`\`
+
+---
+
+## 3. Signals and Termination
+
+Linux communicates events to processes using POSIX signals:
+- **\`SIGTERM\` (Signal 15)**: Graceful shutdown request. The application cleans up connections, commits state, and exits.
+- **\`SIGKILL\` (Signal 9)**: Immediate kernel-level destruction. The application cannot intercept or handle this signal.
+- **\`SIGHUP\` (Signal 1)**: Hangup signal, conventionally used to trigger configuration reload without process restart.
+- **\`SIGINT\` (Signal 2)**: Interrupt sent by terminal when typing \`Ctrl+C\`.
+
+\`\`\`bash
+# Send graceful SIGTERM to process with PID 1420
+kill -15 1420
+
+# Forcefully kill runaway process by name
+pkill -9 -f "bad_worker"
+\`\`\`
+
+---
+
+## 4. Background and Foreground Job Control
+
+\`\`\`bash
+# Start a long-running process in background
+python3 worker.py > worker.log 2>&1 &
+
+# View active background jobs in current shell
+jobs -l
+
+# Bring background job 1 to foreground
+fg %1
+\`\`\``,
+          },
+          {
+            slug: "storage-filesystems-mounts",
+            title: "Storage, Filesystems, and Mounts",
+            estimatedMinutes: 30,
+            orderIndex: 2,
+            content: `## 1. Block Devices and Filesystems
+
+Linux accesses physical and virtual storage through block special devices located in \`/dev/\` (e.g., \`/dev/sda\`, \`/dev/nvme0n1\`, \`/dev/vda\`).
+
+Before storage can store files, it must be formatted with a filesystem (such as **ext4** or **xfs**), which manages metadata, directories, inodes, and data blocks.
+
+\`\`\`bash
+# List all block devices, sizes, and mount points
+lsblk -f
+
+# View filesystem disk space usage in human-readable units
+df -hT
+
+# Check size of specific directory tree
+du -sh /var/log/
+\`\`\`
+
+---
+
+## 2. Mounting Devices & Inodes
+
+A storage partition must be attached to an existing directory (mount point) in the root tree.
+
+\`\`\`bash
+# Mount a partition read-write
+sudo mount /dev/sdb1 /mnt/data
+
+# Unmount cleanly
+sudo umount /mnt/data
+\`\`\`
+
+### Inodes and Links
+An **inode** is a data structure storing file metadata (permissions, owner, size, timestamps, block pointers), excluding the file name.
+- **Hard Link (\`ln target link\`)**: Creates a second directory entry pointing to the same inode. Both have identical permissions and cannot cross filesystem boundaries.
+- **Symbolic (Soft) Link (\`ln -s target link\`)**: A special file containing the path string to the target file. Can point across filesystems and to directories.
+
+---
+
+## 3. Persistent Mounts with /etc/fstab
+
+On boot, \`systemd\` reads \`/etc/fstab\` to mount persistent volumes automatically. Modern best practice uses the filesystem **UUID** rather than device names (which may change on hardware re-enumeration).
+
+\`\`\`bash
+# Obtain filesystem UUID
+sudo blkid /dev/sdb1
+\`\`\`
+
+Example entry in \`/etc/fstab\`:
+\`\`\`
+UUID=3b8f67e0-91a2-4a5c-897b-891d4e123456  /mnt/data  ext4  defaults,noatime  0  2
+\`\`\`
+
+---
+
+## Hands-On Exercise
+1. Run \`lsblk\` and identify the filesystem type of your root mount \`/\`.
+2. Inspect inode usage on your system with \`df -i\`.`,
+          },
+        ],
+      },
+      {
+        slug: "networking-service-admin",
+        title: "Networking & Service Administration",
+        description:
+          "Diagnose network interfaces, configure hardened SSH access, and author production systemd service units.",
+        orderIndex: 3,
+        lessons: [
+          {
+            slug: "network-diagnostics-ssh",
+            title: "Network Diagnostics and SSH Hardening",
+            estimatedMinutes: 25,
+            orderIndex: 1,
+            content: `## 1. Modern Network Diagnostics
+
+Linux provides the \`iproute2\` suite for inspecting and manipulating network interfaces, routing tables, and ARP caches.
+
+\`\`\`bash
+# List all network interfaces and assigned IP addresses
+ip -br addr
+
+# View kernel routing table
+ip route show
+
+# Inspect listening TCP and UDP sockets with process names
+sudo ss -tulpn
+
+# Test endpoint connectivity and port availability
+nc -zv 1.1.1.1 53
+curl -Iv https://github.com
+\`\`\`
+
+---
+
+## 2. SSH Architecture and Key-Based Authentication
+
+SSH (Secure Shell) provides encrypted transport for remote administration. Using Ed25519 public-key cryptography replaces vulnerable password authentication.
+
+### Key Generation and Deployment
+\`\`\`bash
+# Generate modern Ed25519 keypair with comments
+ssh-keygen -t ed25519 -C "contributor@technexus.org"
+
+# Copy public key to remote server authorized_keys
+ssh-copy-id -i ~/.ssh/id_ed25519.pub student@server.internal
+\`\`\`
+
+---
+
+## 3. Hardening /etc/ssh/sshd_config
+
+Production servers must enforce strict SSH daemon settings:
+\`\`\`ini
+# /etc/ssh/sshd_config.d/99-hardened.conf
+Port 2222
+PermitRootLogin no
+PasswordAuthentication no
+PubkeyAuthentication yes
+MaxAuthTries 3
+X11Forwarding no
+\`\`\`
+
+Always test SSH configuration before restarting the daemon:
+\`\`\`bash
+sudo sshd -t
+sudo systemctl reload sshd
+\`\`\``,
+          },
+          {
+            slug: "systemd-services-journald",
+            title: "Systemd Services, Logging, and Journald",
+            estimatedMinutes: 35,
+            orderIndex: 2,
+            content: `## 1. Systemd Architecture
+
+\`systemd\` is the init system and service manager for modern Linux (PID 1). It manages dependencies, mounts, sockets, and daemon lifecycles through declarative **Unit files**.
+
+### Systemctl Command Suite
+\`\`\`bash
+# Check service health and recent logs
+systemctl status nginx
+
+# Start / Stop / Restart
+sudo systemctl start myapp
+sudo systemctl restart myapp
+
+# Enable automatic startup on boot
+sudo systemctl enable myapp
+
+# Reload configuration files after editing unit definitions
+sudo systemctl daemon-reload
+\`\`\`
+
+---
+
+## 2. Authoring a Production Service Unit
+
+Service unit definitions reside in \`/etc/systemd/system/<name>.service\`:
+
+\`\`\`ini
+[Unit]
+Description=TechNexus Health Monitoring Service
+After=network.target
+
+[Service]
+Type=simple
+User=technexus
+Group=technexus
+WorkingDirectory=/opt/technexus/monitor
+ExecStart=/usr/bin/python3 /opt/technexus/monitor/health.py
+Restart=always
+RestartSec=5s
+Environment=NODE_ENV=production
+LimitNOFILE=65535
+
+# Hardening directives
+ProtectSystem=full
+ProtectHome=true
+NoNewPrivileges=true
+
+[Install]
+WantedBy=multi-user.target
+\`\`\`
+
+---
+
+## 3. System Logging with Journald
+
+\`journald\` collects structured logs from the kernel, services, and stdout/stderr of managed processes.
+
+\`\`\`bash
+# Tail live logs for a specific service unit
+journalctl -u myapp.service -f
+
+# Filter logs since previous boot with error priority or higher
+journalctl -b -p err
+
+# Export logs in JSON format for telemetry pipelines
+journalctl -u myapp.service -n 50 -o json-pretty
+\`\`\``,
+            assignment: {
+              title: "Linux System Health Monitor Daemon",
+              description:
+                "Author a bash or python health monitoring script and create a managed systemd service unit. Submit the terminal output showing systemctl status and journalctl logs proving successful execution.",
+              acceptanceCriteria: [
+                "Service unit file contains proper [Unit], [Service], and [Install] sections",
+                "Service executes under a non-root user account with Restart=always policy",
+                "Health script logs CPU and memory usage to stdout/journald every 10 seconds",
+                "Terminal output verifies active (running) status and clean journald logs",
+              ],
+              submissionType: "terminal_output",
+            },
+          },
+        ],
+      },
+    ],
+  },
+  {
+    slug: "git-open-source",
+    title: "Git and Professional Open-Source Development",
+    description:
+      "Learn production-grade Git workflows, commit hygiene, conflict resolution, rebase mechanics, semantic PRs, and open-source contribution standards.",
+    difficulty: "intermediate",
+    estimatedHours: 14,
+    isPublished: true,
+    orderIndex: 2,
+    prerequisites: [
+      "Basic command-line and terminal navigation skills",
+      "An active GitHub account with SSH or PAT credentials configured",
+    ],
+    objectives: [
+      "Understand the Git Directed Acyclic Graph (DAG) and internal object storage",
+      "Apply professional branching models and differentiate merge versus rebase strategies",
+      "Master interactive rebasing (git rebase -i) and squash messy histories into atomic commits",
+      "Resolve complex 3-way merge conflicts accurately using standard Git tools",
+      "Author atomic commits adhering to the Conventional Commits specification",
+      "Integrate automated linting and testing checks via GitHub Actions CI",
+    ],
+    modules: [
+      {
+        slug: "git-foundations",
+        title: "Version Control Foundations & Architecture",
+        description:
+          "Dive into Git internal objects, Directed Acyclic Graph structure, and branching mechanics.",
+        orderIndex: 1,
+        lessons: [
+          {
+            slug: "git-internals-dag-objects",
+            title: "Git Internals, DAG, and Object Storage",
+            estimatedMinutes: 25,
+            orderIndex: 1,
+            content: `## 1. What Git Really Is
+
+Git is not merely a file history tracker; it is a **content-addressable filesystem** with a VCS user interface built on top of a **Directed Acyclic Graph (DAG)** of immutable objects.
+
+### The Four Object Types
+Every object stored in \`.git/objects/\` is compressed with zlib and identified by the SHA-1 (or SHA-256) hash of its type, size, and content:
+1. **Blob**: Raw file contents (does not store file name or permissions).
+2. **Tree**: Represents a directory. Stores file names, permissions, and references to blob or child tree SHA hashes.
+3. **Commit**: Contains a pointer to a root tree, author and committer metadata, timestamps, a log message, and zero or more parent commit hashes.
+4. **Annotated Tag**: A permanent pointer to a specific commit object with a cryptographic signature and message.
+
+\`\`\`bash
+# Inspect the type of an object from its hash
+git cat-file -t HEAD
+
+# Print formatted contents of the root tree
+git cat-file -p HEAD^{tree}
+\`\`\`
+
+---
+
+## 2. The Three Trees
+- **Working Directory**: The active sandbox where you edit files on disk.
+- **Index (Staging Area)**: The binary cache at \`.git/index\` representing the exact snapshot destined for the next commit.
+- **HEAD (Committed Snapshot)**: A pointer referencing the current branch commit.
+
+---
+
+## 3. Plumbing vs Porcelain
+
+Git commands divide into user-friendly **Porcelain** (\`git commit\`, \`git status\`, \`git checkout\`) and low-level **Plumbing** (\`git hash-object\`, \`git write-tree\`, \`git commit-tree\`). Understanding plumbing gives you complete control when debugging repository corruption or detached HEAD states.`,
+          },
+          {
+            slug: "branching-merge-vs-rebase",
+            title: "Branching Strategies and Merge vs Rebase",
+            estimatedMinutes: 25,
+            orderIndex: 2,
+            content: `## 1. Branches are Lightweight Pointers
+
+In Git, a branch is not a copy of code. A branch is simply a 41-byte plain-text file in \`.git/refs/heads/<name>\` containing the 40-character SHA hash of its tip commit. Creating or deleting a branch is instantaneous.
+
+\`\`\`bash
+# Create and switch to a feature branch
+git switch -c feat/telemetry-agent
+
+# View tracking relationships between local and remote branches
+git branch -vv
+\`\`\`
+
+---
+
+## 2. Merge vs Rebase: Mechanical Differences
+
+### 3-Way Merge
+A standard merge finds the **Common Ancestor** of two branch tips and creates a new **Merge Commit** with two parents.
+- **Pros**: Preserves complete chronological history exactly as it occurred.
+- **Cons**: Creates cluttered "railroad track" commit graphs and non-linear history.
+
+### Rebase
+A rebase calculates the commits on your current branch that do not exist on the target base branch, stores them as temporary patches, resets the current branch to the target base, and replays each patch sequentially.
+- **Pros**: Produces a clean, linear, bisectable commit history.
+- **Cons**: Rewrites commit hashes; should never be run on shared public branches.
+
+\`\`\`bash
+# Update local feature branch onto latest upstream main linearly
+git fetch origin
+git rebase origin/main
+\`\`\``,
+          },
+        ],
+      },
+      {
+        slug: "collaborative-pr-hygiene",
+        title: "Collaborative Workflows & PR Hygiene",
+        description:
+          "Author atomic Conventional Commits, master interactive rebasing, and resolve 3-way merge conflicts.",
+        orderIndex: 2,
+        lessons: [
+          {
+            slug: "atomic-commits-clean-prs",
+            title: "Crafting Atomic Commits and Clean PRs",
+            estimatedMinutes: 30,
+            orderIndex: 1,
+            content: `## 1. The Principle of Atomic Commits
+
+An **Atomic Commit** encapsulates one single logical change. It must:
+1. Compile and pass tests independently.
+2. Not bundle unrelated refactorings or styling fixes with feature logic.
+3. Be reversible with \`git revert <hash>\` without side effects on other functionality.
+
+---
+
+## 2. Conventional Commits Specification
+
+TechNexusOrg enforces the Conventional Commits v1.0.0 format:
+
+\`\`\`
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer(s)]
+\`\`\`
+
+### Standard Types:
+- \`feat\`: A new feature for the user or platform.
+- \`fix\`: A bug fix.
+- \`docs\`: Documentation only changes.
+- \`style\`: Formatting, white-space, missing semi-colons (no code logic change).
+- \`refactor\`: Code change that neither fixes a bug nor adds a feature.
+- \`test\`: Adding missing tests or correcting existing tests.
+- \`chore\`: Maintenance tasks, dependency bumps, build tool configurations.
+
+### Real Example:
+\`\`\`
+feat(auth): require constant-time comparison for service tokens
+
+Replace direct string equality checks with crypto.timingSafeEqual in the
+internal sync endpoint to prevent timing side-channel attacks.
+
+Closes #11
+\`\`\``,
+          },
+          {
+            slug: "conflicts-interactive-rebasing",
+            title: "Resolving Conflicts and Interactive Rebasing",
+            estimatedMinutes: 35,
+            orderIndex: 2,
+            content: `## 1. Interactive Rebasing (\`git rebase -i\`)
+
+Interactive rebasing lets you curate your commit history before submitting a Pull Request.
+
+\`\`\`bash
+# Rebase the last 4 commits interactively
+git rebase -i HEAD~4
+\`\`\`
+
+The editor displays commands for each commit:
+- \`pick\`: Use commit as-is.
+- \`reword\`: Change commit message.
+- \`edit\`: Pause rebase to amend files or split commit.
+- \`squash\`: Meld commit into previous commit; combine commit messages.
+- \`fixup\`: Meld commit into previous commit; discard this commit message.
+- \`drop\`: Remove commit entirely.
+
+---
+
+## 2. Resolving 3-Way Merge Conflicts
+
+When Git encounters divergent changes to the same lines, it halts and injects conflict markers:
+
+\`\`\`diff
+<<<<<<< HEAD
+const SESSION_MAX_AGE = 60 * 60 * 24 * 7; // 7 days in production
+=======
+const SESSION_MAX_AGE = 60 * 60 * 24 * 14; // Extended to 14 days
+>>>>>>> feat/extend-session
+\`\`\`
+
+### Resolution Steps:
+1. Open conflicted files and decide the intended combined logic.
+2. Remove all markers (\`<<<<<<<\`, \`=======\`, \`>>>>>>>\`).
+3. Run tests to confirm zero regressions.
+4. Stage resolved files: \`git add <file>\`.
+5. Continue the rebase: \`git rebase --continue\` (never \`git commit\`).
+
+---
+
+## 3. Safe Remote Updates with \`--force-with-lease\`
+
+After rewriting local history via rebase, updating your remote branch requires force pushing. Never use \`git push --force\` as it blindly overwrites remote changes. Always use:
+
+\`\`\`bash
+git push --force-with-lease
+\`\`\`
+
+\`--force-with-lease\` verifies that nobody else has pushed commits to the remote branch since your last fetch.`,
+          },
+        ],
+      },
+      {
+        slug: "governance-ci-integration",
+        title: "Open-Source Governance & CI Integration",
+        description:
+          "Conduct professional code reviews, understand community governance, and enforce GitHub Actions CI pipelines.",
+        orderIndex: 3,
+        lessons: [
+          {
+            slug: "code-review-semantic-prs",
+            title: "Code Review Etiquette and Semantic PRs",
+            estimatedMinutes: 25,
+            orderIndex: 1,
+            content: `## 1. Constructive Code Reviews
+
+In open-source engineering, code reviews are collaborative mentorship sessions, not gatekeeping hurdles.
+
+### Best Practices for Reviewers:
+- **Be specific**: Reference line numbers and explain the architectural reasoning.
+- **Distinguish suggestions from blockers**: Prefix non-critical advice with \`nit:\` (nitpick).
+- **Use GitHub Suggestions**: Provide concrete code diffs that the author can apply with one click.
+- **Praise good solutions**: Acknowledge clean abstractions and thorough test cases.
+
+### Best Practices for Authors:
+- Keep PRs small (< 400 lines of diff where possible).
+- Fill in all sections of the Pull Request template.
+- Test your changes locally before opening the PR.
+- Link relevant issues using GitHub keywords (\`Fixes #12\`, \`Closes #15\`).`,
+          },
+          {
+            slug: "github-actions-ci-integration",
+            title: "GitHub Actions CI Integration",
+            estimatedMinutes: 35,
+            orderIndex: 2,
+            content: `## 1. Automated Continuous Integration (CI)
+
+Continuous Integration ensures that code pushed to branches meets rigorous quality standards before maintainers review it.
+
+### Core CI Pipeline Stages:
+1. **Linting**: Enforces code style, unused variables, and formatting standards.
+2. **Type Checking**: Validates static TypeScript types across all source files.
+3. **Unit & Integration Tests**: Runs test suites using Vitest/Jest to prevent regressions.
+4. **Production Build**: Compiles production artifacts to detect SSR/SSG errors early.
+
+---
+
+## 2. A Production GitHub Actions Workflow
+
+\`\`\`yaml
+# .github/workflows/ci.yml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Typecheck
+        run: npm run typecheck
+
+      - name: Run Test Suite
+        run: npm test
+
+      - name: Production Build
+        run: npm run build
+\`\`\`
+
+---
+
+## 3. Branch Protection Invariants
+Production repositories should configure branch protection rules on \`main\`:
+- Require a pull request before merging.
+- Require status checks to pass before merging (\`validate\` job).
+- Require linear history (squash or rebase merging).
+- Require review from repository maintainers.`,
+            assignment: {
+              title: "Open-Source Pull Request and CI Verification",
+              description:
+                "Fork a TechNexusOrg repository, create a feature branch, author atomic commits following Conventional Commits, push to your fork, and submit a PR with passing CI verification.",
+              acceptanceCriteria: [
+                "Feature branch created from latest upstream main",
+                "Commits adhere to the Conventional Commits standard (e.g., feat, fix, docs)",
+                "Interactive rebase applied to eliminate extraneous WIP commits",
+                "PR opened against main with descriptive summary and passing CI status checks",
+              ],
+              submissionType: "github_pr",
+            },
+          },
+        ],
+      },
+    ],
+  },
+];
diff --git a/src/lib/learning/service.test.ts b/src/lib/learning/service.test.ts
new file mode 100644
index 0000000..2d34ed2
--- /dev/null
+++ b/src/lib/learning/service.test.ts
@@ -0,0 +1,210 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { getDb, schema } from "@/lib/db";
+import { runMigrations } from "@/lib/db/migrate";
+import {
+  seedPilotCurriculum,
+  listTracks,
+  getTrackBySlug,
+  getLesson,
+  enrollInTrack,
+  toggleLessonProgress,
+  submitAssignment,
+} from "./service";
+
+describe("Learning Platform Service", () => {
+  let db: any;
+  const testUserId = `usr_test_${Date.now()}`;
+
+  beforeAll(async () => {
+    db = await getDb();
+    await runMigrations();
+
+    // Create a mock user in database for foreign key constraints
+    await db.insert(schema.users).values({
+      id: testUserId,
+      githubId: Math.floor(Math.random() * 1000000),
+      githubUsername: "teststudent",
+      email: "teststudent@technexus.org",
+      role: "contributor",
+    });
+  });
+
+  it("seeds pilot curriculum idempotently", async () => {
+    await seedPilotCurriculum(db);
+
+    const tracks = await db.select().from(schema.learningTracks);
+    expect(tracks.length).toBeGreaterThanOrEqual(2);
+
+    const linuxTrack = tracks.find((t: any) => t.slug === "linux-fundamentals");
+    expect(linuxTrack).toBeDefined();
+    expect(linuxTrack.title).toBe("Linux Fundamentals and Administration");
+
+    const gitTrack = tracks.find((t: any) => t.slug === "git-open-source");
+    expect(gitTrack).toBeDefined();
+    expect(gitTrack.title).toBe("Git and Professional Open-Source Development");
+
+    // Second run should not throw and should not duplicate tracks
+    await seedPilotCurriculum(db);
+    const tracksAfter = await db.select().from(schema.learningTracks);
+    expect(tracksAfter.length).toBe(tracks.length);
+  });
+
+  it("lists published tracks with accurate module and lesson counts", async () => {
+    const trackList = await listTracks({ userId: testUserId }, db);
+    expect(trackList.length).toBeGreaterThanOrEqual(2);
+
+    const linux = trackList.find((t) => t.slug === "linux-fundamentals");
+    expect(linux).toBeDefined();
+    expect(linux!.moduleCount).toBe(3);
+    expect(linux!.lessonCount).toBe(6);
+    expect(linux!.progressPercentage).toBe(0);
+    expect(linux!.enrollmentStatus).toBeNull();
+  });
+
+  it("fetches detailed track syllabus by slug", async () => {
+    const track = await getTrackBySlug("linux-fundamentals", testUserId, db);
+    expect(track).toBeDefined();
+    expect(track!.slug).toBe("linux-fundamentals");
+    expect(track!.modules.length).toBe(3);
+
+    const firstModule = track!.modules[0];
+    expect(firstModule.slug).toBe("sys-navigation-basics");
+    expect(firstModule.lessons.length).toBe(2);
+
+    const firstLesson = firstModule.lessons[0];
+    expect(firstLesson.slug).toBe("posix-shell-hierarchy");
+    expect(firstLesson.isCompleted).toBe(false);
+  });
+
+  it("enrolls a user into a track", async () => {
+    const track = await getTrackBySlug("linux-fundamentals", testUserId, db);
+    expect(track).toBeDefined();
+
+    const enrollment = await enrollInTrack(testUserId, track!.id, db);
+    expect(enrollment).toBeDefined();
+    expect(enrollment.status).toBe("enrolled");
+
+    // Re-enrolling should return existing record idempotently
+    const secondEnrollment = await enrollInTrack(testUserId, track!.id, db);
+    expect(secondEnrollment.id).toBe(enrollment.id);
+  });
+
+  it("retrieves a detailed lesson with navigation and assignment info", async () => {
+    const lesson = await getLesson(
+      "linux-fundamentals",
+      "posix-shell-hierarchy",
+      testUserId,
+      db
+    );
+
+    expect(lesson).toBeDefined();
+    expect(lesson!.slug).toBe("posix-shell-hierarchy");
+    expect(lesson!.content).toContain("POSIX Shell Environment");
+    expect(lesson!.module.slug).toBe("sys-navigation-basics");
+    expect(lesson!.track.slug).toBe("linux-fundamentals");
+    expect(lesson!.previousLesson).toBeNull();
+    expect(lesson!.nextLesson).toEqual({
+      slug: "file-permissions-security",
+      title: "File Permissions, Ownership, and Security",
+    });
+  });
+
+  it("toggles lesson completion and updates track progress percentage", async () => {
+    const track = await getTrackBySlug("linux-fundamentals", testUserId, db);
+    const firstLesson = track!.modules[0].lessons[0];
+
+    // Mark first lesson complete
+    const progressResult = await toggleLessonProgress(
+      testUserId,
+      firstLesson.id,
+      true,
+      db
+    );
+
+    expect(progressResult.completed).toBe(true);
+    expect(progressResult.completedLessons).toBe(1);
+    expect(progressResult.progressPercentage).toBe(17); // 1 of 6 is ~17%
+    expect(progressResult.trackStatus).toBe("in_progress");
+
+    // Verify track reflects progress
+    const updatedTrack = await getTrackBySlug(
+      "linux-fundamentals",
+      testUserId,
+      db
+    );
+    expect(updatedTrack!.progressPercentage).toBe(17);
+    expect(updatedTrack!.enrollmentStatus).toBe("in_progress");
+    expect(updatedTrack!.modules[0].lessons[0].isCompleted).toBe(true);
+
+    // Unmark lesson complete
+    const unmarkResult = await toggleLessonProgress(
+      testUserId,
+      firstLesson.id,
+      false,
+      db
+    );
+    expect(unmarkResult.completed).toBe(false);
+    expect(unmarkResult.completedLessons).toBe(0);
+    expect(unmarkResult.progressPercentage).toBe(0);
+    expect(unmarkResult.trackStatus).toBe("enrolled");
+  });
+
+  it("submits an assignment and validates submission types", async () => {
+    // Lesson 6 in Linux Fundamentals has a terminal_output assignment
+    const lessonWithAssignment = await getLesson(
+      "linux-fundamentals",
+      "systemd-services-journald",
+      testUserId,
+      db
+    );
+
+    expect(lessonWithAssignment).toBeDefined();
+    expect(lessonWithAssignment!.assignment).toBeDefined();
+    const assignment = lessonWithAssignment!.assignment!;
+
+    // Test rejection of empty content
+    await expect(
+      submitAssignment(testUserId, assignment.id, "   ", db)
+    ).rejects.toThrow("Submission content cannot be empty");
+
+    // Successful terminal output submission
+    const submission = await submitAssignment(
+      testUserId,
+      assignment.id,
+      "● health-monitor.service - TechNexus Health Monitor\n   Active: active (running)",
+      db
+    );
+
+    expect(submission.status).toBe("submitted");
+    expect(submission.content).toContain("Active: active (running)");
+
+    // Test GitHub PR URL assignment validation in Git track
+    const gitLessonWithAssignment = await getLesson(
+      "git-open-source",
+      "github-actions-ci-integration",
+      testUserId,
+      db
+    );
+
+    expect(gitLessonWithAssignment).toBeDefined();
+    const gitAssignment = gitLessonWithAssignment!.assignment!;
+
+    // Reject non-GitHub PR URL
+    await expect(
+      submitAssignment(testUserId, gitAssignment.id, "https://google.com", db)
+    ).rejects.toThrow("Invalid GitHub PR URL");
+
+    // Accept valid GitHub PR URL
+    const prSubmission = await submitAssignment(
+      testUserId,
+      gitAssignment.id,
+      "https://github.com/TechNexusOrg/platform/pull/12",
+      db
+    );
+
+    expect(prSubmission.status).toBe("submitted");
+    expect(prSubmission.content).toBe(
+      "https://github.com/TechNexusOrg/platform/pull/12"
+    );
+  });
+});
diff --git a/src/lib/learning/service.ts b/src/lib/learning/service.ts
new file mode 100644
index 0000000..82ec50f
--- /dev/null
+++ b/src/lib/learning/service.ts
@@ -0,0 +1,880 @@
+import { getDb, schema } from "@/lib/db";
+import { eq, and, asc, desc, inArray } from "drizzle-orm";
+import { PILOT_LEARNING_TRACKS } from "./content";
+
+export interface TrackListItem {
+  id: string;
+  slug: string;
+  title: string;
+  description: string;
+  difficulty: "beginner" | "intermediate" | "advanced";
+  estimatedHours: number;
+  isPublished: boolean;
+  orderIndex: number;
+  prerequisites: string[];
+  objectives: string[];
+  moduleCount: number;
+  lessonCount: number;
+  enrollmentStatus?: "enrolled" | "in_progress" | "completed" | null;
+  completedLessonsCount?: number;
+  progressPercentage?: number;
+}
+
+export interface DetailedTrack extends TrackListItem {
+  modules: Array<{
+    id: string;
+    slug: string;
+    title: string;
+    description: string;
+    orderIndex: number;
+    lessons: Array<{
+      id: string;
+      slug: string;
+      title: string;
+      estimatedMinutes: number;
+      orderIndex: number;
+      isCompleted?: boolean;
+      hasAssignment: boolean;
+    }>;
+  }>;
+}
+
+export interface DetailedLesson {
+  id: string;
+  slug: string;
+  title: string;
+  content: string;
+  estimatedMinutes: number;
+  orderIndex: number;
+  isCompleted: boolean;
+  module: {
+    id: string;
+    slug: string;
+    title: string;
+  };
+  track: {
+    id: string;
+    slug: string;
+    title: string;
+  };
+  previousLesson: { slug: string; title: string } | null;
+  nextLesson: { slug: string; title: string } | null;
+  assignment?: {
+    id: string;
+    title: string;
+    description: string;
+    acceptanceCriteria: string[];
+    submissionType: "github_pr" | "text_submission" | "terminal_output";
+    userSubmission?: {
+      id: string;
+      content: string;
+      status: "submitted" | "approved" | "needs_revision";
+      feedback?: string | null;
+      submittedAt: Date;
+    } | null;
+  } | null;
+}
+
+/**
+ * Seeds pilot curriculum tracks, modules, lessons, and assignments into the database.
+ * Operates idempotently by matching unique slugs.
+ */
+export async function seedPilotCurriculum(database?: any) {
+  const db = database || (await getDb());
+
+  for (const trackData of PILOT_LEARNING_TRACKS) {
+    let [track] = await db
+      .select()
+      .from(schema.learningTracks)
+      .where(eq(schema.learningTracks.slug, trackData.slug));
+
+    const trackId = track?.id || `trk_${crypto.randomUUID()}`;
+
+    if (!track) {
+      [track] = await db
+        .insert(schema.learningTracks)
+        .values({
+          id: trackId,
+          slug: trackData.slug,
+          title: trackData.title,
+          description: trackData.description,
+          difficulty: trackData.difficulty,
+          estimatedHours: trackData.estimatedHours,
+          isPublished: trackData.isPublished,
+          orderIndex: trackData.orderIndex,
+          prerequisites: trackData.prerequisites,
+          objectives: trackData.objectives,
+        })
+        .returning();
+    } else {
+      await db
+        .update(schema.learningTracks)
+        .set({
+          title: trackData.title,
+          description: trackData.description,
+          difficulty: trackData.difficulty,
+          estimatedHours: trackData.estimatedHours,
+          isPublished: trackData.isPublished,
+          orderIndex: trackData.orderIndex,
+          prerequisites: trackData.prerequisites,
+          objectives: trackData.objectives,
+          updatedAt: new Date(),
+        })
+        .where(eq(schema.learningTracks.id, trackId));
+    }
+
+    // Process modules
+    for (const modData of trackData.modules) {
+      let [moduleRecord] = await db
+        .select()
+        .from(schema.learningModules)
+        .where(
+          and(
+            eq(schema.learningModules.trackId, trackId),
+            eq(schema.learningModules.slug, modData.slug)
+          )
+        );
+
+      const moduleId = moduleRecord?.id || `mod_${crypto.randomUUID()}`;
+
+      if (!moduleRecord) {
+        [moduleRecord] = await db
+          .insert(schema.learningModules)
+          .values({
+            id: moduleId,
+            trackId,
+            slug: modData.slug,
+            title: modData.title,
+            description: modData.description,
+            orderIndex: modData.orderIndex,
+          })
+          .returning();
+      } else {
+        await db
+          .update(schema.learningModules)
+          .set({
+            title: modData.title,
+            description: modData.description,
+            orderIndex: modData.orderIndex,
+            updatedAt: new Date(),
+          })
+          .where(eq(schema.learningModules.id, moduleId));
+      }
+
+      // Process lessons
+      for (const lesData of modData.lessons) {
+        let [lessonRecord] = await db
+          .select()
+          .from(schema.learningLessons)
+          .where(
+            and(
+              eq(schema.learningLessons.moduleId, moduleId),
+              eq(schema.learningLessons.slug, lesData.slug)
+            )
+          );
+
+        const lessonId = lessonRecord?.id || `les_${crypto.randomUUID()}`;
+
+        if (!lessonRecord) {
+          [lessonRecord] = await db
+            .insert(schema.learningLessons)
+            .values({
+              id: lessonId,
+              moduleId,
+              slug: lesData.slug,
+              title: lesData.title,
+              content: lesData.content,
+              estimatedMinutes: lesData.estimatedMinutes,
+              orderIndex: lesData.orderIndex,
+            })
+            .returning();
+        } else {
+          await db
+            .update(schema.learningLessons)
+            .set({
+              title: lesData.title,
+              content: lesData.content,
+              estimatedMinutes: lesData.estimatedMinutes,
+              orderIndex: lesData.orderIndex,
+              updatedAt: new Date(),
+            })
+            .where(eq(schema.learningLessons.id, lessonId));
+        }
+
+        // Process assignment if specified
+        if (lesData.assignment) {
+          const [existingAssignment] = await db
+            .select()
+            .from(schema.learningAssignments)
+            .where(eq(schema.learningAssignments.lessonId, lessonId));
+
+          if (!existingAssignment) {
+            await db.insert(schema.learningAssignments).values({
+              id: `asg_${crypto.randomUUID()}`,
+              lessonId,
+              title: lesData.assignment.title,
+              description: lesData.assignment.description,
+              acceptanceCriteria: lesData.assignment.acceptanceCriteria,
+              submissionType: lesData.assignment.submissionType,
+            });
+          } else {
+            await db
+              .update(schema.learningAssignments)
+              .set({
+                title: lesData.assignment.title,
+                description: lesData.assignment.description,
+                acceptanceCriteria: lesData.assignment.acceptanceCriteria,
+                submissionType: lesData.assignment.submissionType,
+              })
+              .where(eq(schema.learningAssignments.id, existingAssignment.id));
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Lists all learning tracks with module and lesson counts and user-specific progress.
+ */
+export async function listTracks(
+  options?: { userId?: string; publishedOnly?: boolean },
+  database?: any
+): Promise<TrackListItem[]> {
+  const db = database || (await getDb());
+  const publishedOnly = options?.publishedOnly ?? true;
+
+  let query = db.select().from(schema.learningTracks);
+  if (publishedOnly) {
+    query = query.where(eq(schema.learningTracks.isPublished, true));
+  }
+
+  const tracks = await query.orderBy(asc(schema.learningTracks.orderIndex));
+
+  // If tracks are empty, run idempotent pilot seed once
+  if (tracks.length === 0) {
+    await seedPilotCurriculum(db);
+    return listTracks(options, db);
+  }
+
+  const results: TrackListItem[] = [];
+
+  for (const track of tracks) {
+    const modules = await db
+      .select({ id: schema.learningModules.id })
+      .from(schema.learningModules)
+      .where(eq(schema.learningModules.trackId, track.id));
+
+    const moduleIds = modules.map((m: any) => m.id);
+
+    let lessonCount = 0;
+    let completedLessonsCount = 0;
+    let enrollmentStatus: "enrolled" | "in_progress" | "completed" | null = null;
+
+    if (moduleIds.length > 0) {
+      const lessons = await db
+        .select({ id: schema.learningLessons.id })
+        .from(schema.learningLessons)
+        .where(inArray(schema.learningLessons.moduleId, moduleIds));
+
+      lessonCount = lessons.length;
+
+      if (options?.userId && lessonCount > 0) {
+        const lessonIds = lessons.map((l: any) => l.id);
+
+        const completedRows = await db
+          .select({ id: schema.lessonProgress.id })
+          .from(schema.lessonProgress)
+          .where(
+            and(
+              eq(schema.lessonProgress.userId, options.userId),
+              eq(schema.lessonProgress.completed, true),
+              inArray(schema.lessonProgress.lessonId, lessonIds)
+            )
+          );
+
+        completedLessonsCount = completedRows.length;
+
+        const [enrollment] = await db
+          .select()
+          .from(schema.learningEnrollments)
+          .where(
+            and(
+              eq(schema.learningEnrollments.userId, options.userId),
+              eq(schema.learningEnrollments.trackId, track.id)
+            )
+          );
+
+        if (enrollment) {
+          enrollmentStatus = enrollment.status as any;
+        }
+      }
+    }
+
+    const progressPercentage =
+      lessonCount > 0
+        ? Math.round((completedLessonsCount / lessonCount) * 100)
+        : 0;
+
+    results.push({
+      id: track.id,
+      slug: track.slug,
+      title: track.title,
+      description: track.description,
+      difficulty: track.difficulty as any,
+      estimatedHours: track.estimatedHours,
+      isPublished: track.isPublished,
+      orderIndex: track.orderIndex,
+      prerequisites: (track.prerequisites as string[]) || [],
+      objectives: (track.objectives as string[]) || [],
+      moduleCount: modules.length,
+      lessonCount,
+      enrollmentStatus,
+      completedLessonsCount,
+      progressPercentage,
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Fetches detailed track syllabus including all modules, lessons, and user completion status.
+ */
+export async function getTrackBySlug(
+  slug: string,
+  userId?: string,
+  database?: any
+): Promise<DetailedTrack | null> {
+  const db = database || (await getDb());
+
+  const [track] = await db
+    .select()
+    .from(schema.learningTracks)
+    .where(eq(schema.learningTracks.slug, slug));
+
+  if (!track) {
+    // If not found, attempt auto-seed if tracks table is completely empty
+    const all = await db.select().from(schema.learningTracks);
+    if (all.length === 0) {
+      await seedPilotCurriculum(db);
+      return getTrackBySlug(slug, userId, db);
+    }
+    return null;
+  }
+
+  const modules = await db
+    .select()
+    .from(schema.learningModules)
+    .where(eq(schema.learningModules.trackId, track.id))
+    .orderBy(asc(schema.learningModules.orderIndex));
+
+  const moduleIds = modules.map((m: any) => m.id);
+
+  let lessons: any[] = [];
+  let assignments: any[] = [];
+  let userProgress: any[] = [];
+
+  if (moduleIds.length > 0) {
+    lessons = await db
+      .select()
+      .from(schema.learningLessons)
+      .where(inArray(schema.learningLessons.moduleId, moduleIds))
+      .orderBy(asc(schema.learningLessons.orderIndex));
+
+    const lessonIds = lessons.map((l: any) => l.id);
+
+    if (lessonIds.length > 0) {
+      assignments = await db
+        .select()
+        .from(schema.learningAssignments)
+        .where(inArray(schema.learningAssignments.lessonId, lessonIds));
+
+      if (userId) {
+        userProgress = await db
+          .select()
+          .from(schema.lessonProgress)
+          .where(
+            and(
+              eq(schema.lessonProgress.userId, userId),
+              inArray(schema.lessonProgress.lessonId, lessonIds)
+            )
+          );
+      }
+    }
+  }
+
+  const completedLessonIdSet = new Set(
+    userProgress
+      .filter((p: any) => p.completed)
+      .map((p: any) => p.lessonId)
+  );
+
+  const assignmentLessonIdSet = new Set(
+    assignments.map((a: any) => a.lessonId)
+  );
+
+  const modulesWithLessons = modules.map((mod: any) => {
+    const modLessons = lessons
+      .filter((l: any) => l.moduleId === mod.id)
+      .map((l: any) => ({
+        id: l.id,
+        slug: l.slug,
+        title: l.title,
+        estimatedMinutes: l.estimatedMinutes,
+        orderIndex: l.orderIndex,
+        isCompleted: completedLessonIdSet.has(l.id),
+        hasAssignment: assignmentLessonIdSet.has(l.id),
+      }));
+
+    return {
+      id: mod.id,
+      slug: mod.slug,
+      title: mod.title,
+      description: mod.description,
+      orderIndex: mod.orderIndex,
+      lessons: modLessons,
+    };
+  });
+
+  const totalLessons = lessons.length;
+  const completedLessonsCount = completedLessonIdSet.size;
+  const progressPercentage =
+    totalLessons > 0
+      ? Math.round((completedLessonsCount / totalLessons) * 100)
+      : 0;
+
+  let enrollmentStatus: "enrolled" | "in_progress" | "completed" | null = null;
+  if (userId) {
+    const [enrollment] = await db
+      .select()
+      .from(schema.learningEnrollments)
+      .where(
+        and(
+          eq(schema.learningEnrollments.userId, userId),
+          eq(schema.learningEnrollments.trackId, track.id)
+        )
+      );
+    if (enrollment) {
+      enrollmentStatus = enrollment.status as any;
+    }
+  }
+
+  return {
+    id: track.id,
+    slug: track.slug,
+    title: track.title,
+    description: track.description,
+    difficulty: track.difficulty as any,
+    estimatedHours: track.estimatedHours,
+    isPublished: track.isPublished,
+    orderIndex: track.orderIndex,
+    prerequisites: (track.prerequisites as string[]) || [],
+    objectives: (track.objectives as string[]) || [],
+    moduleCount: modules.length,
+    lessonCount: totalLessons,
+    enrollmentStatus,
+    completedLessonsCount,
+    progressPercentage,
+    modules: modulesWithLessons,
+  };
+}
+
+/**
+ * Fetches a specific lesson with markdown content, parent track & module info,
+ * previous/next navigation, and assignment (including student's submission if logged in).
+ */
+export async function getLesson(
+  trackSlug: string,
+  lessonSlug: string,
+  userId?: string,
+  database?: any
+): Promise<DetailedLesson | null> {
+  const db = database || (await getDb());
+
+  const [track] = await db
+    .select()
+    .from(schema.learningTracks)
+    .where(eq(schema.learningTracks.slug, trackSlug));
+
+  if (!track) return null;
+
+  const modules = await db
+    .select()
+    .from(schema.learningModules)
+    .where(eq(schema.learningModules.trackId, track.id))
+    .orderBy(asc(schema.learningModules.orderIndex));
+
+  const moduleIds = modules.map((m: any) => m.id);
+  if (moduleIds.length === 0) return null;
+
+  // Fetch all lessons in track to establish navigation order
+  const allLessons = await db
+    .select()
+    .from(schema.learningLessons)
+    .where(inArray(schema.learningLessons.moduleId, moduleIds))
+    .orderBy(asc(schema.learningLessons.orderIndex));
+
+  // Sort lessons according to module orderIndex, then lesson orderIndex
+  const moduleOrderMap = new Map<string, number>(
+    modules.map((m: any) => [m.id, m.orderIndex as number])
+  );
+  allLessons.sort((a: any, b: any) => {
+    const modOrderA = Number(moduleOrderMap.get(a.moduleId) ?? 0);
+    const modOrderB = Number(moduleOrderMap.get(b.moduleId) ?? 0);
+    if (modOrderA !== modOrderB) return modOrderA - modOrderB;
+    return a.orderIndex - b.orderIndex;
+  });
+
+  const currentIndex = allLessons.findIndex((l: any) => l.slug === lessonSlug);
+  if (currentIndex === -1) return null;
+
+  const currentLesson = allLessons[currentIndex];
+  const parentModule = modules.find((m: any) => m.id === currentLesson.moduleId);
+
+  const prevLessonObj =
+    currentIndex > 0
+      ? {
+          slug: allLessons[currentIndex - 1].slug,
+          title: allLessons[currentIndex - 1].title,
+        }
+      : null;
+
+  const nextLessonObj =
+    currentIndex < allLessons.length - 1
+      ? {
+          slug: allLessons[currentIndex + 1].slug,
+          title: allLessons[currentIndex + 1].title,
+        }
+      : null;
+
+  // Check lesson completion status for user
+  let isCompleted = false;
+  if (userId) {
+    const [progress] = await db
+      .select()
+      .from(schema.lessonProgress)
+      .where(
+        and(
+          eq(schema.lessonProgress.userId, userId),
+          eq(schema.lessonProgress.lessonId, currentLesson.id)
+        )
+      );
+    isCompleted = !!progress?.completed;
+  }
+
+  // Check for assignment
+  const [assignment] = await db
+    .select()
+    .from(schema.learningAssignments)
+    .where(eq(schema.learningAssignments.lessonId, currentLesson.id));
+
+  let userSubmission = null;
+  if (assignment && userId) {
+    const [submission] = await db
+      .select()
+      .from(schema.assignmentSubmissions)
+      .where(
+        and(
+          eq(schema.assignmentSubmissions.userId, userId),
+          eq(schema.assignmentSubmissions.assignmentId, assignment.id)
+        )
+      )
+      .orderBy(desc(schema.assignmentSubmissions.submittedAt));
+
+    if (submission) {
+      userSubmission = {
+        id: submission.id,
+        content: submission.content,
+        status: submission.status as any,
+        feedback: submission.feedback,
+        submittedAt: submission.submittedAt,
+      };
+    }
+  }
+
+  return {
+    id: currentLesson.id,
+    slug: currentLesson.slug,
+    title: currentLesson.title,
+    content: currentLesson.content,
+    estimatedMinutes: currentLesson.estimatedMinutes,
+    orderIndex: currentLesson.orderIndex,
+    isCompleted,
+    module: {
+      id: parentModule.id,
+      slug: parentModule.slug,
+      title: parentModule.title,
+    },
+    track: {
+      id: track.id,
+      slug: track.slug,
+      title: track.title,
+    },
+    previousLesson: prevLessonObj,
+    nextLesson: nextLessonObj,
+    assignment: assignment
+      ? {
+          id: assignment.id,
+          title: assignment.title,
+          description: assignment.description,
+          acceptanceCriteria: (assignment.acceptanceCriteria as string[]) || [],
+          submissionType: assignment.submissionType as any,
+          userSubmission,
+        }
+      : null,
+  };
+}
+
+/**
+ * Enrolls a user into a learning track.
+ */
+export async function enrollInTrack(
+  userId: string,
+  trackId: string,
+  database?: any
+) {
+  const db = database || (await getDb());
+
+  const [track] = await db
+    .select()
+    .from(schema.learningTracks)
+    .where(eq(schema.learningTracks.id, trackId));
+
+  if (!track) {
+    throw new Error("Track not found");
+  }
+
+  const [existing] = await db
+    .select()
+    .from(schema.learningEnrollments)
+    .where(
+      and(
+        eq(schema.learningEnrollments.userId, userId),
+        eq(schema.learningEnrollments.trackId, trackId)
+      )
+    );
+
+  if (existing) {
+    return existing;
+  }
+
+  const [enrollment] = await db
+    .insert(schema.learningEnrollments)
+    .values({
+      id: `enr_${crypto.randomUUID()}`,
+      userId,
+      trackId,
+      status: "enrolled",
+    })
+    .returning();
+
+  return enrollment;
+}
+
+/**
+ * Toggles a lesson's completion status for a user and updates overall track progress.
+ */
+export async function toggleLessonProgress(
+  userId: string,
+  lessonId: string,
+  completed: boolean,
+  database?: any
+) {
+  const db = database || (await getDb());
+
+  const [lesson] = await db
+    .select()
+    .from(schema.learningLessons)
+    .where(eq(schema.learningLessons.id, lessonId));
+
+  if (!lesson) {
+    throw new Error("Lesson not found");
+  }
+
+  const [parentModule] = await db
+    .select()
+    .from(schema.learningModules)
+    .where(eq(schema.learningModules.id, lesson.moduleId));
+
+  if (!parentModule) {
+    throw new Error("Parent module not found");
+  }
+
+  const trackId = parentModule.trackId;
+
+  // Auto-enroll if not enrolled
+  await enrollInTrack(userId, trackId, db);
+
+  // Upsert lesson progress
+  const [existingProgress] = await db
+    .select()
+    .from(schema.lessonProgress)
+    .where(
+      and(
+        eq(schema.lessonProgress.userId, userId),
+        eq(schema.lessonProgress.lessonId, lessonId)
+      )
+    );
+
+  if (existingProgress) {
+    await db
+      .update(schema.lessonProgress)
+      .set({
+        completed,
+        completedAt: completed ? new Date() : existingProgress.completedAt,
+      })
+      .where(eq(schema.lessonProgress.id, existingProgress.id));
+  } else if (completed) {
+    await db.insert(schema.lessonProgress).values({
+      id: `lpr_${crypto.randomUUID()}`,
+      userId,
+      lessonId,
+      completed: true,
+      completedAt: new Date(),
+    });
+  }
+
+  // Recalculate track progress
+  const allModules = await db
+    .select({ id: schema.learningModules.id })
+    .from(schema.learningModules)
+    .where(eq(schema.learningModules.trackId, trackId));
+
+  const allLessons = await db
+    .select({ id: schema.learningLessons.id })
+    .from(schema.learningLessons)
+    .where(
+      inArray(
+        schema.learningLessons.moduleId,
+        allModules.map((m: any) => m.id)
+      )
+    );
+
+  const lessonIds = allLessons.map((l: any) => l.id);
+
+  const completedProgressRows = await db
+    .select()
+    .from(schema.lessonProgress)
+    .where(
+      and(
+        eq(schema.lessonProgress.userId, userId),
+        eq(schema.lessonProgress.completed, true),
+        inArray(schema.lessonProgress.lessonId, lessonIds)
+      )
+    );
+
+  const totalLessons = lessonIds.length;
+  const completedCount = completedProgressRows.length;
+  const progressPercentage =
+    totalLessons > 0 ? Math.round((completedCount / totalLessons) * 100) : 0;
+
+  let newStatus: "enrolled" | "in_progress" | "completed" = "in_progress";
+  let completedAt: Date | null = null;
+
+  if (completedCount === totalLessons && totalLessons > 0) {
+    newStatus = "completed";
+    completedAt = new Date();
+  } else if (completedCount === 0) {
+    newStatus = "enrolled";
+  }
+
+  await db
+    .update(schema.learningEnrollments)
+    .set({
+      status: newStatus,
+      completedAt,
+      updatedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(schema.learningEnrollments.userId, userId),
+        eq(schema.learningEnrollments.trackId, trackId)
+      )
+    );
+
+  return {
+    lessonId,
+    completed,
+    totalLessons,
+    completedLessons: completedCount,
+    progressPercentage,
+    trackStatus: newStatus,
+  };
+}
+
+/**
+ * Submits student work for a lesson assignment.
+ */
+export async function submitAssignment(
+  userId: string,
+  assignmentId: string,
+  content: string,
+  database?: any
+) {
+  const db = database || (await getDb());
+
+  if (!content || !content.trim()) {
+    throw new Error("Submission content cannot be empty");
+  }
+
+  const [assignment] = await db
+    .select()
+    .from(schema.learningAssignments)
+    .where(eq(schema.learningAssignments.id, assignmentId));
+
+  if (!assignment) {
+    throw new Error("Assignment not found");
+  }
+
+  // Validate GitHub PR submission type
+  if (assignment.submissionType === "github_pr") {
+    const prUrlPattern = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/;
+    if (!prUrlPattern.test(content.trim())) {
+      throw new Error(
+        "Invalid GitHub PR URL. Format must match: https://github.com/owner/repo/pull/number"
+      );
+    }
+  }
+
+  const [existingSubmission] = await db
+    .select()
+    .from(schema.assignmentSubmissions)
+    .where(
+      and(
+        eq(schema.assignmentSubmissions.userId, userId),
+        eq(schema.assignmentSubmissions.assignmentId, assignmentId)
+      )
+    );
+
+  const now = new Date();
+
+  if (existingSubmission) {
+    const [updated] = await db
+      .update(schema.assignmentSubmissions)
+      .set({
+        content: content.trim(),
+        status: "submitted",
+        feedback: null,
+        submittedAt: now,
+      })
+      .where(eq(schema.assignmentSubmissions.id, existingSubmission.id))
+      .returning();
+
+    return updated;
+  }
+
+  const [submission] = await db
+    .insert(schema.assignmentSubmissions)
+    .values({
+      id: `sub_${crypto.randomUUID()}`,
+      assignmentId,
+      userId,
+      content: content.trim(),
+      status: "submitted",
+      submittedAt: now,
+    })
+    .returning();
+
+  return submission;
+}