Flows

A flow is the screens your users see — built in the browser, frozen when you publish, delivered to phones that already have your app.

What a flow is

Screens, the copy on them, and the order they come in. You build it on the canvas and it renders natively on the phone. Your app never asks for a flow by name: it names a placement, and the placement decides which flow comes back.

The draft

Every flow has one draft — the working document you edit. Nothing you do to it reaches a phone. Installs only ever download a published version, so the draft stays yours to change. Where you dragged each screen on the canvas, and which device the console frames the preview at, sit beside the document rather than inside it and are never delivered.

The key

Each flow has a key: lowercase words separated by single hyphens, derived from its name, with a number appended if that key is already taken. Flows and placements share one namespace per project, so a key is never ambiguous.

The five badges

Only Archived is stored on the flow. The other four are read off what placements and tests are currently doing, so they change without anyone editing the flow.

Draft — never published. No install has ever seen it.
Idle — published, but nothing is serving it and no test is measuring it.
In a test — an arm of a placement-level test.
Live — what this placement is handing out right now.
Archived — filed away. Nothing was deleted.

Creating one

New flow asks two things: a name and which placement serves it, then a description of what you want. The placement is picked from the ones you already have — a flow never creates one — and you can leave it blank. A flow with no placement is in your flows list and you can build, preview and publish it; no install can ask for it until a lane points at it. That is what you want while you are preparing a flow to test against another one.

If you pick one, the flow joins it as a new lane. If the placement already serves a flow to everyone, the new lane needs an audience, and it is checked before the one that catches everyone.

Changing where a flow is served

Edit, on any row, changes a flow’s name and its placement — attach one to a flow that has none, move it to another, or set it to Nowhere. A flow is served through one placement, so choosing another moves it: the lane it had stops serving it. A placement with nothing in it yet also offers this from the other end, with Add a flow — New flow first, then whatever you already have.

You cannot move a flow while people are actually being served it — while a publish of its placement is live, or while a test is running on it. Take the placement offline or stop the test first; the name can still be changed at any time. Nothing takes effect in your app until you publish the placements involved.

Duplicate, on any row, makes a copy of that flow with no placement. Copy from… does the same for any flow in the workspace and lets you name a placement for the copy. Both copy the flow as everybody sees it: a test running inside the original is not carried over, so two flows can never run one test. The copy is fully independent — its own key, its own draft, its own control group. Editing either afterwards changes nothing about the other.

Publishing

Two channels. Staging is your test builds — safe to publish to at any time. Production is your live app: everyone with the production key gets this. Publishing to production requires the project admin role; staging is open to any editor, so QA on a real device never needs permission.

Publishing freezes the draft as a numbered version and points the channel at it. The gate is stricter than the builder: warnings you can live with while editing — an unfinished screen — are errors here.

Versions and rollback

A version is immutable: devices have already downloaded those bytes and events are attributed to them. To change a release you publish a new version.

Republishing an unchanged draft does not mint a duplicate. If the bytes match the version already at the top of history, the channel is re-pointed at that one instead.

A channel is a pointer. Set live on Production against an older version is rollback, and it is the same operation as publishing — no rebuild, just a pointer, so it is instant and returns the exact bytes installs already hold. Take offline removes the pointer and the channel serves nothing.

To change what a published version says, open it and press Copy to draft. That replaces the draft with a copy of the frozen document, and the copy is what you edit. It is the only route from a published version back into editing, and it is refused while a test on this flow is running.

Screen tests

A flow can carry screen tests — arms that swap one screen inside it, configured on the flow itself. These are separate from the whole-flow tests a placement runs across its lanes; only the latter earns a flow the In a test badge. Each published version freezes the plan it ships with, which is why publishing a change to a running test stops and asks: Keep going keeps everyone on the version they were shown, and Start over re-draws everybody while the results so far stay under the old period.

Archive, not delete

Archiving stores one date and removes nothing itself — versions and results survive, and Show archivedbrings the flow back into view. Raw event rows are subject to the platform's data-retention period; summarised results and purchase records are kept. It is refused while a placement is serving the flow on any channel, and while a running test names it as an arm: a flow hidden from every list while installs are still being handed it is a lie by omission.

A flow is served through a placement, to the people an audience qualifies, and judged by the metrics your project defines. The SDK page covers the keys and the calls that ask for one.