Game Masters of tabletop roleplaying games have to create a story that works well, and that can often be difficult not only because a story has to be engaging, but because it’s difficult to keep track of the way in which a story will unfold; it’s easy to forget about some minor elements, or conflate them too heavily with the main plot, and wind up coming to a screeching halt. One great way to handle this is to think of each plot as a thread; it develops from the previous events in sequence, but will eventually be brought to fruition by the players’ actions.

The way I handle this at my table is to use a system of nodes: I plan for a handful of immediate outcomes for each of my narrative threads (unless they are very simple sub-plots), as well as the “finale” for each thread; some threads are essentially continuous across broad swathes of a campaign, but even long threads end at some point and are replaced by another. Because I further like to separate things, I tend to recognize a distinction between major threads (my main plot) and minor threads (side plots), as well as major nodes (the central conflict for a session) and minor nodes (individual actions that the players might undertake).

It is important to consider that each node represents a point where one of four things can happen: a Fail Stop, Fail Forward, Succeed Forward, or Succeed Stop outcome.

Fail Stop is the most dangerous type of outcome: it should only be used for crushing defeats or minor sub-plots that won’t matter (or have to be returned to later). As with the other outcome types, however, Fail Stop nodes are important. Without them there is a high risk of running into a campaign where the players are discouraged to use lateral thinking, and they also provide an opportunity for players to prove themselves; if the players fail, they have to do without whatever reward they would have reaped.

Fail Forward outcomes are simple to integrate; the players lose some resource or are forced to take an alternate path to their desired outcome, but the plot does not change substantially. Fail Forward outcomes are easy, and can also add to dramatic tension or conflicts, but do have the disadvantage of mitigating the effects of success if they are too inconsequential. Fail Forward outcomes are good for subtly influencing the plot; if players go off-rails or pursue wild goose chases and you can’t figure out a solid way to continue the plot with the direction they have taken, you can simply nudge them back toward a path you are prepared for.

Fail Forward plots don’t always have to continue immediately. A character could fail an attempt to rise in the ranks, but be recognized as a candidate for promotion in the future; giving a gap between when you deal with threads can be a great way to plan some additional elements to a thread to have a satisfying conclusion.

Succeed Forward outcomes are common, but it’s important to remember that it’s important to keep another step ahead. Simply having a success complete an objective is good, but having some goal for the direction of the story is important: the outpost receives supplies, then it comes under attack. If you only have one major thread running, you want to make sure that the current node and the node that follows it will be Succeed Forward until you can pass the narrative along to another major thread. Succeed Forward nodes are how you keep the plot moving along the intended path.

Succeed Stop outcomes are appropriate for minor threads, as characters simply complete whatever goal they had: if they want to repair a sword that is a family heirloom, you can simply end with the sword being repaired. Of course, you can continue on with that thread, if, say, some unknown magical powers are restored, but you could also end it and pick up with a new minor thread later. Succeed Stop outcomes aren’t necessarily bad, as they are where you are able to work in feelings of accomplishment. They’re the points in the story where everyone can get a good rest and move on to another goal: having one major thread across the entire campaign can work, but giving a number of stops in between threads gives an opportunity for characters to feel like they have advanced.

Each outcome should typically impact only its own thread, although with all elements of storytelling there may be times where events in one plot have repercussions in another, for instance if a major NPC dies.

Note that although a lot of the succeed/fail outcomes can be based on rolls in game, it is just as likely that they can be based upon other narrative elements, such as characters’ behaviors. If the players do something unexpected, it may be as well to write a thread off as a Fail Stop and continue with plots they have expressed more interest in, resolving the plot elements later.

The reason I use thread-based design when I plan my sessions is because it allows for an easy visual representation of plots; traditional plot diagrams are a bit simpler, but don’t necessarily have the same degree of complexity or responsiveness that you would want in a roleplaying game campaign.  Further, you can take a thread and let it sit out for a while; you choose which threads to bring into a session while planning the session, and you don’t have to always worry about it; the fact that the vast majority of threads are linear means that you don’t have a lot of bookkeeping to worry about, but you can have really fluid and living events in the mix.

In addition, the nice thing about threads is that you can plan for the final node in a thread and begin working backward; by placing nodes right into the campaign’s current state, you can give players easy access to things that you want them to be able to achieve, allowing you to give them predicted outcomes (which allow you to then focus on creating NPCs and interesting setting elements) without forcing their hands into particular actions and depriving them of agency.

There is an additional advantage to these finite end states, however, which is that you can focus on elements that will allow your campaigns to continue along a “sane” path; by bounding the potential outcomes for players you don’t have to worry about accidentally giving them treasure or advancement (either mechanically through experience points or narratively through ranks) that you didn’t fully think through the consequences of prior to unleashing it.

Examples

There are a couple examples of thread-based writing upcoming. One will look at the major threads of a campaign I’ve been running, and one will look at the way you can apply minor threads to simple design to allow for planning for a large number of player actions. I’d suggest taking a brief break before continuing on, as this has been a longer than usual post already.

Campaign

Let’s look, for instance, at an example of a few major nodes from a Degenesis campaign I’ve been running:

This isn’t actually the full diagram for the plot, and it’s written with the advantage of hindsight; the players are at the Return to Open Bunker stage right now (the chart is in chronological order from the bottom up). I planned a couple more threads that players didn’t follow, and there are a couple sessions of side plot stuff that I’m leaving out for simplicity’s sake.

The main thread of this plot is the characters’ journey from Justitian (the main city of many factions in the setting) to an outpost in the north, which is commanded by a sort of Kurtz figure from Heart of Darkness. They’re officially supposed to be checking to see if he really does need reinforcements, but once they arrive he simply starts barking orders at them and they go along with it; they survived an ambush on the way to the camp and want to settle the score, and they don’t do anything rash and set him off on a plan to murder them.

The main thread actually splits at one point, when the party needs to acquire supplies for the outpost: a loose cannon with no social skills wound up being the one to do the negotiation (nobody was watching him closely enough), and they were forced to steal the supplies. It quickly goes back together,

At this point, they are free to return home, but one of the player characters spots signs of Burn use on the commander, and confronts him in private. This triggers a side-thread, largely involving that one character, where they are again used as envoys, only with a betrayal planned at the hands of the traveling traders they are supposed to be bartering with. One of the player characters dies in a duel, but they manage to escape and return to camp, where the Commander, unwilling to reveal his treachery, sends them home despite his concerns about being reported to his superiors.

Minor Threads in a Single Challenge

Let’s look at the concept of a locked, trapped chest with treasure inside. There’s actually a ton of options for what your characters could do, but you really have two outcome states; a Succeed Stop where the players get the treasure, and a Failure Stop where the players get nothing of value.

You can then plan back to what courses of actions lead to either outcome. Opening the chest requires the lock to be picked, but if the trap is not disarmed then the treasure is destroyed by an acid spray that also harms the players’ characters. If the trap is disarmed but the lock proves too difficult, the players have hit a fail stop condition: bashing the chest destroys the fragile contents, and the characters are left with some tattered parchments that were magical scrolls (note that as a GM, you can invoke Schrodinger’s Treasure and have the durability of the contents of the chest differ between success and failure). Creative methods, such as sawing slowly through the chest’s mechanisms, result in reaching the Succeed Stop node and getting the treasure reward.

Because you have the threads planned for, you can create both highly traditional encounters (disarm the trap, unlock the chest, receive the loot), but use reverse design to quickly accommodate players’ unexpected actions.