Scenario-Based Learning: The Complete Guide
By Devlin Peck · Updated
Part of the eLearning Design & Development guide
Scenario-based learning is a training approach that puts learners inside a realistic situation where they make decisions and experience the consequences. Instead of memorizing information, they practice judgment.
I've been in instructional design for nearly a decade, and scenario-based learning has been my signature approach for most of that time. I've taught thousands of instructional designers to build scenario-based projects, and back when I freelanced for clients, scenario work was how I justified higher rates: it was simply more engaging and more effective than the infodump eLearning most vendors were shipping.
This guide covers the whole discipline: what scenario-based learning is, why it works, when to use it, and when not to. I also dive into my step-by-step design process, share real examples and tools, and discuss where AI is taking the format.
What Is Scenario-Based Learning?
Scenario-based learning (SBL) is an instructional approach where learners work through a realistic story, make choices at decision points, and see the outcomes of those choices. Every good scenario has three ingredients: a challenge (a realistic situation that demands a decision), a choice (plausible options, not one obvious answer and two jokes), and a consequence (what actually happens as a result).
I've long described the best scenario-based experiences as choose-your-own-adventure books for the workplace: you go in, experience things for yourself, make your own choices, and forge your own path. That active decision-making is the whole point.
It helps to know that "scenario-based learning" is an umbrella term. Christy Tucker, who writes extensively on the topic, frames it as a spectrum that runs from a single-question mini scenario all the way up to full simulations. Ruth Colvin Clark's book Scenario-Based e-Learning: Evidence-Based Guidelines for Online Workforce Learning (Wiley, 2013, written with Richard E. Mayer) is the authoritative book-length treatment, and it defines the format around the same core: a job-realistic challenge, learner control over decisions, and feedback through consequences.
The four levels of scenario complexity
Scenarios scale from a single multiple-choice question wrapped in a story to an open-ended AI conversation. Here's the spectrum we'll keep returning to:
| Format | What it looks like | Build effort | Typical tools | Best for |
|---|---|---|---|---|
| Mini scenario | One realistic situation, one decision, immediate consequence | Hours | Rise, quiz tools, even Google Forms | Adding practice to any course fast |
| Branching scenario | Multiple decision points; paths diverge and converge based on choices | Days to weeks | Storyline 360, Twine | Multi-step judgment and conversations |
| Gamified / immersive scenario | Branching plus scores, characters, environments, and stakes | Weeks | Storyline 360 | High-engagement flagship experiences |
| AI role-play simulation | Open conversation; the learner responds in their own words and the scenario talks back | Minutes to hours per sim | devlin.ai and similar conversation-sim tools | Realistic conversation practice at scale |
The right level depends on the skill, the stakes, and your constraints. The rest of this guide (plus the format picker below) helps you choose.
Why Does Scenario-Based Learning Work?
Scenario-based learning works because people learn to make decisions by making decisions, with feedback and without real-world risk. A slide full of bullet points can tell someone what good judgment looks like. A scenario makes them actually practice it.
The theory backs this up. SBL is grounded in situated learning theory, developed in 1991 by Jean Lave and Etienne Wenger, which holds that learning sticks best when it happens in the same authentic context where it will be applied. Ohio State's ASC Office of Distance Education published a well-sourced overview of scenario-based learning that cites two studies worth knowing: a 2021 study where student teachers who completed an SBL activity with expert feedback showed a significant positive effect on classroom readiness and self-efficacy, and a 2016-2017 study where 248 first-year chemical engineering students used online SBL to build transferable skills, with a large majority reporting the approach helped bridge the gap between school and industry.
You'll often see a claim floating around that scenarios boost retention by some specific percentage. I'd rather point you to named studies like the ones above than repeat a number nobody can trace to a primary source.
Here's my own small proof story. My first instructional design job, early in my career, was nothing special: I was building company training in Google Slides with subject matter experts. No industry-standard tools, nothing interactive. I bought Julie Dirksen's Design for How People Learn, started applying its advice, and worked scenario-based learning and character avatars into those humble slide decks. I got promoted to team lead. The tools didn't change, but my approach did.
How Is Scenario-Based Learning Different From Problem-Based and Case-Based Learning?
Scenario-based learning gives an individual learner a guided narrative with immediate consequences. Problem-based and case-based learning typically give groups an open-ended problem or a real case to analyze, with instructor facilitation and delayed feedback.
Ohio State's overview draws the core distinction well: what separates SBL from its academic cousins is the scale of the activity and the immediacy of the feedback. Here's the practical breakdown:
| Approach | How it works | Individual or group | Feedback timing | Typical duration | Best fit |
|---|---|---|---|---|---|
| Scenario-based learning | Learner moves through a realistic narrative, making choices with visible consequences | Individual (usually) | Immediate, built into the story | Minutes to an hour | Workplace training, self-paced eLearning |
| Problem-based learning | Groups tackle an open-ended, ill-structured problem over time | Group | Delayed, instructor-facilitated | Days to weeks | Higher education, cohort programs |
| Case-based learning | Learners analyze a real or realistic case that has already played out | Group or individual | Delayed, discussion-driven | One or more sessions | Professional education (law, medicine, business) |
| Simulation | High-fidelity recreation of a task or environment | Individual (usually) | Immediate | Varies | Procedures, equipment, high-stakes conversation practice |
One common confusion: is a simulation the same thing as scenario-based learning? Not exactly. A simulation is one delivery format on the SBL spectrum (the high-fidelity end of it). Every simulation is scenario-based; not every scenario is a full simulation.
When Should You Use Scenario-Based Learning?
Use scenario-based learning when people need to practice decisions or conversations where mistakes are costly. Skip it when the real gap is missing information or a broken process, because no scenario will fix those.
This is where action mapping earns its keep as a diagnostic, not just a design method. Before you build anything, ask why people aren't performing. If the root cause is a knowledge gap, a job aid they can reference in the moment beats a scenario they complete once. If the root cause is environmental (broken tools, bad incentives, unclear ownership), then no training of any kind will fix it.
Elucidat's when-to-use criteria are a useful gut check here, and they match my experience: scenarios shine when motivation is low, when the content is dry or complex, when the topic is sensitive, and when there's no single right answer. Ruth Colvin Clark adds the strongest criterion of all: use scenarios when mistakes on the job are expensive and you need a safe place to fail.
| The situation | Is SBL the right call? | What to build instead (or alongside) |
|---|---|---|
| Decision and judgment skills (triage, prioritization, escalation) | Yes, ideal | Nothing; this is the sweet spot |
| High-stakes conversations (sales objections, difficult feedback, de-escalation) | Yes, ideal | Consider AI role-play for open-ended practice |
| Dry compliance content people must apply | Yes, as applied practice | Pair with a plain-language policy summary |
| Pure knowledge gap (codes, specs, lookup facts) | No | A job aid or searchable reference |
| Environment or process problem (broken tools, bad incentives) | No | Fix the environment; training can't patch it |
Not sure which format fits your project? Answer a few questions and get a recommendation, including the "build a job aid instead" answer when that's what your situation calls for:
Answer six questions about your training problem. I will rank the guide's five formats against your constraints, including the honest answer that you may not need a scenario at all.
How Do You Design Scenario-Based Learning? (Step by Step)
Start from the actions people need to take on the job (action mapping), turn each priority action into a challenge with realistic choices and visible consequences, then write your storyboard, design the visuals, and build. This is the exact process I've taught to thousands of instructional designers, and it sits inside my broader approach to how to design effective eLearning.
I walk through this entire pipeline, from action map to finished simulation, in this video:
Action map the performance problem (don't outline content)
Action mapping is Cathy Moore's design method, and it's the lens I use for every scenario project. Her four steps: identify the business goal, identify what people need to do to reach it, design practice activities for those actions, and only then identify the minimum information people need to complete the practice.
Notice what's missing: a content outline. You're not organizing information into modules. You're listing observable job behaviors and building practice around the high-priority ones. I've written a full guide to the action mapping process for instructional designers, and my review of Map It by Cathy Moore explains why I consider it probably the number one instructional design book I've read. Not the first ID book you should read, but one of your first few.
Turn priority actions into challenge, choice, and consequence
Each high-priority action becomes a decision point. Write the challenge as a realistic moment on the job, then write the choices. The wrong answers should come from your SME interviews: what mistakes do people actually make? Every option should be plausible enough that a real person might pick it.
Then design the consequence. Show what happens, don't tell the learner they were wrong. One of the best projects I've reviewed was a lab-safety scenario built by a member of our community: when you made an unsafe choice, you saw what actually happens in the lab as a result, rather than getting a "sorry, try again" message from a mentor character. Those visible, memorable consequences are what make mistakes teach.
Write a text-based storyboard first
When I work on scenario-based experiences, I never figure everything out inside the authoring tool. It always starts with a text-based storyboard that nails down exactly what content goes where, plus the programming notes the build will need (variables, branching logic, conditions). Text is cheap to revise; slides are not. Here's my full guide on how to create a storyboard for eLearning.
Design the visuals before you build
Once the storyboard is approved, design the look in a fast prototyping tool, not the authoring tool. For years I did all my visual design in Adobe XD because it was so quick for prototyping and iterating. As of mid-2026, Adobe no longer sells XD to new customers, so Figma is the modern equivalent (and it's free to start). Get the visual system right there, then production in the authoring tool becomes assembly instead of exploration.
Develop, test, and iterate
Build one representative scene first: one challenge, its choices, and its consequences. Put it in front of real users and your stakeholders. Fix what confuses people, then scale the pattern across the rest of the map. Prototyping one scene before building forty is the cheapest quality insurance in this entire process.
Show learners the real-world consequences of their choices instead of having a mentor character tell them they got it wrong.
How Do You Structure a Branching Scenario?
Most branching scenarios need only a shallow structure: a handful of decision points with paths that converge back together, not an exponential tree. This section covers the essentials; branching design is deep enough to deserve its own full guide.
Three structural patterns cover almost every project:
- Linear with feedback. One main path. Each choice triggers a consequence, then the story continues. Easiest to build and still far better than a quiz.
- Limited branching with converging paths. Choices send learners down different short paths that merge back at the next decision point. This is the workhorse structure: it feels open while staying buildable.
- Open branching. Paths genuinely diverge toward different endings. Powerful, expensive, and rarely necessary.
One craft habit that has saved me hours in Storyline: give each question its own slide and branch between slides, rather than stacking everything into layers. When you open story view, you can see your entire branching structure laid out visually, which makes debugging and revising dramatically easier.
What Are the Best Scenario-Based Learning Examples?
If you only look at three, make them Shady Sam, the Uber Game, and Lifesaver. Each one teaches through consequences, and each is free to try.
The public classics:
- Shady Sam (Next Gen Personal Finance) puts you in the role of a predatory loan shark. You learn how loan terms hurt borrowers by profiting from them, a brilliant perspective flip.
- The Uber Game (Financial Times) has you drive for a week in the gig economy trying to make rent. It builds empathy and financial understanding through accumulating consequences.
- Lifesaver (Resuscitation Council UK, directed by Martin Percy) teaches CPR through high-pressure interactive video scenarios where your decisions play out in real time.
- Connect with Haji Kamal (designed by Cathy Moore, built by Kinection) is a branching scenario on cross-cultural communication, and a masterclass in plausible choices where no option feels obviously "correct."
I break down what makes each of these work in this video:
Real practitioner projects. Some of my favorite examples come from people building their first flagship projects. For a tour of standout projects, see my roundup of the best scenario-based eLearning examples.
What Tools Do You Need to Build Scenario-Based Learning?
You can build a mini scenario in almost any authoring tool, but branching and immersive scenarios are where Storyline 360 earns its reputation, and AI role-play requires a conversation-simulation tool.
My take on the tool question hasn't changed much in five years, and if anything it has sharpened: the infodump courses people build in Storyline could be done faster and better in Rise. But scenario-based learning is exactly where Storyline thrives, because it gives you branching, variables, gamification, and immersive full-screen experiences that Rise simply can't match.
| Tool | Scenario type it suits | Learning curve | Cost tier |
|---|---|---|---|
| Storyline 360 | Branching, gamified, and immersive scenarios | Moderate to steep | Premium (Articulate 360 subscription) |
| Rise 360 | Mini scenarios and light branching blocks | Gentle | Included with Articulate 360 |
| Twine | Text-based branching prototypes and full scenarios | Gentle | Free, open source |
| devlin.ai (my product) | AI voice and text role-play simulations | Gentle | Usage-based credits; Starter is $9/month for aspiring IDs and portfolio-builders |
| Slides plus forms (PowerPoint, Google Forms) | Budget mini scenarios and proofs of concept | Gentle | Free or already owned |
On a budget? Twine is excellent for planning and even shipping branching scenarios, and my first scenario work happened in Google Slides. The approach matters more than the tool.
If you want to see a scenario come together in Storyline from a blank slide, I built one on camera:
The workshop recording above walks through the build in Storyline — slides, triggers, variables, and conditions — and if you're still choosing your toolkit, my instructional design software roundup compares the wider market.
How Is AI Changing Scenario-Based Learning?
AI turns scenarios from pre-scripted branches into open conversations: learners respond in their own words, and the scenario talks back.
The limitation of classic branching has always been that every path is hand-authored. You choose from three responses I wrote for you, and the realism ends at my imagination. AI role-play removes that ceiling. The learner speaks or types whatever they would actually say to the customer, the employee, the patient, and an AI character responds in kind. This is the core mechanic behind AI role-play simulations, and knowing when they work (and when they don't) is worth understanding before you build one. Voice is what makes the experience: saying the words out loud to a character that pushes back is a different skill than clicking the best option.
I've been building in this direction for a while, and the earliest public debut was my AI Haunted House workshop, where the learner needs to talk to an AI-powered ghost to make it out of a haunted house. This multi-year journey eventually led me to build an enterprise AI simulation authoring tool for learning teams.
So I'll be transparent about my stake here: devlin.ai is my company. It's an AI text and voice conversation simulation builder: describe a scenario in plain English and get a working simulation that embeds in Storyline, Rise, or any LMS, with AI evaluation, transcripts, and scores reporting back to the course. Simulations run in voice and text across 16 languages, and the Storyline 360 variable bridge lets a sim update variables like score, pass/fail, and character mood, so the AI conversation becomes one more layer inside the experience you already know how to build. It's far faster than hand-authoring a branch tree, but the design thinking (challenge, choice, consequence) is still on you.
Is AI practice as good as a human coach? We could debate that. But the reality I see is that a lot of organizations are using AI role-play, on-demand coaches, and adaptive feedback this way right now, because it helps people practice more deeply and more often while saving significant time and money on human coaching.
If you're an L&D leader thinking about piloting, rollout, and ROI rather than design craft, that conversation lives in my guide to AI training simulations for learning teams. This article stays focused on the designer's side of the work.
How Do You Know if Your Scenario Worked?
Measure decisions, not completions. Track which choices learners make, where they fail first, and whether behavior changes on the job.
In a branching scenario, your variables are your analytics: record each decision, then report the choice data out via xAPI so you can see which wrong answers people actually pick. Those patterns tell you where the real-world confusion lives. In AI simulations, you get richer signals: full conversation transcripts and rubric-based scores show you not just that someone struggled, but how.
For connecting all of this to business results, the Kirkpatrick model of training evaluation is the standard framework: scenario analytics cover learning, but the goal is behavior change and results.
Should Your Portfolio Include a Scenario-Based Project?
Yes. A scenario-based eLearning project is the strongest single piece an aspiring instructional designer can show, because it demonstrates analysis, writing, visual design, and development in one artifact.
The portfolio combination I've recommended for years: a scenario-based eLearning project, a job aid, and a video (animated or screen-recorded). That trio covers the range of deliverables most ID jobs actually require. If you need a topic, sales scenarios are a reliable choice: letting salespeople practice responding to objections or an aggravated customer makes for a solid, relatable portfolio project. And I practiced what I preached: when I restructured my own freelance portfolio years ago, I led with my scenario-based work, because it was the work I wanted to be hired for.
If you want structure and feedback while you build that flagship piece, that's what Peck Academy, my licensed career school for people transitioning into instructional design, is for: students build an AI-integrated flagship project in Storyline 360 with extensive feedback, plus a portfolio website to house it (many host theirs free on devlin.host).
Frequently asked questions
What is an example of scenario-based learning?
A classic example is the Financial Times' Uber Game, where you play a gig-economy driver making financial and personal decisions for a week, with every choice carrying visible consequences. See the examples section above for four public classics plus real practitioner projects.
Is scenario-based learning the same as simulation-based learning?
Not quite. A simulation is the high-fidelity end of the scenario-based learning spectrum. Every simulation is scenario-based, but a scenario can be as simple as one story-framed question with a consequence, which is far lighter than a full simulation.
Do scenarios need a single right answer?
No. The best scenarios often have several defensible options with different realistic consequences, because that's how real judgment works. What matters is that each choice produces feedback the learner can learn from, not that one option is marked "correct."
How long should a branching scenario be?
Most effective branching scenarios run three to six decision points, roughly five to fifteen minutes of learner time. Longer than that, split it into multiple scenarios. Depth of consequence beats length of path: a short scenario with vivid outcomes outperforms a sprawling tree of shallow ones.