Every tool in this space promises to save you time. Ten hours a week. Half your production schedule. Pick a number. It's always round, always big, and always made up, and everyone reading it knows it's made up, which is why nobody believes it and nobody can use it. You can't take "saves you ten hours a week" to your principal. You can't put it in a budget. It's a billboard number, and billboard numbers are worth exactly what you paid to read them.
So we did the other thing. We measure it.
The problem with assumptions
An assumed savings number is untethered from your actual work. It's the same number whether you produced four sheets last month or four hundred, whether your set was simple or a nightmare of curves and revisions. It describes a marketing fantasy, not your project. And because it's the same for everyone, it's true for no one.
A measured number is the opposite. It's built from what the tool actually did, on your actual sheets, on your actual machine. If the tool didn't do much this month, the number is small, and it should be. If it carried a forty sheet set through three revisions, the number reflects forty sheets and three revisions. It moves with your work because it's made of your work.
What "measured" actually means here
The heart of it is that we count real output, not actions. When the tool builds a set of sheets, it doesn't credit itself with one tidy "sheet production" event. It counts the layouts it actually touched. A run that produced forty layouts is counted as forty, not as one. That distinction is most of the number: the commands that do the real sheet production account for ninety percent of all the time the tool has ever credited. The large majority of the number is measured output, not estimate.
The whole accounting sorts into three tiers. The measured tier does the heavy lifting, and each kind of work carries its own rate:
TIER WORK RATE
---------------------------------------------------------------------
Measured Multi-viewport sheet build 15 min / layout
Measured Single-viewport sheet build 10 min / layout
Measured Multi-viewport update 8 min / layout
Measured Single-viewport update 5 min / layout
Measured Split profile views 10 min / run
Estimated Standalone actions run on their own 1 to 5 min / run
(adopting drawings, trimming match
lines, renaming sheets, retiling,
scanning the project)
Zero Steps inside a build or update, 0 min
already counted in that run
(north arrows, scale bars, title
blocks, key maps, match lines,
attributes, support viewports,
label and key plan sync)
Zero Panels, health checks, repairs, 0 min
resets, bug reports, debug probes
Building a sheet is credited more than updating one, because building is more work, and a multi-viewport sheet more than a single-viewport one for the same reason. The rate follows the effort, and it comes down as the effort does. Ninety percent of the total comes from those measured rows.
Where we couldn't count precisely, we rounded down. Splitting profile views is credited ten minutes per run, not per profile split, even when a single run splits several. Done by hand it runs about ten minutes, checking the station range each plan view covers and splitting to match, and the credit stays at ten whether the run split one profile or five. When the count was uncertain, we took the low number, not the high one.
The honesty is in what we refuse to count
This is the part that matters most, and it's the part a made-up number never has.
The table is where the discipline shows. The big numbers are the measured ones, the work the tool actually did and can point to directly, most of it counted layout by layout. The numbers we estimated are the small ones, none of them above five minutes. We put the large credits only where we could measure them, and kept the estimated ones deliberately tiny. That is backwards from how a marketing number gets built, and it's backwards on purpose.
It holds even inside the measured work. The tool credits the layouts it changed, not the ones it merely walked past. Point an update at thirty layouts, and if it modifies none of them, the run is worth zero, not thirty layouts of credit for looking. Skipped layouts are excluded on purpose. The number counts what changed, not what was inspected.
And nearly half of everything you do earns nothing at all, for two separate reasons. A large share of your actions are the internal steps of a build the run already counted, a north arrow placed, a scale bar dropped, a match line drawn while a sheet is being produced. Crediting those again would be counting the same work twice, so they earn zero. The rest are panels, health checks, repairs, resets, and diagnostics, work with no output to credit. Between the two, forty-seven percent of all recorded activity adds nothing to the number. We would rather it be low and honest than high and soft.
The roll-up
From there the arithmetic is boring on purpose. Minutes add up, divide by sixty into hours, and multiply by a billable rate into a dollar value. The rate is yours. You set it. It defaults to a hundred and seventy-five dollars an hour, but it's your number, not one we chose to make the total look impressive. Your hours, your rate, your value.
What it sends, and what it never does
Measuring usage raises a fair question: what leaves my machine? The honest answer is counts, and only counts.
To do its job, the program talks to our servers for a few narrow things. It checks your license, because a subscription has to know it's valid. It checks the version, so we can tell you when a newer one is out. And it reports telemetry, which is where the number comes from. That telemetry is numbers, nothing else. Which SheetAgent function ran, and how many layouts it built. Never a file name. Never a drawing. Never a line of your design. There is no mechanism for your project's contents to leave your machine, because the number was never built from your contents. It's built from counts of the tool's own work.
Those counts roll up in a manager portal, where whoever owns the subscription can see the usage and the time it represents across the team. That's the point of measuring in the first place: not to watch what you draw, which we can't and don't, but to give the person paying for the tool a real, defensible picture of what it's doing for them.
Why this matters
A measured number is one you can stand behind. You can show it to the person who signs off on the subscription and defend every part of it, because every part of it came from something that actually happened. You can treat it as a floor rather than a guess, because it was built to under-count: the real value is at least what the number says, and probably more, since a fifth of the work it did earns nothing and the estimates were kept small.
That's the whole point. Not to tell you a big number and hope you believe it, but to show you a real one you don't have to. The tool did the work. The least it can do is count it honestly.
See what it measures on your own project at setline.ai.