Learning Design Series (5): Performance-Support
Performance-Support e-learning is the mode to use when the learner does not need to memorize everything. They need a guide, checklist, decision rule, or reference they can use while doing the work.
This is where many training projects quietly go wrong. A team has a procedure, a policy, or an escalation rule. Someone decides to make a course. The result is 18 minutes of explanation, a quiz, and a downloadable checklist that should probably have been the main artifact all along.
By the end of this article, you should be able to decide when Performance-Support design is the right mode, choose the right e-learning blocks for it, and prompt an AI course builder with enough detail that it creates something usable at the moment of need.
This article builds on What is Instructional Design in E-Learnings?. Start there if you want the overview and comparison of the different learning design modes before going deep on Performance-Support.
What is Performance-Support e-learning?
Performance-Support e-learning is a course design mode focused on helping learners perform a task at the moment they need it. Instead of trying to move every detail into memory, it gives learners a usable aid: a checklist, decision guide, escalation rule, workflow, template, table, or reference.
The key question is not:
Can the learner recall this later?
It is:
Can the learner use this while working and make the right next move?
That sounds less glamorous than a scenario or simulation. Sometimes it is better. If the task is infrequent, detailed, rule-heavy, or constantly changing, memorization is often the wrong goal. A good job aid can beat a polished course because it sits where the mistake happens.
Performance support can still include short explanation and practice. It should. But the center of gravity is different. The course exists to make the aid understandable, trustworthy, and usable.
When should you use Performance-Support e-learning?
Use Performance-Support when learners need reliable guidance during work more than they need deep internalized knowledge. It works best when the task is procedural, reference-heavy, compliance-sensitive, infrequent, or easy to get wrong under pressure.
This mode works especially well when the topic falls into one of these families:
| Job aids and checklists | Decision guides and escalation | Procedures and field work | Role enablement and reference |
|---|---|---|---|
| Pre-call checklists | Refund exception rules | Safety pre-checks | Manager conversation guides |
| Quality review checklists | Escalate / do not escalate guides | Equipment inspection steps | Sales qualification sheets |
| Launch readiness checks | Data handling decision trees | Field-service task cards | Support macro selection guides |
| Onboarding task lists | Approval thresholds | Cleaning or closing procedures | Partner onboarding references |
| Policy quick references | Risk triage guides | Shift handoff checklists | Product comparison tables |
| Documentation templates | Exception handling rules | Incident response aids | Customer education cheat sheets |
It is weaker when learners need emotional judgment, repeated skill practice, or a deep conceptual shift. For an ambiguous customer conversation, use Scenario-Based. For a tool workflow learners must practise repeatedly, use Scaffolded Practice. For a clean update or explainer, use the learning design mode "Clear & Focused".
The watch-out is turning the job aid into a course-shaped obstacle.
If the learner will need the checklist at work, do not bury it behind ten slides and a score.
What are the advantages of Performance-Support design?
Performance-Support design helps learners act correctly without forcing them to memorize every detail. It is practical, maintainable, and often more respectful of real work than a traditional course.
| Advantage | How it helps the learner | What the designer must still do |
|---|---|---|
| Moment-of-need usefulness | Learners can use the aid while doing the task. | Make the aid fast to scan. |
| Lower memory burden | Details live in the guide, not only in the learner's head. | Decide what must be remembered vs. referenced. |
| Fewer work errors | Checklists and rules reduce missed steps. | Base the aid on real failure points. |
| Easier maintenance | Updating a reference can be simpler than rebuilding lessons. | Keep source ownership clear. |
| Better confidence | Learners know where to look when unsure. | Make the guide authoritative. |
| Intrinsic motivation | The asset feels immediately useful. | Connect it to the learner's actual task. |
There is a quiet humility in this mode. It admits that the best learning design is not always "teach more." Sometimes the best design is "make the right thing easier to do."
How do instructional design principles show up in this mode?
Instructional design principles still matter in Performance-Support courses, but they show up differently. Gagne's events are not abandoned. They are compressed around use, trust, and transfer.
| Principle | Performance-Support implementation | Common mistake |
|---|---|---|
| Gain attention | Start with the real work error, risk, or moment of confusion. | Opening with a generic policy overview. |
| Inform objectives | Say what the learner will be able to do with the aid. | Saying only "understand the process." |
| Stimulate recall | Ask when learners currently need help or make mistakes. | Pretending the task happens in a clean classroom context. |
| Present content | Explain the decision rule, checklist, or reference structure. | Copying the full source document. |
| Provide guidance | Show how to use the aid on one realistic case. | Providing the aid without orientation. |
| Elicit performance | Ask learners to use the aid to choose, check, or decide. | Quizzing memorized details from the aid. |
| Provide feedback | Explain where the aid points and why. | Feedback that ignores the reference logic. |
| Assess performance | Use a fresh task that requires the aid. | Testing recall instead of use. |
| Enhance transfer | End with when to use the aid, where to find it, and how to keep it current. | Ending after a completion score. |
Merrill's first principles fit well too: begin with a real problem, demonstrate use, let learners apply the aid, and help them integrate it into their workflow. In Performance-Support, integration is the whole point.
How do you structure a Performance-Support course?
A Performance-Support course should move from the work moment to the aid, then show how to use the aid on realistic cases. The course can be short. In many cases, the most valuable artifact is the guide itself, with just enough learning around it to make it usable.
| Course part | Purpose | Typical blocks |
|---|---|---|
| Work moment | Show the situation where the learner needs support. | TITLE, EXPLANATION, QUOTATION |
| Why it matters | Explain risk, error cost, time saved, or quality standard. | DID_YOU_KNOW, BULLETED_LIST |
| The aid | Present the checklist, guide, table, or workflow. | TABLE, PROCESS, NUMBERED_LIST |
| How to use it | Walk through one realistic example. | TABS, ACCORDION, IMAGE |
| Practice with the aid | Ask learners to use the guide, not recall it. | QUIZ_ONE_CHOICE, CARD_SORT, ORDERING |
| Edge cases | Show exceptions, escalation rules, and limits. | ACCORDION, TABLE, FLIP_CARD |
| Recap and access | Tell learners when and where to use the aid. | BULLETED_LIST, PROCESS, TABLE_OF_CONTENTS |
The course should not be a long detour before the useful thing. Put the aid close to the front. Then teach learners how to trust it, use it, and know when it is not enough.
Which e-learning blocks work best for Performance-Support courses?
Use e-learning blocks to make guidance scannable, usable, and reliable. In Performance-Support mode, a block earns its place if it helps the learner find the right action faster or avoid a real mistake.
Good primary blocks:
| Block type | How to use it in Performance-Support |
|---|---|
| TITLE | Clear guide and section headings. |
| EXPLANATION | Short context, scope, and usage instructions. |
| BULLETED_LIST | Checklists, warnings, and "before you start" items. |
| NUMBERED_LIST | Fixed sequences. |
| PROCESS | Repeatable workflows and escalation paths. |
| TABLE | Thresholds, role/action, if/then, old/new, do/don't, and comparison references. |
| TABS | Role-specific guidance, phases, regions, plans, or customer types. |
| ACCORDION | Optional detail, exceptions, and policy rationale. |
| DID_YOU_KNOW | Critical cautions or non-obvious rules. |
| QUIZ_ONE_CHOICE | "Which action should you take using the guide?" checks. |
| QUIZ_MULTIPLE_CHOICE | Selecting all applicable criteria or required checks. |
| CARD_SORT | Allowed/not allowed, escalate/do not escalate, urgent/not urgent. |
| ORDERING | Procedural sequences. |
| MATCHING_CARDS | Matching cues to actions or issues to owners. |
| FLIP_CARD | Term -> action, rule -> example, or exception -> response. |
| TABLE_OF_CONTENTS | A multi-lesson reference course. |
Usually avoid decorative IMAGE use, long CAROUSELS, and quiz-heavy patterns where the learner is punished for not memorizing the aid. The goal is not to hide the reference and see if they remember it. The goal is to train them to use it well.
Weak quiz:
What is the escalation threshold for refund exceptions?
Better Performance-Support task:
Use the refund exception guide. A customer is 2 days outside the refund window, has documentation of a medical emergency, and is on the standard plan. Which action does the guide recommend?
That second version tests the real behavior: using the guide to decide.
How should AI be prompted to create a Performance-Support course?
To prompt AI for a Performance-Support course, give it the course ingredients, the work situation, the required job aid, the available block types, the lookup logic, and the limits of the aid. Do not assume the AI will know that the checklist is the main artifact. It may turn the whole thing into a lecture with a quiz unless you explicitly stop it.
Here is a detailed prompt template for AI-assisted e-learning course generation:
Create an e-learning course using the Performance-Support instructional design mode.
Course inputs:
- Topic: [topic]
- Audience: [audience]
- Source material: [provided material, uploaded content, or model knowledge]
- Course goal: [what learners should know or be able to do by the end]
- Target depth: [Remember / Understand / Apply / Analyze-Decide / Create]
- Starting point: [Beginner / Novice / Intermediate / Advanced / Expert]
- Prerequisites: [what learners should already know]
- Evidence of learning: [how we will know they got it]
- Common pitfalls: [what learners usually misunderstand or do wrong]
- Relevance angle: [why learners should care]
- Spacing: [revisit key ideas across lessons or cover each once]
- Challenge ramp: [Ease in / Balanced / Push hard]
- Hands-on level: [Mostly reading / Balanced / Hands-on / Conversational]
- Tone: [tone]
- Course length: [minutes]
Your task:
Design a complete e-learning course, not a single lesson.
Use Performance-Support design consistently. The course should create or teach a usable job aid, checklist, decision guide, workflow, table, template, or escalation reference that learners can use while working. Do not turn the job aid into a quiz-heavy memorization course. Do not hide the guide at the end.
The course should follow this arc:
1. Identify the work moment: when and why the learner needs support.
2. Explain the practical risk, error cost, time saved, or quality standard.
3. Present the performance-support artifact early.
4. Explain the artifact's scope: when to use it, when not to use it, and who owns it.
5. Walk through one realistic example using the artifact.
6. Let learners use the artifact on one or more practice cases.
7. Show edge cases, exceptions, escalation triggers, and limits.
8. Finish with access guidance: where the aid lives, how to use it, and what to do when it does not cover the situation.
For every lesson, specify:
- Lesson title.
- Lesson purpose.
- Estimated time.
- The work moment this lesson supports.
- The support artifact used or created.
- What the learner must be able to do with the artifact.
- Recommended e-learning blocks.
- What each block should contain.
- Which part of the artifact is introduced or used.
- Practice task that requires using the artifact.
- Correct answer or recommended action.
- Feedback that explains how the artifact points to the answer.
- Edge case, exception, or escalation rule.
- What learners should remember vs. what they should reference.
- How the aid should be used after the course.
Use only these e-learning block types:
TITLE, EXPLANATION, IMAGE, BULLETED_LIST, NUMBERED_LIST, QUIZ_ONE_CHOICE,
QUIZ_MULTIPLE_CHOICE, ACCORDION, FLIP_CARD, SPACE, COLUMNS, CARD_SORT,
CAROUSEL, DIVIDER, CODE, TABLE_OF_CONTENTS, TABS, TIMELINE, PROCESS,
ORDERING, MATCHING_CARDS, TABLE, DID_YOU_KNOW, QUOTATION.
Preferred blocks for Performance-Support mode:
- TITLE for guide, checklist, and decision-point headings.
- EXPLANATION for short scope, usage, and ownership notes.
- BULLETED_LIST for checklists, cautions, and required conditions.
- NUMBERED_LIST for fixed sequences.
- PROCESS for workflows, escalation paths, and repeatable methods.
- TABLE for thresholds, if/then rules, role/action, do/don't, and comparison references.
- TABS for role-specific, region-specific, product-specific, or phase-specific guidance.
- ACCORDION for exceptions, optional detail, and policy rationale.
- DID_YOU_KNOW for critical cautions or non-obvious rules.
- QUIZ_ONE_CHOICE for choosing the right action using the guide.
- QUIZ_MULTIPLE_CHOICE for selecting all applicable criteria.
- CARD_SORT for allowed/not allowed, escalate/do not escalate, urgent/not urgent.
- ORDERING for procedural sequences.
- MATCHING_CARDS for matching cues to actions, issues to owners, or risks to controls.
- FLIP_CARD for term -> action, rule -> example, or exception -> response.
- TABLE_OF_CONTENTS for multi-lesson reference courses.
Avoid:
- Turning the aid into memorization trivia.
- A course where the useful checklist appears only at the end.
- Copying a long policy document into lessons.
- Too many quizzes that do not mirror workplace use.
- Job aids with vague labels, missing owners, or unclear scope.
- Decision guides that do not say what to do when the case falls outside the guide.
- Checklists that are too long to use in the work moment.
- Feedback that ignores the guide logic.
- Practice cases that can be answered without using the aid.
Adjust the difficulty ramp:
- If Challenge ramp is "Ease in", start with a simple case and clearly show where the guide points.
- If Challenge ramp is "Balanced", model one case, then use two practice cases with increasing complexity.
- If Challenge ramp is "Push hard", move quickly to edge cases, exceptions, and ambiguous cases where escalation may be needed.
Adjust the hands-on level:
- Mostly reading: create the aid and include one light use-check.
- Balanced: teach the aid, include one guided case and one independent use-check.
- Hands-on: include several cases where learners use the aid to decide.
- Conversational: use Q&A prompts that simulate "I am in the work moment; what do I do now?"
Weight the course approximately:
- 10% work moment, relevance, and objective.
- 20% performance-support artifact.
- 20% how to use the artifact.
- 20% practice with the artifact.
- 15% edge cases, limits, and escalation.
- 15% recap, access guidance, and maintenance notes.
The prompt is this explicit because AI tends to make everything course-shaped. Performance-Support needs the opposite discipline. The job aid is not a bonus download. It is the point.
Where AI helps with Performance-Support design
AI can help turn source material into checklists, tables, decision rules, if/then structures, escalation paths, and short usage instructions. It is useful when the source material is accurate but too long for the work moment.
Good AI tasks include asking it to extract decision criteria from a policy, convert an SOP into a field checklist, identify likely lookup questions, create role-specific tabs, draft edge cases, and map each part of the job aid to e-learning blocks.
The useful output is a structured aid plus practice cases. Not a finished authority.
Where human review still matters
Human review matters because performance support often sits close to operational risk. A wrong checklist can normalize the wrong step. A vague escalation rule can delay a necessary handoff. A table that is out of date can quietly teach the wrong threshold.
Review especially for source accuracy, ownership, version control, legal or compliance limits, role permissions, step order, exception handling, wording clarity, and whether the aid is short enough to use in the real work moment.
One practical review question helps:
Would someone actually use this under time pressure?
If the answer is no, the artifact is probably too long, too vague, or too hidden inside the course.
Worked example: refund exception decision guide
Imagine an operations team needs a 12-minute e-learning for support agents. The source material is a refund policy, an exception matrix, and manager escalation notes.
The course goal:
Agents can use a refund exception guide to decide when to resolve, offer an approved alternative, or escalate.
The common pitfall:
Agents either reject every expired refund request or escalate every emotional customer.
A Performance-Support version could look like this:
| Lesson | Support artifact | Blocks | What the learner does |
|---|---|---|---|
| 1. The work moment | Refund exception guide | TITLE, EXPLANATION, QUOTATION | See when the guide should be used. |
| 2. The decision rule | If/then table | TABLE, DID_YOU_KNOW | Learn the key thresholds and exceptions. |
| 3. How to use it | Walkthrough case | TABS, ACCORDION | Follow one customer case through the guide. |
| 4. Practice | Decision checks | QUIZ_ONE_CHOICE, CARD_SORT | Use the guide on three short cases. |
| 5. Limits | Escalation triggers | PROCESS, BULLETED_LIST | Know when the guide is not enough. |
The final check should not ask:
What is the refund policy called?
It should ask:
Use the exception guide. A customer is 2 days outside the refund window, has medical documentation, and asks for an immediate refund. What should the agent do first?
That is Performance-Support doing its job. The learner practises using the guide, not reciting the policy.
How an AI e-learning builder should support this mode
An AI e-learning builder should treat Performance-Support as a course-plus-artifact architecture. It should ask for the topic, audience, source material, goal, target depth, starting point, prerequisites, evidence, pitfalls, relevance, spacing, challenge ramp, hands-on level, tone, and course length.
Then it should produce a course with a clear job aid, usage instructions, practice cases, feedback tied to the aid, edge cases, escalation limits, and a recap that tells learners where the aid lives and how to use it after the course.
The important part is not that the course has fewer lessons. It is that the learner leaves with something useful in the work moment.
Related reading
- Gagne's Nine Events of Instruction
- Merrill's First Principles of Instruction
- The Checklist Manifesto
FAQ
Is performance support the same as a job aid?
Not exactly. A job aid is often the artifact. Performance-Support is the design mode that decides when the job aid should be the center of the learning experience, how it should be introduced, and how learners should practise using it.
When is a job aid better than a course?
A job aid is often better when the task is infrequent, detailed, rule-heavy, or likely to change. If the learner mainly needs accurate guidance at the moment of work, a short course plus a strong aid may beat a long memorization course.
Should Performance-Support e-learning include quizzes?
It can, but the quizzes should require learners to use the guide. Avoid trivia that tests whether they memorized the checklist. The useful question is whether they can use the support artifact to make the right move.
What makes a good performance-support checklist?
A good checklist is short enough to use, specific enough to prevent mistakes, and clear about when it applies. It should also say what to do when the case falls outside the checklist.
When should I choose another design mode?
Choose Clear & Focused for concise explanations, Scaffolded Practice for guided skill-building, Scenario-Based for ambiguous decisions, and Narrative-Driven for context, consequence, and empathy.
Can AI create performance-support e-learning well?
AI can create useful first drafts, especially tables, checklists, decision rules, and practice cases. Human review is still essential because a small error in a job aid can become a repeated workplace error.
Conclusion
Performance-Support e-learning works when the course helps learners use the right guide at the right moment. Do not hide the aid. Make it scannable, test it with real cases, and make the next action obvious when the work gets messy.