For instructional designers, creating branching scenarios can be an effective training method that allows learners to practice making decisions relevant to their jobs. On the other hand, it is easy to get overwhelmed when planning and designing even the most straightforward branching structures.
After as few as three decision points are presented to a learner, a scenario's branching structure can become nearly impossible to manage.
For example, if the first decision point offers three choices. Then each of those three choices has three more options, followed by each of those choices having three more. Before you know it, a branching scenario would have at least 40 screens.
While inexpensive or free tools like Twine can help organize branching structures, scenarios can still grow unwieldy.
In this episode of Insider Training, Learning Experience Design (LXD) Consultant Christy Tucker offers another way to reduce complexity by differentiating three types of branching structures and when it's best to use them.
Want to learn more from other industry experts? Check back every Wednesday for the latest episode of Insider Training, our exclusive quick skills video series.
For the complete story, join us live! Don't miss any of the fantastic speakers we have lined up for our upcoming webinars and events.
Speaker: Christy Tucker, Syniad Learning
I want to stop a little bit and think about the branching structures because it affects the complexity of the number of decision points. A decision point is each place in the scenario where the learners make a decision.
The hardest thing about writing multiple choice questions and writing branching scenario questions is coming up with the wrong answers, coming up with plausible distractors. We can know that if we have one correct choice and two other choices, then that's enough.
Don’t feel like this is a hard and fast rule that you must always make exactly three choices. That’s not what I’m saying. If you're in a situation where realistically, there really are four choices, and that would be what's actually happening, then you should do four.
If there are really only two choices, don't feel obligated to make up a throwaway third choice. But don't feel like you have to try to make four. And having fewer choices greatly reduces the complexity of the branching scenario as you're doing this.
The fastest way to reduce the complexity is to move it from four choices per decision to three choices. I usually generally aim for a good or best choice, a bad choice, and an okay choice. That's not a rigid thing, but that's sort of where I think.
Branching Structure #1: Time Cave
Let's look at an example of this. This is sort of what people often start with for a branching structure. This one's called a Time Cave. If I take this, I’m going to get my pen here. If we start here at the starting point at the top, I make one choice, green is good, yellow is okay, red is bad. I’d make one choice, two choices, three choices.
The learner has only made three choices here, but this is already 40 slides or screens. If I want to have a fourth decision, because this increases exponentially, that'll be 81 more screens to build.
Which is why by necessity, if you do this structure, you are generally limited to a maximum of three decisions in each path. It's very broad. You have many, many alternative endings, but it's not very deep.
It doesn't do well for showing a longer process or a change in a character. You can use this structure if it's really short, but I have seen people get stuck in branching scenarios because this is what they think a branching structure is always supposed to look like.
Branching Structure #2: Branch & Bottleneck
Now let's talk about some other options. This one's called a branch and bottleneck scenario.
This has these bottlenecks where it branches out for a while, but then it comes back. And no matter which one you've done, you come back to a bottleneck. Sometimes you might use some variables and states to control.
There are some variations, even though there are more branches here. But it can be this. In this case, this is 39 screens or slides or passages, but it is six decisions deep.
Here's the first decision, let's say. We go here, one decision, two decisions, and then we're going to come back to the bottleneck.
Three, four, back to the bottleneck. Five, six. You can see that in the path. Now the path is twice as deep. The learners are making twice as many decisions, and there's no more build time required than what I showed you with the Time Cave.
You can go much deeper; you can show a longer process. This is also great if you've got maybe two options that could be done in either order and then once you finish the first one, you're going to backtrack to do the other one.
I was helping somebody build a scenario where they needed to either do a thing or they needed to go report a problem. The answer was that they had to do both of those things, and really, it could be done in either order.
We had to figure out how to do that and get a bottleneck for them to go to where, if they hadn't done the other thing, it'd loop them back to the other choice, and then they'd go through that little branch.
We've got a couple of branches. This sort of structure also works really well if you have a series of smaller decisions, such as troubleshooting or customer service, or maybe it'll be one smaller scenario for one customer, and you resolve it. Then you're back to a bottleneck, and then you do another thing for another customer.
Branching Structure #3: Cut Scenes
Another way to reduce the complexity is doing some cut scenes. If there are some places where you just need to move some dialogue forward and they don't need to do decisions, just show some dialogue.
Have it be passive for a little bit and either watch an animated video or click through the conversation or something. Don't try and make a decision for every single line of dialogue. That also can cut your complexity.