diff --git a/backend/main.py b/backend/main.py
index f827449..b15c237 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -405,6 +405,35 @@ def get_courses_batch(request: Request, codes: List[str]):
     finally:
         conn.close()
 
+@app.get("/courses/{course_code}/instructors")
+@limiter.limit("60/minute")
+def get_course_instructors(request: Request, course_code: str):
+    code = course_code.upper().replace("-", " ")
+    if not COURSE_CODE_RE.match(code):
+        raise HTTPException(status_code=400, detail="Invalid course code")
+    conn = get_connection()
+    try:
+        cur = conn.cursor()
+        cur.execute("""
+            SELECT DISTINCT term, instructor_name
+            FROM course_instructors
+            WHERE course_code = %s
+            ORDER BY term, instructor_name
+        """, (code,))
+        rows = cur.fetchall()
+        cur.close()
+        # Group by term
+        terms: dict = {}
+        for term, name in rows:
+            terms.setdefault(term, []).append(name)
+        return [{"term": t, "instructors": names} for t, names in terms.items()]
+    except Exception as e:
+        logger.error("GET /courses/%s/instructors failed: %s", course_code, e, exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+    finally:
+        conn.close()
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)
diff --git a/backend/timetable_scraper.py b/backend/timetable_scraper.py
new file mode 100644
index 0000000..83779c0
--- /dev/null
+++ b/backend/timetable_scraper.py
@@ -0,0 +1,192 @@
+"""
+Scrapes Carleton Central timetable for instructor names per course per term.
+Populates the course_instructors table.
+
+Usage: python3 timetable_scraper.py
+"""
+
+import os, re, time, requests
+from psycopg2.extras import execute_values
+from db import get_connection
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BASE_URL = "https://central.carleton.ca/prod"
+TERMS = [
+    ("202630", "Fall 2026"),
+    ("202710", "Winter 2027"),
+]
+
+# All undergrad subject codes we care about (pulled from the search page)
+def get_subject_codes(session: requests.Session, term_code: str, session_id: str) -> list[str]:
+    resp = session.post(f"{BASE_URL}/bwysched.p_search_fields", data={
+        "wsea_code": "EXT",
+        "term_code": term_code,
+        "session_id": session_id,
+    })
+    return re.findall(r'<option value="([A-Z]{2,5})"', resp.text)
+
+
+def get_session_id(session: requests.Session, term_code: str) -> str:
+    resp = session.get(f"{BASE_URL}/bwysched.p_select_term?wsea_code=EXT")
+    sid = re.search(r'session_id" value="(\d+)"', resp.text)
+    if not sid:
+        raise RuntimeError("Could not get session_id")
+    # Now post the term selection to advance the session
+    session.post(f"{BASE_URL}/bwysched.p_search_fields", data={
+        "wsea_code": "EXT",
+        "term_code": term_code,
+        "session_id": sid.group(1),
+    })
+    return sid.group(1)
+
+
+DUMMY_FIELDS = {
+    "sel_aud": "dummy", "sel_subj": "dummy", "sel_camp": "dummy",
+    "sel_sess": "dummy", "sel_attr": "dummy", "sel_levl": "dummy",
+    "sel_schd": "dummy", "sel_insm": "dummy", "sel_link": "dummy",
+    "sel_wait": "dummy", "sel_day": "dummy", "sel_begin_hh": "dummy",
+    "sel_begin_mi": "dummy", "sel_begin_am_pm": "dummy",
+    "sel_end_hh": "dummy", "sel_end_mi": "dummy",
+    "sel_end_am_pm": "dummy", "sel_instruct": "dummy",
+    "sel_special": "dummy", "sel_resd": "dummy", "sel_breadth": "dummy",
+}
+
+DAY_FIELDS = {
+    "sel_day": ["m", "t", "w", "r", "f", "s"],
+    "sel_begin_hh": "0", "sel_begin_mi": "0", "sel_begin_am_pm": "a",
+    "sel_end_hh": "23", "sel_end_mi": "59", "sel_end_am_pm": "p",
+    "sel_levl": "UG",
+}
+
+
+def parse_instructors(html: str, subj: str, term_label: str) -> list[tuple]:
+    """
+    Returns list of (course_code, term, instructor_name) tuples.
+    Only includes Lecture/Seminar rows to avoid duplicating per tutorial section.
+    """
+    results = []
+    seen = set()
+    for row in re.split(r'<tr\b', html):
+        code_m = re.search(rf'{re.escape(subj)}\s+(\d{{4}}[A-Z]?)</font>', row)
+        type_m = re.search(r'<td[^>]*>(Lecture|Seminar)</td>', row)
+        if not code_m or not type_m:
+            continue
+        # Instructor is the last plain-text td (no href inside)
+        plain_tds = re.findall(r'<td[^>]*>\s*([A-Za-z][^<\n]{2,50}?)\s*</td>', row)
+        if not plain_tds:
+            continue
+        instructor = plain_tds[-1].strip()
+        if not instructor or '&nbsp;' in instructor or instructor.lower() in (
+            'tba', 'staff', 'lecture', 'tutorial', 'lab', 'seminar', 'yes', 'no', 'open', 'closed'
+        ):
+            continue
+        code = f"{subj} {code_m.group(1)}"
+        key = (code, term_label, instructor)
+        if key not in seen:
+            seen.add(key)
+            results.append(key)
+    return results
+
+
+def scrape_subject(session: requests.Session, term_code: str, term_label: str,
+                   session_id: str, subj: str) -> list[tuple]:
+    data = {
+        "wsea_code": "EXT",
+        "term_code": term_code,
+        "session_id": session_id,
+        "ws_numb": "",
+        **DUMMY_FIELDS,
+        "sel_subj": subj,
+        "sel_number": "",
+        **DAY_FIELDS,
+    }
+    # requests doesn't handle repeated keys well with dict; use list of tuples
+    payload = []
+    for k, v in data.items():
+        if isinstance(v, list):
+            for item in v:
+                payload.append((k, item))
+        else:
+            payload.append((k, v))
+    # Add the multi-value day fields correctly
+    payload = [
+        ("wsea_code", "EXT"), ("term_code", term_code), ("session_id", session_id),
+        ("ws_numb", ""), ("sel_aud", "dummy"), ("sel_subj", "dummy"),
+        ("sel_camp", "dummy"), ("sel_sess", "dummy"), ("sel_attr", "dummy"),
+        ("sel_levl", "dummy"), ("sel_schd", "dummy"), ("sel_insm", "dummy"),
+        ("sel_link", "dummy"), ("sel_wait", "dummy"), ("sel_day", "dummy"),
+        ("sel_begin_hh", "dummy"), ("sel_begin_mi", "dummy"),
+        ("sel_begin_am_pm", "dummy"), ("sel_end_hh", "dummy"),
+        ("sel_end_mi", "dummy"), ("sel_end_am_pm", "dummy"),
+        ("sel_instruct", "dummy"), ("sel_special", "dummy"),
+        ("sel_resd", "dummy"), ("sel_breadth", "dummy"),
+        ("sel_subj", subj), ("sel_number", ""),
+        ("sel_day", "m"), ("sel_day", "t"), ("sel_day", "w"),
+        ("sel_day", "r"), ("sel_day", "f"), ("sel_day", "s"),
+        ("sel_begin_hh", "0"), ("sel_begin_mi", "0"), ("sel_begin_am_pm", "a"),
+        ("sel_end_hh", "23"), ("sel_end_mi", "59"), ("sel_end_am_pm", "p"),
+        ("sel_levl", "UG"),
+    ]
+    resp = session.post(f"{BASE_URL}/bwysched.p_course_search", data=payload)
+    return parse_instructors(resp.text, subj, term_label)
+
+
+def create_table(conn):
+    with conn.cursor() as cur:
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS course_instructors (
+                id SERIAL PRIMARY KEY,
+                course_code TEXT NOT NULL,
+                term TEXT NOT NULL,
+                instructor_name TEXT NOT NULL,
+                UNIQUE(course_code, term, instructor_name)
+            )
+        """)
+    conn.commit()
+
+
+def upsert_rows(conn, rows: list[tuple]):
+    if not rows:
+        return
+    with conn.cursor() as cur:
+        execute_values(cur, """
+            INSERT INTO course_instructors (course_code, term, instructor_name)
+            VALUES %s
+            ON CONFLICT (course_code, term, instructor_name) DO NOTHING
+        """, rows)
+    conn.commit()
+
+
+def main():
+    conn = get_connection()
+    create_table(conn)
+
+    http = requests.Session()
+    http.headers.update({"User-Agent": "CarletonCourseMap/1.0 (student project)"})
+
+    total = 0
+    for term_code, term_label in TERMS:
+        print(f"\n=== {term_label} ===")
+        session_id = get_session_id(http, term_code)
+        subjects = get_subject_codes(http, term_code, session_id)
+        print(f"Found {len(subjects)} subjects")
+
+        for subj in subjects:
+            try:
+                rows = scrape_subject(http, term_code, term_label, session_id, subj)
+                if rows:
+                    upsert_rows(conn, rows)
+                    print(f"  {subj}: {len(rows)} sections")
+                    total += len(rows)
+                time.sleep(0.4)  # be polite
+            except Exception as e:
+                print(f"  {subj}: ERROR {e}")
+
+    conn.close()
+    print(f"\nDone. {total} total rows inserted.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/frontend/app/api/rmp/route.js b/frontend/app/api/rmp/route.js
new file mode 100644
index 0000000..715ce6f
--- /dev/null
+++ b/frontend/app/api/rmp/route.js
@@ -0,0 +1,46 @@
+import { RMPClient } from 'ratemyprofessors-client'
+import { NextResponse } from 'next/server'
+
+const CARLETON_SCHOOL_ID = '1420'
+const client = new RMPClient()
+
+// Cache results in memory for the lifetime of the server process
+const cache = new Map()
+
+export async function GET(request) {
+  const { searchParams } = new URL(request.url)
+  const name = searchParams.get('name')?.trim()
+
+  if (!name) {
+    return NextResponse.json({ error: 'name is required' }, { status: 400 })
+  }
+
+  if (cache.has(name)) {
+    return NextResponse.json(cache.get(name))
+  }
+
+  try {
+    const result = await client.searchProfessors(name, CARLETON_SCHOOL_ID)
+    // Pick the first result that belongs to Carleton
+    const prof = result.professors?.find(p => p.school?.id === CARLETON_SCHOOL_ID) ?? null
+
+    const data = prof
+      ? {
+          found: true,
+          name: prof.name,
+          department: prof.department,
+          overall_rating: prof.overall_rating,
+          difficulty: prof.level_of_difficulty,
+          num_ratings: prof.num_ratings,
+          would_take_again: prof.percent_take_again >= 0 ? Math.round(prof.percent_take_again) : null,
+          rmp_url: `https://www.ratemyprofessors.com/professor/${prof.id}`,
+        }
+      : { found: false }
+
+    cache.set(name, data)
+    return NextResponse.json(data)
+  } catch (err) {
+    console.error('RMP lookup failed for', name, err)
+    return NextResponse.json({ found: false })
+  }
+}
diff --git a/frontend/app/map/components/CoursePanel.jsx b/frontend/app/map/components/CoursePanel.jsx
index b331563..783f991 100644
--- a/frontend/app/map/components/CoursePanel.jsx
+++ b/frontend/app/map/components/CoursePanel.jsx
@@ -1,12 +1,62 @@
+'use client'
+
 /* course detail panel — right sidebar on desktop, bottom drawer on mobile */
 
+import { useState, useEffect } from 'react'
+
+const API = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000'
+
 export const CoursePanel = ({ node, onClose, isMobile }) => {
   const isOpen = node != null && !node.data?.isElective
 
-
   const { code, name, description, credit, prerequisites, offerings } =
     isOpen ? node.data : {}
 
+  const [instructorData, setInstructorData] = useState(null) // [{term, instructors: [{name, rmp}]}]
+  const [loadingInstructors, setLoadingInstructors] = useState(false)
+
+  useEffect(() => {
+    if (!isOpen || !code) {
+      setInstructorData(null)
+      return
+    }
+    setInstructorData(null)
+    setLoadingInstructors(true)
+
+    const encodedCode = code.replace(' ', '-')
+
+    fetch(`${API}/courses/${encodedCode}/instructors`)
+      .then(r => r.json())
+      .then(async termGroups => {
+        if (!termGroups.length) {
+          setInstructorData([])
+          setLoadingInstructors(false)
+          return
+        }
+        // For each unique instructor, fetch RMP data
+        const allNames = [...new Set(termGroups.flatMap(g => g.instructors))]
+        const rmpMap = {}
+        await Promise.all(allNames.map(async name => {
+          try {
+            const res = await fetch(`/api/rmp?name=${encodeURIComponent(name)}`)
+            rmpMap[name] = await res.json()
+          } catch {
+            rmpMap[name] = { found: false }
+          }
+        }))
+        const enriched = termGroups.map(g => ({
+          term: g.term,
+          instructors: g.instructors.map(n => ({ name: n, rmp: rmpMap[n] ?? { found: false } })),
+        }))
+        setInstructorData(enriched)
+        setLoadingInstructors(false)
+      })
+      .catch(() => {
+        setInstructorData([])
+        setLoadingInstructors(false)
+      })
+  }, [code, isOpen])
+
   const panelStyle = isMobile
     ? isOpen
       ? {
@@ -43,7 +93,7 @@ export const CoursePanel = ({ node, onClose, isMobile }) => {
     ? {
         bottom: 0, left: 0, right: 0,
         width: '100%',
-        height: '65vh',
+        height: '75vh',
         borderRadius: '12px 12px 0 0',
         borderTop: '1px solid var(--color-rule)',
       }
@@ -181,12 +231,138 @@ export const CoursePanel = ({ node, onClose, isMobile }) => {
               <div style={bodyText}>{prerequisites}</div>
             </div>
           )}
+
+          {/* Instructors */}
+          <div style={{ marginBottom: 'var(--space-md)' }}>
+            <SectionLabel>Instructors (2026–2027)</SectionLabel>
+            {loadingInstructors && (
+              <div style={{ ...bodyText, color: 'var(--color-ink-3)' }}>Loading…</div>
+            )}
+            {!loadingInstructors && instructorData && instructorData.length === 0 && (
+              <div style={{ ...bodyText, color: 'var(--color-ink-3)' }}>No timetable data yet</div>
+            )}
+            {!loadingInstructors && instructorData && instructorData.map(group => (
+              <div key={group.term} style={{ marginBottom: 'var(--space-sm)' }}>
+                <div style={{
+                  fontSize: 'var(--text-xs)',
+                  fontWeight: 600,
+                  color: 'var(--color-ink-3)',
+                  marginBottom: 6,
+                }}>
+                  {group.term}
+                </div>
+                {group.instructors.map(({ name: profName, rmp }) => (
+                  <ProfCard key={profName} name={profName} rmp={rmp} />
+                ))}
+              </div>
+            ))}
+          </div>
+
         </div>
       </div>
     </>
   )
 }
 
+const ProfCard = ({ name, rmp }) => (
+  <div style={{
+    background: 'var(--color-paper-2)',
+    border: '1px solid var(--color-rule)',
+    borderRadius: 8,
+    padding: '10px 12px',
+    marginBottom: 8,
+  }}>
+    <div style={{
+      display: 'flex',
+      justifyContent: 'space-between',
+      alignItems: 'flex-start',
+      gap: 8,
+    }}>
+      <span style={{
+        fontSize: 'var(--text-sm)',
+        fontWeight: 600,
+        color: 'var(--color-ink)',
+        lineHeight: 1.3,
+      }}>
+        {name}
+      </span>
+      {rmp?.found && (
+        <a
+          href={rmp.rmp_url}
+          target="_blank"
+          rel="noopener noreferrer"
+          style={{
+            fontSize: 'var(--text-xs)',
+            color: 'var(--color-accent)',
+            textDecoration: 'none',
+            whiteSpace: 'nowrap',
+            flexShrink: 0,
+          }}
+        >
+          RMP ↗
+        </a>
+      )}
+    </div>
+
+    {rmp?.found ? (
+      <div style={{
+        display: 'flex',
+        gap: 'var(--space-sm)',
+        marginTop: 6,
+        flexWrap: 'wrap',
+      }}>
+        <RmpStat label="Rating" value={rmp.overall_rating?.toFixed(1)} outOf={5} color={ratingColor(rmp.overall_rating)} />
+        <RmpStat label="Difficulty" value={rmp.difficulty?.toFixed(1)} outOf={5} color={difficultyColor(rmp.difficulty)} />
+        {rmp.would_take_again != null && (
+          <RmpStat label="Take again" value={`${rmp.would_take_again}%`} />
+        )}
+        <span style={{
+          fontSize: 'var(--text-xs)',
+          color: 'var(--color-ink-3)',
+          alignSelf: 'flex-end',
+        }}>
+          {rmp.num_ratings} rating{rmp.num_ratings !== 1 ? 's' : ''}
+        </span>
+      </div>
+    ) : (
+      <div style={{
+        fontSize: 'var(--text-xs)',
+        color: 'var(--color-ink-3)',
+        marginTop: 4,
+      }}>
+        Not on RateMyProfessors
+      </div>
+    )}
+  </div>
+)
+
+const RmpStat = ({ label, value, color }) => (
+  <div style={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+    <span style={{ fontSize: 'var(--text-xs)', color: 'var(--color-ink-3)' }}>{label}</span>
+    <span style={{
+      fontSize: 'var(--text-sm)',
+      fontWeight: 700,
+      color: color ?? 'var(--color-ink)',
+    }}>
+      {value ?? '—'}
+    </span>
+  </div>
+)
+
+function ratingColor(r) {
+  if (r == null) return 'var(--color-ink)'
+  if (r >= 4) return '#2d9e5f'
+  if (r >= 3) return '#d97706'
+  return '#dc2626'
+}
+
+function difficultyColor(d) {
+  if (d == null) return 'var(--color-ink)'
+  if (d <= 2.5) return '#2d9e5f'
+  if (d <= 3.5) return '#d97706'
+  return '#dc2626'
+}
+
 const chipStyle = {
   background: 'var(--color-paper-2)',
   border: '1px solid var(--color-rule)',
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 1792251..c55d369 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -15,6 +15,7 @@
         "dagre": "^0.8.5",
         "next": "16.2.6",
         "postcss": "^8.5.15",
+        "ratemyprofessors-client": "^3.0.0",
         "react": "19.2.4",
         "react-dom": "19.2.4",
         "reactflow": "^11.11.4",
@@ -6469,6 +6470,18 @@
       ],
       "license": "MIT"
     },
+    "node_modules/ratemyprofessors-client": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/ratemyprofessors-client/-/ratemyprofessors-client-3.0.0.tgz",
+      "integrity": "sha512-9rDnuEsxFyL0cXFDGHmS0ZBE6v8X0JuDjauwr7F28XJ8IjtsJ9F4S20S5AOAqcIn7NNtx08vyfYS58njAi9YZw==",
+      "license": "MIT",
+      "dependencies": {
+        "sentiment": "^5.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/react": {
       "version": "19.2.4",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
@@ -6734,6 +6747,15 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/sentiment": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/sentiment/-/sentiment-5.0.2.tgz",
+      "integrity": "sha512-ZeC3y0JsOYTdwujt5uOd7ILJNilbgFzUtg/LEG4wUv43LayFNLZ28ec8+Su+h3saHlJmIwYxBzfDHHZuiMA15g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index d9ac081..4ed6148 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -16,6 +16,7 @@
     "dagre": "^0.8.5",
     "next": "16.2.6",
     "postcss": "^8.5.15",
+    "ratemyprofessors-client": "^3.0.0",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "reactflow": "^11.11.4",