Curriculum Gap Analysis: A Step-by-Step Guide

Your course completion numbers look fine, but the projects tell a different story. Learners finish the videos, pass the quizzes, and still struggle to produce work they could send to a client. Meanwhile, your team keeps suggesting another lesson.

I'd pause the content queue and run a curriculum gap analysis. Before adding anything, I want to know which promised skills learners can demonstrate, where they get stuck, and which existing lessons no longer earn their place.

What Your Curriculum Gap Analysis Should Compare

A curriculum gap analysis compares what learners are supposed to do with what they can show. The useful question is whether the learning experience supports that performance, not whether a topic appears somewhere in the course.

Say your online course promises that learners will write a client proposal. Week 1 names the skill, and Week 3 shows a sample. The only scored task asks learners to define the word proposal.

That outcome is introduced, not assessed. The quiz produces a score, but it doesn't show whether someone can write the document.

Compare the promise, the teaching, and the test

Keep these layers separate:

• Intended curriculum: The standard, framework, or outcome you promised learners.
• Taught curriculum: The lessons, practice, demonstrations, and feedback learners receive.
• Assessed curriculum: The quizzes, projects, or observations used to capture performance.

UNESCO's curriculum-mapping guide defines the intended curriculum through standards, frameworks, competencies, and guidelines, and explains how comparisons with assessed content can expose misalignment.

For our proposal outcome, the promise requires writing. The teaching provides examples. The assessment checks vocabulary. Those are different demands, even though they share a topic label.

If your starting outcomes are vague, Ace Med Boards' guide to turn exam objectives into measurable outcomes offers a useful starting point for making the expected performance explicit. Replace understand proposals with write a proposal that defines scope, deliverables, exclusions, and next steps.

How to code each learning outcome

I use the following working codes. Record the evidence that earns each code rather than choosing the most reassuring label.

Code	Evidence that earns it	What it usually means
Absent	No lesson, practice, or task tied to the outcome	Missing content or a dropped standard
Introduced	Mention, reading, or demo only	Exposure without a chance to perform
Practiced	Learner attempt plus feedback, not yet scored as the outcome	Skill started but not proven
Assessed	A valid quiz, project, or observation produces a result	You can see performance, not just attendance
Mastered	A later realistic task shows the skill without heavy prompting	The outcome holds up after the lesson ends

An assessed code doesn't mean everyone passed. Keep the assessment result beside the code so you can distinguish a missing opportunity from weak attainment.

For mastery, define the required performance before reviewing submissions. A later task needs clear criteria, such as an accurate scope and defensible recommendation, rather than an instructor's general impression.

If you're still establishing what the audience needs, use a training needs assessment template to clarify the required skills before judging the course against them.

List every required outcome as a row before editing a single lesson. Otherwise, you risk polishing content without checking whether it belongs.

How to Run the Analysis From Objective to Fix List

I'd start with a single program and a shared spreadsheet. Open the live course alongside it, including assignments, feedback, and learner submissions. An old course outline isn't enough to reconstruct what people experience.

The mapping sequence documented in UCL Press curriculum-mapping research moves from individual mapping through horizontal aggregation, vertical review, revision needs, and implementation.

Use this process overview to keep the team focused.

Run the mapping session

1. Write the decision you need. Accreditation evidence, faster progression, and less repeated content require different comparison rules. For progression, ask whether learners demonstrate prerequisites before they need them. Avoid the vague objective of improving everything.

2. List program outcomes and their supporting outcomes. Connect each program-level performance to the course or module expected to develop it. Use write a scoped proposal as the unit, not client communication. Broad labels hide missing tasks.

3. Have instructors map the live course. Record topics, skills, activities, assessment methods, and depth for every outcome. Include feedback learners receive. A common slip is copying the planned activity without checking whether instructors still run it.

4. Aggregate across instructors, then follow the learner journey. Compare sections horizontally to find differences in delivery. Then read vertically from the first module to the final task. Check whether one instructor provides essential practice that another section never receives.

5. Apply the evidence codes. Flag required skills that are absent or never progress beyond introduced. Mark repetition separately when lessons revisit the same task without greater complexity. Repeated exposure shouldn't automatically earn a stronger code.

6. Check flow, coverage, and hierarchy. Flow shows whether a skill returns later. Coverage shows where it sits. Hierarchy connects program, term, module, and lesson outcomes. A missing connection may require a clearer outcome rather than another lesson.

7. Score fixes and assign responsibility. Consider learner risk, assessment weight, prerequisite load, and build effort. Give every selected change an owner and a target date. A gap without an accountable person remains an observation.

8. Calibrate before scaling, then remap after implementation. Have two reviewers independently remap a sample course three times as a practical consistency check. Compare disagreements, refine the rules, and repeat the mapping after the changes reach learners.

For distributed training teams, Franchise Foundry's explanation of instructional design for franchisee onboarding offers a useful parallel for organizing analysis, design, implementation, and evaluation across delivery locations.

Which curriculum gaps to fix first

Here's a suggested local scoring rule, not a validated measurement scale. Score each factor from 1 to 3, with 3 meaning greater risk, weight, dependency, or effort.

Priority	Typical scores	Example	When to act
Fix next cohort	Risk 3, assessment 3, prerequisites 3, effort 1 or 2	Capstone skill never practiced before the final	Before the next enrollment date
Redesign the task	Risk 2, assessment 3, effort 2	Quiz tests terms while the outcome is a performance	Same term if the task already exists
Remove a repeat	Risk 1, effort 1	Same role play in three modules with no added difficulty	Next content edit
Schedule later	Risk 1, assessment 1, effort 3	Nice-to-have tool tutorial with no later dependency	Backlog, review next quarter

Use the bands in order when a fix fits more than one. Prioritize the next cohort when risk, assessment weight, and prerequisites all score 3 and effort is 1 or 2. Redesign a task when risk is 2 and assessment weight is 3, and remove a repeat when risk and effort both score 1. Schedule other changes for later review.

Done means you have outcomes, codes, evidence links, and a short fix list. You don't need a redesigned catalog to finish the analysis.

A Worked Map for a Six Module Client Skills Course

Consider a fictional membership course called Client Skills in 6 Weeks. It promises that learners will scope a project, write a proposal, run a discovery call, and present a recommendation.

For the mapping meeting, put the course designer and instructor beside the actual tasks and submissions.

Read the rows before judging the course

Module 1 explains project scoping through slides. Learners never scope a brief, so that row earns introduced.

Module 2 supplies a proposal template and peer feedback. That earns practiced at this point. The capstone scores the proposal in Module 6, so the course eventually reaches assessed, but too late if learners already need proposal-writing ability in Week 3.

Using outcomes as the comparison unit keeps these distinctions visible. A study of curriculum-mapping practice recommends course and program learning outcomes as the measure when mapping for accreditation.

Gap map for Client Skills in 6 Weeks

Program outcome	Where taught	Practice	Assessment	Code	Fix
Scope a project	Module 1 slide deck	None	None	Introduced	Add a scoped brief task in Module 1
Write a proposal	Module 2 template	Peer feedback	Capstone in Module 6	Assessed (late)	Move a scored mini proposal to Module 2
Run a discovery call	Modules 3, 4 and 5	Same role play each time	No scored call observation	Practiced (repeated)	Keep one role play and make Module 5 a difficult client call
Present a recommendation	Quiz on terms	None	Quiz on terms only	Introduced	Add a performance task

Read horizontally across the modules and you'll see the proposal checkpoint arrives after learners need it. Discovery calls occupy several modules, but the activity never becomes harder.

Read vertically from present a recommendation down to the task. The program promises a presentation, while the task asks for definitions. No performance evidence supports a stronger code.

Make the smallest useful changes

I'd move a scored mini proposal into Module 2. Learners would submit a short proposal against the same core criteria used in the capstone, then receive feedback before later work depends on that skill.

For discovery calls, keep the initial role play. Replace the repeated activities with targeted preparation, then make Module 5 a difficult-client call involving unclear requirements or conflicting expectations. Add an observation rubric if you want that task to earn assessed.

The embedded video can serve as a separate discussion prompt during a team review.

Another pattern I'd flag is an outcome taught at the beginning and assessed only at the end. Without an intermediate checkpoint, the instructor has no recorded performance to guide support while learners are struggling.

Practical rule: Move the evidence checkpoint to where the next task depends on the skill.

Copy four or five of your own outcomes into these columns before mapping the whole catalog. The first useful discovery may be a misplaced assessment rather than missing content.

Tips That Keep the Map Honest and the Fixes Small

The mistake I'd correct first is a syllabus line coded as covered because an instructor mentioned the topic. That records exposure. It doesn't establish whether learners tried the skill, received useful feedback, or demonstrated it.

I'd also avoid replacing covered with assessed because a quiz exists. You need to inspect the task, its criteria, and the resulting learner work.

Keep the evidence fields separate

For each important outcome, retain these fields:

• Intended outcome: The action learners should perform.
• Taught content: The lesson, demonstration, or explanation supporting it.
• Learner practice: The attempt and feedback before formal judgment.
• Assessment task: The prompt or observation used to capture performance.
• Performance level: The rubric criteria and required standard.
• Assessment result: What the learner demonstrated.

If practice is blank, investigate the preparation gap. If the result is blank, don't record a completed assessed judgment. A scheduled assignment is an assessment opportunity, not evidence of achievement.

An assessment can exist without prior practice, but that should remain visible as a design problem. Don't fill the practice cell with the assessment itself just to make the row look complete.

Check interpretations with another reviewer

Pull evidence from student work, assessment blueprints, instructor notes, a short learner survey, and the employer or regulatory standard when relevant. These sources answer different questions. Learners can describe confusing instructions, while submissions show whether those instructions led to the required performance.

Have two reviewers code independently using written rules. When they disagree, compare the evidence before negotiating the label.

In a published curriculum-mapping study, LLM-generated weighted mappings achieved Krippendorff's alpha of 0.76 against expert judgments, compared with 0.65 for a machine-learning curriculum-alignment approach. That's useful evidence for checking agreement, and I still wouldn't accept an automated map without human review.

Record why a decision changed. For example, reviewers might downgrade assessed to introduced because the quiz measures terminology rather than the promised performance.

Watch for expensive shortcuts

These failure modes deserve a deliberate check:

• Mapping only the syllabus: Open the current activities and instructor feedback before accepting the documented plan.
• Ignoring task validity: Compare the outcome's action with what the learner must produce in practice.
• Letting one group define every gap: Include teaching, learner, and workplace perspectives without treating any single perspective as decisive.
• Rewriting everything at once: Select changes using the priority bands, then check their effect before expanding the work.

An online course quality assurance review can sit alongside this process to check delivery and usability. Keep those findings distinct from competency gaps so a broken submission button doesn't become a new lesson.

If you cannot point to learner work, you have a content list, not a gap analysis.

A Quarterly Check So the Map Does Not Go Stale

A one-time spreadsheet can become outdated the quarter a hiring trend shifts. I'd keep the coded map, but attach a light review cycle to it rather than wait for a full course rebuild.

The important decision is what to remove. If every review ends with new material, learners inherit a longer course while obsolete lessons remain untouched.

Use a recurring cycle with clear inputs and a small set of decisions.

Separate lasting skills from tool language

Once a quarter, pick the one or two occupations or client jobs your course serves. Collect recent job posts, learner questions, support tickets, frequently missed assessment items, and notes from two employer or member conversations.

Normalize the language before adding rows. Different employers might describe the same underlying capability as requirements gathering, client discovery, or needs clarification.

My working rule is to retain a skill signal only when it appears in more than one source and still matters after the brand name changes. Then map it to existing outcomes.

• No matching outcome: Investigate a possible genuine gap.
• An existing outcome with weak evidence: Improve the practice or assessment.
• Several modules already addressing it: Clarify the wording and check for unnecessary repetition.

The OECD's discussion of skills intelligence describes systematic analysis of labor-market and education signals, and cites UNESCO's estimate that roughly 40% of current skill sets no longer match labor-market needs, alongside a projection that 22% of jobs will transform by 2030.

I'd use that as a reason to subtract selectively, not chase every new tool. Mark one lesson to retire, one assessment to rewrite, and one foundational skill to protect, such as scoping or judgment.

Audit AI behavior alongside technical skill

If your course teaches AI tools, add separate outcomes for checking bias, verifying generated work, protecting data, and disclosing tool use. Include accessible ways to demonstrate those skills when learners lack the same devices or paid tools.

A 2025 UNESCO-UNEVOC survey of 4,268 young people across 128 countries found a 40% gap in ethical-AI training. These rows deserve their own evidence rather than a checkmark beside an AI introduction.

Don't ask an AI tool to declare the gaps and stop there. Retrieval-based checks can help locate relevant documents, but a person should confirm each proposed code against the task and learner work.

Use a consistent approach to learning outcomes measurement so you can compare performance after an assessment changes. Retain the earlier rubric and task version rather than overwriting your baseline.

Keep the meeting short

Try this 45-minute agenda as a working schedule:

1. 15 minutes on missed items: Inspect learner responses and identify the misunderstood action.
2. 15 minutes on external signals: Compare job language, employer feedback, and client needs.
3. 15 minutes on decisions: Name one keep, one cut, and one add, with an owner for each.

The add can be a checkpoint or feedback opportunity. It doesn't have to be another lesson.

Map One Course Before You Touch the Catalog

Pick the course with the most complaints or the weakest project scores. Don't begin with the whole catalog, even if a catalog-wide map is your eventual goal.

Block two hours for a first pass. The time limit is a practical constraint, not a promise that every course can be analyzed completely in that window. You're testing whether the team can connect outcomes, evidence, and decisions.

Build a ten-row working map

Start with a manageable sample:

1. Export the course outcomes. Rewrite unclear statements only enough to identify the performance you need to inspect.
2. Code ten outcomes. Use the evidence codes and attach a piece of learner work to every assessed row.
3. Choose one high-priority fix. Assign an owner and a date before ending the session.
4. Remap those ten rows after release. Check whether the evidence supports a different code and whether learner performance meets the intended standard.

Keep the results in a sheet with these columns:

Outcome	Code	Evidence link	Fix	Owner	Date
Write a scoped proposal	Practiced	Peer-reviewed draft	Add scored mini proposal	Course designer	Agreed release date

The row should tell a colleague what's missing without requiring a meeting. Link directly to the relevant task, rubric, and permitted learner evidence, rather than a folder containing unrelated course files.

Keep the map beside the live course

If the course lives in a learning platform, keep the outcome, code, and assessment link beside the lesson where possible. When someone changes the assignment, they should be able to find the mapping decision without searching a separate archive.

For a membership or cohort course, a shared sheet works until your platform can store outcomes. Restrict access to identifiable learner work and keep the mapping record usable without exposing unnecessary personal details.

Our guide comparing learning management systems for employee training covers team size, pricing, SCORM and xAPI support, and use case, plus a pilot plan. Use those criteria if platform limitations are preventing your team from maintaining the evidence trail, rather than switching systems before testing the process.

A code moving from practiced to assessed confirms that you've added performance evidence. It doesn't automatically confirm better learning. Review the resulting work against the rubric before deciding the fix succeeded.

---

Ship one ten-row map and one dated fix this week. Choose the course, open its actual assignments, and name the person responsible for the change before you close the sheet. A perfect catalog map can wait until this small review loop has worked once.