Twenty handsets, sixty flows, two weeks, pass rates reported per model. The rate card is the easy part. The labour multiplier is where the quote goes wrong.

The old arithmetic

Coordinate scripts, about four minutes per flow per device. Twenty devices, eighty minutes per flow. Sixty flows, eighty hours of execution.

Add re-mapping taps: twenty to forty minutes per device per build, another eight to twelve hours.

Quotes in this line get built in a spreadsheet anyway — devices × flows × minutes, plus an adaptation factor nobody wants to explain. Numbers from a cloud device farm arrive at a per-device-hour rate, which reads cheaper until the re-run row is filled in.

Two people, ten working days, and it barely clears. Then the client changes a screen and the whole thing gets re-mapped again.

The eight to twelve hours is the awkward part. Clients don’t pay for it. They’re buying “does my app run on these twenty devices”, not “someone moved some numbers around”. Unbillable time is where these jobs quietly lose money.

Removing the re-map

Total Control queries UI nodes instead of pixel positions — text, resource ID, class, content description, boolean properties, joined with &&:

device.sendAai({query: “T:Place order&&BP:clickable”, action: “click”})
device.sendAai({query: “T:Total&&OX:1”, action: “getText”})

Configure the flow on device one, reuse it on nineteen. Screen size, font scale, vendor skin: the script asks for the element, the device resolves where it is.

The margin is those eight to twelve hours, gone.

Relative addressing carries most of it. OX/OY step from a label to its value, a relationship that holds across builds. VG scopes a query to one view group, necessary in list rows where name and price sit a few pixels apart. scrollIntoView handles nodes below the fold without swipe distances that overshoot on tall screens.

The habit worth copying: open UI Explorer on each screen before writing the flow. Ten minutes there saves an hour of guessing which property identifies the button.

Delivery eats more time than execution

Clients want pass rates per model. The old method: screenshot every device, then read them. Four hundred images in, attention is gone.

Now devices.sendAai() returns results per device, so failures land in a table with device, step and error. Where evidence is needed, saveImage captures a specific node rather than the full screen, which keeps the folder sortable.

Then there’s the dirty job: twenty returned units, each needing a described fault reproduced. Object mode turns it into one pass — perform the reproduction on the master device, the rack follows the same action sequence:

devices.sendAai({query: “T:Retry payment”, action: “click”})

Two people for a day becomes one person for an hour, and the rest of the day goes into the findings.

What it can’t do

·        Portrait only. Landscape H5 pages were done by hand.

·        WebView and custom-rendered UI often return nothing. The client’s payment page is a WebView; nodes were empty. Image comparison and OCR covered it, but no firm conclusions were drawn from that section.

·        Entry points don’t stack. Object mode, terminal, UI Explorer and REST API take turns; nothing runs in parallel, so the schedule has to be sequential.

·        Five second default timeout. Cheap handsets with slow cold starts need explicit waits; openApp and scrollIntoView are exempt.

And it’s not a test management platform. No case library, no defect tracker, no report templates. Execution gets automated; case design and reporting stay manual.

How to split the quote

Two lines: execution and re-runs.

Execution is devices × flows. Adaptation isn’t worth quoting separately — after the first device it’s fifteen minutes per model, and billing it looks like padding.

Re-runs are where the money is. Every client changes something. With flows behind the REST API (Appium-shaped JSON, {“cmd”:”action”,”action”:”findnode”,”params”:{…}}, status:0 on success), a re-run doesn’t need someone sitting in front of the rack — it can be priced as machine time instead of labour.

That’s the line between breaking even and making something.

When the math doesn’t work

One-off acceptance, three devices, a short flow list: configuring the script costs more than it saves. Do it by hand.

A standing rack, a client who keeps changing requirements, a build that runs three times before sign-off: the saved time is the repeated part, and that’s the part that has a price.

Before quoting, run one flow on the two devices the free edition covers — a high-resolution unit and a cheap one — and time it both ways.