Revisions

A revision is a specific saved version of a strategy. It captures the strategy logic, settings, and configuration exactly as they existed at the moment that revision was created.

In practice, revisions are the unit you use to test and run strategies in Structure. You do not backtest “a strategy in general” and you do not start “the idea in the abstract”. You backtest a specific revision, and when you run a strategy live, you run a specific revision of it.

Why revisions exist

Structure uses revisions so that strategy development remains traceable over time. As a strategy evolves, you may change thresholds, add filters, modify state transitions, or redesign parts of the graph. If those changes were applied directly to a single mutable strategy definition, it would become much harder to answer basic questions later:

Which logic produced a given backtest?
Which version was live during a specific period?
What changed between one iteration and the next?

Revisions solve that by turning each meaningful version into a distinct object with its own identity and history.

Revisions are immutable

Once a revision has been created, it is treated as immutable. If you want to change the strategy, you create a new revision rather than editing an existing one in place.

This matters for a few reasons:

Backtests stay reproducible because the logic they reference does not silently change later.
Live trading stays auditable because you can identify exactly which revision was running.
Iteration stays clearer because each new revision reflects a deliberate change.

This does not mean your work must be perfectly final before you save it. It means that once a revision becomes a saved version, Structure treats it as a stable reference point.

Draft and saved revisions

When working on a strategy, you may encounter a special Draft revision. Draft is the editable working area where you can adjust the graph and other revision-level settings before creating a saved revision.

This gives you a place to experiment without immediately creating a new version. Once the draft is in a good state and passes validation, you can create a revision from it.

Because saved revisions are immutable, making a meaningful change after that point means returning to a draft-like workflow and creating another revision. If you attempt to edit in a way that conflicts with the current draft state, Structure may warn you that continuing will replace the draft’s work in progress.

What a revision contains

A revision typically includes the parts of the strategy that define how it behaves, such as:

The strategy graph and its calculations.
State definitions and transitions.
Target position logic.
Memory and reusable groups used by the strategy.
Revision-specific settings and parameters.

The exact editing experience is covered in the strategy anatomy pages. At a conceptual level, the key point is that a revision represents one complete, runnable definition of the strategy.

Revision statuses

Each revision has a status that tells you where it is in its lifecycle. Common statuses include:

stopped: the revision exists but is not currently running.
baking: Structure is preparing the revision to run.
running: the revision is live and actively operating.
stopping: the revision is in the process of shutting down.
liquidating: the revision is in a protective mode intended to reduce or close exposure.

These statuses apply to the revision itself, not to the strategy as a whole. This is important because a single strategy can have many revisions, while only one of them may be the live one at a given time.

How revisions relate to strategies

A strategy is the long-lived container for a trading idea. A revision is one version of that idea.

That means:

One strategy can have many revisions over time.
A revision belongs to exactly one strategy.
The strategy can show both its latest revision and its currently running revision, if any.

This separation lets you keep a stable top-level object for the idea while still preserving a history of concrete versions underneath it.

How revisions relate to backtests and live trading

Revisions connect directly to two of the most important workflows in Structure.

First, backtests are tied to specific revisions. This makes results easier to interpret because each backtest points to a fixed version of the strategy.

Second, live runs are also tied to specific revisions. When you start a strategy, Structure is really starting one chosen revision and using that exact definition for live operation.

This is why revisions are such an important concept in the app:

They are the version you compare during research.
They are the version you choose before going live.
They are the version you refer back to when reviewing behavior later.

Practical way to think about revisions

If you are new to Structure, a good mental model is:

A strategy is the ongoing trading idea.
A draft is where you prepare changes.
A revision is a saved, stable version of that idea.
Backtests and live runs always point to a specific revision.

Once that model clicks, many parts of the product become easier to understand.