Branch and Bottleneck Scenario Structure

One of the challenges of branching scenarios is that you can generate so many options and paths that it quickly becomes unwieldy. A branch and bottleneck scenario structure is one strategy for keeping the complexity manageable.

Branch and Bottleneck Scenario Structure.

Branch and Bottleneck

In a branch and bottleneck structure, you branch into different options for a while, but then all paths return to a single bottleneck. The bottleneck is an event or choice that happens the same in multiple paths. In the example above, there are 39 screens. Most paths have 6 decisions (plus two bottlenecks), although a few shorter paths end in failure.

I learned the terminology “branch and bottleneck” from Sam Kabo Ashwell in his post on Standard Patterns in Choice-Based Games. Although he’s writing about structures for games and interactive fiction, his concepts also apply to branching scenarios for training.

The branch-and-bottleneck structure is most often used to reflect the growth of the player-character: it allows the player to construct a somewhat-distinctive story and/or personality, while still allowing for a manageable plot.

Sam Kabo Ashwell

Ashwell notes that this structure often relies on states to maintain continuity in the narrative. You might track an overall score or adjust another part of the consequences or intrinsic feedback based on earlier choices.

Expanding Choices in Branching (Time Cave)

Contrast the branch and bottleneck structure with what Ashwell calls the time cave. This is the traditional structure for branching. Each choice leads to more choices, with no rejoining or reusing choices. This leads to numerous endings.

Time cave flow chart

In the example above, players make 3 total decisions, but it’s already 40 screens (1+3+9+27). The number of screens in a time cave increases exponentially. To add a fourth decision in the path, you need to add 81 more screens. By necessity, a time cave is generally limited to a maximum of 3 decisions in each path. It’s broad, giving you lots of alternative endings, but it’s not very deep. It doesn’t do well for showing a longer process or change in a character.

When to Use Branch and Bottleneck

Branch and bottleneck is an effective structure if certain key events will drive the plot forward regardless of prior decisions. For example, in my project management scenario, the client will always ask for something more that wasn’t in the original scope, regardless of what decisions you made prior to that point.

It’s also a good structure if you have two options that could be done in either order (where you then backtrack to the other branch after completing one). For example, if you were interviewing an ID, you might want to talk about both their experience working with SMEs and specific tools. The order in which those parts of the conversation is more a matter of preference than necessity.

That structure might look like the image below where the bottlenecks are tagged in blue. In the passage marked “Continue,” users pick one of two paths. Both paths branch out for a while before reaching a bottleneck. They can choose to take the other path (i.e., ask about the other interview topic), or they can continue to the next required decision point.

Example Branch and Bottleneck Structures

In practice, the branch and bottleneck doesn’t usually look as “clean” as my first graphic. I usually reuse some choices. That gives players a chance to correct their mistakes without continuing down the wrong path indefinitely. It doesn’t immediately force them back to the right path or to restart; it lets them learn from the feedback and adjust.

In my client screening branching scenario, I have one major bottleneck near the end, highlighted in yellow (“Tell me about what changed…”). Several other paths are failures that cause a restart. Mostly, the paths cross and converge multiple times as players have the opportunity to correct mistakes and get back to the ideal path.

The ideal path in that scenario is 4 decisions deep. The complete scenario ended up as 20 slides in Storyline, 1/6 of the number of slides it would have taken to use a full time cave structure.

Another example is my project management scenario, which includes three bottlenecks (a new client request, the senior developer getting sick, and a flaw in a component). As you can see, the branching structure has a fair amount of crossed paths and reused passages. This scenario also uses some variables to track previous decisions that affect exactly what you see, even within a single passage.

Managing Complexity

Branching scenarios don’t have to mean letting the options grow indefinitely. Including a bottleneck or two can drastically reduce the number of slides required while still allowing you to create a longer, deeper scenario narrative. You may also use this with other strategies to manage the complexity of branching scenarios.

If you’d like to read more about branching structures and managing the complexity of branching scenarios, check out these posts.

Original published November 5, 2019. Updated October 9, 2025.


Upcoming events

DevLearn

DevLearn Ambassador Christy Tucker. Save $100 with code CHRISTY.

Register for DevLearn by October 2 for the Advanced Rate. Save an extra $100 with code CHRISTY.

Branch Smarter, Not Harder: Naming Conventions, Variables, and Bottlenecks in Storyline

  • November 3, 2026 at 9:20 AM
  • CE01: Storyline & Rise Pro Lab

Cohesive by Design: Generate Consistent AI Icons, Illustrations & Characters

  • November 4, 2026 at 10:00 AM
  • BYOD (Bring Your Own Device)

Buzz Discussion: Video & Media

  • November 4, 2026 at 3:45 PM

11 thoughts on “Branch and Bottleneck Scenario Structure”

  1. Pingback: UX, Accessibility, & More: ID Links 5/24/22 - Experiencing eLearning

  2. Pingback: Time to Create Branching Scenarios - Experiencing eLearning

  3. Pingback: The Power of Story: Highlights from TLDC's Community Day Spring 2021 | Scissortail Creative Services, LLC

  4. Pingback: Video/ computer games – Literature and media Blog

  5. Pingback: How many options in branching scenario decisions? - Experiencing eLearning

  6. Pingback: Short Sims by Clark Aldrich: Book Review - Experiencing eLearning

  7. This is a very useful summary of a very useful structure.

    In procedure training, it’s important to allow the learner to make a catastrophic error, and figure out what went wrong and why (which requires that they have a good working mental model of the system being operated). Then, they can restart and proceed correctly.

    Even better if the system allows them to identify a potentially-catastrophic error state before it becomes actually catastrophic, and correct it.

    The challenge with many programming tools is that they don’t make the branching structure explicit.

    –Corrie Bergeron, M.Ed.

  8. Use variables to track early choices, then collapse back to a linear path. The variables cause branching later in the story. You can also compute a score using the variables. Maybe encourage people to try again, to increase their score.

Leave a Comment

Your email address will not be published. Required fields are marked *