Manual runs
A manual run is a run a person executes in the dashboard — the model Testomat.io’s manual test runs use, taken as it is: the run lists the cases it expects, each gets Passed · Failed · Skipped with a message and, for a case with steps, a mark per step; Finish run closes it. A mixed run is the same report with both halves in it: the manual cases are marked in the dashboard, the automated ones are reported by CI through the reporter, and the verdict counts both.
Nothing new was invented for it. A mark is a result — the same POST /v1/runs/{id}/results a
reporter sends — and a finish is the same finish event. What the feature adds is one right the
reporter does not have: a person who pressed the wrong button corrects the mark in place instead
of sending a second result that would count twice.
Starting one
Section titled “Starting one”Three roads, one dialog:
- From a plan. A plan of kind
manualormixed— Test plans — launched with Launch run expects every case the plan collects at that moment. - From Runs. New run ▾ › Manual run…: all manual cases, or a selection made with the same
filter bar the cases screen has; Run the automated ones by hand too widens it the way a plan’s
asManualdoes. The dialog counts what the run will expect as you narrow it, and will not start a run of nothing. - From the cases tree. Run manually in the bar over a selection, Run manually… in a suite’s or a folder’s ⋯, or Run manually after Clear all in a filtered list’s chips. The run takes the cases as they stand when the dialog opens: a case added to the suite later is not in it. A manual run takes the manual cases; when there are automated ones too, the dialog says how many, and Run the automated ones by hand too takes them as well. A reader sees none of the three.
The dialog then asks for a title — the plan’s, or a name with today’s date, «Manual · 2026-09-17» — an environment and the assignment, and ends with Cancel · Save · Launch.
Above those buttons a bar shows the project’s run quota: Runs in the last 24 hours: 4 of 1000 used,
996 left. Every run opened in the project counts — a reporter’s, the CLI’s, a plan’s, a manual one —
and a run stops counting 24 hours after it was opened. Once the quota is spent, the bar adds New runs
are refused until the oldest ones age out of the 24-hour window. and when the next slot frees, and a
launch is refused with 429 (Quotas). When the quota cannot be read, the bar is
not drawn and the dialog works as usual.
On the wire the two roads without a plan are the start a reporter sends:
POST /v1/runs{ "schemaVersion": 2, "kind": "manual", "title": "Manual · 2026-09-17", "environment": "staging", "configuration": { "expected": [{ "testCaseId": "6f1c2b3a-0000-4000-8000-0000000000c1" }] }, "assignment": "prefer-assignee"}Save or Launch
Section titled “Save or Launch”Launch starts the run now and opens its page. Save creates the run without starting it: the
run is scheduled, and you stay where you were. A notice names the run, with Open the run.
A scheduled run is a list of cases that waits for people:
- On Runs its row says «scheduled · 12 cases» — what it will expect, since nothing has run.
- On its page the head says Not launched yet, and To run says who saved it and when: «Saved by Alex Morgan · 2 hours ago — not launched: nobody marks a case until someone launches the run.» The cases are listed without buttons. Add tests works as on a launched run.
- Launch run stands where Finish run will be. A run that never began cannot be finished
(
409). One nobody wants goes to the Bin: a scheduled run is not under way, so deleting several runs takes it as it takes a finished one.
On the wire, Save is "schedule": true on the same start — POST /v1/runs, or
POST /v1/plans/{id}/launch for a plan. Launch run is an event:
POST /v1/runs/{id}/events{ "event": "launch" }launch on a run already under way changes nothing. A scheduled run also starts without the button:
the first result that reaches it launches it — a reporter that joins it by its key, or one that posts
to it directly.
Who runs what
Section titled “Who runs what”Every launch dialog has an Assignment row — None or Prefer case assignee — and on the wire
that is assignment on POST /v1/runs and on POST /v1/plans/{id}/launch. With
prefer-assignee, the launch copies each expected case’s assignee
into the run:
"configuration": { "expected": [ … ], "assignees": { "6f1c…c1": "6f1c…a2" } }A copy, on purpose: the run holds who was to run what at launch, and a case that changes hands
afterwards does not rewrite a run already under way. Cases nobody held are absent from the map; a
launch with the strategy and nobody assigned anywhere records an empty map — the strategy was used,
there was nobody to copy. none (the default) stores the configuration as it was sent, which for a
reporter’s run is without the map at all.
On the run page the copy is what you see: the person on each «To run» row, prefer case assignee in
the head, and a Mine · n / All · n toggle above the list — «Mine» keeps the rows assigned to the
signed-in person, and the «x of n done» count follows the toggle. The toggle is there only when the
launch made a copy; without one every row would be nobody’s and it would have nothing to say.
GET /v1/runs/{id}/summary carries the same map as run.assignees, null when there is none.
Marking a case
Section titled “Marking a case”While the run is launched, its page has a To run section: every expected case that has no
result yet, in the order the run expected it. One case at a time is open for marking — the first
one waiting, or the one whose name you press — with its timer running and —
- the case’s steps (a manual case with steps): a toggle per step that turns with each click — passed → failed → skipped → blocked → not marked;
- a Message, one line that grows;
- Files — pictures, JSON and text the mark keeps (below);
- Passed · Failed · Skipped — the button is the request. There is no separate Save: a mark with nothing else said is the common case.
Live, or the version tested
Section titled “Live, or the version tested”Under the case’s name a badge says which version of the case the run shows:
| Badge | What the run shows |
|---|---|
| Live | The case as it is now. A case the run holds no result of yet is live: an edit made to it before you mark it is what you mark. |
| Frozen at vN | The case at version N, the one the run’s first result of it was written against. A later edit or revert, the Bin and a restore leave it as it was; (case is now vM) follows when the case has moved on. A manual case’s steps are that version’s. |
| In the Bin | Beside the other: the case was deleted since. The run still shows it. |
| Version not kept | The version tested was not kept, so it cannot be shown — a result from before Plune kept versions, of a case edited since. The steps under it are the live case’s, and the badge says so. |
So the first mark freezes the case for this run: Change on a marked case shows the steps that were
marked, not an edit made after. GET /v1/runs/{id}/cases/{caseId}/content answers the
case as the run shows it — frozen, version, currentVersion, inBin, and snapshot, null when
the version was not kept.
POST /v1/runs/{id}/results{ "results": [ { "resultKey": "manual:6f1c2b3a-0000-4000-8000-0000000000c1", "testCaseId": "6f1c2b3a-0000-4000-8000-0000000000c1", "source": "manual", "status": "failed", "errorContext": "Step 3: the coupon field accepted an expired code.", "steps": [ { "index": 0, "status": "passed" }, { "index": 1, "status": "passed" }, { "index": 2, "status": "failed" } ], "execution": { "startedAt": "2026-09-17T10:02:11.000Z", "finishedAt": "2026-09-17T10:08:41.000Z", "durationMs": 390000 } } ]}| field | |
|---|---|
resultKey | manual:<testCaseId> — unique within the run, so the run holds one mark per case. A second identical mark is a duplicate; a different one is a conflict that names the result already holding the key, and the dashboard patches that one instead. |
source | manual — what tells the platform a person wrote this. A reporter names its runner here. |
status | The three a person gives: passed, failed, skipped. (broken and blocked are the reporter’s.) |
errorContext | The message. Redacted and truncated like a reporter’s error text. |
steps | Up to 200 { index, status } — the step’s position in the case’s steps, from 0, and passed, failed, skipped or blocked. Steps left unmarked are absent. |
files | Up to 30 ids of the files added to the case while it was being marked (below). Absent when there are none. |
execution | The time the case took — the timer’s, or the time typed — as a window that ends at the mark. The same field a reporter fills. |
Accepted, the row collapses: the badge, the step marks as glyphs (✓ ✕ ○ ⊘), how many files it keeps, by kind, who marked it, the time it took, and Change, with the message under them. The counter in the section’s head — «3 of 12 done» — and the run’s own counts come from the platform after each mark, not from the page’s guess.
The timer
Section titled “The timer”The open case’s clock starts as the case opens and runs beside its name — 02:14, past an hour 1:02:14 — with a pause button, Pause the timer. Paused, the row says paused and the button is Resume the timer. Opening another case pauses this one; back on it, the clock runs on, unless you paused it yourself.
- Type the time instead. Press the time: Time spent takes minutes and seconds —
6:30, or6for six minutes. Enter keeps it, Esc goes back. The clock waits while you type, and if it was running, it runs on from the time kept. - The mark stops it. Passed, Failed or Skipped sends the time with the result, as
executionabove. The marked row shows it after who marked it — «6 min 30 s». Change keeps it. - The run adds it up. Once a mark carries a time, the counts line under the cards ends with the sum: «… · 12 in total · 9 min 18 s spent».
- The clock lives in the page. A reload starts the open case’s clock again from zero. A mark already given keeps its time.
Keyboard shortcuts
Section titled “Keyboard shortcuts”A run is walked without the mouse too. Under the list, Keyboard: press ? for the keys; ? opens
Keyboard shortcuts, the list below, and ? again or Close shuts it.
| key | |
|---|---|
P | Mark the open case passed |
F | Mark the open case failed |
S | Mark the open case skipped |
1 – 9 | Turn the mark of step 1–9 of the open case |
M | Go to the message field |
J | Open the next case to run |
K | Open the previous case to run |
? | Show or hide this list |
- The keys act on the open case.
P,FandSare its Passed, Failed and Skipped, with the steps, the message and the files as they stand; while a file is still going up they wait, as the buttons do. A number past the case’s last step does nothing. JandKwalk the cases still to run, in the list’s order — under Mine, the ones it shows.- Keys do not work while you type in a field. In the message,
Pis a letter. Nor do they work while a dialog is open, or with Ctrl, Cmd or Alt held: those belong to the browser. - The key is where it sits on the keyboard, not the letter it types, so another layout keeps the same
keys. Only
?is read as typed. - A screen reader hears what a key did — «Step 2: failed», «Opened: Pay by card».
The keys that mark and walk work while the run is launched and you can mark: a saved run, and a reader, have nothing to mark.
Files on a mark
Section titled “Files on a mark”Under the message of the case being marked is Files: a zone to drop files on, Add files to pick several at once, and a screenshot pasted anywhere on the page — it is named by the moment, «Pasted 13.10.2026 10.12.png». Each file goes up as soon as it is chosen, one after another, as a row with its percent; a row that did not get there says why and has Retry, and a file the page already knows will be refused — too big, or a kind only a bucket keeps — is refused on its row before it is sent.
- The mark takes them. Passed · Failed · Skipped sends the ids of the files in the same request,
as
files; while one is still going up, the marks stay off until it is there. Change does the same with the files added while it was open. - Until the mark, ✕ takes a file back at once. After it, the result keeps what it was marked
with:
DELETE /v1/files/{id}on it answers409. - A case left unmarked loses its files — the night after its run is finished, or a week after they were added if the run stays open.
- What one may be is what a result may hold: without a bucket, a picture (PNG, JPEG, WebP) up to 2 MB and a JSON or text file up to 512 KB; with one, the bucket’s ceilings. 30 files a result. Without a bucket they count against the project’s built-in storage.
- A picture opens in the same window as a result’s screenshots on the run’s page, and a text in the same window as its text files.
On the wire, one request a file, its bytes as the body:
POST /v1/runs/{id}/cases/{caseId}/files?name=fee-twice.pngContent-Type: image/png201 answers the file — id, name, contentType, size, storage, createdAt, createdBy — and the
id goes into the mark’s files. GET on the same path lists the files waiting for the mark, and
what adding one costs (budget). With a bucket the bytes go to it, as a reporter’s do:
POST …/files/uploads signs a link for each, the browser PUTs the file to the bucket, and
POST /v1/files/{id}/complete says it arrived.
Correcting a mark
Section titled “Correcting a mark”Change opens the same editor with the mark as it stands, and the new verdict goes in place:
PATCH /v1/results/{id}{ "status": "passed", "errorContext": null, "steps": [{ "index": 0, "status": "passed" }] }Any of status, errorContext (null clears it), steps (null clears them), subStatus
(below) and files (the ids of files added since — above), at least one. The result keeps its id and its place in the run; outcome
is recomputed from the new status; the change is audited under the run with the status and the
message before and after.
A sub-status
Section titled “A sub-status”A marked row has Sub-status ▾ after its badge: one optional word for why — Product bug, Environment issue, or whatever the project set up under that status in Settings → Statuses (Sub-statuses). The menu opens by itself on the row you have just marked, under the button, or over it when the window has no room for it below. It says what it asks — «Why it failed — optional» — then the built-in names, the project’s own, and No sub-status. A click saves it; Esc or a click elsewhere leaves the result without one.
The menu opens by itself only while the row’s Sub-status ▾ button is fully inside the window. A marked row that lies above or below what the window shows keeps its mark, and its menu stays closed, so the page is not pulled away from the case you mark next. The button is on the row all the same: scroll to it and press it.
- The name stands on the row in place of «Sub-status», and opens the menu again to change or clear it.
- A status with nothing set up has no button.
skippedandbrokenhave no built-in one, so until the project adds its own, their rows have no Sub-status ▾ at all. - A new status starts without one. Change to another status drops the sub-status, since it was the old status’s; the menu opens again on the row, while its button is inside the window. The same status keeps it.
- The name is kept as it was given. A sub-status renamed or removed in Settings afterwards stays on the result, and shows ticked in its menu until another is picked.
- A reader sees the name as a tag on the row, and no button.
On the wire it is the same PATCH as a correction, with the sub-status alone:
{ "subStatus": "Product bug" }null clears it. A name the result’s status does not offer now answers 400 with the ones it does —
‘Test is outdated’ is not a sub-status of passed — it has Minor issue. A closed run keeps its marks, so
its sub-statuses too (409). The mark itself, POST /v1/runs/{id}/results, carries none: the status
button stays the request, and the sub-status follows it.
Adding tests
Section titled “Adding tests”Add tests, beside Launch run or Finish run, takes more cases into a run that is still open — scheduled or launched. Two roads, one at a time:
- Cases — the tree, suite by suite, with a search by the case’s or the suite’s name. A suite’s box takes its cases; a case is ticked on its own. A case the run already holds says in the run and cannot be ticked.
- Plans — several at once. A plan is read when you tick it, and what it matches then is what goes in.
Under both, the dialog says what it will do — «+ 4 cases → «Release regression» · 2 already in it» — and Add 4 cases does it. The cases join the run unmarked, after the ones it expected; with Prefer case assignee, each brings its assignee. A case is never in a run twice: one case, one result. If somebody added the same case a moment before you, the platform skips it and the page says so — «Added 2 cases. 2 already in the run were skipped — one case, one result.»
POST /v1/runs/{id}/cases{ "testCaseIds": ["6f1c2b3a-0000-4000-8000-0000000000c4", "6f1c2b3a-0000-4000-8000-0000000000c5"] }The answer is added, the ids the run now expects, and skipped, each with a reason: in_run —
the run holds the case already, expected or marked — or not_found — no such case in the project, or
it is in the Bin. Up to 10 000 ids a call. Only an open manual or mixed run takes cases: a finished
or terminated run, or an automated one, answers 409; a reader, 403.
The execution switches
Section titled “The execution switches”How a project walks its manual runs is six settings in Settings → General, under Execution: «How a manual run is walked. The server applies these when a mark is saved or a case is opened, so every client behaves the same.» Five are switches, off until someone turns them on; the sixth is a choice, Next case in the run until someone picks another.
| setting | what it does |
|---|---|
| Fast pass | A passed or skipped mark asks for no details. |
| Auto pass | Every step of the case passed makes the case passed. |
| Fail case on step fail | A failed or blocked step makes the case failed. |
| Auto assignee | The first person to open a case nobody holds becomes its assignee. |
| Assignee result lock | Only the assignee can submit or change the result of a case that has one. |
| Redirect after result | Where the run goes after a result is saved: Next case in the run, The same case or Nowhere. |
Plune applies them, not the page: the API takes a mark and decides by the project’s settings, so a script that marks through the API gets the same verdict as the dashboard. Each applies from the next mark or the next case opened, also in runs already under way. They judge a person’s marks only — a reporter’s results stand as the reporter sent them.
An owner or a member changes them; each change is saved at once. A reader sees them and cannot change
them — the API answers 403. If someone saved the settings while you had them open, nothing is saved and the page says «The
settings changed while you were editing them, so nothing was saved. Reload to see the current list, then
repeat your change on it.», with Reload.
Fast pass
Section titled “Fast pass”After a mark, the Sub-status ▾ menu opens by itself on the row, while the row’s button is inside the window. With Fast pass, a Passed or Skipped mark goes without it: the row is marked and the run moves on. The menu is still on the row’s button. A Failed mark opens it as before.
Auto pass
Section titled “Auto pass”With every step of the case marked passed, the case is saved passed, whichever of Passed, Failed or Skipped was pressed. A step left unmarked, or marked anything else, leaves the mark as it was pressed, and so does a case without steps. Only the case’s own steps count.
Fail case on step fail
Section titled “Fail case on step fail”With a step marked failed or blocked, the case is saved failed, whichever button was pressed. A skipped step does not fail it. This switch is looked at before Auto pass, and the two cannot meet: a case with a failed or blocked step does not have every step passed.
Without the switch, a blocked step changes nothing. A blocked case keeps its meaning — something
outside it stopped it (statuses); it is the blocked step that this switch
counts as a failure of its case.
Both step switches judge Change too, when it changes the status or the steps. A corrected message alone leaves the verdict as it was. The marked row shows the status Plune saved.
Auto assignee
Section titled “Auto assignee”The first person to open a case that nobody holds in the run becomes its assignee in this run — on the run page a case opens as soon as it is the first waiting, or when you press its name — and so does the first to mark one. Two people opening it at once cannot both win, and a case that already has an assignee, from Prefer case assignee or from an earlier opening, is never taken over. The name shows on the case’s row.
Assignee result lock
Section titled “Assignee result lock”A case that has an assignee in the run is marked, and its mark changed, by that person alone. Anybody
else is refused, and nothing is written: 409 with code: "assignee_locked" — «case ’…’ is assigned to
someone else - only they can mark it», or for Change, «the case is assigned to someone else - only
they can change its mark». A batch of marks with one such case in it is refused whole. A case nobody
holds is open to everybody, as without the switch.
Redirect after result
Section titled “Redirect after result”- Next case in the run — the next case the run expects that has no result yet opens, and after the last one the first that still waits. With none left, nothing opens.
- The same case — the case just marked stays open: its Change opens on the row.
- Nowhere — nothing opens; press a case’s name to mark the next one.
On the wire the six are executionToggles in the project’s settings:
PATCH /v1/settings{ "executionToggles": { "fastPass": true, "autoPass": false, "failOnStepFail": true, "autoAssignee": true, "assigneeResultLock": false, "redirectAfterResult": "next" }}PATCH /v1/settings replaces the whole document, so send it back as GET /v1/settings gave it, with the
change; absent, all five are off and redirectAfterResult is next (or same, none). The answer to a
person’s mark, POST /v1/runs/{id}/results, says what the switches decided: each item’s resultStatus is
the status saved, and after carries skipDetails — Fast pass — and redirect with its mode and the
testCaseId to open, null for none. Opening a case is POST /v1/runs/{id}/cases/{caseId}/open, which
answers { "assignee", "claimed" } — who holds the case now, and whether this call made you its assignee.
Retest
Section titled “Retest”A case marked already can be sent back to be run again, in the same run, while the run is launched. Each marked row has a box; tick the cases, and Retest 3 in the head sends them back.
- The mark goes to the history. It is not deleted: it stays in the case’s history and no longer counts in the run.
- The case waits. It comes back to To run, after the cases never run, with Awaiting retest on its row. It is in no count of the run and not among the cases not run.
- A new mark ends the wait. Open it and mark it, as any case; the new result is the case’s answer in the run.
- The run does not finish while a case waits. Finish run is refused with
409andcode: "retest_pending", which names the cases that wait — mark them first. Stop run ends a run with a wait in it.
A page opened before the retest may still show the old mark with Change. Changed while the case waits, that mark stays in the history and the case keeps waiting; changed after a new mark arrived, it is the case’s answer again, as of the change.
An automated run that is under way has Retest too, from a box on each result. Its cases wait under Awaiting retest — «These cases wait for the next result of the case from the reporter; the run does not finish until it arrives.» — and the reporter’s next result of the case ends the wait. Owners and members retest; a reader sees no box.
POST /v1/runs/{id}/retest{ "testCaseIds": ["6f1c2b3a-0000-4000-8000-0000000000c1"] }The answer is retested, the cases now waiting, and skipped, each with a reason: no_result — the
run holds no result of it to send back — or awaiting — it waits already. A finished, terminated or saved
run answers 409, as does an eval run. GET /v1/runs/{id}/summary lists the waiting cases as
awaitingRetest.
Finishing
Section titled “Finishing”Finish run sends POST /v1/runs/{id}/events with { "event": "finish" }. With cases still
to run, the dashboard asks first and says how many will stand as not run — «3 of 12 done →
finished · 9 cases not run». With a case awaiting retest, it does not ask: the run is
refused and says which cases wait. Once closed, the To run section is gone, the head is the verdict
of the counts, and the page names what never arrived: «9 expected cases produced no result» —
the run’s notRun, which a reporter’s crashed shard leaves behind in exactly the same way.
Mixed runs
Section titled “Mixed runs”A mixed run — from a plan of that kind, or started as one through POST /v1/runs — has both
halves on one page. The manual cases are in
To run; the automated ones wait below under Waiting for a reporter, with the command that
starts them where your tests run — a terminal or a CI job. The reporter joins the run by its key
(plune run start --key …, or the Playwright reporter’s
PLUNE_RUN) and reports them, and its results take those cases out of both lists. The counts, the
verdict and notRun are one set of numbers over both sources, and Finish closes the run for
both — a reporter that reports afterwards is refused as it is today.
The command with the key
Section titled “The command with the key”The command puts the run’s key in PLUNE_RUN and the run’s automated cases in --grep, with
copy beside it. A run from a plan greps by the plan:
PLUNE_RUN=rk_4f7c2a9e1b PLUNE_SHARED_RUN=1 npx playwright test --grep "$(plune plan grep 6f1c2b3a-0000-4000-8000-0000000000f3)"
A run of no plan greps by its own key, with plune run grep from CLI 0.21.0. It takes the run’s
automated cases — the ones it expected, those added with Add tests among them, and
the ones it holds a result of:
PLUNE_RUN=rk_4f7c2a9e1b PLUNE_SHARED_RUN=1 npx playwright test --grep "$(plune run grep rk_4f7c2a9e1b)"The plan’s Launch a run dialog shows the same command before the run exists, under Automated
cases · 5. Plune issues the key when the dialog opens (POST /v1/runs/keys), so the command there
is the real one, and Save or Launch keeps that key as the run’s externalKey. A saved run starts
when someone launches it, or when the command reports first.
PLUNE_SHARED_RUN=1 is there because Finish run closes this run, so the reporter leaves it open
when its tests end. A plan of automated cases alone gets the command without it, and its reporter
closes the run.
Only values Plune issued go into the command — a key as Plune makes it, rk_ and ten hex, and the
plan’s id, a UUID — each checked against its shape. A key from anywhere else, such as a CI run’s id
a reporter chose, never goes into a line you paste into a shell. A run of no plan names it in words
instead: «Automated cases are marked by the reporter that joins this run by its key …». A run from a
plan shows <run-key> in the command, with the same words under it.
Not in this version
Section titled “Not in this version”A random distribution of cases among members (only «prefer case assignee» and Auto assignee exist), statuses of your own beside the five (a sub-status says why within one), starting the automated half in CI from Plune — it gives the command, and CI runs it — and a manual mark’s steps in the case page’s history — the history shows the mark’s status, not its steps.
Several environments at once are not one run, they are a group of runs, one per environment: Launch on several environments.