How to Create an Adaptive Course: A Step-by-Step Guide (With Templates)

The hard part when creating an adaptive course isn’t the concept. It’s deciding what triggers a branch, writing rules that don’t strand learners in dead ends, and authoring three versions of a lesson instead of one. In this guide we cover the whole build: four adaptive models and when to use each, a pre-assessment blueprint, a copyable decision-rule table, a branching map from a real module, and an honest estimate of what adaptive costs to author versus linear, on top of standard elearning development costs. Including when it isn’t worth building at all.

The four adaptive models

“Adaptive” isn’t one thing, and the version you choose determines how much content you’ll author and whether you need a dedicated platform at all. Decide this first. Retrofitting a different model after you’ve written the content means rewriting most of it.

1. Pre-test-out. Learners take a diagnostic up front and skip anything they’ve already mastered. The course adapts once, at the start, then runs linear. Use it when your audience has mixed experience: annual refreshers, onboarding that blends new hires and internal transfers.

2. Remediation loop. Learners move through normally. Fail a knowledge check, get routed to a re-teach of that specific objective, then get re-checked. Use it when the content is genuinely difficult and the failure points are predictable: technical procedures, calculations, policy application.

3. Mastery gating. No progression until the learner hits a threshold on the current objective. Sequence is fixed, pace is not. Use it when later content depends on earlier content, or when there’s a real consequence to a gap: safety, clinical, regulated work.

4. AI-driven recommendation. An engine sequences content per learner from performance and behavior data rather than rules you wrote. Use it when you have a large tagged library and a large audience — see how AI for instructional design is being used to sequence content. Below a few hundred learners it has nothing to learn from.

Most corporate courses labelled “adaptive” are models 1 or 2, and that’s the right call. Those two deliver the majority of the benefit at a fraction of the build cost, and neither requires a dedicated adaptive platform.

Step 1: Write objectives granular enough to branch on

When you create an adaptive course, learners are routed based on whether they’ve hit an objective. That means each objective has to be a single, independently testable thing: a node the system can mark pass or fail.

Test: could you write one question that proves it?

If you can’t imagine a single assessment item that will cleanly verify an objective, you can’t branch on it. Two defects break this.

Fuzzy verbs. “Understand the discount policy” isn’t observable, so replace understand, know, be aware of, be familiar with with a verb you could watch someone do. The rewrite: “Given a renewal quote, determine the correct discount tier.”

Compound objectives. “Identify and escalate policy exceptions” contains two behaviors, and a learner can pass one and fail the other. Split anything joined by “and” into separate nodes.

Use the Mager pattern — the criterion is your cut score

Given [condition], the learner will be able to [observable verb + object] to [standard].

In a linear course the standard is documentation, the same criterion you’d write when planning how to create effective elearning courses. In an adaptive course it’s functional: the degree statement is the threshold your rule fires on. Write “with no errors on compliance-critical steps” and you’ve specified a 100% gate. Write “correctly in at least 4 of 5 cases” and you’ve specified 80%.

Terminal vs. enabling — you branch on enabling objectives

The terminal objective is the capstone job task. It’s what the course is for, but it’s too big to route on, so the enabling objectives underneath it are your branch points. Each one is a sub-skill a learner can have or lack independently. Getting this decomposition right is the single highest-leverage piece of instructional design services on an adaptive build.

Terminal: Given an intake form and the CRM, create an onboarding record that passes all validation checks on first submission.

Enabling (each = one routable node):

• Identify required fields by account type
• Apply the three validation rules
• Correct flagged errors before submission

Three nodes, three possible remediation paths, three diagnostic clusters. That’s your branching skeleton.

Before and after

Step 2: Design the diagnostic that decides where learners go

A weak diagnostic sends competent learners through remediation they don’t need, and passes people who guessed.

One item per objective is not enough

A single four-option question has a 25% chance of being right by luck. Route on that and roughly 1 in 4 learners tests out of content they can’t actually do. The minimum is 2 to 3 items per objective, and coverage should be weighted by job risk: compliance-critical objectives get more items and a higher bar.

Build the blueprint before you write a single question

Match the question type to the objective’s verb

If the objective says determine, diagnose, or decide, a recall question tests the wrong thing, and worse, it tests it in a way that will route people incorrectly.

• Identify / recall objectives → multiple choice is fine
• Apply / analyze / decide objectives → short scenario items: a realistic situation, then “what’s the correct action?”

Scenario items also make better diagnostics, because each wrong option can map to a specific misconception, which tells your rules not just that the learner failed but which remediation to send — the same logic behind scenario based elearning services.

Set cut scores you can defend

“80% because it’s round” is how most courses do it. Two better anchors:

• Compliance-critical steps: gate at 100%, because partial credit on a safety step isn’t competence. Your compliance training plan should be the source for which objectives carry that bar.
• Everything else: ask a subject expert what a minimally competent person would get on each item, and add it up.

Decide explicitly whether scoring is compensatory (total across the diagnostic) or gated (must pass each objective independently). Adaptive courses almost always want gated, because you’re routing per objective, so you need a per-objective verdict.

The length problem

8 objectives × 3 items = 24 questions before the course starts. Three options:

• Front-load only the branch-heavy objectives, diagnosing the ones with expensive remediation paths.
• Embed the diagnostic instead: ask the check at the top of each lesson, pass and skip it, fail and stay. This spreads the cost and often feels better to learners.
• Cut objectives, not items. If the diagnostic is too long, you probably over-split in Step 1.

Write distractors that diagnose

In an adaptive diagnostic, each wrong option should correspond to a real misconception you’ve seen learners hold, because that’s what lets you route to a specific fix rather than a generic re-teach.

Step 3: Build the content matrix (and find out what this actually costs)

A content matrix is a grid: objectives down the side, content variants across the top, where every cell is an asset someone has to write, storyboard, record, or build. Fill it in and you have your production schedule and your budget in one artifact.

The linear version of this module is 3 assets. The adaptive version is 8. That’s your multiplier, made explicit, and it’s a design decision you can now argue about with a stakeholder before production starts. It’s also the number to bring to any quote for custom elearning development services, since most vendors price per finished asset, not per objective.

Remediation content has to teach differently

Routing a failed learner back to the slide they just failed doesn’t work. If the explanation didn’t land the first time, repetition won’t fix it. Each remediation asset should change the approach:

• Core lesson explains the rule → remediation shows worked examples
• Core lesson shows a demo → remediation gives guided practice with feedback
• Core lesson is abstract → remediation is a concrete case from the actual job

Not every objective needs every variant

The matrix above has empty cells on purpose, and deciding where to spend is the whole exercise:

• High job risk + high failure rate → build the full column set, including a second-failure path
• High risk + low failure rate → core plus one remediation
• Low risk → core only, and let it run linear

Ask the SME which objectives people actually get wrong, or pull the failure data from existing courses.

Reuse before you author

Before you fill a cell, check what already exists. Job aids, recorded SME sessions, old course versions, support documentation, and internal knowledge-base articles are frequently good enough as remediation assets with light editing, and realistically this cuts 20 to 30% off the matrix for most corporate teams. Where the source material is trapped in dated formats, legacy content conversion services can turn it into usable remediation assets faster than authoring from scratch.

Step 4: Write the adaptive rules

Every rule has four parts: IF [trigger] AND [condition] THEN [action] THEN [next check].

Write it in plain language. The point is that a stakeholder, an SME, and a developer can read the same table and agree on what happens.

Rule 9 is the one to notice. Objective 2 is compliance-critical, so it gates: nobody passes without demonstrating it. Objectives 1 and 3 are compensatory, so after a final failure the learner continues with a flag. That distinction is a business decision, not a technical one, and it should be visible in the table.

The branching map

[INSERT BRANCHING MAP IMAGE: the same 13 rules drawn as a flow diagram — diagnostic at the top, three objective clusters, pass paths on the right, remediation loops on the left, the gate on Objective 2 as a stop node, terminal task at the bottom.]

The map and the table are the same information in two forms. The table is for building and QA. The map is for stakeholder review, because a diagram is the only way most people will spot that a path goes nowhere.

Rule hygiene: six checks

Run every rule set through these before you build:

1. Every path terminates. No learner can reach a state with no next action.
2. No orphaned content. Every asset in your matrix is reachable by at least one rule.
3. The already-competent exit is defined. What does someone who passes everything actually do?
4. Second failure is handled. Never loop the same remediation twice. Escalate to a different asset or to a human.
5. Loops have a ceiling. Cap attempts. Infinite retry is the most common live bug in adaptive builds.
6. Conditions are mutually exclusive. No score can satisfy two rules at once: ≥ 2 and < 2, not ≥ 2 and ≤ 2.

Write the feedback, not just the routing

Routing without explanation feels arbitrary, so each branch needs a line of learner-facing text: “You’ve already demonstrated this, skipping ahead,” or “Let’s look at this one a different way.” Add a column to the rule table for it. Learners who don’t understand why the course is moving them around report adaptive courses as broken.

Then test it as a human

Before anyone builds anything, walk three fictional learners through the table on paper: an expert who passes everything, a novice who fails everything, and a mixed learner who passes two objectives and fails one twice. If any of them hits a dead end, an infinite loop, or content that doesn’t exist, you’ve caught it at the cheapest possible moment.

Step 5: Choose the tech

Take your rule table to the tool, not the tool to your design. Three questions answer this entire section:

1. Can it store a per-objective score across the course?
2. Can it branch on that score conditionally?
3. Can it report which branch each learner took?

If yes to all three, it can run your course. Most vendor evaluation is people asking question four — does it say adaptive on the box — which is not the same thing.

Tier 1: authoring tool variables

Storyline-class tools handle this natively: number variables per objective, conditional triggers, jump-to-slide actions. This covers pre-test-out and remediation loops completely, which is models 1 and 2. Not every product on the best elearning authoring tools list supports variables at this depth, so check against the three questions above before you commit.

• Costs you: nothing extra if you already license it. If you’re standardized on Articulate elearning, this tier costs you nothing but authoring hours.
• Limits: logic lives inside one published file, so cross-course adaptivity isn’t possible and rule changes mean a republish.
• Best for: single modules, teams already using the tool, and your first adaptive build.

Tier 2: LMS-native features

Prerequisites, learning paths, completion rules, and mastery scores. The LMS routes between courses rather than within them, which suits mastery gating across a curriculum.

• Costs you: nothing, it’s already in the licence.
• Limits: granularity. Most LMSs branch at course or module level, so you may need to break objectives into separate SCORM packages — see how to create SCORM content if you’re packaging objectives individually — which gets ugly fast beyond about five. Support for mastery scores and prerequisite chains varies widely, so check your platform against the best LMS for training companies before assuming the routing is there.
• Best for: curriculum-level gating, prerequisite chains, compliance sequencing.

Tier 3: dedicated adaptive platforms

Purpose-built engines with objective-level tracking, item banks, spaced repetition, and in some cases algorithmic sequencing rather than authored rules.

• Costs you: a real licence, plus content migration, plus a content library big enough to justify it.
• Limits: you’re buying a system, not a feature.
• Best for: large audiences, large content libraries, ongoing programs rather than one-off courses.

What actually forces a platform purchase

• You need adaptivity across many courses, not within one.
• You need to change rules frequently without republishing.
• You have thousands of learners and want algorithmic sequencing.
• You need objective-level mastery reporting the LMS can’t produce.
• Your content library is large, and already modular and tagged.

None of these apply to a first adaptive module. If you’re building your first one, build it in what you already have.

Step 6: Pilot, read the data, and fix the rules

An adaptive course is a set of predictions about who knows what, where people struggle, and how much re-teaching they need. Some of those predictions will be wrong. The pilot is what turns your rules from guesswork into a calibrated system.

Pilot properly

• 20 to 30 learners minimum. Below that, one unusual learner distorts every rate you’re reading.
• Deliberately mixed. Recruit known experts, known novices, and the middle. If your pilot group is all new hires, you’ll never find out whether the test-out path works.
• Two weeks of real conditions. Not a room full of people you’re watching.

Run all three of your paper personas from Step 4 as real learners before launch.

The four numbers that actually matter

1. Test-out rate per objective. What share skipped this objective entirely? Above ~60%, most people already knew it, so cut the content or drop the objective from the diagnostic. Below ~5%, nobody’s skipping, so the adaptive logic is costing you build effort for nothing — make it linear.

2. Remediation trigger rate per objective. What share failed the first check and got routed? Above ~50%, fix the lesson before touching any rules, because remediation shouldn’t be the primary path. Near 0%, the check is too easy and passing it proves nothing.

3. Second-failure rate. Of those who got remediation, how many still failed? A high second-failure rate means your remediation asset is repeating the original explanation instead of changing approach.

4. Time-to-completion spread. Fastest versus slowest learner. A narrow spread means the course isn’t actually adapting. An adaptive course should produce a wide, deliberate spread.

The diagnostic-quality check

One extra analysis worth doing: compare diagnostic results against the terminal task. If people who tested out of an objective then fail the final performance task on that same objective, your diagnostic is producing false positives, usually from too few items or recall questions standing in for application.

What to change, in order

When something’s off, the fix order matters, because most teams reach for the thresholds first and that’s the least likely cause.

1. Content. High trigger or second-failure rates are content problems.
2. Items. False positives and near-zero trigger rates are assessment problems.
3. Thresholds. Adjust cut scores last, and only when items and content are sound.

Moving a cut score to make a number look better is how adaptive courses quietly become linear ones.

When adaptive isn’t worth building

Adaptive design is a cost multiplier, not a quality upgrade. These are the situations where it will not repay the build.

Small cohorts. Below roughly 100 learners, the hours you save them will not cover the hours you spend authoring variants. Build it linear and spend the difference on making the linear version good.

A homogenous audience. Adaptive earns its keep on variance. If everyone arrives with the same prior knowledge, your test-out rate will sit near zero and you’ll have built branching nobody uses.

Content that changes quarterly. Every update means revisiting the diagnostic, the variants, and the rules. Volatile content plus adaptive design is a maintenance burden most teams underestimate at build time and abandon within a year.

Short courses. Under about 30 minutes, there isn’t enough content to skip. A five-question diagnostic to save someone eight minutes is a worse experience than just letting them click through.

No assessment data to route on. If the objectives can’t be measured reliably — attitudes, culture, awareness content — there’s no trustworthy signal to branch on, and the course will route people on noise.

Regulatory coverage requirements. Some mandatory training carries a legal requirement that every learner sees every item, which is incompatible with letting people test out. Confirm what your regulator or legal team requires before designing a skip path into compliance content.

Start with one module

You don’t need a platform, budget approval, or a full curriculum redesign to build your first adaptive course. You need one module, five clear objectives, and a rule table you’ve tested on paper.

Build that, pilot it with 30 people, and read the four numbers. You’ll learn more about whether adaptive is right for your organization than any vendor demo will tell you. Pair those numbers with your elearning ROI baseline before you scale the model past one module. The teams who succeed at this aren’t the ones who bought the best tool — they’re the ones who wrote the clearest rules.