diff --git a/routes/create/__tests__/integration/folders.test.js b/routes/create/__tests__/integration/folders.test.js
index 09cae0e4..e9842e75 100644
--- a/routes/create/__tests__/integration/folders.test.js
+++ b/routes/create/__tests__/integration/folders.test.js
@@ -314,6 +314,45 @@ describe('Folder Management API Integration Tests', () => {
       expect(response.body.success).toBe(false);
       expect(response.body.error.message).toContain('already exists');
     });
+
+    test('should link, change and unlink the Canvas course without renaming', async () => {
+      await request(app).put(`/api/folders/${folderId}`).send({ canvasCourseId: '42' }).expect(200);
+      let folderInDb = await Folder.findById(folderId);
+      expect(folderInDb.canvasCourseId).toBe('42');
+      expect(folderInDb.name).toBe('Original Name');
+
+      await request(app).put(`/api/folders/${folderId}`).send({ canvasCourseId: '77' }).expect(200);
+      folderInDb = await Folder.findById(folderId);
+      expect(folderInDb.canvasCourseId).toBe('77');
+
+      await request(app).put(`/api/folders/${folderId}`).send({ canvasCourseId: null }).expect(200);
+      folderInDb = await Folder.findById(folderId);
+      expect(folderInDb.canvasCourseId).toBeNull();
+    });
+
+    test('should keep the Canvas link when only the name changes', async () => {
+      await Folder.updateOne({ _id: folderId }, { canvasCourseId: '42' });
+      await request(app).put(`/api/folders/${folderId}`).send({ name: 'Renamed' }).expect(200);
+      const folderInDb = await Folder.findById(folderId);
+      expect(folderInDb.canvasCourseId).toBe('42');
+    });
+
+    test('should accept a numeric Canvas course ID as Canvas returns it', async () => {
+      await request(app).put(`/api/folders/${folderId}`).send({ canvasCourseId: 42 }).expect(200);
+      const folderInDb = await Folder.findById(folderId);
+      expect(folderInDb.canvasCourseId).toBe('42');
+    });
+
+    test('should reject an invalid Canvas course ID', async () => {
+      for (const canvasCourseId of ['', { id: 42 }, 4.2]) {
+        const response = await request(app)
+          .put(`/api/folders/${folderId}`)
+          .send({ canvasCourseId })
+          .expect(400);
+
+        expect(response.body.success).toBe(false);
+      }
+    });
   });
 
   describe('DELETE /api/folders/:id', () => {
diff --git a/routes/create/controllers/folderController.js b/routes/create/controllers/folderController.js
index a8ffa0fe..9657bde6 100644
--- a/routes/create/controllers/folderController.js
+++ b/routes/create/controllers/folderController.js
@@ -33,7 +33,7 @@ router.get('/', authenticateToken, attachUser, asyncHandler(async (req, res) =>
  * Create new folder with auto-generated quizzes
  */
 router.post('/', authenticateToken, validateCreateFolder, asyncHandler(async (req, res) => {
-  const { name, quizCount = 1, canvasCourseId = null, canvasModuleId = null } = req.body;
+  const { name, quizCount = 1, canvasCourseId = null } = req.body;
   const userId = req.user.id;
   console.log('➕ POST /folders - Creating folder:', name, 'with', quizCount, 'quizzes for user:', userId);
 
@@ -66,8 +66,7 @@ router.post('/', authenticateToken, validateCreateFolder, asyncHandler(async (re
   const folder = new Folder({
     name: name.trim(),
     instructor: userId,
-    canvasCourseId,
-    canvasModuleId
+    canvasCourseId
   });
 
   await folder.save();
@@ -144,7 +143,7 @@ router.get('/:id', authenticateToken, validateMongoId, asyncHandler(async (req,
 
 /**
  * PUT /api/folders/:id
- * Update folder name
+ * Update folder name and/or linked Canvas course (null unlinks)
  */
 router.put('/:id', authenticateToken, validateUpdateFolder, asyncHandler(async (req, res) => {
   const folderId = req.params.id;
@@ -177,6 +176,10 @@ router.put('/:id', authenticateToken, validateUpdateFolder, asyncHandler(async (
     folder.name = name.trim();
   }
 
+  if (Object.prototype.hasOwnProperty.call(req.body, 'canvasCourseId')) {
+    folder.canvasCourseId = req.body.canvasCourseId || null;
+  }
+
   await folder.updateStats();
 
   return successResponse(res, { folder }, 'Folder updated successfully');
diff --git a/routes/create/controllers/quizController.js b/routes/create/controllers/quizController.js
index 027afe7c..160bd28a 100644
--- a/routes/create/controllers/quizController.js
+++ b/routes/create/controllers/quizController.js
@@ -94,7 +94,7 @@ router.get('/:id', authenticateToken, validateMongoId, asyncHandler(async (req,
   const userId = req.user.id;
 
   const quiz = await Quiz.findOne({ _id: quizId, createdBy: userId })
-    .populate('folder', 'name')
+    .populate('folder', 'name canvasCourseId')
     .populate({
       path: 'materials',
       select: 'name type processingStatus fileSize createdAt'
@@ -146,7 +146,7 @@ router.put('/:id/review', authenticateToken, validateMongoId, asyncHandler(async
     ...freeQuestionMutation(new Date()),
     'questionGenerationLease.token': { $exists: false }
   }, { $set: { 'progress.reviewCompleted': true }, $inc: { __v: 1 } }, { new: true })
-    .populate('folder', 'name')
+    .populate('folder', 'name canvasCourseId')
     .populate('materials', 'name type processingStatus fileSize createdAt')
     .populate({ path: 'learningObjectives', select: 'text order generationMetadata createdAt', options: { sort: { order: 1 } } })
     .populate({ path: 'questions', select: 'type difficulty questionText reviewStatus order createdAt', options: { sort: { order: 1 } } })
@@ -212,7 +212,7 @@ router.put('/:id', authenticateToken, validateUpdateQuiz, asyncHandler(async (re
   });
 
   await quiz.save();
-  await quiz.populate('folder', 'name');
+  await quiz.populate('folder', 'name canvasCourseId');
 
   return successResponse(res, { quiz }, 'Quiz updated successfully');
 }));
@@ -319,7 +319,7 @@ router.put('/:id/materials', authenticateToken, validateAssignMaterials, asyncHa
   );
 
   const updatedQuiz = await Quiz.findById(quizId)
-    .populate('folder', 'name')
+    .populate('folder', 'name canvasCourseId')
     .populate('materials', 'name type processingStatus');
 
   return successResponse(res, { quiz: updatedQuiz }, 'Materials assigned successfully');
diff --git a/routes/create/middleware/validator.js b/routes/create/middleware/validator.js
index a5f16b90..ff826cc9 100644
--- a/routes/create/middleware/validator.js
+++ b/routes/create/middleware/validator.js
@@ -89,6 +89,16 @@ export const validateUpdateFolder = [
     .trim()
     .isLength({ min: 1, max: 200 })
     .withMessage('Folder name must be between 1 and 200 characters'),
+
+  // Canvas returns numeric course IDs; store them as strings like the Folder schema.
+  body('canvasCourseId')
+    .optional({ nullable: true })
+    .custom(value => typeof value === 'string' || Number.isInteger(value))
+    .withMessage('Canvas course ID must be a string, an integer or null')
+    .bail()
+    .customSanitizer(value => String(value).trim())
+    .isLength({ min: 1, max: 64 })
+    .withMessage('Canvas course ID must be between 1 and 64 characters'),
   
   handleValidationErrors
 ];
diff --git a/routes/create/models/Folder.js b/routes/create/models/Folder.js
index 071a148f..ed757dca 100644
--- a/routes/create/models/Folder.js
+++ b/routes/create/models/Folder.js
@@ -31,6 +31,7 @@ const folderSchema = new mongoose.Schema({
   
   // Canvas integration (optional — linked Canvas course and module)
   canvasCourseId: { type: String, default: null },
+  // Legacy: set by old course creation; no longer written or read.
   canvasModuleId: { type: String, default: null },
 
   // Folder Statistics (for dashboard)
diff --git a/src/components/CanvasMaterialImportModal.test.tsx b/src/components/CanvasMaterialImportModal.test.tsx
index c9d4de98..14485074 100644
--- a/src/components/CanvasMaterialImportModal.test.tsx
+++ b/src/components/CanvasMaterialImportModal.test.tsx
@@ -2,7 +2,8 @@ import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import CanvasMaterialImportModal from './CanvasMaterialImportModal';
 const mocks = vi.hoisted(() => ({ getConfig: vi.fn(), getAuthStatus: vi.fn(), getImportCourses: vi.fn(), getImportMaterials: vi.fn(), importMaterials: vi.fn(), getConnectUrl: vi.fn() }));
-vi.mock('../services/api', () => ({ canvasApi: mocks }));
+const folderMocks = vi.hoisted(() => ({ setLinkedCanvasCourse: vi.fn() }));
+vi.mock('../services/api', () => ({ canvasApi: mocks, foldersApi: folderMocks }));
 const resources = [
   { id: '4', resourceType: 'file', name: 'Lecture.pdf', materialType: 'pdf', supported: true },
   { id: '1', resourceType: 'page', name: 'Lesson page', materialType: 'text', supported: true },
@@ -65,6 +66,34 @@ describe('Canvas material import', () => {
     expect(screen.getByText('No materials could be listed. Review the access messages above.')).toBeInTheDocument();
     expect(screen.getByRole('button', { name: 'Reconnect Canvas' })).toBeInTheDocument();
   });
+  it('preselects the linked Canvas course and loads its materials', async () => {
+    render(<CanvasMaterialImportModal isOpen folderId="folder" linkedCanvasCourseId="2" onClose={vi.fn()} />);
+    await screen.findByText('Lecture.pdf');
+    expect(screen.getByRole('combobox', { name: 'Canvas course' })).toHaveValue('2');
+    expect(mocks.getImportMaterials).toHaveBeenCalledWith('folder', '2');
+  });
+  it('saves a newly chosen course as the linked course', async () => {
+    folderMocks.setLinkedCanvasCourse.mockResolvedValue({ folder: {} });
+    const onLinked = vi.fn();
+    render(<CanvasMaterialImportModal isOpen folderId="folder" onLinkedCanvasCourseChange={onLinked} onClose={vi.fn()} />);
+    await screen.findByRole('combobox', { name: 'Canvas course' });
+    expect(screen.queryByRole('button', { name: 'Set as linked course' })).not.toBeInTheDocument();
+    fireEvent.change(screen.getByRole('combobox'), { target: { value: '2' } });
+    fireEvent.click(await screen.findByRole('button', { name: 'Set as linked course' }));
+    await waitFor(() => expect(onLinked).toHaveBeenCalledWith('2'));
+    expect(folderMocks.setLinkedCanvasCourse).toHaveBeenCalledWith('folder', '2');
+  });
+  it('does not offer to link the course that is already linked', async () => {
+    render(<CanvasMaterialImportModal isOpen folderId="folder" linkedCanvasCourseId="2" onLinkedCanvasCourseChange={vi.fn()} onClose={vi.fn()} />);
+    await screen.findByText('Lecture.pdf');
+    expect(screen.queryByRole('button', { name: 'Set as linked course' })).not.toBeInTheDocument();
+  });
+  it('falls back to the course list when the linked course is not available', async () => {
+    render(<CanvasMaterialImportModal isOpen folderId="folder" linkedCanvasCourseId="99" onClose={vi.fn()} />);
+    await screen.findByText(/linked to this course isn't available/);
+    expect(screen.getByRole('combobox', { name: 'Canvas course' })).toHaveValue('');
+    expect(mocks.getImportMaterials).not.toHaveBeenCalled();
+  });
   it('explains unavailable configuration and handles blocked sign-in popups', async () => {
     mocks.getAuthStatus.mockResolvedValue({ data: { connected: false } });
     vi.spyOn(window, 'open').mockReturnValue(null);
diff --git a/src/components/CanvasMaterialImportModal.tsx b/src/components/CanvasMaterialImportModal.tsx
index a80a5aaf..f6bb87ac 100644
--- a/src/components/CanvasMaterialImportModal.tsx
+++ b/src/components/CanvasMaterialImportModal.tsx
@@ -1,17 +1,21 @@
 import { useEffect, useRef, useState } from 'react';
-import { canvasApi, CanvasImportResource, CanvasImportReport } from '../services/api';
+import { canvasApi, foldersApi, CanvasImportResource, CanvasImportReport } from '../services/api';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from './ui/dialog';
 import '../styles/components/CanvasMaterialImportModal.css';
 
 interface Props {
   isOpen: boolean;
   folderId: string;
+  /** Canvas course linked to this CREATE course; preselected when the user can still access it. */
+  linkedCanvasCourseId?: string | null;
+  /** Called after the user saves a different Canvas course as this course's link. */
+  onLinkedCanvasCourseChange?: (canvasCourseId: string) => void;
   onClose: () => void;
   onImported?: () => void | Promise<void>;
 }
 const key = (resource: Pick<CanvasImportResource, 'id' | 'resourceType'>) => `${resource.resourceType}:${resource.id}`;
 
-export default function CanvasMaterialImportModal({ isOpen, folderId, onClose, onImported }: Props) {
+export default function CanvasMaterialImportModal({ isOpen, folderId, linkedCanvasCourseId, onLinkedCanvasCourseChange, onClose, onImported }: Props) {
   const [state, setState] = useState<'loading' | 'unavailable' | 'connect' | 'ready'>('loading');
   const [courses, setCourses] = useState<Array<{ id: string; name: string; courseCode: string }>>([]);
   const [courseId, setCourseId] = useState('');
@@ -23,6 +27,8 @@ export default function CanvasMaterialImportModal({ isOpen, folderId, onClose, o
   const [importing, setImporting] = useState(false);
   const [error, setError] = useState('');
   const [warnings, setWarnings] = useState<string[]>([]);
+  const [linkedUnavailable, setLinkedUnavailable] = useState(false);
+  const [linking, setLinking] = useState(false);
   const [limit, setLimit] = useState(10);
   const [maxBytes, setMaxBytes] = useState(50 * 1024 * 1024);
   const [report, setReport] = useState<CanvasImportReport | null>(null);
@@ -41,8 +47,12 @@ export default function CanvasMaterialImportModal({ isOpen, folderId, onClose, o
       if (!auth.data?.connected) { setState('connect'); return; }
       const result = await canvasApi.getImportCourses(folderId);
       if (current !== requestId.current) return;
-      setCourses(result.data?.courses || []); setState('ready');
+      const available = result.data?.courses || [];
+      setCourses(available); setState('ready');
       setCourseId(''); setResources([]); setSelected(new Set()); setReport(null);
+      const linked = linkedCanvasCourseId ? available.find(course => String(course.id) === String(linkedCanvasCourseId)) : undefined;
+      setLinkedUnavailable(!!linkedCanvasCourseId && !linked);
+      if (linked) void loadMaterials(linked.id);
     } catch (err) {
       if (current === requestId.current) { setError(err instanceof Error ? err.message : 'Could not load Canvas. Try again.'); setState('connect'); }
     }
@@ -87,6 +97,16 @@ export default function CanvasMaterialImportModal({ isOpen, folderId, onClose, o
     } catch (err) { if (current === requestId.current) setError(err instanceof Error ? err.message : 'Could not load course materials.'); }
     finally { if (current === requestId.current) setLoadingMaterials(false); }
   }
+  async function linkSelectedCourse() {
+    if (!courseId || linking) return;
+    setLinking(true); setError('');
+    try {
+      await foldersApi.setLinkedCanvasCourse(folderId, courseId);
+      setLinkedUnavailable(false);
+      onLinkedCanvasCourseChange?.(courseId);
+    } catch (err) { setError(err instanceof Error ? err.message : 'Could not save the linked Canvas course.'); }
+    finally { setLinking(false); }
+  }
   async function importSelected() {
     if (!selected.size || importing) return;
     setImporting(true); setError('');
@@ -123,9 +143,14 @@ export default function CanvasMaterialImportModal({ isOpen, folderId, onClose, o
           <label className="canvas-import-field">Canvas course
             <select className="input" value={courseId} disabled={busy} onChange={event => void loadMaterials(event.target.value)}>
               <option value="">Choose a teaching course</option>
-              {courses.map(course => <option key={course.id} value={course.id}>{course.name}</option>)}
+              {courses.map(course => <option key={course.id} value={course.id}>{course.name}{String(course.id) === String(linkedCanvasCourseId) ? ' (linked)' : ''}</option>)}
             </select>
           </label>
+          {linkedUnavailable && <p className="canvas-import-notice">The Canvas course linked to this course isn't available to your account. Choose another course.</p>}
+          {courseId && String(courseId) !== String(linkedCanvasCourseId ?? '') && onLinkedCanvasCourseChange && <div className="canvas-import-tools">
+            <button className="btn btn-outline" disabled={busy || linking} onClick={() => void linkSelectedCourse()}>{linking ? 'Saving…' : 'Set as linked course'}</button>
+            <span className="canvas-import-hint">Imports and exports for this course will start with this Canvas course.</span>
+          </div>}
           {!courses.length && <p>No teaching courses found. This import currently requires a Teacher enrollment in Canvas.</p>}
           {warnings.map((warning, index) => <p key={index} role="alert" className="canvas-import-notice">{warning}</p>)}
           {(warnings.length > 0 || error) && <div className="canvas-import-tools">
diff --git a/src/components/CourseView.tsx b/src/components/CourseView.tsx
index 08469621..e71ddf8f 100644
--- a/src/components/CourseView.tsx
+++ b/src/components/CourseView.tsx
@@ -25,6 +25,7 @@ interface CourseData {
   id: string;
   name: string;
   quizzes: QuizData[];
+  canvasCourseId?: string | null;
 }
 
 const CourseView = () => {
@@ -200,7 +201,8 @@ const CourseView = () => {
           status: typeof quiz === 'string' ? undefined : quiz.status,
           progress: typeof quiz === 'string' ? undefined : quiz.progress,
           updatedAt: typeof quiz === 'string' ? undefined : quiz.updatedAt
-        })) || []
+        })) || [],
+        canvasCourseId: folderResponse.folder.canvasCourseId
       };
 
       setCourse(course);
@@ -654,6 +656,8 @@ const CourseView = () => {
             </div>
             <MaterialUpload
               folderId={courseId}
+              linkedCanvasCourseId={course?.canvasCourseId}
+              onLinkedCanvasCourseChange={canvasCourseId => setCourse(prev => prev ? { ...prev, canvasCourseId } : prev)}
               materials={materials.map(m => ({
                 id: m._id,
                 name: m.name,
diff --git a/src/components/CreateCourseModal.test.tsx b/src/components/CreateCourseModal.test.tsx
index 2c652bb7..b6fc2e68 100644
--- a/src/components/CreateCourseModal.test.tsx
+++ b/src/components/CreateCourseModal.test.tsx
@@ -1,4 +1,4 @@
-import { fireEvent, render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 import CreateCourseModal from './CreateCourseModal';
 import { canvasApi } from '../services/api';
@@ -15,6 +15,8 @@ vi.mock('../services/api', () => ({
   canvasApi: {
     getConfig: vi.fn().mockResolvedValue({ data: { enabled: false } }),
     getAuthStatus: vi.fn(),
+    getCourses: vi.fn(),
+    createModule: vi.fn(),
   },
 }));
 
@@ -54,5 +56,21 @@ describe('CreateCourseModal workflow', () => {
     fireEvent.click(screen.getByRole('button', { name: /Next/ }));
     expect(screen.getByRole('button', { name: 'Connect to Canvas' })).toBeInTheDocument();
   });
+  it('links a Canvas course without creating a Canvas module', async () => {
+    vi.mocked(canvasApi.getConfig).mockResolvedValueOnce({ data: { enabled: true } } as never);
+    vi.mocked(canvasApi.getAuthStatus).mockResolvedValueOnce({ data: { connected: true } } as never);
+    vi.mocked(canvasApi.getCourses).mockResolvedValueOnce({ data: { courses: [{ id: '42', name: 'Physics 101', courseCode: 'PHYS' }] } } as never);
+    const onSubmit = vi.fn().mockResolvedValue(undefined);
+    render(<CreateCourseModal isOpen onClose={vi.fn()} onSubmit={onSubmit} />);
+    await screen.findByRole('tab', { name: /^Canvas/ });
+    fireEvent.change(screen.getByLabelText('Course Name'), { target: { value: 'Physics' } });
+    fireEvent.click(screen.getByRole('button', { name: /Next/ }));
+    fireEvent.click(screen.getByRole('button', { name: /Next/ }));
+    fireEvent.click(await screen.findByText('Physics 101'));
+    expect(screen.queryByText(/will be created/)).not.toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: 'Create Course' }));
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledWith('Physics', [], '42'));
+    expect(canvasApi.createModule).not.toHaveBeenCalled();
+  });
 
 });
diff --git a/src/components/CreateCourseModal.tsx b/src/components/CreateCourseModal.tsx
index 20963f04..cb63c634 100644
--- a/src/components/CreateCourseModal.tsx
+++ b/src/components/CreateCourseModal.tsx
@@ -27,7 +27,7 @@ interface CanvasCourse {
 interface CreateCourseModalProps {
   isOpen: boolean;
   onClose: () => void;
-  onSubmit: (courseName: string, materials: Material[], canvasCourseId?: string, canvasModuleId?: string) => Promise<void>;
+  onSubmit: (courseName: string, materials: Material[], canvasCourseId?: string) => Promise<void>;
 }
 
 const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps) => {
@@ -45,7 +45,6 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
   const [canvasError, setCanvasError] = useState('');
   const [canvasCourses, setCanvasCourses] = useState<CanvasCourse[]>([]);
   const [selectedCourse, setSelectedCourse] = useState<CanvasCourse | null>(null);
-  const [canvasModuleId, setCanvasModuleId] = useState<string | null>(null);
   const [linkToCanvas, setLinkToCanvas] = useState(false);
   const [isDisconnecting, setIsDisconnecting] = useState(false);
 
@@ -163,7 +162,6 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
 
   const handleUnlinkCanvas = () => {
     setSelectedCourse(null);
-    setCanvasModuleId(null);
     setLinkToCanvas(false);
   };
 
@@ -174,8 +172,7 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
       setCanvasConnected(false);
       setCanvasCourses([]);
       setSelectedCourse(null);
-      setCanvasModuleId(null);
-      setLinkToCanvas(false);
+        setLinkToCanvas(false);
     } catch {
       // ignore
     } finally {
@@ -188,23 +185,10 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
       setIsCreating(true);
       setUploadProgress(0);
       try {
-        // Create Canvas module now (only once, at submission time)
-        let moduleId = canvasModuleId;
-        if (linkToCanvas && selectedCourse && !moduleId) {
-          try {
-            const res = await canvasApi.createModule(selectedCourse.id, courseName.trim());
-            moduleId = res.data?.module?.id || null;
-            setCanvasModuleId(moduleId);
-          } catch {
-            moduleId = null;
-          }
-        }
-
         await onSubmit(
           courseName.trim(),
           materials,
-          linkToCanvas && selectedCourse ? selectedCourse.id : undefined,
-          linkToCanvas && moduleId ? moduleId : undefined
+          linkToCanvas && selectedCourse ? selectedCourse.id : undefined
         );
         resetModal();
         onClose();
@@ -230,7 +214,6 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
   const handleSkipCanvas = async () => {
     setLinkToCanvas(false);
     setSelectedCourse(null);
-    setCanvasModuleId(null);
     await handleCreateCourse();
   };
 
@@ -239,7 +222,6 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
     setMaterials([]);
     setCurrentStep(1);
     setSelectedCourse(null);
-    setCanvasModuleId(null);
     setLinkToCanvas(false);
     setCanvasCourses([]);
   };
@@ -391,7 +373,7 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
             <div {...stepPanelProps(3)}>
               <div className="step-header">
                 <h3>Link to Canvas Course</h3>
-                <p>Optionally link this course to a Canvas course. A module named "{courseName}" will be created automatically.</p>
+                <p>Optionally link this course to a Canvas course. Canvas imports and exports will start with this course selected.</p>
               </div>
 
               {!canvasConnected ? (
@@ -421,7 +403,6 @@ const CreateCourseModal = ({ isOpen, onClose, onSubmit }: CreateCourseModalProps
                       <div className="canvas-linked-meta">
                         {selectedCourse.courseCode}{selectedCourse.term ? ` — ${selectedCourse.term}` : ''}
                       </div>
-                      <div className="canvas-linked-module">Module "{courseName}" will be created on submit</div>
                     </div>
                     <button className="btn btn-ghost btn-sm" onClick={handleUnlinkCanvas} title="Unlink">
                       <Link2Off size={16} />
diff --git a/src/components/MaterialUpload.tsx b/src/components/MaterialUpload.tsx
index 59c79e5e..aac6a24e 100644
--- a/src/components/MaterialUpload.tsx
+++ b/src/components/MaterialUpload.tsx
@@ -24,6 +24,8 @@ interface Material {
 
 interface MaterialUploadProps {
   folderId?: string;
+  linkedCanvasCourseId?: string | null;
+  onLinkedCanvasCourseChange?: (canvasCourseId: string) => void;
   materials: Material[];
   onAddMaterial: (
     material: { name: string; type: 'pdf' | 'docx' | 'url' | 'text'; content?: string; file?: File },
@@ -36,6 +38,8 @@ interface MaterialUploadProps {
 
 const MaterialUpload = ({
   folderId,
+  linkedCanvasCourseId,
+  onLinkedCanvasCourseChange,
   materials,
   onAddMaterial,
   onRemoveMaterial,
@@ -316,7 +320,7 @@ const MaterialUpload = ({
             </div>
           </div>
 
-          {folderId && <CanvasMaterialImportModal isOpen={showCanvasImport} folderId={folderId} onClose={() => setShowCanvasImport(false)} onImported={onMaterialReprocessed} />}
+          {folderId && <CanvasMaterialImportModal isOpen={showCanvasImport} folderId={folderId} linkedCanvasCourseId={linkedCanvasCourseId} onLinkedCanvasCourseChange={onLinkedCanvasCourseChange} onClose={() => setShowCanvasImport(false)} onImported={onMaterialReprocessed} />}
 
           {/* URL Form */}
           {showUrlForm && (
diff --git a/src/components/Sidebar.tsx b/src/components/Sidebar.tsx
index baa62e14..b03598c1 100644
--- a/src/components/Sidebar.tsx
+++ b/src/components/Sidebar.tsx
@@ -203,11 +203,11 @@ const Sidebar = ({ isOpen = false, onClose, collapsed = false, onToggleCollapse
     navigate(`/course/${courseId}/quiz/${quizId}`);
   };
 
-  const handleCreateCourse = async (courseName: string, materials: Array<{ type: string; name: string; content?: string; file?: File }> = [], canvasCourseId?: string, canvasModuleId?: string) => {
+  const handleCreateCourse = async (courseName: string, materials: Array<{ type: string; name: string; content?: string; file?: File }> = [], canvasCourseId?: string) => {
     try {
       // Step 1: Create the folder/course (await this - it's fast)
       console.log(`📁 Creating course: ${courseName}`, canvasCourseId ? `(Canvas: ${canvasCourseId})` : '');
-      const response = await foldersApi.createFolder(courseName, 1, canvasCourseId, canvasModuleId);
+      const response = await foldersApi.createFolder(courseName, 1, canvasCourseId);
       const courseId = response.folder._id;
 
       // Step 2: Immediately add the new folder to the sidebar state
diff --git a/src/components/review/CanvasExportModal.test.tsx b/src/components/review/CanvasExportModal.test.tsx
new file mode 100644
index 00000000..69d396ea
--- /dev/null
+++ b/src/components/review/CanvasExportModal.test.tsx
@@ -0,0 +1,65 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import CanvasExportModal from './CanvasExportModal';
+
+const mocks = vi.hoisted(() => ({
+  getConfig: vi.fn(), getAuthStatus: vi.fn(), getCourses: vi.fn(), getModules: vi.fn(),
+  getConnectUrl: vi.fn(), createModule: vi.fn(), exportToCanvas: vi.fn(), disconnect: vi.fn()
+}));
+const folderMocks = vi.hoisted(() => ({ setLinkedCanvasCourse: vi.fn() }));
+vi.mock('../../services/api', () => ({ canvasApi: mocks, foldersApi: folderMocks }));
+
+const renderModal = (linkedCanvasCourseId?: string, onLinkedCanvasCourseChange?: (id: string) => void) => render(
+  <CanvasExportModal isOpen onClose={vi.fn()} quizId="quiz" quizName="Quiz 1" folderId="folder"
+    linkedCanvasCourseId={linkedCanvasCourseId} onLinkedCanvasCourseChange={onLinkedCanvasCourseChange}
+    showNotification={vi.fn()} />
+);
+
+describe('CanvasExportModal linked course', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getConfig.mockResolvedValue({ data: { enabled: true } });
+    mocks.getAuthStatus.mockResolvedValue({ data: { connected: true } });
+    mocks.getCourses.mockResolvedValue({ data: { courses: [
+      // Canvas returns numeric IDs; the linked ID is stored as a string.
+      { id: 2, name: 'Physics', courseCode: 'PHYS' },
+      { id: 3, name: 'Chemistry', courseCode: 'CHEM' }
+    ] } });
+    mocks.getModules.mockResolvedValue({ data: { modules: [] } });
+  });
+
+  it('opens on the module step for the linked course and offers to create a module', async () => {
+    renderModal('2');
+    await screen.findByText('No modules found. Create one below.');
+    expect(screen.getByText('Physics')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Back to courses' })).toBeInTheDocument();
+    expect(mocks.getModules).toHaveBeenCalledWith(2);
+  });
+
+  it('shows the course list with a notice when the linked course is not available', async () => {
+    renderModal('99');
+    await screen.findByText(/linked to this course isn't available/);
+    expect(screen.getByText('Chemistry')).toBeInTheDocument();
+    expect(mocks.getModules).not.toHaveBeenCalled();
+  });
+
+  it('lets the user save a different course as the linked course', async () => {
+    folderMocks.setLinkedCanvasCourse.mockResolvedValue({ folder: {} });
+    const onLinked = vi.fn();
+    renderModal('2', onLinked);
+    await screen.findByText('No modules found. Create one below.');
+    expect(screen.queryByRole('button', { name: /Set as linked course/ })).not.toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: 'Back to courses' }));
+    fireEvent.click(await screen.findByText('Chemistry'));
+    fireEvent.click(await screen.findByRole('button', { name: /Set as linked course/ }));
+    await waitFor(() => expect(onLinked).toHaveBeenCalledWith('3'));
+    expect(folderMocks.setLinkedCanvasCourse).toHaveBeenCalledWith('folder', '3');
+  });
+
+  it('asks for a course when none is linked', async () => {
+    renderModal();
+    await screen.findByText('Chemistry');
+    expect(screen.queryByText(/isn't available/)).not.toBeInTheDocument();
+    expect(mocks.getModules).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/components/review/CanvasExportModal.tsx b/src/components/review/CanvasExportModal.tsx
index 0d91d474..2dba0886 100644
--- a/src/components/review/CanvasExportModal.tsx
+++ b/src/components/review/CanvasExportModal.tsx
@@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react';
-import { X, ExternalLink, Check, Loader2, Plus, LogOut } from 'lucide-react';
-import { canvasApi } from '../../services/api';
+import { X, ExternalLink, Check, Loader2, Plus, LogOut, Link2 } from 'lucide-react';
+import { canvasApi, foldersApi } from '../../services/api';
 import '../../styles/components/CanvasExportModal.css';
 
 interface CanvasExportModalProps {
@@ -8,6 +8,12 @@ interface CanvasExportModalProps {
   onClose: () => void;
   quizId: string;
   quizName: string;
+  /** Canvas course linked to this quiz's CREATE course; preselected when the user can still access it. */
+  linkedCanvasCourseId?: string | null;
+  /** CREATE course (folder) the quiz belongs to; needed to save a new linked Canvas course. */
+  folderId?: string;
+  /** Called after the user saves a different Canvas course as the course's link. */
+  onLinkedCanvasCourseChange?: (canvasCourseId: string) => void;
   showNotification: (type: string, title: string, message: string) => void;
 }
 
@@ -32,6 +38,9 @@ const CanvasExportModal = ({
   onClose,
   quizId,
   quizName,
+  linkedCanvasCourseId,
+  folderId,
+  onLinkedCanvasCourseChange,
   showNotification
 }: CanvasExportModalProps) => {
   const [step, setStep] = useState<Step>('checking');
@@ -44,6 +53,8 @@ const CanvasExportModal = ({
   const [newModuleName, setNewModuleName] = useState('');
   const [creatingModule, setCreatingModule] = useState(false);
   const [isDisconnecting, setIsDisconnecting] = useState(false);
+  const [linkedUnavailable, setLinkedUnavailable] = useState(false);
+  const [linking, setLinking] = useState(false);
 
   // Check Canvas connection on open
   useEffect(() => {
@@ -60,6 +71,7 @@ const CanvasExportModal = ({
       setSelectedCourse(null);
       setSelectedModule(null);
       setResultUrl(null);
+      setLinkedUnavailable(false);
     }
   }, [isOpen]);
 
@@ -77,7 +89,13 @@ const CanvasExportModal = ({
       const res = await canvasApi.getAuthStatus();
       if (res.data?.connected) {
         setStep('select-course');
-        await loadCourses();
+        const available = await loadCourses();
+        const linked = linkedCanvasCourseId
+          ? available.find(course => String(course.id) === String(linkedCanvasCourseId))
+          : undefined;
+        setLinkedUnavailable(!!linkedCanvasCourseId && !linked);
+        // Start at the module step for the linked course; "Back to courses" still allows a different course.
+        if (linked) await handleCourseSelect(linked);
       } else {
         setStep('connect');
       }
@@ -114,14 +132,17 @@ const CanvasExportModal = ({
     }
   }
 
-  async function loadCourses() {
+  async function loadCourses(): Promise<CanvasCourse[]> {
     setLoading(true);
     try {
       const res = await canvasApi.getCourses();
-      setCourses(res.data?.courses || []);
+      const available = res.data?.courses || [];
+      setCourses(available);
+      return available;
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : 'Failed to load courses';
       showNotification('error', 'Error', message);
+      return [];
     } finally {
       setLoading(false);
     }
@@ -167,6 +188,24 @@ const CanvasExportModal = ({
     }
   }
 
+  async function handleLinkCourse() {
+    if (!selectedCourse || !folderId || linking) return;
+    setLinking(true);
+    // Canvas returns numeric IDs at runtime even though the type says string.
+    const canvasCourseId = String(selectedCourse.id);
+    try {
+      await foldersApi.setLinkedCanvasCourse(folderId, canvasCourseId);
+      setLinkedUnavailable(false);
+      onLinkedCanvasCourseChange?.(canvasCourseId);
+      showNotification('success', 'Canvas course linked', `Exports and imports for this course will start with ${selectedCourse.name}.`);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : 'Could not save the linked Canvas course';
+      showNotification('error', 'Error', message);
+    } finally {
+      setLinking(false);
+    }
+  }
+
   async function handleDisconnect() {
     setIsDisconnecting(true);
     try {
@@ -265,6 +304,9 @@ const CanvasExportModal = ({
                   Disconnect
                 </button>
               </div>
+              {linkedUnavailable && !loading && (
+                <p className="canvas-selected-info">The Canvas course linked to this course isn't available to your account. Choose another course.</p>
+              )}
               {loading ? (
                 <div className="canvas-loading"><Loader2 size={24} className="spinner" /> Loading courses...</div>
               ) : courses.length === 0 ? (
@@ -278,7 +320,7 @@ const CanvasExportModal = ({
                       onClick={() => handleCourseSelect(course)}
                     >
                       <div className="canvas-item-name">{course.name}</div>
-                      <div className="canvas-item-meta">{course.courseCode}{course.term ? ` - ${course.term}` : ''}</div>
+                      <div className="canvas-item-meta">{course.courseCode}{course.term ? ` - ${course.term}` : ''}{String(course.id) === String(linkedCanvasCourseId) ? ' · Linked' : ''}</div>
                     </button>
                   ))}
                 </div>
@@ -293,6 +335,13 @@ const CanvasExportModal = ({
                 Back to courses
               </button>
               <p className="canvas-selected-info">Course: <strong>{selectedCourse?.name}</strong></p>
+              {selectedCourse && folderId && onLinkedCanvasCourseChange
+                && String(selectedCourse.id) !== String(linkedCanvasCourseId ?? '') && (
+                <button className="btn btn-ghost btn-sm" style={{ alignSelf: 'flex-start' }} onClick={handleLinkCourse} disabled={linking || loading}>
+                  {linking ? <Loader2 size={14} className="spinner" /> : <Link2 size={14} />}
+                  Set as linked course
+                </button>
+              )}
               {loading ? (
                 <div className="canvas-loading"><Loader2 size={24} className="spinner" /> Loading modules...</div>
               ) : (
diff --git a/src/components/review/ReviewEdit.tsx b/src/components/review/ReviewEdit.tsx
index bb94e47a..b7bca6db 100644
--- a/src/components/review/ReviewEdit.tsx
+++ b/src/components/review/ReviewEdit.tsx
@@ -1056,6 +1056,13 @@ const ReviewEdit = ({ quizId, learningObjectives, workflowMode = 'review' }: Rev
         onClose={() => setCanvasExportModalOpen(false)}
         quizId={quizId}
         quizName={currentQuiz?.name || 'Learning Object'}
+        linkedCanvasCourseId={typeof currentQuiz?.folder === 'object' ? currentQuiz.folder.canvasCourseId : undefined}
+        folderId={typeof currentQuiz?.folder === 'object' ? currentQuiz.folder._id : currentQuiz?.folder}
+        onLinkedCanvasCourseChange={canvasCourseId => {
+          if (currentQuiz && typeof currentQuiz.folder === 'object') {
+            dispatch(updateQuizLocally({ ...currentQuiz, folder: { ...currentQuiz.folder, canvasCourseId } }));
+          }
+        }}
         showNotification={showNotification}
       />
 
diff --git a/src/services/api.ts b/src/services/api.ts
index 00b21a18..7a8946a1 100644
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -50,6 +50,7 @@ export interface Folder {
   instructor: string;
   materials: Array<string | FolderMaterialSummary>;
   quizzes: Array<string | FolderQuizSummary>;
+  canvasCourseId?: string | null;
   stats: {
     totalQuizzes: number;
     totalQuestions: number;
@@ -187,7 +188,7 @@ export interface CoverageMap {
 export interface Quiz {
   _id: string;
   name: string;
-  folder: string | Pick<Folder, '_id' | 'name'>;
+  folder: string | Pick<Folder, '_id' | 'name' | 'canvasCourseId'>;
   materials: string[] | Material[];
   learningObjectives: string[];
   questions: string[];
@@ -677,8 +678,8 @@ export const foldersApi = {
   },
 
   // POST /api/create/folders - Create new folder with quizzes
-  createFolder: async (name: string, quizCount: number = 1, canvasCourseId?: string, canvasModuleId?: string): Promise<{ folder: Folder }> => {
-    const response = await apiClient.post<{ success: boolean; data: { folder: Folder }; message: string }>('/folders', { name, quizCount, canvasCourseId, canvasModuleId });
+  createFolder: async (name: string, quizCount: number = 1, canvasCourseId?: string): Promise<{ folder: Folder }> => {
+    const response = await apiClient.post<{ success: boolean; data: { folder: Folder }; message: string }>('/folders', { name, quizCount, canvasCourseId });
     return response.data;
   },
 
@@ -688,6 +689,12 @@ export const foldersApi = {
     return response.data;
   },
 
+  // PUT /api/create/folders/:id - Link (or unlink with null) a Canvas course
+  setLinkedCanvasCourse: async (id: string, canvasCourseId: string | null): Promise<{ folder: Folder }> => {
+    const response = await apiClient.put<{ success: boolean; data: { folder: Folder }; message: string }>(`/folders/${id}`, { canvasCourseId });
+    return response.data;
+  },
+
   // PUT /api/create/folders/:id - Update folder name
   updateFolder: async (id: string, name: string): Promise<{ folder: Folder }> => {
     const response = await apiClient.put<{ success: boolean; data: { folder: Folder }; message: string }>(`/folders/${id}`, { name });
diff --git a/src/styles/components/CreateCourseModal.css b/src/styles/components/CreateCourseModal.css
index bb914ffd..14834f1b 100644
--- a/src/styles/components/CreateCourseModal.css
+++ b/src/styles/components/CreateCourseModal.css
@@ -232,15 +232,6 @@
     color: var(--color-muted-foreground);
 }
 
-.canvas-linked-module {
-    font-size: var(--font-size-xs);
-    color: var(--color-primary);
-    margin-top: 2px;
-    display: flex;
-    align-items: center;
-    gap: 4px;
-}
-
 /* Reuse CanvasExportModal styles for course list */
 .canvas-connect-step {
     text-align: center;