diff --git a/VueApp/src/Effort/__tests__/course-add-dialog.test.ts b/VueApp/src/Effort/__tests__/course-add-dialog.test.ts
new file mode 100644
index 00000000..d70f0171
--- /dev/null
+++ b/VueApp/src/Effort/__tests__/course-add-dialog.test.ts
@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { ref } from "vue"
+import { setActivePinia, createPinia } from "pinia"
+
+/**
+ * Tests for CourseAddDialog error handling and validation behavior.
+ *
+ * These tests validate that the component properly handles errors
+ * when creating courses manually.
+ *
+ * The actual component UI is tested via Playwright MCP (see SMOKETEST-EFFORT-COURSE.md).
+ */
+
+// Mock the effort service
+const mockCreateCourse = vi.fn()
+vi.mock("../services/effort-service", () => ({
+    effortService: {
+        createCourse: (...args: unknown[]) => mockCreateCourse(...args),
+    },
+}))
+
+// Validation helper functions (moved outside tests for consistent-function-scoping)
+const isValidEnrollment = (v: number) => v >= 0 && Number.isInteger(v)
+const isValidUnits = (v: number) => v >= 0
+
+describe("CourseAddDialog - Error Handling", () => {
+    beforeEach(() => {
+        setActivePinia(createPinia())
+        vi.clearAllMocks()
+    })
+
+    describe("Create Course Error States", () => {
+        it("should capture error message when API returns success: false", () => {
+            const error = ref<string | null>(null)
+
+            const result = { success: false, error: "Course already exists for this term" }
+
+            if (!result.success) {
+                error.value = result.error ?? "Failed to create course"
+            }
+
+            expect(error.value).toBe("Course already exists for this term")
+        })
+
+        it("should use default message when API returns no error message", () => {
+            const error = ref<string | null>(null)
+
+            const result = { success: false, error: null }
+
+            if (!result.success) {
+                error.value = result.error ?? "Failed to create course"
+            }
+
+            expect(error.value).toBe("Failed to create course")
+        })
+    })
+
+    describe("Service Mock Behavior", () => {
+        it("effortService.createCourse returns success with course data", async () => {
+            mockCreateCourse.mockResolvedValue({ success: true, course: { id: 1 } })
+
+            const result = await mockCreateCourse()
+
+            expect(result.success).toBeTruthy()
+            expect(result.course.id).toBe(1)
+        })
+
+        it("effortService.createCourse returns failure with error message", async () => {
+            mockCreateCourse.mockResolvedValue({
+                success: false,
+                error: "Course already exists",
+            })
+
+            const result = await mockCreateCourse()
+
+            expect(result.success).toBeFalsy()
+            expect(result.error).toBe("Course already exists")
+        })
+
+        it("effortService.createCourse rejects with exception", async () => {
+            mockCreateCourse.mockRejectedValue(new Error("Database error"))
+
+            await expect(mockCreateCourse()).rejects.toThrow("Database error")
+        })
+    })
+
+    describe("Form Data Normalization", () => {
+        it("should trim and uppercase subject code", () => {
+            const input = " dvm "
+            const normalized = input.trim().toUpperCase()
+
+            expect(normalized).toBe("DVM")
+        })
+
+        it("should trim and uppercase course number", () => {
+            const input = " 443r "
+            const normalized = input.trim().toUpperCase()
+
+            expect(normalized).toBe("443R")
+        })
+
+        it("should trim CRN", () => {
+            const input = " 12345 "
+            const normalized = input.trim()
+
+            expect(normalized).toBe("12345")
+        })
+    })
+
+    describe("Validation Logic", () => {
+        it("should validate CRN is 5 digits", () => {
+            const crnRegex = /^\d{5}$/
+
+            expect(crnRegex.test("12345")).toBeTruthy()
+            expect(crnRegex.test("1234")).toBeFalsy()
+            expect(crnRegex.test("123456")).toBeFalsy()
+            expect(crnRegex.test("abcde")).toBeFalsy()
+        })
+
+        it("should validate enrollment is non-negative integer", () => {
+            expect(isValidEnrollment(0)).toBeTruthy()
+            expect(isValidEnrollment(25)).toBeTruthy()
+            expect(isValidEnrollment(-1)).toBeFalsy()
+            expect(isValidEnrollment(2.5)).toBeFalsy()
+        })
+
+        it("should validate units is non-negative", () => {
+            expect(isValidUnits(0)).toBeTruthy()
+            expect(isValidUnits(4)).toBeTruthy()
+            expect(isValidUnits(0.5)).toBeTruthy()
+            expect(isValidUnits(-1)).toBeFalsy()
+        })
+
+        it("should validate subject code max length", () => {
+            const maxLength = 3
+
+            expect("DVM".length <= maxLength).toBeTruthy()
+            expect("DVMX".length <= maxLength).toBeFalsy()
+        })
+    })
+
+    describe("Form Reset Behavior", () => {
+        it("should reset form data to defaults", () => {
+            const defaultDepartment = "APC"
+            const formData = ref({
+                subjCode: "OLD",
+                crseNumb: "999",
+                seqNumb: "002",
+                crn: "99999",
+                enrollment: 50,
+                units: 5,
+                custDept: "VME",
+            })
+
+            // Simulate reset logic
+            formData.value = {
+                subjCode: "",
+                crseNumb: "",
+                seqNumb: "",
+                crn: "",
+                enrollment: 0,
+                units: 0,
+                custDept: defaultDepartment,
+            }
+
+            expect(formData.value.subjCode).toBe("")
+            expect(formData.value.enrollment).toBe(0)
+            expect(formData.value.custDept).toBe("APC")
+        })
+    })
+})
diff --git a/VueApp/src/Effort/__tests__/course-edit-dialog.test.ts b/VueApp/src/Effort/__tests__/course-edit-dialog.test.ts
new file mode 100644
index 00000000..e33a1c7e
--- /dev/null
+++ b/VueApp/src/Effort/__tests__/course-edit-dialog.test.ts
@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { ref } from "vue"
+import { setActivePinia, createPinia } from "pinia"
+
+/**
+ * Tests for CourseEditDialog error handling and validation behavior.
+ *
+ * These tests validate that the component properly handles errors
+ * when updating courses.
+ *
+ * The actual component UI is tested via Playwright MCP (see SMOKETEST-EFFORT-COURSE.md).
+ */
+
+// Mock the effort service
+const mockUpdateCourse = vi.fn()
+const mockUpdateCourseEnrollment = vi.fn()
+vi.mock("../services/effort-service", () => ({
+    effortService: {
+        updateCourse: (...args: unknown[]) => mockUpdateCourse(...args),
+        updateCourseEnrollment: (...args: unknown[]) => mockUpdateCourseEnrollment(...args),
+    },
+}))
+
+// Validation helper functions (moved outside tests for consistent-function-scoping)
+const isRCourse = (crseNumb: string) => crseNumb.toUpperCase().endsWith("R")
+const isValidEnrollment = (v: number) => v >= 0
+const isValidUnits = (v: number) => v >= 0
+
+describe("CourseEditDialog - Error Handling", () => {
+    beforeEach(() => {
+        setActivePinia(createPinia())
+        vi.clearAllMocks()
+    })
+
+    describe("Update Course Error States", () => {
+        it("should capture error message when API returns success: false", () => {
+            const error = ref<string | null>(null)
+
+            const result = { success: false, error: "Failed to update course" }
+
+            if (!result.success) {
+                error.value = result.error ?? "Failed to update course"
+            }
+
+            expect(error.value).toBe("Failed to update course")
+        })
+
+        it("should use default message when API returns no error message", () => {
+            const error = ref<string | null>(null)
+
+            const result = { success: false, error: null }
+
+            if (!result.success) {
+                error.value = result.error ?? "Failed to update course"
+            }
+
+            expect(error.value).toBe("Failed to update course")
+        })
+    })
+
+    describe("Service Mock Behavior - Full Update", () => {
+        it("effortService.updateCourse returns success", async () => {
+            mockUpdateCourse.mockResolvedValue({ success: true })
+
+            const result = await mockUpdateCourse(1, { enrollment: 30, units: 4, custDept: "DVM" })
+
+            expect(result.success).toBeTruthy()
+        })
+
+        it("effortService.updateCourse returns failure with error message", async () => {
+            mockUpdateCourse.mockResolvedValue({
+                success: false,
+                error: "Invalid department code",
+            })
+
+            const result = await mockUpdateCourse()
+
+            expect(result.success).toBeFalsy()
+            expect(result.error).toBe("Invalid department code")
+        })
+
+        it("effortService.updateCourse rejects with exception", async () => {
+            mockUpdateCourse.mockRejectedValue(new Error("Database error"))
+
+            await expect(mockUpdateCourse()).rejects.toThrow("Database error")
+        })
+    })
+
+    describe("Service Mock Behavior - Enrollment Only", () => {
+        it("effortService.updateCourseEnrollment returns success", async () => {
+            mockUpdateCourseEnrollment.mockResolvedValue({ success: true })
+
+            const result = await mockUpdateCourseEnrollment(2, 75)
+
+            expect(result.success).toBeTruthy()
+        })
+
+        it("effortService.updateCourseEnrollment returns failure", async () => {
+            mockUpdateCourseEnrollment.mockResolvedValue({
+                success: false,
+                error: "Cannot update enrollment for non-R course",
+            })
+
+            const result = await mockUpdateCourseEnrollment()
+
+            expect(result.success).toBeFalsy()
+            expect(result.error).toBe("Cannot update enrollment for non-R course")
+        })
+    })
+
+    describe("R-Course Detection Logic", () => {
+        it("should identify R-course by course number suffix", () => {
+            expect(isRCourse("443R")).toBeTruthy()
+            expect(isRCourse("443r")).toBeTruthy()
+            expect(isRCourse("443")).toBeFalsy()
+            expect(isRCourse("R443")).toBeFalsy()
+        })
+    })
+
+    describe("Validation Logic", () => {
+        it("should validate enrollment is non-negative", () => {
+            expect(isValidEnrollment(0)).toBeTruthy()
+            expect(isValidEnrollment(30)).toBeTruthy()
+            expect(isValidEnrollment(-1)).toBeFalsy()
+        })
+
+        it("should validate units is non-negative", () => {
+            expect(isValidUnits(0)).toBeTruthy()
+            expect(isValidUnits(4)).toBeTruthy()
+            expect(isValidUnits(-1)).toBeFalsy()
+        })
+    })
+
+    describe("Form Data Population", () => {
+        it("should populate form with course data", () => {
+            const course = {
+                id: 1,
+                enrollment: 20,
+                units: 4,
+                custDept: "DVM",
+            }
+
+            const formData = ref({
+                enrollment: 0,
+                units: 0,
+                custDept: "",
+            })
+
+            // Simulate form population
+            formData.value = {
+                enrollment: course.enrollment,
+                units: course.units,
+                custDept: course.custDept,
+            }
+
+            expect(formData.value.enrollment).toBe(20)
+            expect(formData.value.units).toBe(4)
+            expect(formData.value.custDept).toBe("DVM")
+        })
+
+        it("should handle null course gracefully", () => {
+            const course = null
+            const formData = ref({
+                enrollment: 0,
+                units: 0,
+                custDept: "",
+            })
+
+            // Simulate null handling
+            if (course) {
+                formData.value = {
+                    enrollment: course.enrollment,
+                    units: course.units,
+                    custDept: course.custDept,
+                }
+            }
+
+            // Form should remain unchanged
+            expect(formData.value.enrollment).toBe(0)
+        })
+    })
+
+    describe("Edit Mode Selection", () => {
+        it("should use updateCourseEnrollment for enrollment-only mode", async () => {
+            const enrollmentOnly = true
+            const courseId = 2
+            const newEnrollment = 75
+
+            if (enrollmentOnly) {
+                mockUpdateCourseEnrollment.mockResolvedValue({ success: true })
+                await mockUpdateCourseEnrollment(courseId, newEnrollment)
+            } else {
+                await mockUpdateCourse(courseId, {})
+            }
+
+            expect(mockUpdateCourseEnrollment).toHaveBeenCalledWith(2, 75)
+            expect(mockUpdateCourse).not.toHaveBeenCalled()
+        })
+
+        it("should use updateCourse for full edit mode", async () => {
+            const enrollmentOnly = false
+            const courseId = 1
+            const updateData = { enrollment: 30, units: 4, custDept: "DVM" }
+
+            if (enrollmentOnly) {
+                await mockUpdateCourseEnrollment(courseId, updateData.enrollment)
+            } else {
+                mockUpdateCourse.mockResolvedValue({ success: true })
+                await mockUpdateCourse(courseId, updateData)
+            }
+
+            expect(mockUpdateCourse).toHaveBeenCalledWith(1, updateData)
+            expect(mockUpdateCourseEnrollment).not.toHaveBeenCalled()
+        })
+    })
+})
diff --git a/VueApp/src/Effort/__tests__/course-import-dialog.test.ts b/VueApp/src/Effort/__tests__/course-import-dialog.test.ts
new file mode 100644
index 00000000..e9cfdb80
--- /dev/null
+++ b/VueApp/src/Effort/__tests__/course-import-dialog.test.ts
@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { ref } from "vue"
+import { setActivePinia, createPinia } from "pinia"
+
+/**
+ * Tests for CourseImportDialog error handling behavior.
+ *
+ * These tests validate that the component properly displays error feedback
+ * to users when import operations fail, rather than showing generic errors.
+ *
+ * The actual component UI is tested via Playwright MCP (see SMOKETEST-EFFORT-COURSE.md).
+ */
+
+// Mock the effort service
+const mockSearchBannerCourses = vi.fn()
+const mockImportCourse = vi.fn()
+vi.mock("../services/effort-service", () => ({
+    effortService: {
+        searchBannerCourses: (...args: unknown[]) => mockSearchBannerCourses(...args),
+        importCourse: (...args: unknown[]) => mockImportCourse(...args),
+    },
+}))
+
+describe("CourseImportDialog - Error Handling", () => {
+    beforeEach(() => {
+        setActivePinia(createPinia())
+        vi.clearAllMocks()
+    })
+
+    describe("Import Error States", () => {
+        it("should capture error message when API returns success: false", () => {
+            const importError = ref<string | null>(null)
+
+            // Simulate the error handling logic from the component
+            const result = { success: false, error: "Course DVM 443 with 4 units already exists for this term" }
+
+            if (!result.success) {
+                importError.value = result.error ?? "Failed to import course"
+            }
+
+            expect(importError.value).toBe("Course DVM 443 with 4 units already exists for this term")
+        })
+
+        it("should use default message when API returns no error message", () => {
+            const importError = ref<string | null>(null)
+
+            const result = { success: false, error: null }
+
+            if (!result.success) {
+                importError.value = result.error ?? "Failed to import course"
+            }
+
+            expect(importError.value).toBe("Failed to import course")
+        })
+
+        it("should capture error message from thrown exception", () => {
+            const importError = ref<string | null>(null)
+
+            // Simulate exception handling logic
+            try {
+                throw new Error("Failed to import course. Please check all field values are valid.")
+            } catch (err) {
+                importError.value = err instanceof Error ? err.message : "Failed to import course"
+            }
+
+            expect(importError.value).toBe("Failed to import course. Please check all field values are valid.")
+        })
+
+        it("should handle non-Error exceptions gracefully", () => {
+            const importError = ref<string | null>(null)
+
+            // Simulate handling a non-Error value (e.g., from external code)
+            const nonErrorValue: string = "string error"
+            importError.value = nonErrorValue instanceof Error ? nonErrorValue.message : "Failed to import course"
+
+            expect(importError.value).toBe("Failed to import course")
+        })
+    })
+
+    describe("Search Error States", () => {
+        it("should capture search error from thrown exception", () => {
+            const searchError = ref("")
+
+            try {
+                throw new Error("Search failed")
+            } catch (err) {
+                searchError.value = err instanceof Error ? err.message : "Error searching for courses"
+            }
+
+            expect(searchError.value).toBe("Search failed")
+        })
+
+        it("should use default message for non-Error exceptions", () => {
+            const searchError = ref("")
+
+            // Simulate handling a non-Error value (e.g., from external code)
+            const nonErrorValue: string = "unknown error"
+            searchError.value = nonErrorValue instanceof Error ? nonErrorValue.message : "Error searching for courses"
+
+            expect(searchError.value).toBe("Error searching for courses")
+        })
+    })
+
+    describe("Service Mock Behavior", () => {
+        it("effortService.importCourse rejects with specific error message", async () => {
+            mockImportCourse.mockRejectedValue(
+                new Error("Failed to import course. Please check all field values are valid."),
+            )
+
+            await expect(mockImportCourse()).rejects.toThrow("Failed to import course")
+        })
+
+        it("effortService.importCourse rejects with duplicate error message", async () => {
+            mockImportCourse.mockRejectedValue(new Error("Course DVM 443 with 4 units already exists for this term"))
+
+            await expect(mockImportCourse()).rejects.toThrow("already exists")
+        })
+
+        it("effortService.searchBannerCourses rejects with error message", async () => {
+            mockSearchBannerCourses.mockRejectedValue(new Error("Search failed"))
+
+            await expect(mockSearchBannerCourses()).rejects.toThrow("Search failed")
+        })
+
+        it("effortService.importCourse returns success with course data", async () => {
+            mockImportCourse.mockResolvedValue({ success: true, course: { id: 1, crn: "12345" } })
+
+            const result = await mockImportCourse()
+
+            expect(result.success).toBeTruthy()
+            expect(result.course.id).toBe(1)
+        })
+
+        it("effortService.importCourse returns failure with error message", async () => {
+            mockImportCourse.mockResolvedValue({
+                success: false,
+                error: "Course already exists",
+            })
+
+            const result = await mockImportCourse()
+
+            expect(result.success).toBeFalsy()
+            expect(result.error).toBe("Course already exists")
+        })
+    })
+
+    describe("Error Reset Behavior", () => {
+        it("should clear import error when starting new import", () => {
+            const importError = ref<string | null>("Previous error")
+
+            // Simulate the startImport logic
+            importError.value = null
+
+            expect(importError.value).toBeNull()
+        })
+
+        it("should clear search error when dialog opens", () => {
+            const searchError = ref("Previous search error")
+
+            // Simulate the dialog open watcher logic
+            searchError.value = ""
+
+            expect(searchError.value).toBe("")
+        })
+    })
+})
diff --git a/VueApp/src/Effort/components/CourseAddDialog.vue b/VueApp/src/Effort/components/CourseAddDialog.vue
new file mode 100644
index 00000000..b0e6e154
--- /dev/null
+++ b/VueApp/src/Effort/components/CourseAddDialog.vue
@@ -0,0 +1,213 @@
+<template>
+    <q-dialog
+        v-model="dialogOpen"
+        persistent
+        maximized-on-mobile
+    >
+        <q-card style="width: 100%; max-width: 600px">
+            <q-card-section class="row items-center q-pb-none">
+                <div class="text-h6">Add Course Manually</div>
+                <q-space />
+                <q-btn
+                    v-close-popup
+                    icon="close"
+                    flat
+                    round
+                    dense
+                />
+            </q-card-section>
+
+            <q-card-section>
+                <p class="text-body2 text-grey q-mb-md">
+                    Use this form to add a course that is not available in Banner. For Banner courses, use "Import from
+                    Banner" instead.
+                </p>
+
+                <q-form ref="formRef">
+                    <div class="row q-col-gutter-sm">
+                        <div class="col-12 col-sm-5">
+                            <q-input
+                                v-model="formData.subjCode"
+                                label="Subject Code"
+                                dense
+                                outlined
+                                maxlength="3"
+                                :rules="[
+                                    (v: string) => !!v?.trim() || 'Required',
+                                    (v: string) => v?.trim().length <= 3 || 'Max 3 characters',
+                                ]"
+                            />
+                        </div>
+                        <div class="col-12 col-sm-4">
+                            <q-input
+                                v-model="formData.crseNumb"
+                                label="Course Number"
+                                dense
+                                outlined
+                                maxlength="5"
+                                :rules="[(v: string) => !!v?.trim() || 'Required']"
+                            />
+                        </div>
+                        <div class="col-12 col-sm-3">
+                            <q-input
+                                v-model="formData.seqNumb"
+                                label="Section"
+                                dense
+                                outlined
+                                maxlength="3"
+                                :rules="[(v: string) => !!v?.trim() || 'Required']"
+                            />
+                        </div>
+                        <div class="col-12">
+                            <q-input
+                                v-model="formData.crn"
+                                label="CRN"
+                                dense
+                                outlined
+                                maxlength="5"
+                                :rules="[
+                                    (v: string) => !!v?.trim() || 'CRN is required',
+                                    (v: string) => /^\d{5}$/.test(v?.trim()) || 'CRN must be 5 digits',
+                                ]"
+                            />
+                        </div>
+                        <div class="col-6">
+                            <q-input
+                                v-model.number="formData.enrollment"
+                                type="number"
+                                label="Enrollment"
+                                dense
+                                outlined
+                                :rules="[
+                                    (v: number) => v >= 0 || 'Must be non-negative',
+                                    (v: number) => Number.isInteger(v) || 'Must be a whole number',
+                                ]"
+                            />
+                        </div>
+                        <div class="col-6">
+                            <q-input
+                                v-model.number="formData.units"
+                                type="number"
+                                label="Units"
+                                dense
+                                outlined
+                                step="0.5"
+                                :rules="[(v: number) => v >= 0 || 'Must be non-negative']"
+                            />
+                        </div>
+                        <div class="col-12">
+                            <q-select
+                                v-model="formData.custDept"
+                                :options="departments"
+                                label="Custodial Department"
+                                dense
+                                options-dense
+                                outlined
+                                :rules="[(v: string) => !!v || 'Department is required']"
+                            />
+                        </div>
+                    </div>
+                </q-form>
+            </q-card-section>
+
+            <q-card-actions align="right">
+                <q-btn
+                    v-close-popup
+                    label="Cancel"
+                    flat
+                />
+                <q-btn
+                    label="Create Course"
+                    color="primary"
+                    :loading="isCreating"
+                    @click="create"
+                />
+            </q-card-actions>
+        </q-card>
+    </q-dialog>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, watch } from "vue"
+import { useQuasar, QForm } from "quasar"
+import { effortService } from "../services/effort-service"
+
+const props = defineProps<{
+    modelValue: boolean
+    termCode: number | null
+    departments: string[]
+}>()
+
+const emit = defineEmits<{
+    "update:modelValue": [value: boolean]
+    created: []
+}>()
+
+const $q = useQuasar()
+
+const dialogOpen = computed({
+    get: () => props.modelValue,
+    set: (value) => emit("update:modelValue", value),
+})
+
+const formRef = ref<QForm | null>(null)
+const isCreating = ref(false)
+const formData = ref({
+    subjCode: "",
+    crseNumb: "",
+    seqNumb: "",
+    crn: "",
+    enrollment: 0,
+    units: 0,
+    custDept: "",
+})
+
+// Reset form when dialog opens
+watch(dialogOpen, (open) => {
+    if (open) {
+        formData.value = {
+            subjCode: "",
+            crseNumb: "",
+            seqNumb: "",
+            crn: "",
+            enrollment: 0,
+            units: 0,
+            custDept: props.departments[0] ?? "",
+        }
+    }
+})
+
+async function create() {
+    if (!props.termCode) {
+        $q.notify({ type: "negative", message: "No term selected" })
+        return
+    }
+
+    const valid = await formRef.value?.validate()
+    if (!valid) return
+
+    isCreating.value = true
+
+    try {
+        const result = await effortService.createCourse({
+            termCode: props.termCode,
+            crn: formData.value.crn.trim(),
+            subjCode: formData.value.subjCode.trim().toUpperCase(),
+            crseNumb: formData.value.crseNumb.trim().toUpperCase(),
+            seqNumb: formData.value.seqNumb.trim().toUpperCase(),
+            enrollment: formData.value.enrollment,
+            units: formData.value.units,
+            custDept: formData.value.custDept,
+        })
+
+        if (result.success) {
+            dialogOpen.value = false
+            emit("created")
+        } else {
+            $q.notify({ type: "negative", message: result.error ?? "Failed to create course" })
+        }
+    } finally {
+        isCreating.value = false
+    }
+}
+</script>
diff --git a/VueApp/src/Effort/components/CourseEditDialog.vue b/VueApp/src/Effort/components/CourseEditDialog.vue
new file mode 100644
index 00000000..fa398133
--- /dev/null
+++ b/VueApp/src/Effort/components/CourseEditDialog.vue
@@ -0,0 +1,163 @@
+<template>
+    <q-dialog
+        v-model="dialogOpen"
+        persistent
+        maximized-on-mobile
+    >
+        <q-card style="width: 100%; max-width: 500px">
+            <q-card-section class="row items-center q-pb-none">
+                <div class="text-h6">{{ enrollmentOnly ? "Edit R-Course Enrollment" : "Edit Course" }}</div>
+                <q-space />
+                <q-btn
+                    v-close-popup
+                    icon="close"
+                    flat
+                    round
+                    dense
+                />
+            </q-card-section>
+
+            <q-card-section v-if="course">
+                <div class="text-subtitle1 q-mb-md">
+                    {{ course.courseCode }}-{{ course.seqNumb }}
+                    <span class="text-grey-7">(CRN: {{ course.crn }})</span>
+                </div>
+
+                <q-form
+                    ref="formRef"
+                    class="q-gutter-sm"
+                >
+                    <q-input
+                        v-model.number="formData.enrollment"
+                        type="number"
+                        label="Enrollment"
+                        dense
+                        outlined
+                        :rules="[
+                            (v: number) => v >= 0 || 'Enrollment must be non-negative',
+                            (v: number) => Number.isInteger(v) || 'Enrollment must be a whole number',
+                        ]"
+                    />
+
+                    <template v-if="!enrollmentOnly">
+                        <q-input
+                            v-model.number="formData.units"
+                            type="number"
+                            label="Units"
+                            dense
+                            outlined
+                            step="0.5"
+                            :rules="[(v: number) => v >= 0 || 'Units must be non-negative']"
+                        />
+
+                        <q-select
+                            v-model="formData.custDept"
+                            :options="departments"
+                            label="Custodial Department"
+                            dense
+                            options-dense
+                            outlined
+                            :rules="[(v: string) => !!v || 'Department is required']"
+                        />
+                    </template>
+                </q-form>
+            </q-card-section>
+
+            <q-card-actions align="right">
+                <q-btn
+                    v-close-popup
+                    label="Cancel"
+                    flat
+                />
+                <q-btn
+                    label="Save"
+                    color="primary"
+                    :loading="isSaving"
+                    @click="save"
+                />
+            </q-card-actions>
+        </q-card>
+    </q-dialog>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, watch } from "vue"
+import { useQuasar, QForm } from "quasar"
+import { effortService } from "../services/effort-service"
+import type { CourseDto } from "../types"
+
+const props = defineProps<{
+    modelValue: boolean
+    course: CourseDto | null
+    departments: string[]
+    enrollmentOnly?: boolean
+}>()
+
+const emit = defineEmits<{
+    "update:modelValue": [value: boolean]
+    updated: []
+}>()
+
+const $q = useQuasar()
+
+const dialogOpen = computed({
+    get: () => props.modelValue,
+    set: (value) => emit("update:modelValue", value),
+})
+
+const formRef = ref<QForm | null>(null)
+const isSaving = ref(false)
+const formData = ref({
+    enrollment: 0,
+    units: 0,
+    custDept: "",
+})
+
+// Reset form when dialog opens with course data
+watch(
+    () => props.modelValue,
+    (open) => {
+        if (open && props.course) {
+            formData.value = {
+                enrollment: props.course.enrollment,
+                units: props.course.units,
+                custDept: props.course.custDept,
+            }
+        }
+    },
+)
+
+async function save() {
+    if (!props.course) return
+
+    const valid = await formRef.value?.validate()
+    if (!valid) return
+
+    isSaving.value = true
+
+    try {
+        let result: { success: boolean; error?: string }
+
+        if (props.enrollmentOnly) {
+            // Use the enrollment-only endpoint for R-course enrollment updates
+            result = await effortService.updateCourseEnrollment(props.course.id, formData.value.enrollment)
+        } else {
+            // Use the full update endpoint
+            result = await effortService.updateCourse(props.course.id, {
+                enrollment: formData.value.enrollment,
+                units: formData.value.units,
+                custDept: formData.value.custDept,
+            })
+        }
+
+        if (result.success) {
+            dialogOpen.value = false
+            emit("updated")
+        } else {
+            $q.notify({ type: "negative", message: result.error ?? "Failed to update course" })
+        }
+    } finally {
+        isSaving.value = false
+    }
+}
+</script>
diff --git a/VueApp/src/Effort/components/CourseImportDialog.vue b/VueApp/src/Effort/components/CourseImportDialog.vue
new file mode 100644
index 00000000..c360cf5a
--- /dev/null
+++ b/VueApp/src/Effort/components/CourseImportDialog.vue
@@ -0,0 +1,457 @@
+<template>
+    <q-dialog
+        v-model="dialogOpen"
+        persistent
+        maximized-on-mobile
+    >
+        <q-card style="width: 100%; max-width: 900px; position: relative">
+            <q-btn
+                v-close-popup
+                icon="close"
+                flat
+                round
+                dense
+                class="absolute-top-right q-ma-sm"
+                style="z-index: 1"
+            />
+            <q-card-section class="q-pb-none q-pr-xl">
+                <div class="text-h6">Import Course from Banner ({{ termName }})</div>
+                <div class="text-caption text-grey-7">Enter one or more fields to search</div>
+            </q-card-section>
+
+            <q-card-section>
+                <!-- Search Form -->
+                <div class="row q-col-gutter-sm items-end q-mb-md">
+                    <div class="col-12 col-sm-3">
+                        <q-input
+                            v-model="searchSubjCode"
+                            label="Subject Code"
+                            dense
+                            outlined
+                            placeholder="e.g., VME"
+                            @keyup.enter="searchCourses"
+                        />
+                    </div>
+                    <div class="col-12 col-sm-3">
+                        <q-input
+                            v-model="searchCrseNumb"
+                            label="Course Number"
+                            dense
+                            outlined
+                            placeholder="e.g., 443"
+                            @keyup.enter="searchCourses"
+                        />
+                    </div>
+                    <div class="col-12 col-sm-2">
+                        <q-input
+                            v-model="searchSeqNumb"
+                            label="Section"
+                            dense
+                            outlined
+                            placeholder="e.g., 001"
+                            @keyup.enter="searchCourses"
+                        />
+                    </div>
+                    <div class="col-12 col-sm-2">
+                        <q-input
+                            v-model="searchCrn"
+                            label="CRN"
+                            dense
+                            outlined
+                            placeholder="e.g., 5-digit number"
+                            @keyup.enter="searchCourses"
+                        />
+                    </div>
+                    <div class="col-12 col-sm-auto self-center">
+                        <q-btn
+                            label="Search"
+                            color="primary"
+                            :loading="isSearching"
+                            :disable="!canSearch"
+                            class="full-width-xs"
+                            @click="searchCourses"
+                        />
+                    </div>
+                </div>
+
+                <div
+                    v-if="searchError"
+                    class="text-negative q-mb-md"
+                >
+                    {{ searchError }}
+                </div>
+
+                <!-- Search Results - Card view for mobile -->
+                <div
+                    v-if="searchResults.length > 0"
+                    class="lt-sm"
+                >
+                    <q-card
+                        v-for="course in searchResults"
+                        :key="course.crn"
+                        flat
+                        bordered
+                        class="q-mb-sm"
+                    >
+                        <q-card-section class="q-py-sm">
+                            <div class="row items-center justify-between q-mb-xs">
+                                <div>
+                                    <span class="text-weight-bold">{{ course.courseCode }}</span
+                                    ><span class="text-grey-7">-{{ course.seqNumb }}</span>
+                                </div>
+                                <q-badge
+                                    v-if="course.alreadyImported"
+                                    color="grey"
+                                    >Already Imported</q-badge
+                                >
+                                <q-badge
+                                    v-else-if="course.importedUnitValues.length > 0"
+                                    color="orange"
+                                    >Imported: {{ course.importedUnitValues.join(", ") }} units</q-badge
+                                >
+                                <q-badge
+                                    v-else
+                                    color="positive"
+                                    >Available</q-badge
+                                >
+                            </div>
+                            <div class="text-body2">{{ course.title }}</div>
+                            <div class="text-caption text-grey-7">
+                                CRN: {{ course.crn }} |
+                                <template v-if="course.isVariableUnits">
+                                    Units: {{ course.unitLow }}-{{ course.unitHigh }}
+                                    <q-badge
+                                        color="info"
+                                        dense
+                                        class="q-ml-xs"
+                                        >Variable</q-badge
+                                    >
+                                </template>
+                                <template v-else> Units: {{ course.unitLow }} </template>
+                                | Enrollment: {{ course.enrollment }}
+                            </div>
+                            <div
+                                v-if="!course.alreadyImported"
+                                class="q-mt-sm"
+                            >
+                                <q-btn
+                                    label="Import"
+                                    color="primary"
+                                    dense
+                                    size="sm"
+                                    :loading="importingCrn === course.crn"
+                                    @click="startImport(course)"
+                                />
+                            </div>
+                        </q-card-section>
+                    </q-card>
+                </div>
+
+                <!-- Search Results - Table view for larger screens -->
+                <q-table
+                    v-if="searchResults.length > 0"
+                    class="gt-xs"
+                    :rows="searchResults"
+                    :columns="columns"
+                    row-key="crn"
+                    dense
+                    flat
+                    bordered
+                    :pagination="{ rowsPerPage: 10 }"
+                >
+                    <template #body-cell-courseCode="slotProps">
+                        <q-td :props="slotProps">
+                            <span class="text-weight-medium">{{ slotProps.row.courseCode }}</span
+                            ><span class="text-grey-7">-{{ slotProps.row.seqNumb }}</span>
+                        </q-td>
+                    </template>
+                    <template #body-cell-units="slotProps">
+                        <q-td
+                            :props="slotProps"
+                            class="text-center"
+                        >
+                            <template v-if="slotProps.row.isVariableUnits">
+                                {{ slotProps.row.unitLow }} - {{ slotProps.row.unitHigh }}
+                                <q-badge
+                                    color="info"
+                                    class="q-ml-xs"
+                                    >Variable</q-badge
+                                >
+                            </template>
+                            <template v-else>
+                                {{ slotProps.row.unitLow }}
+                            </template>
+                        </q-td>
+                    </template>
+                    <template #body-cell-status="slotProps">
+                        <q-td :props="slotProps">
+                            <template v-if="slotProps.row.alreadyImported">
+                                <q-badge color="grey">Already Imported</q-badge>
+                            </template>
+                            <template v-else-if="slotProps.row.importedUnitValues.length > 0">
+                                <q-badge color="orange"
+                                    >Imported: {{ slotProps.row.importedUnitValues.join(", ") }} units</q-badge
+                                >
+                            </template>
+                            <template v-else>
+                                <q-badge color="positive">Available</q-badge>
+                            </template>
+                        </q-td>
+                    </template>
+                    <template #body-cell-actions="slotProps">
+                        <q-td :props="slotProps">
+                            <q-btn
+                                v-if="!slotProps.row.alreadyImported"
+                                label="Import"
+                                color="primary"
+                                dense
+                                size="sm"
+                                :loading="importingCrn === slotProps.row.crn"
+                                @click="startImport(slotProps.row)"
+                            />
+                        </q-td>
+                    </template>
+                </q-table>
+
+                <div
+                    v-else-if="hasSearched && !isSearching"
+                    class="text-grey text-center q-py-lg"
+                >
+                    No courses found matching your search criteria.
+                </div>
+            </q-card-section>
+        </q-card>
+    </q-dialog>
+
+    <!-- Import Options Dialog -->
+    <q-dialog
+        v-model="showImportOptionsDialog"
+        persistent
+    >
+        <q-card style="min-width: 350px">
+            <q-card-section>
+                <div class="text-h6">Import Options</div>
+                <div class="text-subtitle2 text-grey q-mt-sm">
+                    {{ selectedBannerCourse?.courseCode }}-{{ selectedBannerCourse?.seqNumb }}
+                </div>
+            </q-card-section>
+
+            <q-card-section>
+                <!-- Variable units input -->
+                <template v-if="selectedBannerCourse?.isVariableUnits">
+                    <p class="text-body2">
+                        This is a variable-unit course. Please enter the units for this import ({{
+                            selectedBannerCourse?.unitLow
+                        }}
+                        - {{ selectedBannerCourse?.unitHigh }}).
+                    </p>
+                    <q-input
+                        v-model.number="importUnits"
+                        type="number"
+                        label="Units"
+                        dense
+                        outlined
+                        class="q-mb-md"
+                        :min="selectedBannerCourse?.unitLow"
+                        :max="selectedBannerCourse?.unitHigh"
+                        step="0.5"
+                        :rules="[
+                            (v: number) =>
+                                (v >= (selectedBannerCourse?.unitLow ?? 0) &&
+                                    v <= (selectedBannerCourse?.unitHigh ?? 99)) ||
+                                `Units must be between ${selectedBannerCourse?.unitLow} and ${selectedBannerCourse?.unitHigh}`,
+                        ]"
+                    />
+                    <div
+                        v-if="selectedBannerCourse?.importedUnitValues.length"
+                        class="text-caption text-orange q-mb-md"
+                    >
+                        Already imported with: {{ selectedBannerCourse.importedUnitValues.join(", ") }} units
+                    </div>
+                </template>
+
+                <!-- Import error display -->
+                <q-banner
+                    v-if="importError"
+                    class="bg-negative text-white q-mt-md"
+                    dense
+                >
+                    <template #avatar>
+                        <q-icon name="error" />
+                    </template>
+                    {{ importError }}
+                </q-banner>
+            </q-card-section>
+
+            <q-card-actions align="right">
+                <q-btn
+                    v-close-popup
+                    label="Cancel"
+                    flat
+                />
+                <q-btn
+                    label="Import"
+                    color="primary"
+                    :loading="isImporting"
+                    :disable="!canImport"
+                    @click="doImport"
+                />
+            </q-card-actions>
+        </q-card>
+    </q-dialog>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, watch } from "vue"
+import { useQuasar } from "quasar"
+import { effortService } from "../services/effort-service"
+import type { BannerCourseDto } from "../types"
+import type { QTableColumn } from "quasar"
+
+const props = defineProps<{
+    modelValue: boolean
+    termCode: number | null
+    termName: string
+}>()
+
+const emit = defineEmits<{
+    "update:modelValue": [value: boolean]
+    imported: []
+}>()
+
+const $q = useQuasar()
+
+// Dialog state
+const dialogOpen = computed({
+    get: () => props.modelValue,
+    set: (value) => emit("update:modelValue", value),
+})
+
+// Search state
+const searchSubjCode = ref("")
+const searchCrseNumb = ref("")
+const searchSeqNumb = ref("")
+const searchCrn = ref("")
+const searchResults = ref<BannerCourseDto[]>([])
+const isSearching = ref(false)
+const hasSearched = ref(false)
+const searchError = ref("")
+
+// Import state
+const showImportOptionsDialog = ref(false)
+const selectedBannerCourse = ref<BannerCourseDto | null>(null)
+const importUnits = ref<number>(0)
+const isImporting = ref(false)
+const importingCrn = ref<string | null>(null)
+const importError = ref<string | null>(null)
+
+const canSearch = computed(
+    () =>
+        props.termCode &&
+        (searchSubjCode.value.trim() ||
+            searchCrseNumb.value.trim() ||
+            searchSeqNumb.value.trim() ||
+            searchCrn.value.trim()),
+)
+
+const canImport = computed(() => {
+    if (!selectedBannerCourse.value) return false
+
+    // For variable-unit courses, validate units
+    if (selectedBannerCourse.value.isVariableUnits) {
+        if (
+            importUnits.value < selectedBannerCourse.value.unitLow ||
+            importUnits.value > selectedBannerCourse.value.unitHigh
+        ) {
+            return false
+        }
+    }
+
+    return true
+})
+
+const columns: QTableColumn[] = [
+    { name: "courseCode", label: "Course", field: "courseCode", align: "left" },
+    { name: "crn", label: "CRN", field: "crn", align: "left" },
+    { name: "title", label: "Title", field: "title", align: "left" },
+    { name: "enrollment", label: "Enrollment", field: "enrollment", align: "center" },
+    { name: "units", label: "Units", field: "unitLow", align: "center" },
+    { name: "status", label: "Status", field: "alreadyImported", align: "center" },
+    { name: "actions", label: "", field: "actions", align: "center" },
+]
+
+// Reset search when dialog opens
+watch(dialogOpen, (open) => {
+    if (open) {
+        searchSubjCode.value = ""
+        searchCrseNumb.value = ""
+        searchSeqNumb.value = ""
+        searchCrn.value = ""
+        searchResults.value = []
+        hasSearched.value = false
+        searchError.value = ""
+    }
+})
+
+async function searchCourses() {
+    if (!canSearch.value || !props.termCode) return
+
+    isSearching.value = true
+    searchError.value = ""
+    hasSearched.value = true
+
+    try {
+        searchResults.value = await effortService.searchBannerCourses(props.termCode, {
+            subjCode: searchSubjCode.value.trim() || undefined,
+            crseNumb: searchCrseNumb.value.trim() || undefined,
+            seqNumb: searchSeqNumb.value.trim() || undefined,
+            crn: searchCrn.value.trim() || undefined,
+        })
+    } catch (err) {
+        searchError.value = err instanceof Error ? err.message : "Error searching for courses"
+        searchResults.value = []
+    } finally {
+        isSearching.value = false
+    }
+}
+
+function startImport(course: BannerCourseDto) {
+    selectedBannerCourse.value = course
+    importUnits.value = course.unitLow
+    importError.value = null
+    showImportOptionsDialog.value = true
+}
+
+async function doImport() {
+    if (!selectedBannerCourse.value || !props.termCode) return
+
+    isImporting.value = true
+    importingCrn.value = selectedBannerCourse.value.crn
+    importError.value = null
+
+    try {
+        const request = {
+            termCode: props.termCode,
+            crn: selectedBannerCourse.value.crn,
+            units: selectedBannerCourse.value.isVariableUnits ? importUnits.value : undefined,
+        }
+
+        const result = await effortService.importCourse(request)
+
+        if (result.success) {
+            showImportOptionsDialog.value = false
+            dialogOpen.value = false
+            emit("imported")
+        } else {
+            importError.value = result.error ?? "Failed to import course"
+            $q.notify({ type: "negative", message: importError.value })
+        }
+    } catch (err) {
+        importError.value = err instanceof Error ? err.message : "Failed to import course"
+        $q.notify({ type: "negative", message: importError.value })
+    } finally {
+        isImporting.value = false
+        importingCrn.value = null
+    }
+}
+</script>
diff --git a/VueApp/src/Effort/components/EffortLeftNav.vue b/VueApp/src/Effort/components/EffortLeftNav.vue
index 178d8ff2..7450f5c6 100644
--- a/VueApp/src/Effort/components/EffortLeftNav.vue
+++ b/VueApp/src/Effort/components/EffortLeftNav.vue
@@ -66,7 +66,11 @@
                     v-if="hasManageTerms"
                     clickable
                     v-ripple
-                    :to="{ name: 'TermManagement' }"
+                    :to="
+                        currentTerm
+                            ? { name: 'TermManagement', query: { termCode: currentTerm.termCode } }
+                            : { name: 'TermManagement' }
+                    "
                     class="leftNavLink"
                 >
                     <q-item-section>
@@ -74,12 +78,29 @@
                     </q-item-section>
                 </q-item>
 
-                <!-- Audit - only for ViewAudit users -->
+                <!-- Courses - for users with course permissions -->
+                <q-item
+                    v-if="canViewCourses && currentTerm"
+                    clickable
+                    v-ripple
+                    :to="{ name: 'CourseList', params: { termCode: currentTerm.termCode } }"
+                    class="leftNavLink"
+                >
+                    <q-item-section>
+                        <q-item-label lines="1">Courses</q-item-label>
+                    </q-item-section>
+                </q-item>
+
+                <!-- Audit - only for ViewAudit users (term optional) -->
                 <q-item
                     v-if="hasViewAudit"
                     clickable
                     v-ripple
-                    :to="{ name: 'EffortAudit', query: currentTerm ? { termCode: currentTerm.termCode } : {} }"
+                    :to="
+                        currentTerm
+                            ? { name: 'EffortAuditWithTerm', params: { termCode: currentTerm.termCode } }
+                            : { name: 'EffortAudit' }
+                    "
                     class="leftNavLink"
                 >
                     <q-item-section>
@@ -117,7 +138,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, watch } from "vue"
+import { ref, watch, computed } from "vue"
 import { useRoute } from "vue-router"
 import { effortService } from "../services/effort-service"
 import { useEffortPermissions } from "../composables/use-effort-permissions"
@@ -129,7 +150,25 @@ const props = defineProps<{
 }>()
 
 const route = useRoute()
-const { hasManageTerms, hasViewAudit } = useEffortPermissions()
+const {
+    hasManageTerms,
+    hasViewAudit,
+    hasImportCourse,
+    hasEditCourse,
+    hasDeleteCourse,
+    hasManageRCourseEnrollment,
+    isAdmin,
+} = useEffortPermissions()
+
+// Users who can add/edit/delete courses or manage R-course enrollment should see the Courses link
+const canViewCourses = computed(
+    () =>
+        hasImportCourse.value ||
+        hasEditCourse.value ||
+        hasDeleteCourse.value ||
+        hasManageRCourseEnrollment.value ||
+        isAdmin.value,
+)
 
 const localDrawerOpen = ref(props.drawerOpen)
 const currentTerm = ref<TermDto | null>(null)
@@ -151,12 +190,14 @@ async function loadCurrentTerm(termCode: number | null) {
     if (termCode) {
         currentTerm.value = await effortService.getTerm(termCode)
     } else {
-        currentTerm.value = await effortService.getCurrentTerm()
+        // No term selected - don't show any term until user picks one
+        currentTerm.value = null
     }
 }
 
+// Watch both route params and query params for termCode
 watch(
-    () => route.params.termCode,
+    () => route.params.termCode || route.query.termCode,
     (newTermCode) => {
         const termCode = newTermCode ? parseInt(newTermCode as string, 10) : null
         loadCurrentTerm(termCode)
diff --git a/VueApp/src/Effort/composables/use-effort-permissions.ts b/VueApp/src/Effort/composables/use-effort-permissions.ts
index a30a010b..c0ba39b2 100644
--- a/VueApp/src/Effort/composables/use-effort-permissions.ts
+++ b/VueApp/src/Effort/composables/use-effort-permissions.ts
@@ -52,6 +52,10 @@ function useEffortPermissions() {
     const hasManageTerms = computed(() => hasPermission(EffortPermissions.ManageTerms))
     const hasVerifyEffort = computed(() => hasPermission(EffortPermissions.VerifyEffort))
     const hasViewAudit = computed(() => hasPermission(EffortPermissions.ViewAudit))
+    const hasImportCourse = computed(() => hasPermission(EffortPermissions.ImportCourse))
+    const hasEditCourse = computed(() => hasPermission(EffortPermissions.EditCourse))
+    const hasDeleteCourse = computed(() => hasPermission(EffortPermissions.DeleteCourse))
+    const hasManageRCourseEnrollment = computed(() => hasPermission(EffortPermissions.ManageRCourseEnrollment))
     const isAdmin = computed(() => hasViewAllDepartments.value)
 
     return {
@@ -62,6 +66,10 @@ function useEffortPermissions() {
         hasManageTerms,
         hasVerifyEffort,
         hasViewAudit,
+        hasImportCourse,
+        hasEditCourse,
+        hasDeleteCourse,
+        hasManageRCourseEnrollment,
         isAdmin,
         permissions: computed(() => userStore.userInfo.permissions),
     }
diff --git a/VueApp/src/Effort/pages/AuditList.vue b/VueApp/src/Effort/pages/AuditList.vue
index fe7bbbfe..339cd448 100644
--- a/VueApp/src/Effort/pages/AuditList.vue
+++ b/VueApp/src/Effort/pages/AuditList.vue
@@ -527,15 +527,15 @@ function getActionColor(action: string): string {
     return "grey"
 }
 
-async function loadFilterOptions() {
+async function loadFilterOptions(termCode: number | null = null) {
     const [termsResult, actionsResult, modifiersResult, instructorsResult, subjectCodesResult, courseNumbersResult] =
         await Promise.all([
             effortService.getTerms(),
             effortAuditService.getActions(),
             effortAuditService.getModifiers(),
             effortAuditService.getInstructors(),
-            effortAuditService.getSubjectCodes(filter.value.termCode),
-            effortAuditService.getCourseNumbers(filter.value.termCode),
+            effortAuditService.getSubjectCodes(termCode),
+            effortAuditService.getCourseNumbers(termCode),
         ])
     terms.value = termsResult
     actions.value = actionsResult
@@ -643,9 +643,6 @@ async function loadAuditRows(props: { pagination: QTableProps["pagination"] }) {
 function updateUrlParams() {
     const query: Record<string, string> = {}
 
-    if (filter.value.termCode !== null) {
-        query.termCode = filter.value.termCode.toString()
-    }
     if (filter.value.action !== null) {
         query.action = filter.value.action
     }
@@ -671,7 +668,12 @@ function updateUrlParams() {
         query.courseNumber = filter.value.courseNumber
     }
 
-    router.replace({ query })
+    // Navigate to term-specific route or generic audit route
+    if (filter.value.termCode !== null) {
+        router.replace({ name: "EffortAuditWithTerm", params: { termCode: filter.value.termCode.toString() }, query })
+    } else {
+        router.replace({ name: "EffortAudit", query })
+    }
 }
 
 function buildSearchParams(page: number, perPage: number, sortBy: string, descending: boolean): URLSearchParams {
@@ -734,7 +736,7 @@ async function clearFilter() {
     courseNumbers.value = newCourseNumbers
     allSubjectCodes.value = newSubjectCodes
     allCourseNumbers.value = newCourseNumbers
-    router.replace({ query: {} })
+    router.replace({ name: "EffortAudit", query: {} })
     await applyFilters()
 }
 
@@ -815,11 +817,15 @@ watch(
 )
 
 onMounted(async () => {
-    // Restore filter state from URL query parameters
+    const paramTermCode = route.params.termCode
     const q = route.query
-    if (q.termCode) {
-        filter.value.termCode = parseInt(q.termCode as string, 10)
-    }
+    const parsedTermCode = paramTermCode
+        ? parseInt(paramTermCode as string, 10)
+        : q.termCode
+          ? parseInt(q.termCode as string, 10)
+          : null
+    const urlTermCode = Number.isFinite(parsedTermCode) ? parsedTermCode : null
+
     if (q.action) {
         filter.value.action = q.action as string
     }
@@ -845,7 +851,12 @@ onMounted(async () => {
         filter.value.courseNumber = q.courseNumber as string
     }
 
-    await loadFilterOptions()
+    await loadFilterOptions(urlTermCode)
+
+    // Set termCode after terms loaded to prevent flash of raw number in dropdown
+    if (urlTermCode !== null) {
+        filter.value.termCode = urlTermCode
+    }
 
     // Update bidirectional filter options based on URL params
     if (filter.value.subjectCode) {
diff --git a/VueApp/src/Effort/pages/CourseList.vue b/VueApp/src/Effort/pages/CourseList.vue
new file mode 100644
index 00000000..a2e0f3f2
--- /dev/null
+++ b/VueApp/src/Effort/pages/CourseList.vue
@@ -0,0 +1,412 @@
+<template>
+    <div class="q-pa-md">
+        <h2>Course List</h2>
+
+        <!-- Term selector and filters -->
+        <div class="row q-col-gutter-sm q-mb-md items-center">
+            <div class="col-12 col-sm-4 col-md-3">
+                <q-select
+                    v-model="selectedTermCode"
+                    :options="terms"
+                    option-label="termName"
+                    option-value="termCode"
+                    emit-value
+                    map-options
+                    label="Term"
+                    dense
+                    options-dense
+                    outlined
+                />
+            </div>
+            <div class="col-6 col-sm-3 col-md-2">
+                <q-select
+                    v-model="selectedDept"
+                    :options="deptOptions"
+                    label="Department"
+                    dense
+                    options-dense
+                    outlined
+                    clearable
+                />
+            </div>
+            <div class="col-6 col-sm-3 col-md-2">
+                <q-input
+                    v-model="searchText"
+                    label="Search"
+                    dense
+                    outlined
+                    clearable
+                >
+                    <template #append>
+                        <q-icon name="search" />
+                    </template>
+                </q-input>
+            </div>
+
+            <div class="col-12 col-sm-auto">
+                <!-- Add course actions -->
+                <q-btn-dropdown
+                    v-if="canAddCourse"
+                    color="primary"
+                    icon="add"
+                    label="Add Course"
+                    dense
+                    class="full-width-xs"
+                >
+                    <q-list>
+                        <q-item
+                            v-if="hasImportCourse"
+                            v-close-popup
+                            clickable
+                            @click="showImportDialog = true"
+                        >
+                            <q-item-section avatar>
+                                <q-icon name="cloud_download" />
+                            </q-item-section>
+                            <q-item-section>Import from Banner</q-item-section>
+                        </q-item>
+                        <q-item
+                            v-if="hasEditCourse || isAdmin"
+                            v-close-popup
+                            clickable
+                            @click="showAddDialog = true"
+                        >
+                            <q-item-section avatar>
+                                <q-icon name="add" />
+                            </q-item-section>
+                            <q-item-section>Manual Entry</q-item-section>
+                        </q-item>
+                    </q-list>
+                </q-btn-dropdown>
+            </div>
+        </div>
+
+        <!-- Loading state -->
+        <div
+            v-if="isLoading"
+            class="text-grey q-my-md"
+        >
+            Loading courses...
+        </div>
+
+        <!-- Courses table -->
+        <q-table
+            v-else
+            :rows="filteredCourses"
+            :columns="columns"
+            row-key="id"
+            dense
+            flat
+            bordered
+            :pagination="pagination"
+            :rows-per-page-options="[25, 50, 100, 0]"
+        >
+            <template #body-cell-courseCode="props">
+                <q-td :props="props">
+                    <div>
+                        <span class="text-weight-medium">{{ props.row.courseCode }}</span
+                        ><span class="text-grey-7">-{{ props.row.seqNumb }}</span>
+                    </div>
+                    <div class="text-caption text-grey-7 lt-sm">
+                        {{ props.row.enrollment }} enrolled &bull; {{ props.row.units }} units
+                    </div>
+                </q-td>
+            </template>
+            <template #body-cell-actions="props">
+                <q-td :props="props">
+                    <q-btn
+                        v-if="canEditCourse(props.row)"
+                        icon="edit"
+                        color="primary"
+                        dense
+                        flat
+                        round
+                        size="sm"
+                        @click="openEditDialog(props.row)"
+                    >
+                        <q-tooltip>Edit course</q-tooltip>
+                    </q-btn>
+                    <q-btn
+                        v-if="hasDeleteCourse"
+                        icon="delete"
+                        color="negative"
+                        dense
+                        flat
+                        round
+                        size="sm"
+                        @click="confirmDeleteCourse(props.row)"
+                    >
+                        <q-tooltip>Delete course</q-tooltip>
+                    </q-btn>
+                </q-td>
+            </template>
+            <template #no-data>
+                <div class="full-width row flex-center text-grey q-gutter-sm q-py-lg">
+                    <q-icon
+                        name="school"
+                        size="2em"
+                    />
+                    <span>No courses found for this term</span>
+                </div>
+            </template>
+        </q-table>
+
+        <!-- Import Dialog -->
+        <CourseImportDialog
+            v-model="showImportDialog"
+            :term-code="selectedTermCode"
+            :term-name="selectedTermName"
+            @imported="onCourseImported"
+        />
+
+        <!-- Edit Dialog -->
+        <CourseEditDialog
+            v-model="showEditDialog"
+            :course="selectedCourse"
+            :departments="departments"
+            :enrollment-only="editEnrollmentOnly"
+            @updated="onCourseUpdated"
+        />
+
+        <!-- Add Dialog -->
+        <CourseAddDialog
+            v-model="showAddDialog"
+            :term-code="selectedTermCode"
+            :departments="departments"
+            @created="onCourseCreated"
+        />
+    </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted, watch } from "vue"
+import { useQuasar } from "quasar"
+import { useRoute, useRouter } from "vue-router"
+import { effortService } from "../services/effort-service"
+import { useEffortPermissions } from "../composables/use-effort-permissions"
+import type { CourseDto, TermDto } from "../types"
+import type { QTableColumn } from "quasar"
+import CourseImportDialog from "../components/CourseImportDialog.vue"
+import CourseEditDialog from "../components/CourseEditDialog.vue"
+import CourseAddDialog from "../components/CourseAddDialog.vue"
+
+const $q = useQuasar()
+const route = useRoute()
+const router = useRouter()
+const { hasImportCourse, hasEditCourse, hasDeleteCourse, hasManageRCourseEnrollment, isAdmin } = useEffortPermissions()
+
+// State
+const terms = ref<TermDto[]>([])
+const selectedTermCode = ref<number | null>(null)
+const courses = ref<CourseDto[]>([])
+const departments = ref<string[]>([])
+const selectedDept = ref<string | null>(null)
+const searchText = ref("")
+const isLoading = ref(false)
+const pagination = ref({ rowsPerPage: 50 })
+
+// Dialogs
+const showImportDialog = ref(false)
+const showEditDialog = ref(false)
+const showAddDialog = ref(false)
+const selectedCourse = ref<CourseDto | null>(null)
+const editEnrollmentOnly = ref(false)
+
+// Computed
+const canAddCourse = computed(() => hasImportCourse.value || hasEditCourse.value || isAdmin.value)
+const selectedTermName = computed(() => terms.value.find((t) => t.termCode === selectedTermCode.value)?.termName ?? "")
+
+const deptOptions = computed(() => {
+    const uniqueDepts = [...new Set(courses.value.map((c) => c.custDept))].sort()
+    return ["", ...uniqueDepts]
+})
+
+const filteredCourses = computed(() => {
+    let result = courses.value
+
+    if (selectedDept.value) {
+        result = result.filter((c) => c.custDept === selectedDept.value)
+    }
+
+    if (searchText.value) {
+        const search = searchText.value.toLowerCase()
+        result = result.filter(
+            (c) =>
+                c.courseCode.toLowerCase().includes(search) ||
+                c.crn.toLowerCase().includes(search) ||
+                c.seqNumb.toLowerCase().includes(search),
+        )
+    }
+
+    return result
+})
+
+const columns = computed<QTableColumn[]>(() => [
+    {
+        name: "courseCode",
+        label: "Course",
+        field: "courseCode",
+        align: "left",
+        sortable: true,
+    },
+    {
+        name: "crn",
+        label: "CRN",
+        field: "crn",
+        align: "left",
+        sortable: true,
+    },
+    {
+        name: "enrollment",
+        label: "Enrollment",
+        field: "enrollment",
+        align: "left",
+        sortable: true,
+        classes: "gt-xs",
+        headerClasses: "gt-xs",
+    },
+    {
+        name: "units",
+        label: "Units",
+        field: "units",
+        align: "left",
+        sortable: true,
+        classes: "gt-xs",
+        headerClasses: "gt-xs",
+    },
+    {
+        name: "custDept",
+        label: "Dept",
+        field: "custDept",
+        align: "left",
+        sortable: true,
+    },
+    {
+        name: "actions",
+        label: "",
+        field: "actions",
+        align: "center",
+    },
+])
+
+// Methods
+function canEditCourse(course: CourseDto): boolean {
+    if (isAdmin.value || hasEditCourse.value) return true
+    // ManageRCourseEnrollment only for R-courses (course number ends with R)
+    if (hasManageRCourseEnrollment.value && course.crseNumb.trim().toUpperCase().endsWith("R")) return true
+    return false
+}
+
+async function loadTerms() {
+    const paramTermCode = route.params.termCode ? parseInt(route.params.termCode as string, 10) : null
+
+    terms.value = await effortService.getTerms()
+
+    // Set termCode after terms loaded to prevent flash of raw number in dropdown
+    if (paramTermCode && terms.value.some((t) => t.termCode === paramTermCode)) {
+        selectedTermCode.value = paramTermCode
+        await loadCourses()
+    } else {
+        router.replace({ name: "EffortHome" })
+    }
+}
+
+// Keep URL in sync with selected term when user changes the dropdown
+watch(selectedTermCode, (newTermCode, oldTermCode) => {
+    if (newTermCode && oldTermCode !== null) {
+        router.replace({ name: "CourseList", params: { termCode: newTermCode.toString() } })
+        loadCourses()
+    }
+})
+
+// Handle browser back/forward navigation that changes the termCode param
+watch(
+    () => route.params.termCode,
+    (newTermCode) => {
+        const parsed = newTermCode ? parseInt(newTermCode as string, 10) : null
+        if (parsed && parsed !== selectedTermCode.value && terms.value.some((t) => t.termCode === parsed)) {
+            selectedTermCode.value = parsed
+        }
+    },
+)
+
+async function loadCourses() {
+    if (!selectedTermCode.value) return
+
+    isLoading.value = true
+    try {
+        const [coursesResult, deptsResult] = await Promise.all([
+            effortService.getCourses(selectedTermCode.value),
+            effortService.getDepartments(),
+        ])
+        courses.value = coursesResult
+        departments.value = deptsResult
+    } finally {
+        isLoading.value = false
+    }
+}
+
+function openEditDialog(course: CourseDto) {
+    selectedCourse.value = course
+    // Determine if this is enrollment-only edit (ManageRCourseEnrollment without EditCourse)
+    editEnrollmentOnly.value = !isAdmin.value && !hasEditCourse.value && hasManageRCourseEnrollment.value
+    showEditDialog.value = true
+}
+
+function confirmDeleteCourse(course: CourseDto) {
+    $q.dialog({
+        title: "Delete Course",
+        message: `Are you sure you want to delete ${course.courseCode}-${course.seqNumb} (CRN: ${course.crn})? This will also delete all associated effort records.`,
+        cancel: true,
+        persistent: true,
+    }).onOk(async () => {
+        // Check record count first
+        const { recordCount } = await effortService.canDeleteCourse(course.id)
+        if (recordCount > 0) {
+            $q.dialog({
+                title: "Confirm Delete",
+                message: `This course has ${recordCount} effort record(s) that will also be deleted. Are you sure you want to proceed?`,
+                cancel: true,
+                persistent: true,
+            }).onOk(() => deleteCourse(course.id))
+        } else {
+            await deleteCourse(course.id)
+        }
+    })
+}
+
+async function deleteCourse(courseId: number) {
+    const success = await effortService.deleteCourse(courseId)
+    if (success) {
+        $q.notify({ type: "positive", message: "Course deleted successfully" })
+        await loadCourses()
+    } else {
+        $q.notify({ type: "negative", message: "Failed to delete course" })
+    }
+}
+
+function onCourseImported() {
+    $q.notify({ type: "positive", message: "Course imported successfully" })
+    loadCourses()
+}
+
+function onCourseUpdated() {
+    $q.notify({ type: "positive", message: "Course updated successfully" })
+    loadCourses()
+}
+
+function onCourseCreated() {
+    $q.notify({ type: "positive", message: "Course created successfully" })
+    loadCourses()
+}
+
+onMounted(loadTerms)
+</script>
+
+<style scoped>
+@media (width <= 599px) {
+    .full-width-xs {
+        width: 100%;
+    }
+}
+</style>
diff --git a/VueApp/src/Effort/pages/EffortHome.vue b/VueApp/src/Effort/pages/EffortHome.vue
index f0e68ee6..41e3b606 100644
--- a/VueApp/src/Effort/pages/EffortHome.vue
+++ b/VueApp/src/Effort/pages/EffortHome.vue
@@ -1,7 +1,37 @@
 <template>
     <div class="q-pa-md">
-        <h2 class="text-grey-7">Select your action from the menu</h2>
+        <template v-if="isLoading">
+            <div class="text-grey q-my-md">Loading...</div>
+        </template>
+        <template v-else>
+            <h2 class="text-grey-7">Select your action from the menu</h2>
+        </template>
     </div>
 </template>
 
-<script setup lang="ts"></script>
+<script setup lang="ts">
+import { ref, onMounted } from "vue"
+import { useRoute, useRouter } from "vue-router"
+import { effortService } from "../services/effort-service"
+
+const route = useRoute()
+const router = useRouter()
+
+const isLoading = ref(true)
+
+onMounted(async () => {
+    const termCode = route.params.termCode ? parseInt(route.params.termCode as string, 10) : null
+
+    if (termCode) {
+        try {
+            await effortService.getTerm(termCode)
+        } catch {
+            router.replace({ name: "TermSelection" })
+        } finally {
+            isLoading.value = false
+        }
+    } else {
+        router.replace({ name: "TermSelection" })
+    }
+})
+</script>
diff --git a/VueApp/src/Effort/pages/TermManagement.vue b/VueApp/src/Effort/pages/TermManagement.vue
index 4f3288ec..a9968257 100644
--- a/VueApp/src/Effort/pages/TermManagement.vue
+++ b/VueApp/src/Effort/pages/TermManagement.vue
@@ -269,10 +269,10 @@
 
             <div class="q-mt-lg">
                 <router-link
-                    to="/Effort/terms"
+                    :to="backLink"
                     class="text-primary"
                 >
-                    Back to Term Selection
+                    {{ currentTermCode ? "Back" : "Back to Term Selection" }}
                 </router-link>
             </div>
         </template>
@@ -280,16 +280,27 @@
 </template>
 
 <script setup lang="ts">
-import { ref, onMounted } from "vue"
+import { ref, computed, onMounted } from "vue"
 import { useQuasar } from "quasar"
+import { useRoute } from "vue-router"
 import { effortService } from "../services/effort-service"
 import { useDateFunctions } from "@/composables/DateFunctions"
 import type { TermDto, AvailableTermDto } from "../types"
 import type { QTableColumn } from "quasar"
 
 const $q = useQuasar()
+const route = useRoute()
 const { formatDate } = useDateFunctions()
 
+// Get termCode from query param to maintain context
+const currentTermCode = computed(() => {
+    const parsed = route.query.termCode ? parseInt(route.query.termCode as string, 10) : null
+    return Number.isFinite(parsed) ? parsed : null
+})
+
+// Build back link - go to term home if we have a term, otherwise term selection
+const backLink = computed(() => (currentTermCode.value ? `/Effort/${currentTermCode.value}` : "/Effort/terms"))
+
 const terms = ref<TermDto[]>([])
 const availableTerms = ref<AvailableTermDto[]>([])
 const selectedNewTerm = ref<AvailableTermDto | null>(null)
diff --git a/VueApp/src/Effort/router/routes.ts b/VueApp/src/Effort/router/routes.ts
index fc3597ad..ea844590 100644
--- a/VueApp/src/Effort/router/routes.ts
+++ b/VueApp/src/Effort/router/routes.ts
@@ -1,5 +1,10 @@
 import EffortLayout from "@/Effort/layouts/EffortLayout.vue"
 
+// Term code format: YYYYXX where XX is 01-10 (valid semester/quarter codes)
+// Vue Router's path-to-regexp doesn't support alternation (|) in custom patterns.
+// Using \d{6} for basic validation; backend validates the full format.
+const TERM_CODE_PATTERN = String.raw`\d{6}`
+
 const routes = [
     {
         path: "/Effort/",
@@ -24,6 +29,21 @@ const routes = [
         component: () => import("@/Effort/pages/TermManagement.vue"),
         name: "TermManagement",
     },
+    {
+        path: `/Effort/:termCode(${TERM_CODE_PATTERN})/courses`,
+        meta: {
+            layout: EffortLayout,
+            permissions: [
+                "SVMSecure.Effort.ViewAllDepartments",
+                "SVMSecure.Effort.ImportCourse",
+                "SVMSecure.Effort.EditCourse",
+                "SVMSecure.Effort.DeleteCourse",
+                "SVMSecure.Effort.ManageRCourseEnrollment",
+            ],
+        },
+        component: () => import("@/Effort/pages/CourseList.vue"),
+        name: "CourseList",
+    },
     {
         path: "/Effort/audit",
         meta: { layout: EffortLayout, permissions: ["SVMSecure.Effort.ViewAudit"] },
@@ -31,7 +51,13 @@ const routes = [
         name: "EffortAudit",
     },
     {
-        path: "/Effort/:termCode(\\d+)",
+        path: `/Effort/:termCode(${TERM_CODE_PATTERN})/audit`,
+        meta: { layout: EffortLayout, permissions: ["SVMSecure.Effort.ViewAudit"] },
+        component: () => import("@/Effort/pages/AuditList.vue"),
+        name: "EffortAuditWithTerm",
+    },
+    {
+        path: `/Effort/:termCode(${TERM_CODE_PATTERN})`,
         meta: { layout: EffortLayout },
         component: () => import("@/Effort/pages/EffortHome.vue"),
         name: "EffortHomeWithTerm",
diff --git a/VueApp/src/Effort/services/effort-service.ts b/VueApp/src/Effort/services/effort-service.ts
index cf1be563..b3d99c1b 100644
--- a/VueApp/src/Effort/services/effort-service.ts
+++ b/VueApp/src/Effort/services/effort-service.ts
@@ -1,7 +1,15 @@
 import { useFetch } from "@/composables/ViperFetch"
-import type { TermDto, AvailableTermDto } from "../types"
+import type {
+    TermDto,
+    AvailableTermDto,
+    CourseDto,
+    BannerCourseDto,
+    CreateCourseRequest,
+    UpdateCourseRequest,
+    ImportCourseRequest,
+} from "../types"
 
-const { get, post, del } = useFetch()
+const { get, post, put, del, patch } = useFetch()
 
 /**
  * Service for Effort API calls.
@@ -9,6 +17,22 @@ const { get, post, del } = useFetch()
 class EffortService {
     private baseUrl = `${import.meta.env.VITE_API_URL}effort`
 
+    private static extractErrorMessage(errors: unknown, fallback: string): string {
+        if (typeof errors === "string") {
+            return errors
+        }
+        if (Array.isArray(errors)) {
+            return errors.join(", ")
+        }
+        if (errors && typeof errors === "object") {
+            const values = Object.values(errors)
+            if (values.length > 0) {
+                return values.flat().join(", ")
+            }
+        }
+        return fallback
+    }
+
     /**
      * Get all terms with effort status.
      */
@@ -74,13 +98,7 @@ class EffortService {
     async closeTerm(termCode: number): Promise<{ success: boolean; error?: string }> {
         const response = await post(`${this.baseUrl}/terms/${termCode}/close`, {})
         if (!response.success) {
-            let errorMessage = "Failed to close term"
-            if (typeof response.errors === "string") {
-                errorMessage = response.errors
-            } else if (Array.isArray(response.errors)) {
-                errorMessage = response.errors.join(", ")
-            }
-            return { success: false, error: errorMessage }
+            return { success: false, error: EffortService.extractErrorMessage(response.errors, "Failed to close term") }
         }
         return { success: true }
     }
@@ -111,6 +129,158 @@ class EffortService {
         }
         return response.result as AvailableTermDto[]
     }
+
+    // Course Operations
+
+    /**
+     * Get all courses for a term, optionally filtered by department.
+     */
+    async getCourses(termCode: number, dept?: string): Promise<CourseDto[]> {
+        const params = new URLSearchParams({ termCode: termCode.toString() })
+        if (dept) {
+            params.append("dept", dept)
+        }
+        const response = await get(`${this.baseUrl}/courses?${params.toString()}`)
+        if (!response.success || !Array.isArray(response.result)) {
+            return []
+        }
+        return response.result as CourseDto[]
+    }
+
+    /**
+     * Get a single course by ID.
+     */
+    async getCourse(courseId: number): Promise<CourseDto | null> {
+        const response = await get(`${this.baseUrl}/courses/${courseId}`)
+        if (!response.success || !response.result) {
+            return null
+        }
+        return response.result as CourseDto
+    }
+
+    /**
+     * Search for courses in Banner.
+     */
+    async searchBannerCourses(
+        termCode: number,
+        filters: { subjCode?: string; crseNumb?: string; seqNumb?: string; crn?: string } = {},
+    ): Promise<BannerCourseDto[]> {
+        const params = new URLSearchParams({ termCode: termCode.toString() })
+        if (filters.subjCode) {
+            params.append("subjCode", filters.subjCode)
+        }
+        if (filters.crseNumb) {
+            params.append("crseNumb", filters.crseNumb)
+        }
+        if (filters.seqNumb) {
+            params.append("seqNumb", filters.seqNumb)
+        }
+        if (filters.crn) {
+            params.append("crn", filters.crn)
+        }
+
+        const response = await get(`${this.baseUrl}/courses/search?${params.toString()}`)
+        if (!response.success || !Array.isArray(response.result)) {
+            throw new Error(EffortService.extractErrorMessage(response.errors, "Search failed"))
+        }
+        return response.result as BannerCourseDto[]
+    }
+
+    /**
+     * Import a course from Banner.
+     */
+    async importCourse(
+        request: ImportCourseRequest,
+    ): Promise<{ success: boolean; course?: CourseDto; error?: string }> {
+        const response = await post(`${this.baseUrl}/courses/import`, request)
+        if (!response.success) {
+            return {
+                success: false,
+                error: EffortService.extractErrorMessage(response.errors, "Failed to import course"),
+            }
+        }
+        return { success: true, course: response.result as CourseDto }
+    }
+
+    /**
+     * Create a course manually.
+     */
+    async createCourse(
+        request: CreateCourseRequest,
+    ): Promise<{ success: boolean; course?: CourseDto; error?: string }> {
+        const response = await post(`${this.baseUrl}/courses`, request)
+        if (!response.success) {
+            return {
+                success: false,
+                error: EffortService.extractErrorMessage(response.errors, "Failed to create course"),
+            }
+        }
+        return { success: true, course: response.result as CourseDto }
+    }
+
+    /**
+     * Update a course (full update - requires EditCourse permission).
+     */
+    async updateCourse(
+        courseId: number,
+        request: UpdateCourseRequest,
+    ): Promise<{ success: boolean; course?: CourseDto; error?: string }> {
+        const response = await put(`${this.baseUrl}/courses/${courseId}`, request)
+        if (!response.success) {
+            return {
+                success: false,
+                error: EffortService.extractErrorMessage(response.errors, "Failed to update course"),
+            }
+        }
+        return { success: true, course: response.result as CourseDto }
+    }
+
+    /**
+     * Update only the enrollment for an R-course (requires ManageRCourseEnrollment permission).
+     */
+    async updateCourseEnrollment(
+        courseId: number,
+        enrollment: number,
+    ): Promise<{ success: boolean; course?: CourseDto; error?: string }> {
+        const response = await patch(`${this.baseUrl}/courses/${courseId}/enrollment`, { enrollment })
+        if (!response.success) {
+            return {
+                success: false,
+                error: EffortService.extractErrorMessage(response.errors, "Failed to update enrollment"),
+            }
+        }
+        return { success: true, course: response.result as CourseDto }
+    }
+
+    /**
+     * Delete a course.
+     */
+    async deleteCourse(courseId: number): Promise<boolean> {
+        const response = await del(`${this.baseUrl}/courses/${courseId}`)
+        return response.success
+    }
+
+    /**
+     * Check if a course can be deleted.
+     */
+    async canDeleteCourse(courseId: number): Promise<{ canDelete: boolean; recordCount: number }> {
+        const response = await get(`${this.baseUrl}/courses/${courseId}/can-delete`)
+        if (!response.success || !response.result) {
+            return { canDelete: false, recordCount: 0 }
+        }
+        return response.result as { canDelete: boolean; recordCount: number }
+    }
+
+    /**
+     * Get valid custodial department codes.
+     */
+    async getDepartments(): Promise<string[]> {
+        const response = await get(`${this.baseUrl}/courses/departments`)
+        if (!response.success || !Array.isArray(response.result)) {
+            return []
+        }
+        return response.result as string[]
+    }
 }
 
 const effortService = new EffortService()
diff --git a/VueApp/src/Effort/types/index.ts b/VueApp/src/Effort/types/index.ts
index 5188684a..3edf8b81 100644
--- a/VueApp/src/Effort/types/index.ts
+++ b/VueApp/src/Effort/types/index.ts
@@ -106,6 +106,47 @@ type TermOptionDto = {
     termName: string
 }
 
+// Course management types
+type BannerCourseDto = {
+    crn: string
+    subjCode: string
+    crseNumb: string
+    seqNumb: string
+    title: string
+    enrollment: number
+    unitType: string // F=Fixed, V=Variable
+    unitLow: number
+    unitHigh: number
+    deptCode: string
+    courseCode: string
+    isVariableUnits: boolean
+    alreadyImported: boolean
+    importedUnitValues: number[]
+}
+
+type CreateCourseRequest = {
+    termCode: number
+    crn: string
+    subjCode: string
+    crseNumb: string
+    seqNumb: string
+    enrollment: number
+    units: number
+    custDept: string
+}
+
+type UpdateCourseRequest = {
+    enrollment: number
+    units: number
+    custDept: string
+}
+
+type ImportCourseRequest = {
+    termCode: number
+    crn: string
+    units?: number // For variable-unit courses
+}
+
 export type {
     TermDto,
     PersonDto,
@@ -116,4 +157,8 @@ export type {
     ChangeDetail,
     ModifierInfo,
     TermOptionDto,
+    BannerCourseDto,
+    CreateCourseRequest,
+    UpdateCourseRequest,
+    ImportCourseRequest,
 }
diff --git a/VueApp/src/composables/ViperFetch.ts b/VueApp/src/composables/ViperFetch.ts
index c8d48e10..e76d5724 100644
--- a/VueApp/src/composables/ViperFetch.ts
+++ b/VueApp/src/composables/ViperFetch.ts
@@ -230,7 +230,14 @@ function useFetch() {
         return await fetchWrapper(url, options)
     }
 
-    return { get, post, put, del, createUrlSearchParams }
+    async function patch(url: string = "", body: any = {}, options: any = {}): Promise<Result> {
+        options.method = "PATCH"
+        options.body = JSON.stringify(body)
+        addHeader(options, "Content-Type", "application/json")
+        return await fetchWrapper(url, options)
+    }
+
+    return { get, post, put, del, patch, createUrlSearchParams }
 }
 
 export { useFetch, postForBlob }
diff --git a/test/Effort/CourseServiceTests.cs b/test/Effort/CourseServiceTests.cs
new file mode 100644
index 00000000..eee98c06
--- /dev/null
+++ b/test/Effort/CourseServiceTests.cs
@@ -0,0 +1,706 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Viper.Areas.Effort;
+using Viper.Areas.Effort.Models.DTOs.Requests;
+using Viper.Areas.Effort.Models.DTOs.Responses;
+using Viper.Areas.Effort.Models.Entities;
+using Viper.Areas.Effort.Services;
+
+namespace Viper.test.Effort;
+
+/// <summary>
+/// Unit tests for CourseService course management operations.
+/// Note: Banner search tests are skipped as they require a real database with the
+/// sp_search_banner_courses stored procedure. Use integration tests for Banner functionality.
+/// </summary>
+public sealed class CourseServiceTests : IDisposable
+{
+    private readonly EffortDbContext _context;
+    private readonly Mock<IEffortAuditService> _auditServiceMock;
+    private readonly Mock<ILogger<CourseService>> _loggerMock;
+    private readonly CourseService _courseService;
+
+    public CourseServiceTests()
+    {
+        var effortOptions = new DbContextOptionsBuilder<EffortDbContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning))
+            .Options;
+
+        _context = new EffortDbContext(effortOptions);
+        _auditServiceMock = new Mock<IEffortAuditService>();
+        _loggerMock = new Mock<ILogger<CourseService>>();
+
+        // Setup synchronous audit methods used within transactions
+        _auditServiceMock
+            .Setup(s => s.AddCourseChangeAudit(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<object?>(), It.IsAny<object?>()));
+
+        _courseService = new CourseService(_context, _auditServiceMock.Object, _loggerMock.Object);
+    }
+
+    public void Dispose()
+    {
+        _context.Dispose();
+    }
+
+    #region GetCoursesAsync Tests
+
+    [Fact]
+    public async Task GetCoursesAsync_ReturnsAllCoursesForTerm_OrderedBySubjCodeCrseNumbSeqNumb()
+    {
+        // Arrange
+        _context.Courses.AddRange(
+            new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "VME", CrseNumb = "200", SeqNumb = "001", Enrollment = 10, Units = 4, CustDept = "VME" },
+            new EffortCourse { Id = 2, TermCode = 202410, Crn = "12346", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" },
+            new EffortCourse { Id = 3, TermCode = 202410, Crn = "12347", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "002", Enrollment = 15, Units = 4, CustDept = "DVM" }
+        );
+        await _context.SaveChangesAsync();
+
+        // Act
+        var courses = await _courseService.GetCoursesAsync(202410);
+
+        // Assert
+        Assert.Equal(3, courses.Count);
+        Assert.Equal("DVM", courses[0].SubjCode);
+        Assert.Equal("001", courses[0].SeqNumb);
+        Assert.Equal("DVM", courses[1].SubjCode);
+        Assert.Equal("002", courses[1].SeqNumb);
+        Assert.Equal("VME", courses[2].SubjCode);
+    }
+
+    [Fact]
+    public async Task GetCoursesAsync_FiltersByDepartment_WhenDepartmentProvided()
+    {
+        // Arrange
+        _context.Courses.AddRange(
+            new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "VME", CrseNumb = "200", SeqNumb = "001", Enrollment = 10, Units = 4, CustDept = "VME" },
+            new EffortCourse { Id = 2, TermCode = 202410, Crn = "12346", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" }
+        );
+        await _context.SaveChangesAsync();
+
+        // Act
+        var courses = await _courseService.GetCoursesAsync(202410, "DVM");
+
+        // Assert
+        Assert.Single(courses);
+        Assert.Equal("DVM", courses[0].CustDept);
+    }
+
+    [Fact]
+    public async Task GetCoursesAsync_ReturnsEmptyList_WhenNoCoursesExistForTerm()
+    {
+        // Act
+        var courses = await _courseService.GetCoursesAsync(999999);
+
+        // Assert
+        Assert.Empty(courses);
+    }
+
+    #endregion
+
+    #region GetCourseAsync Tests
+
+    [Fact]
+    public async Task GetCourseAsync_ReturnsCourse_WhenCourseExists()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act
+        var course = await _courseService.GetCourseAsync(1);
+
+        // Assert
+        Assert.NotNull(course);
+        Assert.Equal(1, course.Id);
+        Assert.Equal("DVM", course.SubjCode);
+        Assert.Equal("443", course.CrseNumb);
+    }
+
+    [Fact]
+    public async Task GetCourseAsync_ReturnsNull_WhenCourseDoesNotExist()
+    {
+        // Act
+        var course = await _courseService.GetCourseAsync(999);
+
+        // Assert
+        Assert.Null(course);
+    }
+
+    #endregion
+
+    #region CreateCourseAsync Tests
+
+    [Fact]
+    public async Task CreateCourseAsync_CreatesCourse_WithValidData()
+    {
+        // Arrange
+        _context.Terms.Add(new EffortTerm { TermCode = 202410 });
+        await _context.SaveChangesAsync();
+
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "DVM"
+        };
+
+        // Act
+        var course = await _courseService.CreateCourseAsync(request);
+
+        // Assert
+        Assert.NotNull(course);
+        Assert.Equal("99999", course.Crn);
+        Assert.Equal("TST", course.SubjCode);
+        Assert.Equal("101", course.CrseNumb);
+        Assert.Equal(25, course.Enrollment);
+        Assert.Equal(4, course.Units);
+        Assert.Equal("DVM", course.CustDept);
+
+        // Verify saved to database
+        var savedCourse = await _context.Courses.FirstOrDefaultAsync(c => c.Crn == "99999");
+        Assert.NotNull(savedCourse);
+    }
+
+    [Fact]
+    public async Task CreateCourseAsync_TrimsAndUppercasesStringFields()
+    {
+        // Arrange
+        _context.Terms.Add(new EffortTerm { TermCode = 202410 });
+        await _context.SaveChangesAsync();
+
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = " 99999 ",
+            SubjCode = " tst ",
+            CrseNumb = " 101 ",
+            SeqNumb = " 001 ",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "DVM"
+        };
+
+        // Act
+        var course = await _courseService.CreateCourseAsync(request);
+
+        // Assert
+        Assert.Equal("99999", course.Crn);
+        Assert.Equal("TST", course.SubjCode);
+        Assert.Equal("101", course.CrseNumb);
+        Assert.Equal("001", course.SeqNumb);
+        Assert.Equal("DVM", course.CustDept);
+    }
+
+    [Fact]
+    public void IsValidCustodialDepartment_ReturnsFalse_ForInvalidDepartment()
+    {
+        // Act & Assert
+        Assert.False(_courseService.IsValidCustodialDepartment("INVALID"));
+    }
+
+    [Fact]
+    public void IsValidCustodialDepartment_ReturnsTrue_ForValidDepartment()
+    {
+        // Act & Assert
+        Assert.True(_courseService.IsValidCustodialDepartment("DVM"));
+        Assert.True(_courseService.IsValidCustodialDepartment("dvm")); // Case insensitive
+    }
+
+    [Fact]
+    public async Task CourseExistsAsync_ReturnsTrue_WhenCourseExists()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "99999", SubjCode = "TST", CrseNumb = "101", SeqNumb = "001", Enrollment = 25, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act & Assert
+        Assert.True(await _courseService.CourseExistsAsync(202410, "99999", 4));
+    }
+
+    [Fact]
+    public async Task CourseExistsAsync_ReturnsFalse_WhenCourseDoesNotExist()
+    {
+        // Act & Assert
+        Assert.False(await _courseService.CourseExistsAsync(202410, "99999", 4));
+    }
+
+    [Fact]
+    public async Task CourseExistsAsync_ReturnsFalse_WhenSameCrnDifferentUnits()
+    {
+        // Arrange - course exists with 4 units
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "99999", SubjCode = "TST", CrseNumb = "101", SeqNumb = "001", Enrollment = 25, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act & Assert - checking for 2 units should return false
+        Assert.False(await _courseService.CourseExistsAsync(202410, "99999", 2));
+    }
+
+    [Fact]
+    public async Task CreateCourseAsync_CreatesAuditEntry()
+    {
+        // Arrange
+        _context.Terms.Add(new EffortTerm { TermCode = 202410 });
+        await _context.SaveChangesAsync();
+
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "DVM"
+        };
+
+        // Act
+        await _courseService.CreateCourseAsync(request);
+
+        // Assert
+        _auditServiceMock.Verify(
+            s => s.AddCourseChangeAudit(
+                It.IsAny<int>(),
+                202410,
+                "CreateCourse",
+                null,
+                It.IsAny<object>()),
+            Times.Once);
+    }
+
+    #endregion
+
+    #region UpdateCourseAsync Tests
+
+    [Fact]
+    public async Task UpdateCourseAsync_UpdatesCourse_WithValidData()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+
+        // Act
+        var course = await _courseService.UpdateCourseAsync(1, request);
+
+        // Assert
+        Assert.NotNull(course);
+        Assert.Equal(30, course.Enrollment);
+        Assert.Equal(5, course.Units);
+        Assert.Equal("VME", course.CustDept);
+    }
+
+    [Fact]
+    public async Task UpdateCourseAsync_ReturnsNull_WhenCourseDoesNotExist()
+    {
+        // Arrange
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+
+        // Act
+        var course = await _courseService.UpdateCourseAsync(999, request);
+
+        // Assert
+        Assert.Null(course);
+    }
+
+    [Fact]
+    public async Task UpdateCourseAsync_ThrowsArgumentException_ForInvalidCustodialDepartment()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "INVALID"
+        };
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<ArgumentException>(
+            () => _courseService.UpdateCourseAsync(1, request)
+        );
+        Assert.Contains("Invalid custodial department", exception.Message);
+    }
+
+    [Fact]
+    public async Task UpdateCourseAsync_CreatesAuditEntryWithOldAndNewValues()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+
+        // Act
+        await _courseService.UpdateCourseAsync(1, request);
+
+        // Assert
+        _auditServiceMock.Verify(
+            s => s.AddCourseChangeAudit(
+                1,
+                202410,
+                "UpdateCourse",
+                It.IsAny<object>(), // Old values
+                It.IsAny<object>()), // New values
+            Times.Once);
+    }
+
+    #endregion
+
+    #region UpdateCourseEnrollmentAsync Tests
+
+    [Fact]
+    public async Task UpdateCourseEnrollmentAsync_UpdatesEnrollment_ForRCourse()
+    {
+        // Arrange - R-course ends with 'R'
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443R", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act
+        var course = await _courseService.UpdateCourseEnrollmentAsync(1, 50);
+
+        // Assert
+        Assert.NotNull(course);
+        Assert.Equal(50, course.Enrollment);
+    }
+
+    [Fact]
+    public async Task UpdateCourseEnrollmentAsync_ThrowsInvalidOperationException_ForNonRCourse()
+    {
+        // Arrange - Non R-course (doesn't end with 'R')
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act & Assert
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => _courseService.UpdateCourseEnrollmentAsync(1, 50)
+        );
+        Assert.Contains("not an R-course", exception.Message);
+    }
+
+    [Fact]
+    public async Task UpdateCourseEnrollmentAsync_ReturnsNull_WhenCourseDoesNotExist()
+    {
+        // Act
+        var course = await _courseService.UpdateCourseEnrollmentAsync(999, 50);
+
+        // Assert
+        Assert.Null(course);
+    }
+
+    #endregion
+
+    #region DeleteCourseAsync Tests
+
+    [Fact]
+    public async Task DeleteCourseAsync_DeletesCourse_WhenCourseExists()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act
+        var result = await _courseService.DeleteCourseAsync(1);
+
+        // Assert
+        Assert.True(result);
+        Assert.Null(await _context.Courses.FindAsync(1));
+    }
+
+    [Fact]
+    public async Task DeleteCourseAsync_ReturnsFalse_WhenCourseDoesNotExist()
+    {
+        // Act
+        var result = await _courseService.DeleteCourseAsync(999);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task DeleteCourseAsync_DeletesAssociatedRecords()
+    {
+        // Arrange
+        var course = new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        _context.Courses.Add(course);
+        await _context.SaveChangesAsync();
+
+        _context.Records.AddRange(
+            new EffortRecord { Id = 1, TermCode = 202410, CourseId = 1, PersonId = 100 },
+            new EffortRecord { Id = 2, TermCode = 202410, CourseId = 1, PersonId = 101 }
+        );
+        await _context.SaveChangesAsync();
+
+        // Act
+        var result = await _courseService.DeleteCourseAsync(1);
+
+        // Assert
+        Assert.True(result);
+        Assert.Empty(await _context.Records.Where(r => r.CourseId == 1).ToListAsync());
+    }
+
+    [Fact]
+    public async Task DeleteCourseAsync_CreatesAuditEntry()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act
+        await _courseService.DeleteCourseAsync(1);
+
+        // Assert
+        _auditServiceMock.Verify(
+            s => s.AddCourseChangeAudit(
+                1,
+                202410,
+                "DeleteCourse",
+                It.IsAny<object>(), // Course info
+                null),
+            Times.Once);
+    }
+
+    #endregion
+
+    #region CanDeleteCourseAsync Tests
+
+    [Fact]
+    public async Task CanDeleteCourseAsync_ReturnsTrueAndZeroCount_WhenNoRecords()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        await _context.SaveChangesAsync();
+
+        // Act
+        var (canDelete, recordCount) = await _courseService.CanDeleteCourseAsync(1);
+
+        // Assert
+        Assert.True(canDelete);
+        Assert.Equal(0, recordCount);
+    }
+
+    [Fact]
+    public async Task CanDeleteCourseAsync_ReturnsTrueWithRecordCount_WhenRecordsExist()
+    {
+        // Arrange
+        _context.Courses.Add(new EffortCourse { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" });
+        _context.Records.AddRange(
+            new EffortRecord { Id = 1, TermCode = 202410, CourseId = 1, PersonId = 100 },
+            new EffortRecord { Id = 2, TermCode = 202410, CourseId = 1, PersonId = 101 },
+            new EffortRecord { Id = 3, TermCode = 202410, CourseId = 1, PersonId = 102 }
+        );
+        await _context.SaveChangesAsync();
+
+        // Act
+        var (canDelete, recordCount) = await _courseService.CanDeleteCourseAsync(1);
+
+        // Assert
+        Assert.True(canDelete); // Always true - deletion is allowed
+        Assert.Equal(3, recordCount);
+    }
+
+    #endregion
+
+    #region GetValidCustodialDepartments Tests
+
+    [Fact]
+    public void GetValidCustodialDepartments_ReturnsAllValidDepartments()
+    {
+        // Act
+        var departments = _courseService.GetValidCustodialDepartments();
+
+        // Assert
+        Assert.Contains("APC", departments);
+        Assert.Contains("VMB", departments);
+        Assert.Contains("VME", departments);
+        Assert.Contains("VSR", departments);
+        Assert.Contains("PMI", departments);
+        Assert.Contains("PHR", departments);
+        Assert.Contains("UNK", departments);
+        Assert.Contains("DVM", departments);
+        Assert.Contains("VET", departments);
+        Assert.Equal(9, departments.Count);
+    }
+
+    #endregion
+
+    #region SearchBannerCoursesAsync Tests
+
+    // Note: SearchBannerCoursesAsync tests are skipped because the method now calls
+    // the sp_search_banner_courses stored procedure via raw SQL, which requires
+    // a real database connection. These tests should be run as integration tests.
+
+    [Fact]
+    public async Task SearchBannerCoursesAsync_ThrowsArgumentException_WhenNoParametersProvided()
+    {
+        // Act & Assert
+        await Assert.ThrowsAsync<ArgumentException>(
+            () => _courseService.SearchBannerCoursesAsync(202410));
+    }
+
+    #endregion
+
+    #region ImportCourseFromBannerAsync Tests
+
+    [Fact]
+    public async Task ImportCourseFromBannerAsync_ImportsCourse_WithCorrectDataMapping()
+    {
+        // Arrange
+        var bannerCourse = new BannerCourseDto
+        {
+            Crn = "12345",
+            SubjCode = "DVM",
+            CrseNumb = "443",
+            SeqNumb = "001",
+            Enrollment = 20,
+            UnitType = "F",
+            UnitLow = 4,
+            UnitHigh = 4,
+            DeptCode = "72030"
+        };
+
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345"
+        };
+
+        // Act
+        var course = await _courseService.ImportCourseFromBannerAsync(request, bannerCourse);
+
+        // Assert
+        Assert.NotNull(course);
+        Assert.Equal("12345", course.Crn);
+        Assert.Equal("DVM", course.SubjCode);
+        Assert.Equal("443", course.CrseNumb);
+        Assert.Equal("001", course.SeqNumb);
+        Assert.Equal(20, course.Enrollment);
+        Assert.Equal(4, course.Units);
+        // DVM is a valid SVM subject code, so it becomes the custodial department directly
+        Assert.Equal("DVM", course.CustDept);
+    }
+
+    // Note: GetBannerCourseAsync tests are skipped because the method now uses
+    // SearchBannerCoursesAsync which calls the sp_search_banner_courses stored procedure.
+    // These tests should be run as integration tests against a real database.
+
+    [Fact]
+    public async Task ImportCourseFromBannerAsync_UsesDeptCodeMapping_WhenSubjCodeNotValidDept()
+    {
+        // Arrange - BIS is not a valid SVM department, so it should fall back to DeptCode mapping
+        var bannerCourse = new BannerCourseDto
+        {
+            Crn = "12345",
+            SubjCode = "BIS",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 20,
+            UnitType = "F",
+            UnitLow = 4,
+            UnitHigh = 4,
+            DeptCode = "72030" // Should map to VME
+        };
+
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345"
+        };
+
+        // Act
+        var course = await _courseService.ImportCourseFromBannerAsync(request, bannerCourse);
+
+        // Assert - DeptCode 72030 maps to VME when subject code is not a valid department
+        Assert.Equal("VME", course.CustDept);
+    }
+
+    [Fact]
+    public async Task ImportCourseFromBannerAsync_HandlesVariableUnitCourse_WithSpecifiedUnits()
+    {
+        // Arrange
+        var bannerCourse = new BannerCourseDto
+        {
+            Crn = "12345",
+            SubjCode = "DVM",
+            CrseNumb = "443",
+            SeqNumb = "001",
+            Enrollment = 20,
+            UnitType = "V",
+            UnitLow = 1,
+            UnitHigh = 4,
+            DeptCode = "72030"
+        };
+
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345",
+            Units = 3
+        };
+
+        // Act
+        var course = await _courseService.ImportCourseFromBannerAsync(request, bannerCourse);
+
+        // Assert
+        Assert.Equal(3, course.Units);
+    }
+
+    [Fact]
+    public async Task ImportCourseFromBannerAsync_UsesUnitLow_WhenNoUnitsSpecifiedForVariableCourse()
+    {
+        // Arrange
+        var bannerCourse = new BannerCourseDto
+        {
+            Crn = "12345",
+            SubjCode = "DVM",
+            CrseNumb = "443",
+            SeqNumb = "001",
+            Enrollment = 20,
+            UnitType = "V",
+            UnitLow = 1,
+            UnitHigh = 4,
+            DeptCode = "72030"
+        };
+
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345"
+            // Units not specified
+        };
+
+        // Act
+        var course = await _courseService.ImportCourseFromBannerAsync(request, bannerCourse);
+
+        // Assert - should use UnitLow
+        Assert.Equal(1, course.Units);
+    }
+
+    #endregion
+}
diff --git a/test/Effort/CoursesControllerTests.cs b/test/Effort/CoursesControllerTests.cs
new file mode 100644
index 00000000..f67bbb25
--- /dev/null
+++ b/test/Effort/CoursesControllerTests.cs
@@ -0,0 +1,739 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Viper.Areas.Effort.Controllers;
+using Viper.Areas.Effort.Models.DTOs.Requests;
+using Viper.Areas.Effort.Models.DTOs.Responses;
+using Viper.Areas.Effort.Services;
+
+namespace Viper.test.Effort;
+
+/// <summary>
+/// Unit tests for CoursesController API endpoints.
+/// </summary>
+public sealed class CoursesControllerTests
+{
+    private readonly Mock<ICourseService> _courseServiceMock;
+    private readonly Mock<IEffortPermissionService> _permissionServiceMock;
+    private readonly Mock<ILogger<CoursesController>> _loggerMock;
+    private readonly CoursesController _controller;
+
+    public CoursesControllerTests()
+    {
+        _courseServiceMock = new Mock<ICourseService>();
+        _permissionServiceMock = new Mock<IEffortPermissionService>();
+        _loggerMock = new Mock<ILogger<CoursesController>>();
+
+        _controller = new CoursesController(
+            _courseServiceMock.Object,
+            _permissionServiceMock.Object,
+            _loggerMock.Object);
+
+        SetupControllerContext();
+    }
+
+    private void SetupControllerContext()
+    {
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        _controller.ControllerContext = new ControllerContext
+        {
+            HttpContext = new DefaultHttpContext
+            {
+                RequestServices = serviceProvider
+            }
+        };
+    }
+
+    #region GetCourses Tests
+
+    [Fact]
+    public async Task GetCourses_ReturnsOk_WithCourseList()
+    {
+        // Arrange
+        var courses = new List<CourseDto>
+        {
+            new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" },
+            new CourseDto { Id = 2, TermCode = 202410, Crn = "12346", SubjCode = "VME", CrseNumb = "200", SeqNumb = "001", Enrollment = 15, Units = 3, CustDept = "VME" }
+        };
+        _permissionServiceMock.Setup(s => s.HasFullAccessAsync(It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.GetCoursesAsync(202410, null, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(courses);
+
+        // Act
+        var result = await _controller.GetCourses(202410);
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourses = Assert.IsAssignableFrom<IEnumerable<CourseDto>>(okResult.Value);
+        Assert.Equal(2, returnedCourses.Count());
+    }
+
+    [Fact]
+    public async Task GetCourses_FiltersByDepartment_WhenProvided()
+    {
+        // Arrange
+        var courses = new List<CourseDto>
+        {
+            new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" }
+        };
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _permissionServiceMock.Setup(s => s.HasFullAccessAsync(It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.GetCoursesAsync(202410, "DVM", It.IsAny<CancellationToken>()))
+            .ReturnsAsync(courses);
+
+        // Act
+        var result = await _controller.GetCourses(202410, "DVM");
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourses = Assert.IsAssignableFrom<IEnumerable<CourseDto>>(okResult.Value);
+        Assert.Single(returnedCourses);
+    }
+
+    #endregion
+
+    #region GetCourse Tests
+
+    [Fact]
+    public async Task GetCourse_ReturnsOk_WhenCourseExists()
+    {
+        // Arrange
+        var course = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(course);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+
+        // Act
+        var result = await _controller.GetCourse(1);
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourse = Assert.IsType<CourseDto>(okResult.Value);
+        Assert.Equal(1, returnedCourse.Id);
+    }
+
+    [Fact]
+    public async Task GetCourse_ReturnsNotFound_WhenCourseDoesNotExist()
+    {
+        // Arrange
+        _courseServiceMock.Setup(s => s.GetCourseAsync(999, It.IsAny<CancellationToken>()))
+            .ReturnsAsync((CourseDto?)null);
+
+        // Act
+        var result = await _controller.GetCourse(999);
+
+        // Assert
+        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result.Result);
+        Assert.Contains("999", notFoundResult.Value?.ToString());
+    }
+
+    #endregion
+
+    #region CreateCourse Tests
+
+    [Fact]
+    public async Task CreateCourse_ReturnsCreated_WithCourseDto()
+    {
+        // Arrange
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "DVM"
+        };
+        var createdCourse = new CourseDto { Id = 10, TermCode = 202410, Crn = "99999", SubjCode = "TST", CrseNumb = "101", SeqNumb = "001", Enrollment = 25, Units = 4, CustDept = "DVM" };
+
+        _courseServiceMock.Setup(s => s.IsValidCustodialDepartment("DVM")).Returns(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.CourseExistsAsync(202410, "99999", 4, It.IsAny<CancellationToken>())).ReturnsAsync(false);
+        _courseServiceMock.Setup(s => s.CreateCourseAsync(request, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(createdCourse);
+
+        // Act
+        var result = await _controller.CreateCourse(request);
+
+        // Assert
+        var createdResult = Assert.IsType<CreatedAtActionResult>(result.Result);
+        Assert.Equal(201, createdResult.StatusCode);
+        var returnedCourse = Assert.IsType<CourseDto>(createdResult.Value);
+        Assert.Equal(10, returnedCourse.Id);
+    }
+
+    [Fact]
+    public async Task CreateCourse_ReturnsBadRequest_WhenUserNotAuthorizedForDepartment()
+    {
+        // Arrange
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "VME"
+        };
+
+        _courseServiceMock.Setup(s => s.IsValidCustodialDepartment("VME")).Returns(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("VME", It.IsAny<CancellationToken>())).ReturnsAsync(false);
+
+        // Act
+        var result = await _controller.CreateCourse(request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Equal(400, badRequestResult.StatusCode);
+        Assert.Contains("Invalid custodial department", badRequestResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task CreateCourse_ReturnsConflict_ForDuplicateCourse()
+    {
+        // Arrange
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "DVM"
+        };
+
+        _courseServiceMock.Setup(s => s.IsValidCustodialDepartment("DVM")).Returns(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.CourseExistsAsync(202410, "99999", 4, It.IsAny<CancellationToken>())).ReturnsAsync(true);
+
+        // Act
+        var result = await _controller.CreateCourse(request);
+
+        // Assert
+        var conflictResult = Assert.IsType<ConflictObjectResult>(result.Result);
+        Assert.Equal(409, conflictResult.StatusCode);
+        Assert.Contains("already exists", conflictResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task CreateCourse_ReturnsBadRequest_ForInvalidCustodialDepartment()
+    {
+        // Arrange
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "INVALID"
+        };
+
+        _courseServiceMock.Setup(s => s.IsValidCustodialDepartment("INVALID")).Returns(false);
+
+        // Act
+        var result = await _controller.CreateCourse(request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Equal(400, badRequestResult.StatusCode);
+        Assert.Contains("Invalid custodial department", badRequestResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task CreateCourse_ReturnsBadRequest_ForDbUpdateException()
+    {
+        // Arrange
+        var request = new CreateCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999",
+            SubjCode = "TST",
+            CrseNumb = "101",
+            SeqNumb = "001",
+            Enrollment = 25,
+            Units = 4,
+            CustDept = "DVM"
+        };
+
+        _courseServiceMock.Setup(s => s.IsValidCustodialDepartment("DVM")).Returns(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.CourseExistsAsync(202410, "99999", 4, It.IsAny<CancellationToken>())).ReturnsAsync(false);
+        _courseServiceMock.Setup(s => s.CreateCourseAsync(request, It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new DbUpdateException("Database constraint violation"));
+
+        // Act
+        var result = await _controller.CreateCourse(request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Equal(400, badRequestResult.StatusCode);
+        Assert.Contains("Failed to save course", badRequestResult.Value?.ToString());
+    }
+
+    #endregion
+
+    #region UpdateCourse Tests
+
+    [Fact]
+    public async Task UpdateCourse_ReturnsOk_WithUpdatedCourse()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+        var updatedCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 30, Units = 5, CustDept = "VME" };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("VME", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.UpdateCourseAsync(1, request, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(updatedCourse);
+
+        // Act
+        var result = await _controller.UpdateCourse(1, request);
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourse = Assert.IsType<CourseDto>(okResult.Value);
+        Assert.Equal(30, returnedCourse.Enrollment);
+        Assert.Equal(5, returnedCourse.Units);
+    }
+
+    [Fact]
+    public async Task UpdateCourse_ReturnsNotFound_WhenUserNotAuthorizedForNewDepartment()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("VME", It.IsAny<CancellationToken>())).ReturnsAsync(false);
+
+        // Act
+        var result = await _controller.UpdateCourse(1, request);
+
+        // Assert
+        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result.Result);
+        Assert.Contains("1", notFoundResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task UpdateCourse_AllowsSameDepartment_WithoutNewDepartmentAuth()
+    {
+        // Arrange - User can update course within their authorized department without needing extra check
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "DVM"
+        };
+        var updatedCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 30, Units = 5, CustDept = "DVM" };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.UpdateCourseAsync(1, request, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(updatedCourse);
+
+        // Act
+        var result = await _controller.UpdateCourse(1, request);
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourse = Assert.IsType<CourseDto>(okResult.Value);
+        Assert.Equal(30, returnedCourse.Enrollment);
+    }
+
+    [Fact]
+    public async Task UpdateCourse_ReturnsNotFound_WhenCourseDoesNotExist()
+    {
+        // Arrange
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(999, It.IsAny<CancellationToken>())).ReturnsAsync((CourseDto?)null);
+
+        // Act
+        var result = await _controller.UpdateCourse(999, request);
+
+        // Assert
+        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result.Result);
+        Assert.Contains("999", notFoundResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task UpdateCourse_ReturnsBadRequest_ForInvalidCustodialDepartment()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "INVALID"
+        };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("INVALID", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.UpdateCourseAsync(1, request, It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new ArgumentException("Invalid custodial department: INVALID"));
+
+        // Act
+        var result = await _controller.UpdateCourse(1, request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Contains("Invalid custodial department", badRequestResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task UpdateCourse_ReturnsBadRequest_ForDbUpdateException()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateCourseRequest
+        {
+            Enrollment = 30,
+            Units = 5,
+            CustDept = "VME"
+        };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("VME", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.UpdateCourseAsync(1, request, It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new DbUpdateException("Database constraint violation"));
+
+        // Act
+        var result = await _controller.UpdateCourse(1, request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Contains("Failed to update course", badRequestResult.Value?.ToString());
+    }
+
+    #endregion
+
+    #region UpdateCourseEnrollment Tests
+
+    [Fact]
+    public async Task UpdateCourseEnrollment_ReturnsOk_ForRCourse()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443R", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateEnrollmentRequest { Enrollment = 50 };
+        var updatedCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443R", SeqNumb = "001", Enrollment = 50, Units = 4, CustDept = "DVM" };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.UpdateCourseEnrollmentAsync(1, 50, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(updatedCourse);
+
+        // Act
+        var result = await _controller.UpdateCourseEnrollment(1, request);
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourse = Assert.IsType<CourseDto>(okResult.Value);
+        Assert.Equal(50, returnedCourse.Enrollment);
+    }
+
+    [Fact]
+    public async Task UpdateCourseEnrollment_ReturnsNotFound_WhenCourseDoesNotExist()
+    {
+        // Arrange
+        var request = new UpdateEnrollmentRequest { Enrollment = 50 };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(999, It.IsAny<CancellationToken>())).ReturnsAsync((CourseDto?)null);
+
+        // Act
+        var result = await _controller.UpdateCourseEnrollment(999, request);
+
+        // Assert
+        Assert.IsType<NotFoundObjectResult>(result.Result);
+    }
+
+    [Fact]
+    public async Task UpdateCourseEnrollment_ReturnsBadRequest_ForNonRCourse()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+        var request = new UpdateEnrollmentRequest { Enrollment = 50 };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.UpdateCourseEnrollmentAsync(1, 50, It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new InvalidOperationException("Course is not an R-course"));
+
+        // Act
+        var result = await _controller.UpdateCourseEnrollment(1, request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Contains("R-course", badRequestResult.Value?.ToString());
+    }
+
+    #endregion
+
+    #region DeleteCourse Tests
+
+    [Fact]
+    public async Task DeleteCourse_ReturnsNoContent_OnSuccess()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.DeleteCourseAsync(1, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
+
+        // Act
+        var result = await _controller.DeleteCourse(1);
+
+        // Assert
+        Assert.IsType<NoContentResult>(result);
+    }
+
+    [Fact]
+    public async Task DeleteCourse_ReturnsNotFound_WhenCourseDoesNotExist()
+    {
+        // Arrange
+        _courseServiceMock.Setup(s => s.GetCourseAsync(999, It.IsAny<CancellationToken>())).ReturnsAsync((CourseDto?)null);
+
+        // Act
+        var result = await _controller.DeleteCourse(999);
+
+        // Assert
+        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result);
+        Assert.Contains("999", notFoundResult.Value?.ToString());
+    }
+
+    #endregion
+
+    #region CanDeleteCourse Tests
+
+    [Fact]
+    public async Task CanDeleteCourse_ReturnsOk_WithDeleteInfo()
+    {
+        // Arrange
+        var existingCourse = new CourseDto { Id = 1, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "DVM" };
+
+        _courseServiceMock.Setup(s => s.GetCourseAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(existingCourse);
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("DVM", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.CanDeleteCourseAsync(1, It.IsAny<CancellationToken>()))
+            .ReturnsAsync((true, 5));
+
+        // Act
+        var result = await _controller.CanDeleteCourse(1);
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        Assert.NotNull(okResult.Value);
+    }
+
+    #endregion
+
+    #region GetDepartments Tests
+
+    [Fact]
+    public async Task GetDepartments_ReturnsOk_WithDepartmentList()
+    {
+        // Arrange
+        var departments = new List<string> { "APC", "VMB", "VME", "VSR", "PMI", "PHR", "UNK", "DVM", "VET" };
+        _courseServiceMock.Setup(s => s.GetValidCustodialDepartments())
+            .Returns(departments);
+        _permissionServiceMock.Setup(s => s.HasFullAccessAsync(It.IsAny<CancellationToken>())).ReturnsAsync(true);
+
+        // Act
+        var result = await _controller.GetDepartments();
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedDepartments = Assert.IsAssignableFrom<IEnumerable<string>>(okResult.Value);
+        Assert.Equal(9, returnedDepartments.Count());
+    }
+
+    #endregion
+
+    #region ImportCourse Tests
+
+    [Fact]
+    public async Task ImportCourse_ReturnsCreated_OnSuccess()
+    {
+        // Arrange
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345"
+        };
+        var bannerCourse = new BannerCourseDto { Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, UnitType = "F", UnitLow = 4, UnitHigh = 4, DeptCode = "72030" };
+        var importedCourse = new CourseDto { Id = 10, TermCode = 202410, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = "VME" };
+
+        _courseServiceMock.Setup(s => s.GetBannerCourseAsync(202410, "12345", It.IsAny<CancellationToken>())).ReturnsAsync(bannerCourse);
+        _courseServiceMock.Setup(s => s.CourseExistsAsync(202410, "12345", 4, It.IsAny<CancellationToken>())).ReturnsAsync(false);
+        _courseServiceMock.Setup(s => s.GetCustodialDepartmentForBannerCode("72030")).Returns("VME");
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("VME", It.IsAny<CancellationToken>())).ReturnsAsync(true);
+        _courseServiceMock.Setup(s => s.ImportCourseFromBannerAsync(request, bannerCourse, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(importedCourse);
+
+        // Act
+        var result = await _controller.ImportCourse(request);
+
+        // Assert
+        var createdResult = Assert.IsType<CreatedAtActionResult>(result.Result);
+        Assert.Equal(201, createdResult.StatusCode);
+    }
+
+    [Fact]
+    public async Task ImportCourse_ReturnsNotFound_WhenUserNotAuthorizedForTargetDepartment()
+    {
+        // Arrange
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345"
+        };
+        var bannerCourse = new BannerCourseDto { Crn = "12345", SubjCode = "VME", CrseNumb = "200", SeqNumb = "001", Enrollment = 20, UnitType = "F", UnitLow = 4, UnitHigh = 4, DeptCode = "72030" };
+
+        _courseServiceMock.Setup(s => s.GetBannerCourseAsync(202410, "12345", It.IsAny<CancellationToken>())).ReturnsAsync(bannerCourse);
+        _courseServiceMock.Setup(s => s.CourseExistsAsync(202410, "12345", 4, It.IsAny<CancellationToken>())).ReturnsAsync(false);
+        _courseServiceMock.Setup(s => s.GetCustodialDepartmentForBannerCode("72030")).Returns("VME");
+        _permissionServiceMock.Setup(s => s.CanViewDepartmentAsync("VME", It.IsAny<CancellationToken>())).ReturnsAsync(false);
+
+        // Act
+        var result = await _controller.ImportCourse(request);
+
+        // Assert
+        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result.Result);
+        Assert.Contains("not found in Banner", notFoundResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task ImportCourse_ReturnsConflict_WhenCourseAlreadyExists()
+    {
+        // Arrange
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345"
+        };
+        var bannerCourse = new BannerCourseDto { Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, UnitType = "F", UnitLow = 4, UnitHigh = 4, DeptCode = "72030" };
+
+        _courseServiceMock.Setup(s => s.GetBannerCourseAsync(202410, "12345", It.IsAny<CancellationToken>())).ReturnsAsync(bannerCourse);
+        _courseServiceMock.Setup(s => s.CourseExistsAsync(202410, "12345", 4, It.IsAny<CancellationToken>())).ReturnsAsync(true);
+
+        // Act
+        var result = await _controller.ImportCourse(request);
+
+        // Assert
+        var conflictResult = Assert.IsType<ConflictObjectResult>(result.Result);
+        Assert.Contains("already exists", conflictResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task ImportCourse_ReturnsNotFound_WhenBannerCourseNotFound()
+    {
+        // Arrange
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "99999"
+        };
+
+        _courseServiceMock.Setup(s => s.GetBannerCourseAsync(202410, "99999", It.IsAny<CancellationToken>())).ReturnsAsync((BannerCourseDto?)null);
+
+        // Act
+        var result = await _controller.ImportCourse(request);
+
+        // Assert
+        var notFoundResult = Assert.IsType<NotFoundObjectResult>(result.Result);
+        Assert.Contains("not found in Banner", notFoundResult.Value?.ToString());
+    }
+
+    [Fact]
+    public async Task ImportCourse_ReturnsBadRequest_WhenUnitsOutOfRange()
+    {
+        // Arrange
+        var request = new ImportCourseRequest
+        {
+            TermCode = 202410,
+            Crn = "12345",
+            Units = 10 // Out of range
+        };
+        var bannerCourse = new BannerCourseDto { Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, UnitType = "V", UnitLow = 1, UnitHigh = 4, DeptCode = "72030" };
+
+        _courseServiceMock.Setup(s => s.GetBannerCourseAsync(202410, "12345", It.IsAny<CancellationToken>())).ReturnsAsync(bannerCourse);
+
+        // Act
+        var result = await _controller.ImportCourse(request);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Contains("must be between", badRequestResult.Value?.ToString());
+    }
+
+    #endregion
+
+    #region SearchBannerCourses Tests
+
+    [Fact]
+    public async Task SearchBannerCourses_ReturnsOk_WithResults()
+    {
+        // Arrange
+        var bannerCourses = new List<BannerCourseDto>
+        {
+            new BannerCourseDto { Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20 }
+        };
+        _courseServiceMock.Setup(s => s.SearchBannerCoursesAsync(202410, "DVM", null, null, null, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(bannerCourses);
+
+        // Act
+        var result = await _controller.SearchBannerCourses(202410, "DVM");
+
+        // Assert
+        var okResult = Assert.IsType<OkObjectResult>(result.Result);
+        var returnedCourses = Assert.IsAssignableFrom<IEnumerable<BannerCourseDto>>(okResult.Value);
+        Assert.Single(returnedCourses);
+    }
+
+    [Fact]
+    public async Task SearchBannerCourses_ReturnsBadRequest_WhenNoSearchParametersProvided()
+    {
+        // Act
+        var result = await _controller.SearchBannerCourses(202410);
+
+        // Assert
+        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result.Result);
+        Assert.Contains("At least one search parameter", badRequestResult.Value?.ToString());
+    }
+
+    #endregion
+}
diff --git a/test/Effort/EffortIntegrationTestBase.cs b/test/Effort/EffortIntegrationTestBase.cs
new file mode 100644
index 00000000..f8d156a7
--- /dev/null
+++ b/test/Effort/EffortIntegrationTestBase.cs
@@ -0,0 +1,402 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using Viper.Areas.Effort;
+using Viper.Areas.Effort.Constants;
+using Viper.Areas.Effort.Models.Entities;
+using Viper.Classes.SQLContext;
+using Viper.Models.AAUD;
+
+namespace Viper.test.Effort;
+
+/// <summary>
+/// Base class for Effort integration tests that require AAUD and RAPS contexts.
+/// Provides pre-configured contexts and common setup methods to eliminate
+/// repetitive test data setup across integration test files.
+/// </summary>
+public abstract class EffortIntegrationTestBase : IDisposable
+{
+    // Test user constants
+    public const string TestUserMothraId = "testuser";
+    public const string TestUserLoginId = "testuser";
+    public const string TestUserDisplayName = "Test User";
+    public const int TestUserAaudId = 999;
+
+    // Department constants
+    public const string DvmDepartment = "DVM";
+    public const string VmeDepartment = "VME";
+    public const string ApcDepartment = "APC";
+
+    // Term constants
+    public const int TestTermCode = 202410;
+
+    protected readonly EffortDbContext EffortContext;
+    protected readonly RAPSContext RapsContext;
+    protected readonly Mock<IUserHelper> MockUserHelper;
+
+    protected EffortIntegrationTestBase()
+    {
+        // Create real in-memory database for Entity Framework operations
+        var effortOptions = new DbContextOptionsBuilder<EffortDbContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning))
+            .Options;
+        EffortContext = new EffortDbContext(effortOptions);
+
+        // Create RAPS context for permission checking
+        RapsContext = CreateRAPSContext();
+
+        // Setup UserHelper mock
+        MockUserHelper = new Mock<IUserHelper>();
+
+        // Seed basic test data
+        SeedBasicTestData();
+    }
+
+    /// <summary>
+    /// Creates and configures an in-memory RAPS context with Effort permissions
+    /// </summary>
+    private static RAPSContext CreateRAPSContext()
+    {
+        var options = new DbContextOptionsBuilder<RAPSContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .Options;
+        var context = new RAPSContext(options);
+
+        // Setup HttpHelper.Cache for UserHelper permission caching
+        var memoryCache = new MemoryCache(new MemoryCacheOptions());
+        Viper.HttpHelper.Configure(memoryCache, null!, null!, null!, null!, null!);
+
+        // Create standard Effort permissions
+        var permissions = new List<Viper.Models.RAPS.TblPermission>
+        {
+            new() { PermissionId = 1, Permission = EffortPermissions.Base, Description = "Effort Base Permission" },
+            new() { PermissionId = 2, Permission = EffortPermissions.ViewAllDepartments, Description = "View All Departments" },
+            new() { PermissionId = 3, Permission = EffortPermissions.ViewDept, Description = "View Department" },
+            new() { PermissionId = 4, Permission = EffortPermissions.EditCourse, Description = "Edit Course" },
+            new() { PermissionId = 5, Permission = EffortPermissions.ImportCourse, Description = "Import Course" },
+            new() { PermissionId = 6, Permission = EffortPermissions.DeleteCourse, Description = "Delete Course" },
+            new() { PermissionId = 7, Permission = EffortPermissions.EditEffort, Description = "Edit Effort" },
+            new() { PermissionId = 8, Permission = EffortPermissions.CreateEffort, Description = "Create Effort" },
+            new() { PermissionId = 9, Permission = EffortPermissions.DeleteEffort, Description = "Delete Effort" },
+            new() { PermissionId = 10, Permission = EffortPermissions.VerifyEffort, Description = "Verify Effort" },
+            new() { PermissionId = 11, Permission = EffortPermissions.ManageRCourseEnrollment, Description = "Manage R Course Enrollment" },
+            new() { PermissionId = 12, Permission = EffortPermissions.ViewAudit, Description = "View Audit" },
+            new() { PermissionId = 13, Permission = EffortPermissions.ManageTerms, Description = "Manage Terms" }
+        };
+
+        context.TblPermissions.AddRange(permissions);
+        context.SaveChanges();
+        return context;
+    }
+
+    /// <summary>
+    /// Seeds basic test data required for integration tests
+    /// </summary>
+    private void SeedBasicTestData()
+    {
+        // Add test term
+        EffortContext.Terms.Add(new EffortTerm
+        {
+            TermCode = TestTermCode,
+            Status = "Open",
+            CreatedDate = DateTime.UtcNow
+        });
+
+        // Add test courses
+        var courses = new[]
+        {
+            new EffortCourse { Id = 1, TermCode = TestTermCode, Crn = "12345", SubjCode = "DVM", CrseNumb = "443", SeqNumb = "001", Enrollment = 20, Units = 4, CustDept = DvmDepartment },
+            new EffortCourse { Id = 2, TermCode = TestTermCode, Crn = "12346", SubjCode = "VME", CrseNumb = "200", SeqNumb = "001", Enrollment = 15, Units = 3, CustDept = VmeDepartment },
+            new EffortCourse { Id = 3, TermCode = TestTermCode, Crn = "12347", SubjCode = "APC", CrseNumb = "100", SeqNumb = "001", Enrollment = 10, Units = 2, CustDept = ApcDepartment }
+        };
+        EffortContext.Courses.AddRange(courses);
+
+        // Add test persons
+        var persons = new[]
+        {
+            new EffortPerson { PersonId = TestUserAaudId, TermCode = TestTermCode, FirstName = "Test", LastName = "User", EffortDept = DvmDepartment },
+            new EffortPerson { PersonId = 1001, TermCode = TestTermCode, FirstName = "Alice", LastName = "Johnson", EffortDept = VmeDepartment },
+            new EffortPerson { PersonId = 1002, TermCode = TestTermCode, FirstName = "Bob", LastName = "Smith", EffortDept = ApcDepartment }
+        };
+        EffortContext.Persons.AddRange(persons);
+
+        EffortContext.SaveChanges();
+    }
+
+    /// <summary>
+    /// Creates a test user with standard properties
+    /// </summary>
+    protected static AaudUser CreateTestUser(string? mothraId = null, int? aaudUserId = null) => new()
+    {
+        MothraId = mothraId ?? TestUserMothraId,
+        LoginId = mothraId ?? TestUserLoginId,
+        DisplayFullName = TestUserDisplayName,
+        AaudUserId = aaudUserId ?? TestUserAaudId
+    };
+
+    /// <summary>
+    /// Sets up user with ViewAllDepartments (full access) permission
+    /// </summary>
+    protected void SetupUserWithFullAccess()
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.ViewAllDepartments);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.ViewAllDepartments
+        });
+    }
+
+    /// <summary>
+    /// Sets up user with department-level view permission
+    /// </summary>
+    protected void SetupUserWithDepartmentViewAccess(params string[] departments)
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.ViewDept);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.ViewDept
+        });
+
+        // Add UserAccess entries for departments
+        foreach (var dept in departments)
+        {
+            EffortContext.UserAccess.Add(new UserAccess
+            {
+                PersonId = TestUserAaudId,
+                DepartmentCode = dept,
+                IsActive = true
+            });
+        }
+        EffortContext.SaveChanges();
+    }
+
+    /// <summary>
+    /// Sets up user with course edit permission
+    /// </summary>
+    protected void SetupUserWithEditCoursePermission()
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.EditCourse);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.EditCourse
+        });
+    }
+
+    /// <summary>
+    /// Sets up user with course import permission
+    /// </summary>
+    protected void SetupUserWithImportCoursePermission()
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.ImportCourse);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.ImportCourse
+        });
+    }
+
+    /// <summary>
+    /// Sets up user with course delete permission
+    /// </summary>
+    protected void SetupUserWithDeleteCoursePermission()
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.DeleteCourse);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.DeleteCourse
+        });
+    }
+
+    /// <summary>
+    /// Sets up user with effort edit permission for a department
+    /// </summary>
+    protected void SetupUserWithEditEffortPermission(params string[] departments)
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.ViewDept,
+            EffortPermissions.EditEffort);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.ViewDept,
+            EffortPermissions.EditEffort
+        });
+
+        // Add UserAccess entries for departments
+        foreach (var dept in departments)
+        {
+            EffortContext.UserAccess.Add(new UserAccess
+            {
+                PersonId = TestUserAaudId,
+                DepartmentCode = dept,
+                IsActive = true
+            });
+        }
+        EffortContext.SaveChanges();
+    }
+
+    /// <summary>
+    /// Sets up user with self-service (VerifyEffort) permission only
+    /// </summary>
+    protected void SetupUserWithSelfServiceAccess()
+    {
+        AddMemberPermissions(TestUserMothraId,
+            EffortPermissions.Base,
+            EffortPermissions.VerifyEffort);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base,
+            EffortPermissions.VerifyEffort
+        });
+    }
+
+    /// <summary>
+    /// Sets up user with base permission only (view-only, no edit)
+    /// </summary>
+    protected void SetupUserWithBasePermissionOnly()
+    {
+        AddMemberPermissions(TestUserMothraId, EffortPermissions.Base);
+
+        SetupUserWithPermissionsForIntegration(TestUserMothraId, new[]
+        {
+            EffortPermissions.Base
+        });
+    }
+
+    /// <summary>
+    /// Sets up user with no permissions
+    /// </summary>
+    protected void SetupUserWithNoPermissions()
+    {
+        var testUser = CreateTestUser();
+        MockUserHelper.Setup(x => x.GetCurrentUser()).Returns(testUser);
+        MockUserHelper.Setup(x => x.HasPermission(It.IsAny<RAPSContext>(), It.IsAny<AaudUser>(), It.IsAny<string>()))
+            .Returns(false);
+    }
+
+    /// <summary>
+    /// Sets up null user (unauthenticated)
+    /// </summary>
+    protected void SetupNullUser()
+    {
+        MockUserHelper.Setup(x => x.GetCurrentUser()).Returns((AaudUser?)null);
+    }
+
+    /// <summary>
+    /// Sets up user permissions for integration tests
+    /// </summary>
+    protected void SetupUserWithPermissionsForIntegration(string? userMothraId, IEnumerable<string> permissions, int? aaudUserId = null)
+    {
+        if (userMothraId == null)
+        {
+            MockUserHelper.Setup(x => x.GetCurrentUser()).Returns((AaudUser?)null);
+            return;
+        }
+
+        var testUser = CreateTestUser(userMothraId, aaudUserId);
+        MockUserHelper.Setup(x => x.GetCurrentUser()).Returns(testUser);
+
+        // Default all permissions to false
+        MockUserHelper.Setup(x => x.HasPermission(It.IsAny<RAPSContext>(), It.IsAny<AaudUser>(), It.IsAny<string>()))
+            .Returns(false);
+
+        // Set up the specific permissions to return true
+        foreach (var permission in permissions)
+        {
+            MockUserHelper.Setup(x => x.HasPermission(RapsContext, testUser, permission))
+                .Returns(true);
+        }
+    }
+
+    /// <summary>
+    /// Adds member permissions to RAPS context
+    /// </summary>
+    protected void AddMemberPermissions(string mothraId, params string[] permissions)
+    {
+        foreach (var permission in permissions)
+        {
+            var permissionEntity = RapsContext.TblPermissions.FirstOrDefault(p => p.Permission == permission);
+            if (permissionEntity != null)
+            {
+                RapsContext.TblMemberPermissions.Add(new Viper.Models.RAPS.TblMemberPermission
+                {
+                    MemberId = mothraId,
+                    PermissionId = permissionEntity.PermissionId,
+                    Access = 1,
+                    StartDate = DateTime.Today.AddYears(-1),
+                    EndDate = null
+                });
+            }
+        }
+        RapsContext.SaveChanges();
+    }
+
+    /// <summary>
+    /// Sets up authenticated HttpContext with required services for controllers
+    /// </summary>
+    protected void SetupControllerContext(ControllerBase controller)
+    {
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddScoped<RAPSContext>(_ => RapsContext);
+        serviceCollection.AddScoped<EffortDbContext>(_ => EffortContext);
+        var serviceProvider = serviceCollection.BuildServiceProvider();
+
+        var httpContext = new DefaultHttpContext
+        {
+            RequestServices = serviceProvider,
+            User = new System.Security.Claims.ClaimsPrincipal(
+                new System.Security.Claims.ClaimsIdentity(
+                    new[] { new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.Name, TestUserLoginId) },
+                    "test"
+                )
+            )
+        };
+
+        controller.ControllerContext = new ControllerContext
+        {
+            HttpContext = httpContext
+        };
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            EffortContext?.Dispose();
+            RapsContext?.Dispose();
+        }
+    }
+}
diff --git a/test/Effort/Integration/EffortPermissionIntegrationTests.cs b/test/Effort/Integration/EffortPermissionIntegrationTests.cs
new file mode 100644
index 00000000..62d5814a
--- /dev/null
+++ b/test/Effort/Integration/EffortPermissionIntegrationTests.cs
@@ -0,0 +1,541 @@
+using Viper.Areas.Effort.Models.Entities;
+using Viper.Areas.Effort.Services;
+
+namespace Viper.test.Effort.Integration;
+
+/// <summary>
+/// Integration tests for the Effort permission service architecture.
+/// Tests the complete flow of permission checks for department-level,
+/// full access, and self-service permission models.
+/// </summary>
+public class EffortPermissionIntegrationTests : EffortIntegrationTestBase
+{
+    private readonly EffortPermissionService _permissionService;
+
+    public EffortPermissionIntegrationTests()
+    {
+        _permissionService = new EffortPermissionService(
+            EffortContext,
+            RapsContext,
+            MockUserHelper.Object
+        );
+    }
+
+    #region Full Access (ViewAllDepartments) Tests
+
+    [Fact]
+    public async Task FullAccess_HasFullAccessAsync_ReturnsTrue()
+    {
+        // Arrange
+        SetupUserWithFullAccess();
+
+        // Act
+        var hasFullAccess = await _permissionService.HasFullAccessAsync();
+
+        // Assert
+        Assert.True(hasFullAccess);
+    }
+
+    [Fact]
+    public async Task FullAccess_CanViewAnyDepartment()
+    {
+        // Arrange
+        SetupUserWithFullAccess();
+
+        // Act
+        var canViewDvm = await _permissionService.CanViewDepartmentAsync(DvmDepartment);
+        var canViewVme = await _permissionService.CanViewDepartmentAsync(VmeDepartment);
+        var canViewApc = await _permissionService.CanViewDepartmentAsync(ApcDepartment);
+
+        // Assert
+        Assert.True(canViewDvm);
+        Assert.True(canViewVme);
+        Assert.True(canViewApc);
+    }
+
+    [Fact]
+    public async Task FullAccess_CanEditAnyDepartment()
+    {
+        // Arrange - Full access user also needs EditEffort permission
+        SetupUserWithFullAccess();
+
+        // Act
+        var canEditDvm = await _permissionService.CanEditDepartmentAsync(DvmDepartment);
+        var canEditVme = await _permissionService.CanEditDepartmentAsync(VmeDepartment);
+
+        // Assert - Full access bypasses department filtering
+        Assert.True(canEditDvm);
+        Assert.True(canEditVme);
+    }
+
+    [Fact]
+    public async Task FullAccess_GetAuthorizedDepartmentsAsync_ReturnsEmptyList()
+    {
+        // Arrange - Full access means ALL departments
+        SetupUserWithFullAccess();
+
+        // Act
+        var departments = await _permissionService.GetAuthorizedDepartmentsAsync();
+
+        // Assert - Empty list indicates full access (all departments)
+        Assert.Empty(departments);
+    }
+
+    [Fact]
+    public async Task FullAccess_CanViewAnyPersonEffort()
+    {
+        // Arrange
+        SetupUserWithFullAccess();
+
+        // Act - Can view any person regardless of department
+        var canViewDvmPerson = await _permissionService.CanViewPersonEffortAsync(TestUserAaudId, TestTermCode);
+        var canViewVmePerson = await _permissionService.CanViewPersonEffortAsync(1001, TestTermCode);
+        var canViewApcPerson = await _permissionService.CanViewPersonEffortAsync(1002, TestTermCode);
+
+        // Assert
+        Assert.True(canViewDvmPerson);
+        Assert.True(canViewVmePerson);
+        Assert.True(canViewApcPerson);
+    }
+
+    #endregion
+
+    #region Department-Level Access (ViewDept) Tests
+
+    [Fact]
+    public async Task DepartmentAccess_HasDepartmentLevelAccessAsync_ReturnsTrue()
+    {
+        // Arrange
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act
+        var hasDeptAccess = await _permissionService.HasDepartmentLevelAccessAsync();
+
+        // Assert
+        Assert.True(hasDeptAccess);
+    }
+
+    [Fact]
+    public async Task DepartmentAccess_CanViewOnlyAuthorizedDepartments()
+    {
+        // Arrange - User only has access to DVM
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act
+        var canViewDvm = await _permissionService.CanViewDepartmentAsync(DvmDepartment);
+        var canViewVme = await _permissionService.CanViewDepartmentAsync(VmeDepartment);
+        var canViewApc = await _permissionService.CanViewDepartmentAsync(ApcDepartment);
+
+        // Assert
+        Assert.True(canViewDvm);
+        Assert.False(canViewVme);
+        Assert.False(canViewApc);
+    }
+
+    [Fact]
+    public async Task DepartmentAccess_CanViewMultipleAuthorizedDepartments()
+    {
+        // Arrange - User has access to DVM and VME
+        SetupUserWithDepartmentViewAccess(DvmDepartment, VmeDepartment);
+
+        // Act
+        var canViewDvm = await _permissionService.CanViewDepartmentAsync(DvmDepartment);
+        var canViewVme = await _permissionService.CanViewDepartmentAsync(VmeDepartment);
+        var canViewApc = await _permissionService.CanViewDepartmentAsync(ApcDepartment);
+
+        // Assert
+        Assert.True(canViewDvm);
+        Assert.True(canViewVme);
+        Assert.False(canViewApc);
+    }
+
+    [Fact]
+    public async Task DepartmentAccess_GetAuthorizedDepartmentsAsync_ReturnsUserDepartments()
+    {
+        // Arrange
+        SetupUserWithDepartmentViewAccess(DvmDepartment, VmeDepartment);
+
+        // Act
+        var departments = await _permissionService.GetAuthorizedDepartmentsAsync();
+
+        // Assert
+        Assert.Equal(2, departments.Count);
+        Assert.Contains(DvmDepartment, departments);
+        Assert.Contains(VmeDepartment, departments);
+    }
+
+    [Fact]
+    public async Task DepartmentAccess_CanOnlyViewPersonsInAuthorizedDepartment()
+    {
+        // Arrange - User only has access to DVM
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act
+        var canViewDvmPerson = await _permissionService.CanViewPersonEffortAsync(TestUserAaudId, TestTermCode);
+        var canViewVmePerson = await _permissionService.CanViewPersonEffortAsync(1001, TestTermCode);
+        var canViewApcPerson = await _permissionService.CanViewPersonEffortAsync(1002, TestTermCode);
+
+        // Assert
+        Assert.True(canViewDvmPerson);
+        Assert.False(canViewVmePerson);
+        Assert.False(canViewApcPerson);
+    }
+
+    #endregion
+
+    #region Edit Permission Tests
+
+    [Fact]
+    public async Task EditEffort_CanOnlyEditAuthorizedDepartments()
+    {
+        // Arrange - User has edit permission for DVM only
+        SetupUserWithEditEffortPermission(DvmDepartment);
+
+        // Act
+        var canEditDvm = await _permissionService.CanEditDepartmentAsync(DvmDepartment);
+        var canEditVme = await _permissionService.CanEditDepartmentAsync(VmeDepartment);
+
+        // Assert
+        Assert.True(canEditDvm);
+        Assert.False(canEditVme);
+    }
+
+    [Fact]
+    public async Task EditEffort_CanOnlyEditPersonsInAuthorizedDepartment()
+    {
+        // Arrange - User has edit permission for DVM only
+        SetupUserWithEditEffortPermission(DvmDepartment);
+
+        // Act
+        var canEditDvmPerson = await _permissionService.CanEditPersonEffortAsync(TestUserAaudId, TestTermCode);
+        var canEditVmePerson = await _permissionService.CanEditPersonEffortAsync(1001, TestTermCode);
+
+        // Assert
+        Assert.True(canEditDvmPerson);
+        Assert.False(canEditVmePerson);
+    }
+
+    [Fact]
+    public async Task EditEffort_WithoutPermission_CannotEditAnyDepartment()
+    {
+        // Arrange - User has only ViewDept, not EditEffort
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act
+        var canEditDvm = await _permissionService.CanEditDepartmentAsync(DvmDepartment);
+
+        // Assert - Cannot edit even their own department without EditEffort permission
+        Assert.False(canEditDvm);
+    }
+
+    #endregion
+
+    #region Self-Service Access (VerifyEffort) Tests
+
+    [Fact]
+    public async Task SelfService_HasSelfServiceAccessAsync_ReturnsTrue()
+    {
+        // Arrange
+        SetupUserWithSelfServiceAccess();
+
+        // Act
+        var hasSelfService = await _permissionService.HasSelfServiceAccessAsync();
+
+        // Assert
+        Assert.True(hasSelfService);
+    }
+
+    [Fact]
+    public async Task SelfService_CanViewOwnEffort()
+    {
+        // Arrange - Self-service user can only view their own effort
+        SetupUserWithSelfServiceAccess();
+
+        // Act
+        var canViewOwn = await _permissionService.CanViewPersonEffortAsync(TestUserAaudId, TestTermCode);
+
+        // Assert
+        Assert.True(canViewOwn);
+    }
+
+    [Fact]
+    public async Task SelfService_CannotViewOtherPersonEffort()
+    {
+        // Arrange - Self-service only
+        SetupUserWithSelfServiceAccess();
+
+        // Act
+        var canViewOther = await _permissionService.CanViewPersonEffortAsync(1001, TestTermCode);
+
+        // Assert
+        Assert.False(canViewOther);
+    }
+
+    [Fact]
+    public void SelfService_IsCurrentUser_ReturnsTrue()
+    {
+        // Arrange
+        SetupUserWithSelfServiceAccess();
+
+        // Act
+        var isCurrentUser = _permissionService.IsCurrentUser(TestUserAaudId);
+
+        // Assert
+        Assert.True(isCurrentUser);
+    }
+
+    [Fact]
+    public void SelfService_IsCurrentUser_ReturnsFalseForOtherPerson()
+    {
+        // Arrange
+        SetupUserWithSelfServiceAccess();
+
+        // Act
+        var isCurrentUser = _permissionService.IsCurrentUser(1001);
+
+        // Assert
+        Assert.False(isCurrentUser);
+    }
+
+    #endregion
+
+    #region No Permission / Null User Tests
+
+    [Fact]
+    public async Task NoPermissions_HasFullAccessAsync_ReturnsFalse()
+    {
+        // Arrange
+        SetupUserWithNoPermissions();
+
+        // Act
+        var hasFullAccess = await _permissionService.HasFullAccessAsync();
+
+        // Assert
+        Assert.False(hasFullAccess);
+    }
+
+    [Fact]
+    public async Task NoPermissions_HasDepartmentLevelAccessAsync_ReturnsFalse()
+    {
+        // Arrange
+        SetupUserWithNoPermissions();
+
+        // Act
+        var hasDeptAccess = await _permissionService.HasDepartmentLevelAccessAsync();
+
+        // Assert
+        Assert.False(hasDeptAccess);
+    }
+
+    [Fact]
+    public async Task NoPermissions_CannotViewAnyDepartment()
+    {
+        // Arrange
+        SetupUserWithNoPermissions();
+
+        // Act
+        var canViewDvm = await _permissionService.CanViewDepartmentAsync(DvmDepartment);
+        var canViewVme = await _permissionService.CanViewDepartmentAsync(VmeDepartment);
+
+        // Assert
+        Assert.False(canViewDvm);
+        Assert.False(canViewVme);
+    }
+
+    [Fact]
+    public async Task NoPermissions_CannotViewAnyPersonEffort()
+    {
+        // Arrange
+        SetupUserWithNoPermissions();
+
+        // Act
+        var canViewPerson = await _permissionService.CanViewPersonEffortAsync(TestUserAaudId, TestTermCode);
+
+        // Assert
+        Assert.False(canViewPerson);
+    }
+
+    [Fact]
+    public async Task NullUser_HasFullAccessAsync_ReturnsFalse()
+    {
+        // Arrange
+        SetupNullUser();
+
+        // Act
+        var hasFullAccess = await _permissionService.HasFullAccessAsync();
+
+        // Assert
+        Assert.False(hasFullAccess);
+    }
+
+    [Fact]
+    public async Task NullUser_CannotViewAnyDepartment()
+    {
+        // Arrange
+        SetupNullUser();
+
+        // Act
+        var canViewDvm = await _permissionService.CanViewDepartmentAsync(DvmDepartment);
+
+        // Assert
+        Assert.False(canViewDvm);
+    }
+
+    [Fact]
+    public void NullUser_GetCurrentPersonId_ReturnsZero()
+    {
+        // Arrange
+        SetupNullUser();
+
+        // Act
+        var personId = _permissionService.GetCurrentPersonId();
+
+        // Assert
+        Assert.Equal(0, personId);
+    }
+
+    #endregion
+
+    #region Base Permission Only Tests
+
+    [Fact]
+    public async Task BasePermissionOnly_HasFullAccessAsync_ReturnsFalse()
+    {
+        // Arrange
+        SetupUserWithBasePermissionOnly();
+
+        // Act
+        var hasFullAccess = await _permissionService.HasFullAccessAsync();
+
+        // Assert
+        Assert.False(hasFullAccess);
+    }
+
+    [Fact]
+    public async Task BasePermissionOnly_HasDepartmentLevelAccessAsync_ReturnsFalse()
+    {
+        // Arrange - Base permission does not include ViewDept
+        SetupUserWithBasePermissionOnly();
+
+        // Act
+        var hasDeptAccess = await _permissionService.HasDepartmentLevelAccessAsync();
+
+        // Assert
+        Assert.False(hasDeptAccess);
+    }
+
+    [Fact]
+    public async Task BasePermissionOnly_CannotViewAnyDepartment()
+    {
+        // Arrange
+        SetupUserWithBasePermissionOnly();
+
+        // Act
+        var canViewDvm = await _permissionService.CanViewDepartmentAsync(DvmDepartment);
+
+        // Assert
+        Assert.False(canViewDvm);
+    }
+
+    #endregion
+
+    #region Permission Hierarchy Tests
+
+    [Fact]
+    public async Task FullAccess_OverridesDepartmentLevelAccess()
+    {
+        // Arrange - User has ViewAllDepartments (full access)
+        SetupUserWithFullAccess();
+
+        // Act - Should have access to all departments regardless of UserAccess entries
+        var hasDeptAccess = await _permissionService.HasDepartmentLevelAccessAsync();
+        var canViewAllDepts = await _permissionService.CanViewDepartmentAsync(ApcDepartment);
+
+        // Assert
+        Assert.False(hasDeptAccess); // ViewDept is not set
+        Assert.True(canViewAllDepts); // But full access grants view to all
+    }
+
+    [Fact]
+    public async Task DepartmentAccess_CaseInsensitive()
+    {
+        // Arrange
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act - Test case insensitivity
+        var canViewUppercase = await _permissionService.CanViewDepartmentAsync("DVM");
+        var canViewLowercase = await _permissionService.CanViewDepartmentAsync("dvm");
+        var canViewMixed = await _permissionService.CanViewDepartmentAsync("Dvm");
+
+        // Assert
+        Assert.True(canViewUppercase);
+        Assert.True(canViewLowercase);
+        Assert.True(canViewMixed);
+    }
+
+    [Fact]
+    public async Task InactiveUserAccess_IsIgnored()
+    {
+        // Arrange - Add inactive UserAccess entry
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Add an inactive entry for VME
+        EffortContext.UserAccess.Add(new UserAccess
+        {
+            PersonId = TestUserAaudId,
+            DepartmentCode = VmeDepartment,
+            IsActive = false // Inactive!
+        });
+        await EffortContext.SaveChangesAsync();
+
+        // Act
+        var canViewVme = await _permissionService.CanViewDepartmentAsync(VmeDepartment);
+
+        // Assert - Inactive access should be ignored
+        Assert.False(canViewVme);
+    }
+
+    #endregion
+
+    #region Person Effort with ReportUnit Tests
+
+    [Fact]
+    public async Task DepartmentAccess_CanViewPersonByReportUnit()
+    {
+        // Arrange - Add a person with different EffortDept but matching ReportUnit
+        var personWithReportUnit = new EffortPerson
+        {
+            PersonId = 2000,
+            TermCode = TestTermCode,
+            FirstName = "Charlie",
+            LastName = "Brown",
+            EffortDept = ApcDepartment, // Different from user's department
+            ReportUnit = DvmDepartment  // But ReportUnit matches
+        };
+        EffortContext.Persons.Add(personWithReportUnit);
+        await EffortContext.SaveChangesAsync();
+
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act
+        var canViewPerson = await _permissionService.CanViewPersonEffortAsync(2000, TestTermCode);
+
+        // Assert - Should be able to view via ReportUnit match
+        Assert.True(canViewPerson);
+    }
+
+    [Fact]
+    public async Task DepartmentAccess_CannotViewPersonWithNoMatchingDeptOrReportUnit()
+    {
+        // Arrange - Person in completely different department with no matching ReportUnit
+        SetupUserWithDepartmentViewAccess(DvmDepartment);
+
+        // Act
+        var canViewApcPerson = await _permissionService.CanViewPersonEffortAsync(1002, TestTermCode);
+
+        // Assert
+        Assert.False(canViewApcPerson);
+    }
+
+    #endregion
+}
diff --git a/web/Areas/Effort/Controllers/CoursesController.cs b/web/Areas/Effort/Controllers/CoursesController.cs
new file mode 100644
index 00000000..ba55e1ed
--- /dev/null
+++ b/web/Areas/Effort/Controllers/CoursesController.cs
@@ -0,0 +1,419 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Viper.Areas.Effort.Constants;
+using Viper.Areas.Effort.Models.DTOs.Requests;
+using Viper.Areas.Effort.Models.DTOs.Responses;
+using Viper.Areas.Effort.Services;
+using Viper.Classes.Utilities;
+using Web.Authorization;
+
+namespace Viper.Areas.Effort.Controllers;
+
+/// <summary>
+/// API controller for course operations in the Effort system.
+/// </summary>
+[Route("/api/effort/courses")]
+[Permission(Allow = $"{EffortPermissions.ViewDept},{EffortPermissions.ViewAllDepartments}")]
+public class CoursesController : BaseEffortController
+{
+    private readonly ICourseService _courseService;
+    private readonly IEffortPermissionService _permissionService;
+
+    public CoursesController(
+        ICourseService courseService,
+        IEffortPermissionService permissionService,
+        ILogger<CoursesController> logger) : base(logger)
+    {
+        _courseService = courseService;
+        _permissionService = permissionService;
+    }
+
+    /// <summary>
+    /// Verifies the user is authorized to access a course by its department.
+    /// Returns null if authorized, or a NotFound result if not.
+    /// Note: Authorization for target departments in Create/Import/Update uses inline checks
+    /// with different error responses to prevent department enumeration attacks.
+    /// </summary>
+    private async Task<(CourseDto? course, ActionResult? errorResult)> GetAuthorizedCourseAsync(int id, CancellationToken ct)
+    {
+        var course = await _courseService.GetCourseAsync(id, ct);
+        if (course == null || !await _permissionService.CanViewDepartmentAsync(course.CustDept, ct))
+        {
+            return (null, NotFound($"Course {id} not found"));
+        }
+        return (course, null);
+    }
+
+    /// <summary>
+    /// Get all courses for a term, optionally filtered by department.
+    /// Non-admin users are restricted to their authorized departments.
+    /// </summary>
+    [HttpGet]
+    public async Task<ActionResult<IEnumerable<CourseDto>>> GetCourses(
+        [FromQuery] int termCode,
+        [FromQuery] string? dept = null,
+        CancellationToken ct = default)
+    {
+        SetExceptionContext("termCode", termCode);
+        if (!string.IsNullOrEmpty(dept))
+        {
+            SetExceptionContext("dept", dept);
+        }
+
+        // If department specified, verify user can view it
+        if (!string.IsNullOrEmpty(dept) && !await _permissionService.CanViewDepartmentAsync(dept, ct))
+        {
+            // Return empty list instead of 403 to prevent department enumeration
+            return Ok(Array.Empty<CourseDto>());
+        }
+
+        // For non-full-access users, filter to authorized departments
+        if (!await _permissionService.HasFullAccessAsync(ct))
+        {
+            var authorizedDepts = await _permissionService.GetAuthorizedDepartmentsAsync(ct);
+            if (authorizedDepts.Count == 0)
+            {
+                return Ok(Array.Empty<CourseDto>());
+            }
+
+            // If no dept specified, get courses for all authorized departments
+            if (string.IsNullOrEmpty(dept))
+            {
+                var allCourses = new List<CourseDto>();
+                foreach (var authorizedDept in authorizedDepts)
+                {
+                    var deptCourses = await _courseService.GetCoursesAsync(termCode, authorizedDept, ct);
+                    allCourses.AddRange(deptCourses);
+                }
+                return Ok(allCourses.OrderBy(c => c.SubjCode).ThenBy(c => c.CrseNumb));
+            }
+        }
+
+        var courses = await _courseService.GetCoursesAsync(termCode, dept, ct);
+        return Ok(courses);
+    }
+
+    /// <summary>
+    /// Get a single course by ID.
+    /// Non-admin users can only view courses in their authorized departments.
+    /// </summary>
+    [HttpGet("{id:int}")]
+    public async Task<ActionResult<CourseDto>> GetCourse(int id, CancellationToken ct = default)
+    {
+        SetExceptionContext("courseId", id);
+
+        var course = await _courseService.GetCourseAsync(id, ct);
+        if (course == null)
+        {
+            _logger.LogWarning("Course not found: {CourseId}", id);
+            return NotFound($"Course {id} not found");
+        }
+
+        // Verify user can view the course's custodial department
+        // Return 404 (not 403) to prevent enumeration attacks
+        if (!await _permissionService.CanViewDepartmentAsync(course.CustDept, ct))
+        {
+            _logger.LogWarning("User not authorized to view course {CourseId} in department {Dept}", id, course.CustDept);
+            return NotFound($"Course {id} not found");
+        }
+
+        return Ok(course);
+    }
+
+    /// <summary>
+    /// Search for courses in Banner by subject code, course number, sequence number, and/or CRN.
+    /// Queries Banner directly via linked server.
+    /// </summary>
+    [HttpGet("search")]
+    [Permission(Allow = EffortPermissions.ImportCourse)]
+    public async Task<ActionResult<IEnumerable<BannerCourseDto>>> SearchBannerCourses(
+        [FromQuery] int termCode,
+        [FromQuery] string? subjCode = null,
+        [FromQuery] string? crseNumb = null,
+        [FromQuery] string? seqNumb = null,
+        [FromQuery] string? crn = null,
+        CancellationToken ct = default)
+    {
+        SetExceptionContext("termCode", termCode);
+
+        if (string.IsNullOrWhiteSpace(subjCode) && string.IsNullOrWhiteSpace(crseNumb) &&
+            string.IsNullOrWhiteSpace(seqNumb) && string.IsNullOrWhiteSpace(crn))
+        {
+            return BadRequest("At least one search parameter (subjCode, crseNumb, seqNumb, or crn) is required");
+        }
+
+        try
+        {
+            var courses = await _courseService.SearchBannerCoursesAsync(termCode, subjCode, crseNumb, seqNumb, crn, ct);
+            return Ok(courses);
+        }
+        catch (Microsoft.Data.SqlClient.SqlException ex)
+        {
+            // Check for linked server / connectivity issues
+            if (ex.Message.Contains("UCDBanner") || ex.Message.Contains("OPENQUERY") || ex.Message.Contains("linked server"))
+            {
+                _logger.LogError(ex, "Banner linked server connection failed");
+                return StatusCode(503, "Banner system is temporarily unavailable. Please try again later.");
+            }
+
+            // Check for stored procedure not found
+            if (ex.Message.Contains("Could not find stored procedure") || ex.Number == 2812)
+            {
+                _logger.LogError(ex, "Banner search stored procedure not found");
+                return StatusCode(503, "Banner search is not configured. Please contact support.");
+            }
+
+            _logger.LogError(ex, "Database error during Banner course search");
+            return StatusCode(500, "An error occurred while searching Banner. Please try again.");
+        }
+    }
+
+    /// <summary>
+    /// Import a course from Banner into the Effort system.
+    /// </summary>
+    [HttpPost("import")]
+    [Permission(Allow = EffortPermissions.ImportCourse)]
+    public async Task<ActionResult<CourseDto>> ImportCourse([FromBody] ImportCourseRequest request, CancellationToken ct = default)
+    {
+        SetExceptionContext("termCode", request.TermCode);
+        SetExceptionContext("crn", request.Crn);
+
+        // Validate: Course exists in Banner
+        var bannerCourse = await _courseService.GetBannerCourseAsync(request.TermCode, request.Crn, ct);
+        if (bannerCourse == null)
+        {
+            _logger.LogWarning("Course {Crn} not found in Banner for term {TermCode}", LogSanitizer.SanitizeId(request.Crn), request.TermCode);
+            return NotFound($"Course with CRN {request.Crn} not found in Banner for term {request.TermCode}");
+        }
+
+        // Validate: Units in range for variable-unit courses
+        var isVariable = bannerCourse.UnitType == "V";
+        decimal units;
+        if (isVariable && request.Units.HasValue)
+        {
+            units = request.Units.Value;
+            if (units < bannerCourse.UnitLow || units > bannerCourse.UnitHigh)
+            {
+                _logger.LogWarning("Units {Units} out of range [{Low}-{High}] for course {Crn}",
+                    units, bannerCourse.UnitLow, bannerCourse.UnitHigh, LogSanitizer.SanitizeId(request.Crn));
+                return BadRequest($"Units {units} must be between {bannerCourse.UnitLow} and {bannerCourse.UnitHigh}");
+            }
+        }
+        else
+        {
+            units = bannerCourse.UnitLow;
+        }
+
+        // Validate: Course not already imported with same units
+        if (await _courseService.CourseExistsAsync(request.TermCode, request.Crn, units, ct))
+        {
+            _logger.LogWarning("Course {Crn} with {Units} units already exists for term {TermCode}",
+                LogSanitizer.SanitizeId(request.Crn), units, request.TermCode);
+            return Conflict($"Course {bannerCourse.SubjCode} {bannerCourse.CrseNumb} with {units} units already exists for this term");
+        }
+
+        var targetDept = _courseService.GetCustodialDepartmentForBannerCode(bannerCourse.DeptCode);
+        if (!await _permissionService.CanViewDepartmentAsync(targetDept, ct))
+        {
+            _logger.LogWarning("User not authorized for department {CustDept} when importing course {Crn}",
+                targetDept, LogSanitizer.SanitizeId(request.Crn));
+            return NotFound($"Course with CRN {request.Crn} not found in Banner for term {request.TermCode}");
+        }
+
+        try
+        {
+            var course = await _courseService.ImportCourseFromBannerAsync(request, bannerCourse, ct);
+            _logger.LogInformation("Course imported: {Crn} for term {TermCode}",
+                LogSanitizer.SanitizeId(request.Crn), request.TermCode);
+            return CreatedAtAction(nameof(GetCourse), new { id = course.Id }, course);
+        }
+        catch (DbUpdateException ex)
+        {
+            _logger.LogWarning(ex, "Database error importing course {Crn}: {Message}", LogSanitizer.SanitizeId(request.Crn), LogSanitizer.SanitizeString(ex.InnerException?.Message ?? ex.Message));
+            return BadRequest("Failed to import course. Please check all field values are valid.");
+        }
+    }
+
+    /// <summary>
+    /// Manually create a course in the Effort system.
+    /// </summary>
+    [HttpPost]
+    [Permission(Allow = EffortPermissions.EditCourse)]
+    public async Task<ActionResult<CourseDto>> CreateCourse([FromBody] CreateCourseRequest request, CancellationToken ct = default)
+    {
+        SetExceptionContext("termCode", request.TermCode);
+        SetExceptionContext("crn", request.Crn);
+
+        // Validate: Custodial department is valid
+        if (!_courseService.IsValidCustodialDepartment(request.CustDept))
+        {
+            _logger.LogWarning("Invalid custodial department: {CustDept}", LogSanitizer.SanitizeId(request.CustDept));
+            return BadRequest($"Invalid custodial department: {request.CustDept}");
+        }
+
+        if (!await _permissionService.CanViewDepartmentAsync(request.CustDept, ct))
+        {
+            _logger.LogWarning("User not authorized for department {CustDept}", LogSanitizer.SanitizeId(request.CustDept));
+            return BadRequest($"Invalid custodial department: {request.CustDept}");
+        }
+
+        // Validate: Course not already exists with same CRN and units
+        if (await _courseService.CourseExistsAsync(request.TermCode, request.Crn, request.Units, ct))
+        {
+            _logger.LogWarning("Course {Crn} with {Units} units already exists for term {TermCode}",
+                LogSanitizer.SanitizeId(request.Crn), request.Units, request.TermCode);
+            return Conflict($"Course with CRN {request.Crn} and {request.Units} units already exists for this term");
+        }
+
+        try
+        {
+            var course = await _courseService.CreateCourseAsync(request, ct);
+            _logger.LogInformation("Course created manually: {SubjCode} {CrseNumb} for term {TermCode}",
+                LogSanitizer.SanitizeId(request.SubjCode), LogSanitizer.SanitizeId(request.CrseNumb), request.TermCode);
+            return CreatedAtAction(nameof(GetCourse), new { id = course.Id }, course);
+        }
+        catch (DbUpdateException ex)
+        {
+            _logger.LogWarning(ex, "Database error creating course: {Message}", LogSanitizer.SanitizeString(ex.InnerException?.Message ?? ex.Message));
+            return BadRequest("Failed to save course. Please check all field values are valid.");
+        }
+    }
+
+    /// <summary>
+    /// Update an existing course (full update - requires EditCourse permission).
+    /// </summary>
+    [HttpPut("{id:int}")]
+    [Permission(Allow = EffortPermissions.EditCourse)]
+    public async Task<ActionResult<CourseDto>> UpdateCourse(int id, [FromBody] UpdateCourseRequest request, CancellationToken ct = default)
+    {
+        SetExceptionContext("courseId", id);
+
+        var (existingCourse, errorResult) = await GetAuthorizedCourseAsync(id, ct);
+        if (errorResult != null) return errorResult;
+
+        if (existingCourse != null &&
+            !string.Equals(existingCourse.CustDept, request.CustDept, StringComparison.OrdinalIgnoreCase) &&
+            !await _permissionService.CanViewDepartmentAsync(request.CustDept, ct))
+        {
+            return NotFound($"Course {id} not found");
+        }
+
+        try
+        {
+            var course = await _courseService.UpdateCourseAsync(id, request, ct);
+            if (course == null)
+            {
+                _logger.LogWarning("Course not found for update: {CourseId}", id);
+                return NotFound($"Course {id} not found");
+            }
+
+            _logger.LogInformation("Course updated: {CourseId}", id);
+            return Ok(course);
+        }
+        catch (ArgumentException ex)
+        {
+            _logger.LogWarning(ex, "Invalid course update data: {Message}", LogSanitizer.SanitizeString(ex.Message));
+            return BadRequest(ex.Message);
+        }
+        catch (DbUpdateException ex)
+        {
+            _logger.LogWarning(ex, "Database error updating course: {Message}", LogSanitizer.SanitizeString(ex.InnerException?.Message ?? ex.Message));
+            return BadRequest("Failed to update course. Please check all field values are valid.");
+        }
+    }
+
+    /// <summary>
+    /// Update only the enrollment for an R-course.
+    /// This is a restricted endpoint for users with ManageRCourseEnrollment permission.
+    /// </summary>
+    [HttpPatch("{id:int}/enrollment")]
+    [Permission(Allow = EffortPermissions.ManageRCourseEnrollment)]
+    public async Task<ActionResult<CourseDto>> UpdateCourseEnrollment(int id, [FromBody] UpdateEnrollmentRequest request, CancellationToken ct = default)
+    {
+        SetExceptionContext("courseId", id);
+
+        var (_, errorResult) = await GetAuthorizedCourseAsync(id, ct);
+        if (errorResult != null) return errorResult;
+
+        try
+        {
+            var course = await _courseService.UpdateCourseEnrollmentAsync(id, request.Enrollment, ct);
+            if (course == null)
+            {
+                _logger.LogWarning("Course not found for enrollment update: {CourseId}", id);
+                return NotFound($"Course {id} not found");
+            }
+
+            _logger.LogInformation("Course enrollment updated: {CourseId}", id);
+            return Ok(course);
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning(ex, "Cannot update enrollment for course {CourseId}: {Message}", id, LogSanitizer.SanitizeString(ex.Message));
+            return BadRequest(ex.Message);
+        }
+    }
+
+    /// <summary>
+    /// Delete a course and all associated effort records.
+    /// </summary>
+    [HttpDelete("{id:int}")]
+    [Permission(Allow = EffortPermissions.DeleteCourse)]
+    public async Task<ActionResult> DeleteCourse(int id, CancellationToken ct = default)
+    {
+        SetExceptionContext("courseId", id);
+
+        var (_, errorResult) = await GetAuthorizedCourseAsync(id, ct);
+        if (errorResult != null) return errorResult;
+
+        var deleted = await _courseService.DeleteCourseAsync(id, ct);
+        if (!deleted)
+        {
+            _logger.LogWarning("Course not found for delete: {CourseId}", id);
+            return NotFound($"Course {id} not found");
+        }
+
+        _logger.LogInformation("Course deleted: {CourseId}", id);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Check if a course can be deleted and get the count of associated effort records.
+    /// </summary>
+    [HttpGet("{id:int}/can-delete")]
+    [Permission(Allow = EffortPermissions.DeleteCourse)]
+    public async Task<ActionResult<object>> CanDeleteCourse(int id, CancellationToken ct = default)
+    {
+        SetExceptionContext("courseId", id);
+
+        var (_, errorResult) = await GetAuthorizedCourseAsync(id, ct);
+        if (errorResult != null) return errorResult;
+
+        var (canDelete, recordCount) = await _courseService.CanDeleteCourseAsync(id, ct);
+        return Ok(new { canDelete, recordCount });
+    }
+
+    /// <summary>
+    /// Get the list of valid custodial department codes.
+    /// Non-admin users only see their authorized departments.
+    /// </summary>
+    [HttpGet("departments")]
+    public async Task<ActionResult<IEnumerable<string>>> GetDepartments(CancellationToken ct = default)
+    {
+        var allDepartments = _courseService.GetValidCustodialDepartments();
+
+        // Full access users see all departments
+        if (await _permissionService.HasFullAccessAsync(ct))
+        {
+            return Ok(allDepartments);
+        }
+
+        // Non-admin users only see their authorized departments
+        var authorizedDepts = await _permissionService.GetAuthorizedDepartmentsAsync(ct);
+        var filteredDepts = allDepartments
+            .Where(d => authorizedDepts.Contains(d, StringComparer.OrdinalIgnoreCase))
+            .ToList();
+
+        return Ok(filteredDepts);
+    }
+}
diff --git a/web/Areas/Effort/Controllers/TermsController.cs b/web/Areas/Effort/Controllers/TermsController.cs
index 6e846a40..0d68090a 100644
--- a/web/Areas/Effort/Controllers/TermsController.cs
+++ b/web/Areas/Effort/Controllers/TermsController.cs
@@ -3,6 +3,7 @@
 using Viper.Areas.Effort.Models.DTOs.Requests;
 using Viper.Areas.Effort.Models.DTOs.Responses;
 using Viper.Areas.Effort.Services;
+using Viper.Classes.Utilities;
 using Web.Authorization;
 
 namespace Viper.Areas.Effort.Controllers;
@@ -95,7 +96,7 @@ public async Task<ActionResult<TermDto>> CreateTerm([FromBody] CreateTermRequest
         }
         catch (InvalidOperationException ex)
         {
-            _logger.LogWarning(ex, "Cannot create term {TermCode}: {Message}", request.TermCode, ex.Message);
+            _logger.LogWarning(ex, "Cannot create term {TermCode}: {Message}", request.TermCode, LogSanitizer.SanitizeString(ex.Message));
             return Conflict(ex.Message);
         }
     }
@@ -138,7 +139,7 @@ public async Task<ActionResult<TermDto>> OpenTerm(int termCode, CancellationToke
         }
         catch (InvalidOperationException ex)
         {
-            _logger.LogWarning(ex, "Cannot open term {TermCode}: {Message}", termCode, ex.Message);
+            _logger.LogWarning(ex, "Cannot open term {TermCode}: {Message}", termCode, LogSanitizer.SanitizeString(ex.Message));
             return BadRequest(ex.Message);
         }
 
@@ -166,7 +167,7 @@ public async Task<ActionResult<TermDto>> CloseTerm(int termCode, CancellationTok
 
         if (!success)
         {
-            _logger.LogWarning("Cannot close term {TermCode}: {ErrorMessage}", termCode, errorMessage);
+            _logger.LogWarning("Cannot close term {TermCode}: {ErrorMessage}", termCode, LogSanitizer.SanitizeString(errorMessage));
             return BadRequest(errorMessage);
         }
 
@@ -192,7 +193,7 @@ public async Task<ActionResult<TermDto>> ReopenTerm(int termCode, CancellationTo
         }
         catch (InvalidOperationException ex)
         {
-            _logger.LogWarning(ex, "Cannot reopen term {TermCode}: {Message}", termCode, ex.Message);
+            _logger.LogWarning(ex, "Cannot reopen term {TermCode}: {Message}", termCode, LogSanitizer.SanitizeString(ex.Message));
             return BadRequest(ex.Message);
         }
 
@@ -223,7 +224,7 @@ public async Task<ActionResult<TermDto>> UnopenTerm(int termCode, CancellationTo
         }
         catch (InvalidOperationException ex)
         {
-            _logger.LogWarning(ex, "Cannot unopen term {TermCode}: {Message}", termCode, ex.Message);
+            _logger.LogWarning(ex, "Cannot unopen term {TermCode}: {Message}", termCode, LogSanitizer.SanitizeString(ex.Message));
             return BadRequest(ex.Message);
         }
 
diff --git a/web/Areas/Effort/Models/DTOs/Requests/CreateCourseRequest.cs b/web/Areas/Effort/Models/DTOs/Requests/CreateCourseRequest.cs
new file mode 100644
index 00000000..dbe787b2
--- /dev/null
+++ b/web/Areas/Effort/Models/DTOs/Requests/CreateCourseRequest.cs
@@ -0,0 +1,39 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Viper.Areas.Effort.Models.DTOs.Requests;
+
+/// <summary>
+/// Request DTO for manually creating a course in the Effort system.
+/// Used for courses that are not in Banner or need custom values.
+/// </summary>
+public class CreateCourseRequest
+{
+    [Required]
+    public required int TermCode { get; set; }
+
+    [Required]
+    [RegularExpression(@"^\d{5}$", ErrorMessage = "CRN must be exactly 5 digits")]
+    public string Crn { get; set; } = string.Empty;
+
+    [Required]
+    [StringLength(3, MinimumLength = 1)]
+    public string SubjCode { get; set; } = string.Empty;
+
+    [Required]
+    [StringLength(5, MinimumLength = 1)]
+    public string CrseNumb { get; set; } = string.Empty;
+
+    [Required]
+    [StringLength(3, MinimumLength = 1)]
+    public string SeqNumb { get; set; } = string.Empty;
+
+    [Range(0, int.MaxValue)]
+    public int Enrollment { get; set; }
+
+    [Range(0, 99.99)]
+    public decimal Units { get; set; }
+
+    [Required]
+    [StringLength(6, MinimumLength = 1)]
+    public string CustDept { get; set; } = string.Empty;
+}
diff --git a/web/Areas/Effort/Models/DTOs/Requests/ImportCourseRequest.cs b/web/Areas/Effort/Models/DTOs/Requests/ImportCourseRequest.cs
new file mode 100644
index 00000000..a7d6d262
--- /dev/null
+++ b/web/Areas/Effort/Models/DTOs/Requests/ImportCourseRequest.cs
@@ -0,0 +1,23 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Viper.Areas.Effort.Models.DTOs.Requests;
+
+/// <summary>
+/// Request DTO for importing a course from Banner into the Effort system.
+/// </summary>
+public class ImportCourseRequest
+{
+    [Required]
+    public required int TermCode { get; set; }
+
+    [Required]
+    [RegularExpression(@"^\d{5}$", ErrorMessage = "CRN must be exactly 5 digits")]
+    public string Crn { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Units for variable-unit courses. If null, uses the default (UnitLow) from Banner.
+    /// For fixed-unit courses, this is ignored.
+    /// </summary>
+    [Range(0, 99.99)]
+    public decimal? Units { get; set; }
+}
diff --git a/web/Areas/Effort/Models/DTOs/Requests/UpdateCourseRequest.cs b/web/Areas/Effort/Models/DTOs/Requests/UpdateCourseRequest.cs
new file mode 100644
index 00000000..effe2cbc
--- /dev/null
+++ b/web/Areas/Effort/Models/DTOs/Requests/UpdateCourseRequest.cs
@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Viper.Areas.Effort.Models.DTOs.Requests;
+
+/// <summary>
+/// Request DTO for updating a course in the Effort system.
+/// Only enrollment, units, and custodial department can be modified.
+/// </summary>
+public class UpdateCourseRequest
+{
+    [Range(0, int.MaxValue)]
+    public int Enrollment { get; set; }
+
+    [Range(0, 99.99)]
+    public decimal Units { get; set; }
+
+    [Required]
+    [StringLength(6, MinimumLength = 1)]
+    public string CustDept { get; set; } = string.Empty;
+}
diff --git a/web/Areas/Effort/Models/DTOs/Requests/UpdateEnrollmentRequest.cs b/web/Areas/Effort/Models/DTOs/Requests/UpdateEnrollmentRequest.cs
new file mode 100644
index 00000000..c29419fe
--- /dev/null
+++ b/web/Areas/Effort/Models/DTOs/Requests/UpdateEnrollmentRequest.cs
@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Viper.Areas.Effort.Models.DTOs.Requests;
+
+/// <summary>
+/// Request DTO for updating only the enrollment of an R-course.
+/// Used by users with ManageRCourseEnrollment permission.
+/// </summary>
+public class UpdateEnrollmentRequest
+{
+    [Range(0, int.MaxValue)]
+    public int Enrollment { get; set; }
+}
diff --git a/web/Areas/Effort/Models/DTOs/Responses/BannerCourseDto.cs b/web/Areas/Effort/Models/DTOs/Responses/BannerCourseDto.cs
new file mode 100644
index 00000000..1fecc2f4
--- /dev/null
+++ b/web/Areas/Effort/Models/DTOs/Responses/BannerCourseDto.cs
@@ -0,0 +1,55 @@
+namespace Viper.Areas.Effort.Models.DTOs.Responses;
+
+/// <summary>
+/// DTO for Banner course information retrieved from the courses database.
+/// Used for course import search results.
+/// </summary>
+public class BannerCourseDto
+{
+    public string Crn { get; set; } = string.Empty;
+    public string SubjCode { get; set; } = string.Empty;
+    public string CrseNumb { get; set; } = string.Empty;
+    public string SeqNumb { get; set; } = string.Empty;
+    public string Title { get; set; } = string.Empty;
+    public int Enrollment { get; set; }
+
+    /// <summary>
+    /// F = Fixed units, V = Variable units
+    /// </summary>
+    public string UnitType { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Minimum units (or the fixed value for fixed-unit courses).
+    /// </summary>
+    public decimal UnitLow { get; set; }
+
+    /// <summary>
+    /// Maximum units (same as UnitLow for fixed-unit courses).
+    /// </summary>
+    public decimal UnitHigh { get; set; }
+
+    /// <summary>
+    /// Banner department code (e.g., "72030" which maps to VME).
+    /// </summary>
+    public string DeptCode { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Combined course code (e.g., "VET 410").
+    /// </summary>
+    public string CourseCode => $"{SubjCode.Trim()} {CrseNumb.Trim()}";
+
+    /// <summary>
+    /// True if this is a variable-unit course.
+    /// </summary>
+    public bool IsVariableUnits => UnitType == "V";
+
+    /// <summary>
+    /// True if this course has already been imported into the Effort system for this term.
+    /// </summary>
+    public bool AlreadyImported { get; set; }
+
+    /// <summary>
+    /// List of unit values already imported for variable-unit courses.
+    /// </summary>
+    public List<decimal> ImportedUnitValues { get; set; } = new();
+}
diff --git a/web/Areas/Effort/Scripts/CreateEffortReportingProcedures.cs b/web/Areas/Effort/Scripts/CreateEffortReportingProcedures.cs
index bb6a723b..97d3c3a2 100644
--- a/web/Areas/Effort/Scripts/CreateEffortReportingProcedures.cs
+++ b/web/Areas/Effort/Scripts/CreateEffortReportingProcedures.cs
@@ -143,7 +143,7 @@ static bool VerifyPrerequisites(string connectionString)
             return true;
         }
 
-        // List of all managed stored procedures (16 total)
+        // List of all managed stored procedures (17 total)
         static readonly HashSet<string> ManagedProcedures = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
         {
             // Merit & Promotion Reports (6 procedures)
@@ -165,7 +165,9 @@ static bool VerifyPrerequisites(string connectionString)
             "sp_instructor_evals_average",
             // Other Reports (2 procedures)
             "sp_effort_general_report",
-            "sp_zero_effort_check"
+            "sp_zero_effort_check",
+            // Banner Integration (1 procedure)
+            "sp_search_banner_courses"
         };
 
         static void CreateReportingProcedures(string connectionString, bool executeMode, bool cleanMode)
@@ -208,6 +210,9 @@ static void CreateReportingProcedures(string connectionString, bool executeMode,
                 CreateProcedure(connection, transaction, "sp_effort_general_report", GetEffortGeneralReportSql(), ref successCount, ref failureCount, failedProcedures);
                 CreateProcedure(connection, transaction, "sp_zero_effort_check", GetZeroEffortCheckSql(), ref successCount, ref failureCount, failedProcedures);
 
+                // Banner Integration (1 procedure)
+                CreateProcedure(connection, transaction, "sp_search_banner_courses", GetSearchBannerCoursesSql(), ref successCount, ref failureCount, failedProcedures);
+
                 Console.WriteLine();
                 Console.WriteLine($"Summary: {successCount} succeeded, {failureCount} failed");
 
@@ -1233,6 +1238,105 @@ FROM [effort].[Persons] p
         AND (@Department IS NULL OR p.EffortDept = @Department)
     ORDER BY p.EffortDept, p.LastName, p.FirstName;
 END;
+";
+        }
+
+        // ============================================
+        // Banner Integration Procedures
+        // ============================================
+
+        static string GetSearchBannerCoursesSql()
+        {
+            return @"
+CREATE OR ALTER PROCEDURE [effort].[sp_search_banner_courses]
+    @TermCode VARCHAR(6),
+    @SubjCode VARCHAR(4) = NULL,
+    @CrseNumb VARCHAR(5) = NULL,
+    @SeqNumb VARCHAR(3) = NULL,
+    @Crn VARCHAR(5) = NULL
+AS
+BEGIN
+    SET NOCOUNT ON;
+
+    -- Search Banner courses directly via linked server
+    -- Based on legacy usp_get_foreign_course but returns multiple results
+    -- Allows flexible searching by any combination of parameters
+
+    -- Validate TermCode format (must be exactly 6 digits)
+    IF @TermCode IS NULL OR @TermCode LIKE '%[^0-9]%' OR LEN(@TermCode) <> 6
+    BEGIN
+        RAISERROR('TermCode must be a 6-digit number', 16, 1);
+        RETURN;
+    END
+
+    -- Require at least one search parameter to prevent returning all courses
+    IF @SubjCode IS NULL AND @CrseNumb IS NULL AND @SeqNumb IS NULL AND @Crn IS NULL
+    BEGIN
+        RAISERROR('At least one search parameter (SubjCode, CrseNumb, SeqNumb, or Crn) is required', 16, 1);
+        RETURN;
+    END
+
+    -- Validate inputs to prevent injection and malformed queries
+    IF @SubjCode IS NOT NULL AND @SubjCode LIKE '%[^A-Za-z0-9]%'
+    BEGIN
+        RAISERROR('SubjCode must be alphanumeric', 16, 1);
+        RETURN;
+    END
+    IF @CrseNumb IS NOT NULL AND @CrseNumb LIKE '%[^A-Za-z0-9]%'
+    BEGIN
+        RAISERROR('CrseNumb must be alphanumeric', 16, 1);
+        RETURN;
+    END
+    IF @SeqNumb IS NOT NULL AND @SeqNumb LIKE '%[^0-9]%'
+    BEGIN
+        RAISERROR('SeqNumb must be numeric', 16, 1);
+        RETURN;
+    END
+    IF @Crn IS NOT NULL AND @Crn LIKE '%[^0-9]%'
+    BEGIN
+        RAISERROR('Crn must be numeric', 16, 1);
+        RETURN;
+    END
+
+    DECLARE @bannerCmd NVARCHAR(MAX);
+    DECLARE @whereClause NVARCHAR(1000) = '';
+
+    -- Build dynamic WHERE clause based on provided parameters
+    IF @SubjCode IS NOT NULL
+        SET @whereClause = @whereClause + ' AND SSBSECT_SUBJ_CODE = ''''' + REPLACE(@SubjCode, '''', '''''''''') + ''''' ';
+    IF @CrseNumb IS NOT NULL
+        SET @whereClause = @whereClause + ' AND SSBSECT_CRSE_NUMB = ''''' + REPLACE(@CrseNumb, '''', '''''''''') + ''''' ';
+    IF @SeqNumb IS NOT NULL
+        SET @whereClause = @whereClause + ' AND SSBSECT_SEQ_NUMB = ''''' + REPLACE(@SeqNumb, '''', '''''''''') + ''''' ';
+    IF @Crn IS NOT NULL
+        SET @whereClause = @whereClause + ' AND SSBSECT_CRN = ''''' + REPLACE(@Crn, '''', '''''''''') + ''''' ';
+
+    SET @bannerCmd = '
+        SELECT DISTINCT
+            SSBSECT_CRN as Crn,
+            SSBSECT_SUBJ_CODE as SubjCode,
+            SSBSECT_CRSE_NUMB as CrseNumb,
+            SSBSECT_SEQ_NUMB as SeqNumb,
+            SCBCRSE_TITLE as Title,
+            SSBSECT_ENRL as Enrollment,
+            DECODE(NVL(SCBCRSE_CREDIT_HR_IND,''''F''''),''''F'''',''''F'''',''''V'''') as UnitType,
+            NVL(SCBCRSE_CREDIT_HR_LOW,0.0) as UnitLow,
+            NVL(SCBCRSE_CREDIT_HR_HIGH,0.0) as UnitHigh,
+            SCBCRSE_DEPT_CODE as DeptCode
+        FROM SATURN.SSBSECT, SATURN.SCBCRSE
+        WHERE SSBSECT_TERM_CODE = ''''' + @TermCode + '''''
+            AND SCBCRSE_SUBJ_CODE = SSBSECT_SUBJ_CODE
+            AND SCBCRSE_CRSE_NUMB = SSBSECT_CRSE_NUMB
+            AND SCBCRSE_EFF_TERM = (
+                SELECT MAX(SCBCRSE_EFF_TERM) FROM SATURN.SCBCRSE
+                WHERE SCBCRSE_SUBJ_CODE = SSBSECT_SUBJ_CODE
+                AND SCBCRSE_CRSE_NUMB = SSBSECT_CRSE_NUMB
+            )' + @whereClause + '
+        ORDER BY SSBSECT_SUBJ_CODE, SSBSECT_CRSE_NUMB, SSBSECT_SEQ_NUMB
+        FETCH FIRST 100 ROWS ONLY';
+
+    EXEC('SELECT * FROM OPENQUERY(UCDBanner, ''' + @bannerCmd + ''')');
+END;
 ";
         }
     }
diff --git a/web/Areas/Effort/Services/CourseService.cs b/web/Areas/Effort/Services/CourseService.cs
new file mode 100644
index 00000000..99e9ce39
--- /dev/null
+++ b/web/Areas/Effort/Services/CourseService.cs
@@ -0,0 +1,453 @@
+using System.Data;
+using Microsoft.EntityFrameworkCore;
+using Viper.Areas.Effort.Constants;
+using Viper.Areas.Effort.Models.DTOs.Requests;
+using Viper.Areas.Effort.Models.DTOs.Responses;
+using Viper.Areas.Effort.Models.Entities;
+using Viper.Classes.Utilities;
+
+namespace Viper.Areas.Effort.Services;
+
+/// <summary>
+/// Service for course-related operations in the Effort system.
+/// </summary>
+public class CourseService : ICourseService
+{
+    private readonly EffortDbContext _context;
+    private readonly IEffortAuditService _auditService;
+    private readonly ILogger<CourseService> _logger;
+
+    /// <summary>
+    /// Valid custodial department codes for the Effort system.
+    /// </summary>
+    private static readonly List<string> ValidCustDepts = new()
+    {
+        "APC", "VMB", "VME", "VSR", "PMI", "PHR", "UNK", "DVM", "VET"
+    };
+
+    /// <summary>
+    /// Mapping from Banner custodial department codes to Effort custodial departments.
+    /// Banner codes may be stored with or without leading zeros (e.g., "72030" or "072030").
+    /// The GetCustodialDepartment method normalizes input by padding to 6 digits.
+    /// </summary>
+    private static readonly Dictionary<string, string> BannerDeptMapping = new()
+    {
+        { "072030", "VME" },
+        { "072035", "VSR" },
+        { "072037", "APC" },
+        { "072047", "VMB" },
+        { "072057", "PMI" },
+        { "072067", "PHR" }
+    };
+
+    public CourseService(
+        EffortDbContext context,
+        IEffortAuditService auditService,
+        ILogger<CourseService> logger)
+    {
+        _context = context;
+        _auditService = auditService;
+        _logger = logger;
+    }
+
+    public async Task<List<CourseDto>> GetCoursesAsync(int termCode, string? department = null, CancellationToken ct = default)
+    {
+        var query = _context.Courses
+            .AsNoTracking()
+            .Where(c => c.TermCode == termCode);
+
+        if (!string.IsNullOrWhiteSpace(department))
+        {
+            query = query.Where(c => c.CustDept == department);
+        }
+
+        var courses = await query
+            .OrderBy(c => c.SubjCode)
+            .ThenBy(c => c.CrseNumb)
+            .ThenBy(c => c.SeqNumb)
+            .ToListAsync(ct);
+
+        return courses.Select(ToDto).ToList();
+    }
+
+    public async Task<CourseDto?> GetCourseAsync(int courseId, CancellationToken ct = default)
+    {
+        var course = await _context.Courses
+            .AsNoTracking()
+            .FirstOrDefaultAsync(c => c.Id == courseId, ct);
+
+        return course == null ? null : ToDto(course);
+    }
+
+    public async Task<List<BannerCourseDto>> SearchBannerCoursesAsync(int termCode, string? subjCode = null,
+        string? crseNumb = null, string? seqNumb = null, string? crn = null, CancellationToken ct = default)
+    {
+        // Validate that at least one search parameter is provided
+        if (string.IsNullOrWhiteSpace(subjCode) && string.IsNullOrWhiteSpace(crseNumb) &&
+            string.IsNullOrWhiteSpace(seqNumb) && string.IsNullOrWhiteSpace(crn))
+        {
+            throw new ArgumentException("At least one search parameter (subjCode, crseNumb, seqNumb, or crn) is required");
+        }
+
+        var connectionString = _context.Database.GetConnectionString()
+            ?? throw new InvalidOperationException("Database connection string not configured");
+
+        var bannerCourses = new List<BannerCourseDto>();
+
+        await using var connection = new Microsoft.Data.SqlClient.SqlConnection(connectionString);
+        await connection.OpenAsync(ct);
+
+        await using var command = new Microsoft.Data.SqlClient.SqlCommand("[effort].[sp_search_banner_courses]", connection);
+        command.CommandType = CommandType.StoredProcedure;
+        command.Parameters.AddWithValue("@TermCode", termCode.ToString());
+        command.Parameters.AddWithValue("@SubjCode", string.IsNullOrWhiteSpace(subjCode) ? DBNull.Value : subjCode.ToUpperInvariant());
+        command.Parameters.AddWithValue("@CrseNumb", string.IsNullOrWhiteSpace(crseNumb) ? DBNull.Value : crseNumb.ToUpperInvariant());
+        command.Parameters.AddWithValue("@SeqNumb", string.IsNullOrWhiteSpace(seqNumb) ? DBNull.Value : seqNumb.ToUpperInvariant());
+        command.Parameters.AddWithValue("@Crn", string.IsNullOrWhiteSpace(crn) ? DBNull.Value : crn.Trim());
+
+        await using var reader = await command.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+        {
+            bannerCourses.Add(new BannerCourseDto
+            {
+                Crn = reader.GetString(0).Trim(),
+                SubjCode = reader.GetString(1).Trim(),
+                CrseNumb = reader.GetString(2).Trim(),
+                SeqNumb = reader.GetString(3).Trim(),
+                Title = await reader.IsDBNullAsync(4, ct) ? null : reader.GetString(4),
+                Enrollment = Convert.ToInt32(reader.GetValue(5)),
+                UnitType = reader.GetString(6),
+                UnitLow = Convert.ToDecimal(reader.GetValue(7)),
+                UnitHigh = Convert.ToDecimal(reader.GetValue(8)),
+                DeptCode = reader.GetString(9).Trim()
+            });
+        }
+
+        // Check which courses are already imported
+        var crns = bannerCourses.Select(b => b.Crn).Distinct().ToList();
+        if (crns.Count > 0)
+        {
+            var importedCourses = await _context.Courses
+                .AsNoTracking()
+                .Where(c => c.TermCode == termCode && crns.Contains(c.Crn))
+                .Select(c => new { c.Crn, c.Units })
+                .ToListAsync(ct);
+
+            var importedByCrn = importedCourses
+                .GroupBy(c => c.Crn.Trim())
+                .ToDictionary(g => g.Key, g => g.Select(c => c.Units).ToList());
+
+            foreach (var course in bannerCourses)
+            {
+                var isFixed = course.UnitType == "F";
+                var importedUnits = importedByCrn.GetValueOrDefault(course.Crn, new List<decimal>());
+                course.AlreadyImported = isFixed && importedUnits.Count > 0;
+                course.ImportedUnitValues = importedUnits;
+            }
+        }
+
+        return bannerCourses;
+    }
+
+    public async Task<BannerCourseDto?> GetBannerCourseAsync(int termCode, string crn, CancellationToken ct = default)
+    {
+        // Use the search SP with CRN filter to get a single course from Banner
+        var courses = await SearchBannerCoursesAsync(termCode, crn: crn.Trim(), ct: ct);
+        return courses.FirstOrDefault();
+    }
+
+    public async Task<bool> CourseExistsAsync(int termCode, string crn, decimal units, CancellationToken ct = default)
+    {
+        return await _context.Courses
+            .AnyAsync(c => c.TermCode == termCode && c.Crn.Trim() == crn.Trim() && c.Units == units, ct);
+    }
+
+    public async Task<CourseDto> ImportCourseFromBannerAsync(ImportCourseRequest request, BannerCourseDto bannerCourse, CancellationToken ct = default)
+    {
+        // Determine units - controller has validated units are in range if variable
+        var isVariable = bannerCourse.UnitType == "V";
+        var units = isVariable && request.Units.HasValue
+            ? request.Units.Value
+            : bannerCourse.UnitLow;
+
+        // Determine custodial department - check subject code first, then fall back to dept code mapping
+        // For SVM courses, the subject code (e.g., "DVM", "VME", "PHR") often matches the custodial department
+        var custDept = GetCustodialDepartment(bannerCourse.SubjCode, bannerCourse.DeptCode);
+
+        // Create the course
+        var course = new EffortCourse
+        {
+            Crn = bannerCourse.Crn,
+            TermCode = request.TermCode,
+            SubjCode = bannerCourse.SubjCode,
+            CrseNumb = bannerCourse.CrseNumb,
+            SeqNumb = bannerCourse.SeqNumb,
+            Enrollment = bannerCourse.Enrollment,
+            Units = units,
+            CustDept = custDept
+        };
+
+        await using var transaction = await _context.Database.BeginTransactionAsync(ct);
+
+        _context.Courses.Add(course);
+        await _context.SaveChangesAsync(ct);
+
+        _auditService.AddCourseChangeAudit(course.Id, course.TermCode, EffortAuditActions.CreateCourse,
+            null,
+            new
+            {
+                course.Crn,
+                course.SubjCode,
+                course.CrseNumb,
+                course.SeqNumb,
+                course.Enrollment,
+                course.Units,
+                course.CustDept
+            });
+        await _context.SaveChangesAsync(ct);
+        await transaction.CommitAsync(ct);
+
+        _logger.LogInformation("Imported course {SubjCode} {CrseNumb}-{SeqNumb} (CRN: {Crn}) for term {TermCode}",
+            LogSanitizer.SanitizeId(course.SubjCode), LogSanitizer.SanitizeId(course.CrseNumb), LogSanitizer.SanitizeId(course.SeqNumb), LogSanitizer.SanitizeId(course.Crn), course.TermCode);
+
+        return ToDto(course);
+    }
+
+    public async Task<CourseDto> CreateCourseAsync(CreateCourseRequest request, CancellationToken ct = default)
+    {
+        var course = new EffortCourse
+        {
+            Crn = request.Crn.Trim().ToUpperInvariant(),
+            TermCode = request.TermCode,
+            SubjCode = request.SubjCode.Trim().ToUpperInvariant(),
+            CrseNumb = request.CrseNumb.Trim().ToUpperInvariant(),
+            SeqNumb = request.SeqNumb.Trim().ToUpperInvariant(),
+            Enrollment = request.Enrollment,
+            Units = request.Units,
+            CustDept = request.CustDept.Trim().ToUpperInvariant()
+        };
+
+        await using var transaction = await _context.Database.BeginTransactionAsync(ct);
+
+        _context.Courses.Add(course);
+        await _context.SaveChangesAsync(ct);
+
+        _auditService.AddCourseChangeAudit(course.Id, course.TermCode, EffortAuditActions.CreateCourse,
+            null,
+            new
+            {
+                course.Crn,
+                course.SubjCode,
+                course.CrseNumb,
+                course.SeqNumb,
+                course.Enrollment,
+                course.Units,
+                course.CustDept
+            });
+        await _context.SaveChangesAsync(ct);
+        await transaction.CommitAsync(ct);
+
+        _logger.LogInformation("Created manual course {SubjCode} {CrseNumb}-{SeqNumb} (CRN: {Crn}) for term {TermCode}",
+            LogSanitizer.SanitizeId(course.SubjCode), LogSanitizer.SanitizeId(course.CrseNumb), LogSanitizer.SanitizeId(course.SeqNumb), LogSanitizer.SanitizeId(course.Crn), course.TermCode);
+
+        return ToDto(course);
+    }
+
+    public async Task<CourseDto?> UpdateCourseAsync(int courseId, UpdateCourseRequest request, CancellationToken ct = default)
+    {
+        var course = await _context.Courses.FirstOrDefaultAsync(c => c.Id == courseId, ct);
+        if (course == null)
+        {
+            return null;
+        }
+
+        // Validate custodial department
+        if (!ValidCustDepts.Contains(request.CustDept.ToUpperInvariant()))
+        {
+            throw new ArgumentException($"Invalid custodial department: {request.CustDept}");
+        }
+
+        var oldValues = new
+        {
+            course.Enrollment,
+            course.Units,
+            course.CustDept
+        };
+
+        course.Enrollment = request.Enrollment;
+        course.Units = request.Units;
+        course.CustDept = request.CustDept.ToUpperInvariant();
+
+        await using var transaction = await _context.Database.BeginTransactionAsync(ct);
+
+        _auditService.AddCourseChangeAudit(course.Id, course.TermCode, EffortAuditActions.UpdateCourse,
+            oldValues,
+            new
+            {
+                course.Enrollment,
+                course.Units,
+                course.CustDept
+            });
+        await _context.SaveChangesAsync(ct);
+        await transaction.CommitAsync(ct);
+
+        _logger.LogInformation("Updated course {CourseId} ({SubjCode} {CrseNumb})",
+            courseId, LogSanitizer.SanitizeId(course.SubjCode), LogSanitizer.SanitizeId(course.CrseNumb));
+
+        return ToDto(course);
+    }
+
+    public async Task<CourseDto?> UpdateCourseEnrollmentAsync(int courseId, int enrollment, CancellationToken ct = default)
+    {
+        var course = await _context.Courses.FirstOrDefaultAsync(c => c.Id == courseId, ct);
+        if (course == null)
+        {
+            return null;
+        }
+
+        // Enforce R-course restriction: course number must end with 'R'
+        if (!course.CrseNumb.Trim().EndsWith("R", StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidOperationException(
+                $"Course {course.SubjCode} {course.CrseNumb} is not an R-course. Only R-courses can be updated with this permission.");
+        }
+
+        var oldEnrollment = course.Enrollment;
+        course.Enrollment = enrollment;
+
+        await using var transaction = await _context.Database.BeginTransactionAsync(ct);
+
+        _auditService.AddCourseChangeAudit(course.Id, course.TermCode, EffortAuditActions.UpdateCourse,
+            new { Enrollment = oldEnrollment },
+            new { Enrollment = enrollment });
+        await _context.SaveChangesAsync(ct);
+        await transaction.CommitAsync(ct);
+
+        _logger.LogInformation("Updated R-course enrollment {CourseId} ({SubjCode} {CrseNumb}): {OldEnrollment} -> {NewEnrollment}",
+            courseId, LogSanitizer.SanitizeId(course.SubjCode), LogSanitizer.SanitizeId(course.CrseNumb), oldEnrollment, enrollment);
+
+        return ToDto(course);
+    }
+
+    public async Task<bool> DeleteCourseAsync(int courseId, CancellationToken ct = default)
+    {
+        var course = await _context.Courses
+            .Include(c => c.Records)
+            .FirstOrDefaultAsync(c => c.Id == courseId, ct);
+
+        if (course == null)
+        {
+            return false;
+        }
+
+        var courseInfo = new
+        {
+            course.Crn,
+            course.SubjCode,
+            course.CrseNumb,
+            course.SeqNumb,
+            course.Enrollment,
+            course.Units,
+            course.CustDept,
+            RecordCount = course.Records.Count
+        };
+
+        await using var transaction = await _context.Database.BeginTransactionAsync(ct);
+
+        // Delete associated effort records first (cascade)
+        if (course.Records.Count > 0)
+        {
+            _context.Records.RemoveRange(course.Records);
+            _logger.LogInformation("Deleted {RecordCount} effort records for course {CourseId}",
+                course.Records.Count, courseId);
+        }
+
+        _context.Courses.Remove(course);
+
+        _auditService.AddCourseChangeAudit(courseId, course.TermCode, EffortAuditActions.DeleteCourse,
+            courseInfo,
+            null);
+
+        await _context.SaveChangesAsync(ct);
+        await transaction.CommitAsync(ct);
+
+        _logger.LogInformation("Deleted course {CourseId} ({SubjCode} {CrseNumb})",
+            courseId, LogSanitizer.SanitizeId(courseInfo.SubjCode), LogSanitizer.SanitizeId(courseInfo.CrseNumb));
+
+        return true;
+    }
+
+    public async Task<(bool CanDelete, int RecordCount)> CanDeleteCourseAsync(int courseId, CancellationToken ct = default)
+    {
+        var recordCount = await _context.Records
+            .CountAsync(r => r.CourseId == courseId, ct);
+
+        // Course can always be deleted, but we return the record count so the UI can warn the user
+        return (true, recordCount);
+    }
+
+    public List<string> GetValidCustodialDepartments()
+    {
+        return ValidCustDepts.ToList();
+    }
+
+    public bool IsValidCustodialDepartment(string departmentCode)
+    {
+        return ValidCustDepts.Contains(departmentCode.ToUpperInvariant());
+    }
+
+    public string GetCustodialDepartmentForBannerCode(string bannerDeptCode)
+    {
+        return GetCustodialDepartment(null, bannerDeptCode);
+    }
+
+    /// <summary>
+    /// Get the custodial department based on subject code and/or Banner department code.
+    /// For SVM courses, the subject code (e.g., "DVM", "VME") often IS the custodial department.
+    /// Falls back to department code mapping for non-SVM subject codes.
+    /// </summary>
+    private static string GetCustodialDepartment(string? subjCode, string bannerDeptCode)
+    {
+        // First check if subject code is a valid SVM department (most common case for SVM courses)
+        if (!string.IsNullOrWhiteSpace(subjCode))
+        {
+            var trimmedSubj = subjCode.Trim().ToUpperInvariant();
+            if (ValidCustDepts.Contains(trimmedSubj))
+            {
+                return trimmedSubj;
+            }
+        }
+
+        // Then check if dept code is already a valid SVM department code
+        var trimmed = bannerDeptCode.Trim();
+        if (ValidCustDepts.Contains(trimmed.ToUpperInvariant()))
+        {
+            return trimmed.ToUpperInvariant();
+        }
+
+        // Try to look up by numeric Banner code - normalize to 6 digits with leading zero
+        var normalizedCode = trimmed.PadLeft(6, '0');
+        if (BannerDeptMapping.TryGetValue(normalizedCode, out var custDept))
+        {
+            return custDept;
+        }
+
+        return "UNK";
+    }
+
+    private static CourseDto ToDto(EffortCourse course)
+    {
+        return new CourseDto
+        {
+            Id = course.Id,
+            Crn = course.Crn.Trim(),
+            TermCode = course.TermCode,
+            SubjCode = course.SubjCode.Trim(),
+            CrseNumb = course.CrseNumb.Trim(),
+            SeqNumb = course.SeqNumb.Trim(),
+            Enrollment = course.Enrollment,
+            Units = course.Units,
+            CustDept = course.CustDept.Trim()
+        };
+    }
+}
diff --git a/web/Areas/Effort/Services/EffortAuditService.cs b/web/Areas/Effort/Services/EffortAuditService.cs
index 4641d406..2a6266d0 100644
--- a/web/Areas/Effort/Services/EffortAuditService.cs
+++ b/web/Areas/Effort/Services/EffortAuditService.cs
@@ -87,6 +87,11 @@ public void AddTermChangeAudit(int termCode, string action, object? oldValues, o
         AddAuditEntry(EffortAuditTables.Terms, termCode, termCode, action, SerializeChanges(oldValues, newValues));
     }
 
+    public void AddCourseChangeAudit(int courseId, int termCode, string action, object? oldValues, object? newValues)
+    {
+        AddAuditEntry(EffortAuditTables.Courses, courseId, termCode, action, SerializeChanges(oldValues, newValues));
+    }
+
     public void AddImportAudit(int termCode, string action, string details)
     {
         AddAuditEntry(EffortAuditTables.Terms, termCode, termCode, action, details);
diff --git a/web/Areas/Effort/Services/ICourseService.cs b/web/Areas/Effort/Services/ICourseService.cs
new file mode 100644
index 00000000..f796c476
--- /dev/null
+++ b/web/Areas/Effort/Services/ICourseService.cs
@@ -0,0 +1,141 @@
+using Viper.Areas.Effort.Models.DTOs.Requests;
+using Viper.Areas.Effort.Models.DTOs.Responses;
+
+namespace Viper.Areas.Effort.Services;
+
+/// <summary>
+/// Service for course-related operations in the Effort system.
+/// </summary>
+public interface ICourseService
+{
+    /// <summary>
+    /// Get all courses for a term, optionally filtered by department.
+    /// </summary>
+    /// <param name="termCode">The term code.</param>
+    /// <param name="department">Optional department filter.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>List of courses.</returns>
+    Task<List<CourseDto>> GetCoursesAsync(int termCode, string? department = null, CancellationToken ct = default);
+
+    /// <summary>
+    /// Get a single course by ID.
+    /// </summary>
+    /// <param name="courseId">The course ID.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>The course, or null if not found.</returns>
+    Task<CourseDto?> GetCourseAsync(int courseId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Search for courses in Banner by subject code, course number, sequence number, and/or CRN.
+    /// Queries Banner directly via linked server stored procedure.
+    /// At least one search parameter is required.
+    /// </summary>
+    /// <param name="termCode">The term code to search in.</param>
+    /// <param name="subjCode">Optional subject code filter (e.g., "VME", "PHI").</param>
+    /// <param name="crseNumb">Optional course number filter (e.g., "443").</param>
+    /// <param name="seqNumb">Optional sequence number filter (e.g., "001").</param>
+    /// <param name="crn">Optional CRN filter.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>List of Banner courses matching the criteria.</returns>
+    /// <exception cref="ArgumentException">Thrown if no search parameters are provided.</exception>
+    Task<List<BannerCourseDto>> SearchBannerCoursesAsync(int termCode, string? subjCode = null,
+        string? crseNumb = null, string? seqNumb = null, string? crn = null, CancellationToken ct = default);
+
+    /// <summary>
+    /// Get a single Banner course by term code and CRN.
+    /// Used by the controller to validate before import.
+    /// </summary>
+    /// <param name="termCode">The term code.</param>
+    /// <param name="crn">The course reference number.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>The Banner course, or null if not found.</returns>
+    Task<BannerCourseDto?> GetBannerCourseAsync(int termCode, string crn, CancellationToken ct = default);
+
+    /// <summary>
+    /// Check if a course with the given key already exists in the Effort system.
+    /// Used by the controller to check for duplicates before import/create.
+    /// </summary>
+    /// <param name="termCode">The term code.</param>
+    /// <param name="crn">The course reference number.</param>
+    /// <param name="units">The unit value.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>True if a course with this key exists, false otherwise.</returns>
+    Task<bool> CourseExistsAsync(int termCode, string crn, decimal units, CancellationToken ct = default);
+
+    /// <summary>
+    /// Import a course from Banner into the Effort system.
+    /// The controller should validate the Banner course exists and check for duplicates before calling this.
+    /// </summary>
+    /// <param name="request">The import request with term code, CRN, and optional units.</param>
+    /// <param name="bannerCourse">The pre-fetched Banner course data.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>The created course.</returns>
+    Task<CourseDto> ImportCourseFromBannerAsync(ImportCourseRequest request, BannerCourseDto bannerCourse, CancellationToken ct = default);
+
+    /// <summary>
+    /// Manually create a course in the Effort system (for courses not in Banner).
+    /// </summary>
+    /// <param name="request">The course creation request.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>The created course.</returns>
+    Task<CourseDto> CreateCourseAsync(CreateCourseRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Update an existing course (full update).
+    /// </summary>
+    /// <param name="courseId">The course ID to update.</param>
+    /// <param name="request">The update request with new values.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>The updated course, or null if not found.</returns>
+    Task<CourseDto?> UpdateCourseAsync(int courseId, UpdateCourseRequest request, CancellationToken ct = default);
+
+    /// <summary>
+    /// Update only the enrollment for an R-course.
+    /// This enforces that only R-courses (course number ending with 'R') can be updated.
+    /// </summary>
+    /// <param name="courseId">The course ID to update.</param>
+    /// <param name="enrollment">The new enrollment value.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>The updated course, or null if not found.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the course is not an R-course.</exception>
+    Task<CourseDto?> UpdateCourseEnrollmentAsync(int courseId, int enrollment, CancellationToken ct = default);
+
+    /// <summary>
+    /// Delete a course and all associated effort records.
+    /// </summary>
+    /// <param name="courseId">The course ID to delete.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>True if deleted, false if not found.</returns>
+    Task<bool> DeleteCourseAsync(int courseId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Get deletion info for a course. Returns record count so the UI can warn
+    /// the user about associated effort records that will be cascade-deleted.
+    /// Users with DeleteCourse permission can always delete.
+    /// </summary>
+    /// <param name="courseId">The course ID.</param>
+    /// <param name="ct">Cancellation token.</param>
+    /// <returns>Tuple with canDelete flag (always true for authorized users) and count of associated effort records for UI warning.</returns>
+    Task<(bool CanDelete, int RecordCount)> CanDeleteCourseAsync(int courseId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Get the list of valid custodial department codes.
+    /// </summary>
+    /// <returns>List of valid department codes.</returns>
+    List<string> GetValidCustodialDepartments();
+
+    /// <summary>
+    /// Check if a custodial department code is valid.
+    /// </summary>
+    /// <param name="departmentCode">The department code to validate.</param>
+    /// <returns>True if valid, false otherwise.</returns>
+    bool IsValidCustodialDepartment(string departmentCode);
+
+    /// <summary>
+    /// Get the custodial department code that would be assigned for a Banner department code.
+    /// Used by the controller to check authorization before import.
+    /// </summary>
+    /// <param name="bannerDeptCode">The Banner department code.</param>
+    /// <returns>The mapped custodial department code.</returns>
+    string GetCustodialDepartmentForBannerCode(string bannerDeptCode);
+}
diff --git a/web/Areas/Effort/Services/IEffortAuditService.cs b/web/Areas/Effort/Services/IEffortAuditService.cs
index 72bb3f4b..030e096b 100644
--- a/web/Areas/Effort/Services/IEffortAuditService.cs
+++ b/web/Areas/Effort/Services/IEffortAuditService.cs
@@ -31,6 +31,12 @@ Task LogTermChangeAsync(int termCode, string action,
     /// </summary>
     void AddTermChangeAudit(int termCode, string action, object? oldValues, object? newValues);
 
+    /// <summary>
+    /// Add a course change audit entry to the context without saving.
+    /// Use this within a transaction where the caller manages SaveChangesAsync.
+    /// </summary>
+    void AddCourseChangeAudit(int courseId, int termCode, string action, object? oldValues, object? newValues);
+
     /// <summary>
     /// Add an import audit entry to the context without saving.
     /// Use this within a transaction where the caller manages SaveChangesAsync.
diff --git a/web/Program.cs b/web/Program.cs
index 8379bad5..576443fb 100644
--- a/web/Program.cs
+++ b/web/Program.cs
@@ -225,6 +225,7 @@ void ConfigureDbContextOptions(DbContextOptionsBuilder options)
     builder.Services.AddScoped<Viper.Areas.Effort.Services.IEffortPermissionService, Viper.Areas.Effort.Services.EffortPermissionService>();
     builder.Services.AddScoped<Viper.Areas.Effort.Services.ITermService, Viper.Areas.Effort.Services.TermService>();
     builder.Services.AddScoped<Viper.Areas.Effort.Services.IEffortAuditService, Viper.Areas.Effort.Services.EffortAuditService>();
+    builder.Services.AddScoped<Viper.Areas.Effort.Services.ICourseService, Viper.Areas.Effort.Services.CourseService>();
 
     // Add in a custom ClaimsTransformer that injects user ROLES
     builder.Services.AddTransient<IClaimsTransformation, ClaimsTransformer>();