Every course in your program looks fine on its own. The syllabi are clean, the outcomes are listed, the assessments are graded, and each instructor can tell you exactly what their course does. Pull any one of them and it holds up. That's the trap. A program is not a pile of good courses. It's a sequence that's supposed to add up to a graduate who can do things no single course claims to produce — and nobody in the department is looking at the sum, because everybody is looking at their own course.
So the program develops two problems at once, and neither is visible from inside a course. The first is redundancy nobody planned: three courses all teach and assess "communicate technical findings to a non-expert audience," because it's a reasonable thing to teach and each instructor added it independently, and now a third of your program's assessment weight lands on one outcome while others go hungry. The second is the outcome every course assumes someone else covers. "Students will demonstrate ethical reasoning in professional practice" is a program outcome. Every instructor believes it's handled — in the capstone, or the intro course, or the field placement. Ask each of them directly and you'll find it's handled nowhere. It falls through the seam between courses, and the seam is invisible unless you draw the whole thing on one screen.
Here's the part that stings: you already know how to catch this inside a single course. It's the alignment matrix — outcomes down the rows, assessments across the columns, evidence in the cells, and you read across for the promise nothing keeps and down for the assessment tied to nothing. The alignment matrix is that audit for one course. The curriculum map is the same instrument aimed one level up: program outcomes down the rows, courses across the columns. Same logic, wider lens — and the gaps it exposes are the ones no course-level check can ever see, because they live in the space between courses.
Why the seam stays hidden
Nobody owns the seam. An instructor is accountable for their course, a program director is accountable for outcomes on paper, and the place where course-level design meets program-level promise has no owner and no artifact. The syllabi don't reveal it — each one is internally consistent. The catalog doesn't reveal it — it lists courses, not the map from courses to outcomes. The only time the whole picture gets assembled is the accreditation retreat, when someone finally builds the grid under deadline, discovers the program has been quietly over-teaching two outcomes and never assessing a third, and everyone acts surprised. The information was always there. It was just never on one screen.
Building the map
The curriculum map is a grid, and building it honestly is most of the work. Here's a stripped-down version for a four-course core:
| Intro course | Methods course | Field placement | Capstone | |
|---|---|---|---|---|
| PO1: Evaluate published research | I | D | M | |
| PO2: Design an original study | I / D | M | ||
| PO3: Communicate to non-experts | D | M | M | M |
| PO4: Ethical reasoning in practice |
I means the outcome is introduced, D means it's developed and practiced, and M means students are expected to demonstrate mastery and are assessed on it. A blank means the course doesn't touch that outcome at all. Read the grid and the two program-level failures jump out: PO3 carries four marks and three Ms — the redundancy nobody planned — while PO4 is an empty row, the outcome every course assumed someone else covered. Here's the sequence to build your own.
- Put your program outcomes down the rows. Not course outcomes — the program-level promises, the ones in the accreditation self-study and the catalog's program description. The claims a graduate embodies, not any single course. There are usually six to ten.
- Put every required course across the columns. Include the ones that feel peripheral — the methods course, the field placement, the capstone. A course you leave off the map is a course whose contribution you've decided not to look at.
- Mark each cell for what the course actually does with that outcome, not what it mentions. Use I / D / M as above. The discipline is the same as the course-level matrix: mark what the course provides evidence for, not what you hope it gestures at.
- Read across every row. A row with no M is the outcome your program never assesses at mastery — the ethical-reasoning promise everybody assumed was handled downstream. A row that's blank until the capstone is an outcome introduced nowhere and expected everywhere. A row with three or four Ms is the redundancy nobody planned.
- Read down every column. A course that's all Ms across every outcome is claiming to be the whole program by itself — usually a capstone doing the job three earlier courses quietly skipped. A course with no marks at all is one you can't currently connect to any program promise, which is worth knowing before a reviewer asks.
The map you want has every outcome introduced somewhere early, developed in the middle, and assessed at mastery at least once near the end — a clean diagonal drift from I to D to M as students move through the sequence. What you'll actually find on the first honest pass is a grid with bright clusters where instructors independently converged and cold empty rows where everyone deferred to everyone else. That gap between the map you want and the map you have is the entire value of the exercise.
Where the tool fits
Everything above works with a spreadsheet and an afternoon — and, like the single-course matrix, it works right up until the program changes. A course gets revised, an outcome gets reworded for the next accreditation cycle, a required course is swapped for two electives, and your hand-built grid is stale the same week you built it. So it rots in a shared drive until the next retreat forces a rebuild from scratch, and the map is only ever true for the meeting it was made for.
This is the part TeachingsByDesign is built to carry. Because each course's alignment matrix already lives in the platform, the curriculum map is the aggregation of them: it rolls each course's outcomes up against the program's outcomes and renders the whole program on one screen — the I/D/M grid, the empty rows, the over-taught clusters — without anyone assembling it by hand the night before. When a course's matrix changes, the program map re-rolls. And when the accreditation committee wants it, you export it clean, so the map that caught your gap is the same document you hand across the table.
The tool doesn't decide what your program should promise, or which course should own the orphaned outcome once you've found it. That's the faculty's judgment, and it should stay there. What it removes is the reason the program-level check only ever happens under accreditation duress: the labor of building the map by hand and the certainty that it's stale before the meeting ends.
The bottom line
A program is a set of courses that each look fine alone and, together, over-teach some outcomes and never assess others — and that mismatch is structurally invisible from inside any single course. The curriculum map is where it becomes visible: program outcomes down the rows, courses across the columns, I/D/M in the cells, then read across for the outcome every course assumes someone else covers and down for the course carrying more than its share. It's the program-level companion to the single-course alignment matrix, and it answers the question no syllabus can — not "is this course coherent?" but "does the whole program add up?" You can draw it in an afternoon. The hard part is keeping it true as the program moves, and that's the part worth automating.
TeachingsByDesign rolls each course's alignment matrix up into a program-level curriculum map — program outcomes against every course, mastery gaps and redundancies surfaced on one screen — and exports it clean for review. See the whole program before your accreditor does. See how it works.