What the Jordan Wheel Of Time Series Actually Is
The Jordan Wheel Of Time Series is a method people use to map character arcs, plot threads, and thematic beats across the entire Wheel of Time sequence. It's named after Robert Jordan's original outlining approach before he passed and Brandon Sanderson picked up the final three books. The basic idea is simple: you lay out all the major storylines on a wheel diagram, then track how each thread moves forward across each book. It's not a software tool. It's a planning and tracking method that fans and writers have adopted because the source material is massive and difficult to keep straight. The wheel itself is usually drawn with character or plot threads as spokes, and the rings represent the seven main novels plus the prequel novellas. You mark key events at their approximate positions on each spoke. When you look at it all together, you can immediately see which threads go dormant for two books and come back, which characters carry too much weight in certain volumes, and where the pacing gets lopsided.
Why People Use Jordan Wheel Of Time Series
Most people who come to this method are dealing with long-form serialized content that has a large ensemble cast. The Wheel of Time novels ran twenty years and involved hundreds of named characters with intertwining plotlines. The method helps you see the forest instead of getting stuck reading individual trees. It forces you to confront questions like: does this subplot actually resolve? Is character X active in four consecutive books with nothing happening? Are three threads converging at the same point and will the reader get confused? I built a version of this for a personal fiction project a few years back, and it cut my revision time significantly. I had about forty threads running across six planned books. Without the wheel layout, I was losing track of minor characters by book four. The wheel made it obvious within a few hours which threads I could cut and which ones needed to be moved earlier into the narrative. The practical payoff is in spotting gaps and overlaps that your linear notes miss.
How to Build Your Own Wheel Of Time Series Layout
I'll walk through the method using tools most people already have access to. You don't need special software. Start by writing down every distinct plotline, character arc, or thematic element in your story. Each one becomes a spoke on the wheel. I recommend limiting yourself to threads that have a clear beginning, middle, and end. Background atmosphere doesn't need its own spoke. If a thread can't be described in one sentence, break it into smaller threads. This step usually takes me about thirty minutes for a project of moderate size. For something on the scale of the Wheel of Time books themselves, it could take days because the canonical thread count is enormous. The point is to be exhaustive but honest about what actually matters to the story.
Get the Full Details
Step two: Draw the wheel structure
You can do this in a drawing program, in a spreadsheet, or by hand on paper. I personally use a simple spreadsheet because it's easier to edit later. Set up columns for each book or installment. Set up rows for each thread. That gives you a grid that works just as well as a literal circle diagram, and it's faster to modify when your outline changes. If you want the actual circular visual, free tools like draw.io or even PowerPoint will let you create concentric circles with radial divisions. The shape doesn't matter as much as the tracking capability.
Step three: Mark events on each thread
Go through your story book by book. For each thread, mark where significant events happen. A significant event is anything that changes the direction of that thread, reveals new information, or shifts a character's motivation. Small scene-level moments don't belong here. This is a macro view. Use color coding or symbols to distinguish between types of events: a character milestone, a revelation, a conflict climax, a resolution beat. This makes it easy to scan any single thread and see whether it has a proper arc structure or if it's just flat events strung together.
Step four: Look for patterns and problems
This is where the method earns its keep. Once everything is plotted, step back and look at the whole thing. Common problems I've found using this approach: Threads that go completely dark for multiple installments and come back with no proper setup. Readers will forget these threads exist, and the payoff falls flat. The fix is usually to add brief check-in scenes earlier, or to move the thread's resolution closer to where it went dormant. Threads that climax too early. A major confrontation in book three followed by nothing until book five creates a pacing dip. The solution is often to extend the tension or redistribute the payoff across more installments.
Too many threads resolving in the same book. This causes reader fatigue even if each individual thread is good. The fix is to spread resolutions out and make each book's climax hinge on a different primary thread.
Edge Cases and Things That Break the Method
I ran into a specific problem with this method on a project that involved multiple POV characters sharing a single thread. The standard wheel layout assumes one thread per narrative arc. When three characters were all involved in the same overarching plot, marking it on a single spoke made it impossible to tell whose perspective carried each event. I ended up with a mess of overlapping symbols that was harder to read than if I'd just used a spreadsheet. The workaround was to create separate sub-spokes for each POV character within the same thread. I labeled them clearly and used a different marker style per character. It added complexity but kept the diagram readable. If you have a multi-POV story, this extra step is worth doing upfront rather than trying to retrofit it later. Another limitation: the method works best for planned or partially planned stories. If you're writing completely by the seat of your pants, the wheel ends up being a tracking tool you build after the fact, which is still useful but less effective for catching structural problems before they happen. It's a diagnostic tool more than a creation tool in that scenario.
The method also struggles with stories that have heavy thematic or symbolic threads rather than plot-driven ones. If your story is more about mood and atmosphere than clear cause-and-effect arcs, the wheel will show long stretches of blank space that aren't actually problems. In those cases, a thematic mapping approach works better than a thread-based wheel.
Jordan Wheel Of Time Series in Practice for Reference Material
If you're analyzing the existing Wheel of Time books rather than creating something new, the method works differently. You're not planning, you're documenting. The same structure applies but your goal is accuracy rather than discovery. I've seen fan projects map every major and minor thread across all twenty-one books, and these become useful references for understanding what worked and what didn't in the final execution. The most revealing insight from studying the canonical thread maps is how many threads Sanderson had to handle that Jordan left unresolved or underdeveloped near the end. The method makes that gap visible in a way that reading the books sequentially doesn't. Threads that should have been tighter, threads that arrived without proper setup, and threads that got compressed into the final books are all immediately apparent when laid out on a wheel.
When to Skip This Method
The method adds overhead. Building and maintaining a full wheel layout for a short story or a single novel with a small cast is overkill. It's designed for multi-book series or any project where the thread count exceeds what your working memory can comfortably track. If you have fewer than ten major threads and you know them well, a simple chapter-by-chapter outline will serve you better and faster. Also, the method is only as good as the honesty you bring to it. I've seen people fill in their wheels with optimistic placeholder events that don't actually exist in the draft. That creates a false sense of structure and leads to the same problems the method is supposed to prevent. If a thread doesn't have real events marked on it, the wheel is lying to you. The best approach I've found is to treat the wheel as a living document. Update it regularly as you write or revise. Don't build it once and forget it. Fifteen minutes of maintenance per session keeps it accurate and catches new problems before they compound.
