Using Scrivener for Story Continuity: What Works and What Gets Awkward

Scrivener is one of the strongest manuscript management tools available to fiction writers. Its binder, corkboard, outliner, document notes, custom metadata, and scene-level structure make it a natural fit for long novels, scripts, and series.

It also provides several places to store information about a story: document notes, synopsis cards, labels, keywords, metadata fields, and research files.

The harder problem is turning all of that separate information into an answer to a scene-specific question:

What is true at this point in the story?

That question sits in an awkward space between manuscript organization and worldbuilding notes. It is also the problem I am trying to address with Scriptri.

In my own writing, recording a detail somewhere is usually not the difficult part. The difficulty is reconnecting that note to the right point in the manuscript later, especially as both the draft and the surrounding notes become larger and more complicated.

What Scrivener Does Well

Scrivener’s project tree maps naturally to manuscript structure. A folder can hold a chapter, and documents inside it can hold scenes. That setup makes it easy to see the shape of a manuscript, rearrange scenes, and split or merge material as drafting and revision progress.

Scrivener also provides several useful supporting tools:

• Document notes are free-text notes attached to a specific document or scene. They can hold revision reminders, scene intentions, loose ideas, or continuity details.
• Custom metadata lets you add fields such as point of view, location, timeline position, draft status, or subplot.
• Synopsis cards provide a short scene summary that can be viewed on the corkboard or in the outliner.
• The research folder keeps planning documents, reference material, images, and archived webpages in the same project as the manuscript.
• Collections let you group or filter documents based on searches, status, point of view, or other criteria.

Those features are excellent for organizing a manuscript. They can also support a substantial amount of worldbuilding and continuity work, especially when the writer has a consistent system for recording information.

Where Continuity Issues Still Crop Up

Most information in Scrivener is attached to a particular document. A note about scene 14 remains attached to scene 14. You can search for it, open the document, or review it in context, but Scrivener does not automatically gather those notes into a running answer to a question such as:

What does Marcus know at the beginning of chapter 22?

Custom metadata can record part of that answer. You might create a “Character State” field for every scene, for example. But checking the character’s state across the manuscript still requires scanning those fields and reconstructing the answer.

If you need the same answer again later, you may need to repeat much of that search.

A synopsis can also contain continuity details, but the more state it has to hold, the less useful it becomes as a concise summary of the scene.

A synopsis might tell you that Marcus visits Elena in chapter 14. It may not tell you whether Marcus already knows she found the missing key, who currently possesses that key, or whether the injury he received three scenes earlier should still be affecting him.

Scrivener is not failing to do its job here. It is built around documents, manuscript structure, and the information attached to them. The awkwardness appears when you need to reconstruct a changing detail across several documents at once.

Continuity Systems I Have Tried

In my own fiction projects, I have repeatedly built improvised systems for tracking continuity and details that are not stated directly in the manuscript.

Those systems can work. The difficulty is keeping them useful as the manuscript grows or changes shape.

Character Sheet Documents

Keeping a separate document for each important character works well for relatively stable information:

• Age and appearance
• Background
• Family relationships
• Personality
• Role in the story

The document becomes harder to use when it also has to track time-bound changes:

• Injuries
• Secrets
• Possessions
• Shifting loyalties
• Changes in a relationship
• What the character knows at different points in the manuscript

A character’s background may remain stable, while their beliefs, physical state, relationships, and knowledge change repeatedly. Mixing both kinds of information into one long character sheet can make it difficult to determine which details are currently true.

Running Worldbuilding Documents

I also tend to combine character information with larger worldbuilding documents.

These can evolve into long records of background lore, relationships, institutions, systems, history, and any other information I need while drafting. In some projects, my notes have grown almost as complicated as the manuscript itself.

The problem is not only the amount of information. It is also the connection between the two documents. When the manuscript changes, the worldbuilding notes may need to change with it. Maintaining both has occasionally caused me to preserve an outdated fact in one place after revising it in the other.

Keywords as Tags

Scrivener keywords can identify which characters, places, objects, or subplots appear in a scene. That makes them useful for searching and filtering.

A keyword can tell you that Marcus appears in a scene. It cannot, by itself, tell you what Marcus knows, what condition he is in, or what has changed for him by the end of it.

Spreadsheets Alongside Scrivener

Another technique I have heard suggested, but have not personally used for my fiction, is a spreadsheet that records character state scene by scene.

At a basic level, Scriptri is designed to organize some of the same information.

The difficulty is that a spreadsheet leaves the writer responsible for designing the data model in advance. You have to decide which columns matter, how changing information should be represented, and how the spreadsheet will stay synchronized when scenes move, merge, or disappear.

A sophisticated spreadsheet can hold a remarkable amount of information. But as that information grows, presenting only the state relevant to one particular scene can become cumbersome.

None of these approaches is inherently wrong. The common difficulty is maintenance. The writer must keep the continuity system connected to a manuscript that is still changing.

The Workflow I Am Trying to Build

My answer was not to make Scrivener do a job it was never primarily designed around.

Instead, I began working toward a two-part workflow:

• Scrivener remains where the manuscript is written, structured, revised, compiled, and exported.
• Scriptri holds the semantic connections and changing story information attached to that manuscript.

That can include character knowledge, relationship changes, physical state, object possession, timeline events, locations, continuity flags, and other details that develop across scenes.

The practical difficulty is synchronization.

If the manuscript lives in Scrivener while its connected continuity information lives somewhere else, the second tool needs a way to follow changes in the manuscript without forcing the writer to rebuild the project after every revision.

That is why Scriptri supports both manual Scrivener imports and a connected synchronization workflow.

Importing a Scrivener Project Into Scriptri

Scriptri can import a zipped Scrivener project directly.

In Scrivener, create a zipped backup using:

File → Back Up → Back Up To… Make sure Back up as zip file is selected.

Inside Scriptri, open: Data → Import Scrivener (from zip)

Scriptri reads the project structure, document titles, and manuscript text and creates corresponding scenes inside the Scriptri project.

Once the scenes are imported, you can associate important characters, places, objects, factions, clues, or other entities with them. You can then add notes about what changes during each scene and review that information in manuscript order.

Connecting a Live Scrivener Project

Scriptri also supports connecting directly to a Scrivener project folder in Chrome, Edge, and other Chromium-based browsers.

Open: Data → Connect Scrivener Project

The browser asks you to select the project folder and grants Scriptri read-only access to it. Scriptri can then watch for changes while the application is open.

The connection is one-way. Scriptri reads the Scrivener project, but it does not attempt to write changes back into it.

That limitation is intentional. Because Scriptri is designed to help preserve continuity, I want it to be extremely cautious about modifying a writer’s source manuscript.

What Happens When the Manuscript Changes

With the manual workflow, you can export another zipped Scrivener backup and use Scriptri’s refresh process.

Scriptri compares the new project data with the scenes that were previously imported. It identifies documents that appear to be:

• Changed
• New
• Unchanged
• Missing from the latest import

You can then decide which changes to apply.

With a connected Scrivener project, Scriptri watches for changes while the project is open. Changes it can handle safely are applied automatically. Anything uncertain is sent to the Audit workspace for review.

That includes situations where accepting the Scrivener version could remove entity tags, overwrite text that was also edited inside Scriptri, or require judgment about a missing, duplicated, or renamed document.

The sync process remains deliberately conservative.

Updating an imported scene replaces its manuscript text while preserving the existing Scriptri scene record and its continuity notes. However, the changed text may no longer support all of the entity associations or notes attached to the previous version, so refreshed scenes may still need review.

Scriptri also does not automatically delete a scene simply because it is missing from the latest Scrivener project. A missing document could have been deleted, moved, excluded, or temporarily changed in a way that requires the writer’s judgment.

What This Looks Like During Revision

Imagine that you are revising a mystery novel.

In Scrivener, you move two second-act scenes earlier and add a new confrontation scene. The new scene changes when Elena discovers an important clue, which also changes what she knows during several later conversations.

When Scriptri reads the revised project, it recognizes the existing documents in their new positions, identifies changed documents, and imports the new one. Routine changes can be applied automatically, while anything that could overwrite local edits, remove entity tags, or require judgment is sent to the Audit workspace.

You can then review the affected scenes, restore or update entity associations where necessary, and use Scriptri’s At This Point view to check the information that has accumulated by the new position of each scene.

If Elena now discovers the clue earlier, the continuity notes can be updated where that discovery occurs. The later scenes can then be reviewed against the new sequence without relying entirely on memory or searching through every earlier chapter again.

Does Scrivener Fill the Same Role as Scriptri?

Not entirely, although the two applications overlap in places.

Scrivener can hold a manuscript, research, notes, metadata, and substantial worldbuilding material. Scriptri can also be used for drafting. A short or relatively straightforward project may be perfectly manageable inside Scrivener without another tool.

The difference is where each application begins.

Scrivener is built around creating and organizing the manuscript. I am building Scriptri around connecting that manuscript to the state of its characters, places, objects, and other story elements as they change.

I do not want that distinction to require writers to abandon tools they already trust.

Scriptri can function on its own, but one of my main development goals is to let the manuscript remain in Scrivener while Scriptri provides a connected continuity layer beside it.

The Scrivener connection is the first implementation of that idea.