About Benchmark Builder
After running a few performance tests, you end up with a pile of raw "name + number" results, and it is hard to see at a glance who is fastest and by how much. This tool turns those measurements into a clear comparison board: paste one name and value per line. It parses them, sorts by higher-is-better or lower-is-better, computes each item percentage relative to the best, draws comparison bars, and copies a ranked report in one tap. It converts scattered numbers into a readable leaderboard worth sharing with the team. Inconsistent measurement conditions are the primary source of distorted conclusions. The same code behaves very differently at different input sizes and concurrency, so comparing two runs made under different conditions shows the conditions rather than the implementations. Record the condition fields — input size, concurrency, hardware, version — alongside every entry so readers can judge comparability. Throughput and latency must be read separately, the pair most often conflated in performance comparison. Throughput alone hides the tail: raising concurrency can lift throughput while the slowest few percent become several times slower, which is worse for users. State both throughput and a named percentile latency, since an average latency conceals exactly the problem worth seeing. Run-to-run variance is routinely underestimated. Cache warm-up, background tasks and scheduling can move the same configuration by several percent, which makes small gaps meaningless. Repeat several rounds and take a median or a trimmed mean, and report the spread so readers know how large a gap has to be to mean anything. Its boundary with load testing matters: benchmarking asks who is faster under controlled conditions, load testing asks when the system starts failing under pressure. Inputs and conclusions differ, and reading a load test as a benchmark produces judgements like "this approach slows down under concurrency" that are really capacity findings. Choose the method by the question. Finally, keeping the measurement script and the raw data makes the conclusion credible. The table is the conclusion, the script records the method, and the raw data lets others re-analyse differently. With all three the result can be checked and reproduced; with only the table it rests on trust, which is rarely enough for internal technical decisions. One premise concerns presentation: a sorted table expresses strength but readers overlook whether a gap is significant. Annotate relative differences as percentages, or group entries that fall inside the noise band as one tier, so a two percent gap is not displayed as prominently as a twofold one, which is exactly where ranking misleads.
How It Works Internally
A leaderboard only reorders measurements and does not make them more trustworthy. For the comparison to hold, conditions must match (same input size and concurrency), the run must be repeated rather than a single pass, and throughput must be kept apart from latency — one run is heavily influenced by the environment, and without that split a gap in the table may be noise.
A scores 1200 and B scores 1180, one run eachA gap of about 1.7%, inside the normal spread of a single run — repeat and take medians before comparingMeasured on This Page
| All six rendered | Chrome / Firefox / Safari / Edge / Brave / Opera all appear with their values and the ops/sec unit |
|---|---|
| Tolerant parsing | The raw text is loose 'name: value' lines padded with spaces, and parsing aligns them to the right names |
| higherBetter meaning | The toggle flips 'higher is better', driving sort direction and which entry gets marked fastest |
| Copyable | The generated result copies out as text in one click |
Two things make benchmark comparisons easy to misread. Without error bars a single number implies precision that does not exist — the gap between 162000 and 170200 may be smaller than run-to-run variance. And a comparison is only meaningful when every entry ran on the same data, machine and moment; browsers tested hours apart on different loads are illustrative at best. Suggested practice: run each entry at least 5 times, enter the median, and state the environment (CPU, memory, versions) alongside, so readers do not take the chart as an experimental conclusion.
How to Use
- Open "Benchmark Builder"
- Paste one "name value" measurement per line
- Set the unit and pick higher or lower is better
- Review ranks and percentage vs the best
- Click "Copy report" to export the comparison
Use Cases
- Framework choice — Paste several frameworks ops/sec scores to compare the performance gap visually.
- API comparison — List endpoint latencies and use lower-is-better to surface the slowest one.
- Build speedup — Compare build times before and after to quantify the percent improvement.
- Hardware review — Organize benchmark scores across machines into a shareable ranking shot.
- Algorithm trade-offs — Place implementation throughputs side by side and decide using the relative percentages.
- CI performance regression — Track benchmark results across CI runs and compare before/after numbers to detect performance regressions.
- Library comparison — Compare multiple npm packages, Python libraries, or Go modules head-to-head to pick the fastest option.
FAQ
What input format is required?
One entry per line as "name value", with name and number separated by a colon or space, e.g. Chrome: 185000. It extracts the first number via regex and ignores extra columns.
How do I choose higher- vs lower-is-better?
Pick higher for throughput, ops/sec, and frame rate; pick lower for latency, time, and memory. It only changes the sort direction and the relative-to-best calculation.
How is the relative percentage computed?
In higher-is-better mode it is value divided by the max; in lower-is-better mode it is the min divided by value. The best item is always 100%, and closer to 100% is better.
Can numbers include thousands commas?
Plain numbers are best. Parsing reads only continuous digits and a decimal point, so a comma in 185,000 truncates the read; write 185000 to be safe.
Does it run the benchmarks itself?
No. It only organizes, ranks, and visualizes measurements you already have; it runs no benchmark, so you must obtain the numbers from your testing tools and paste them in.
Some rows are treated as text and the ordering is wrong. Why?
Parsing expects a clean name-plus-number split, so a value carrying a unit, a thousands separator or an affix such as 1.2s or 3,400ms is read as text and cannot take part in the comparison. Normalize to plain numbers before pasting and move the unit into the name column, which keeps ordering and deltas accurate; verify by hand-checking the first and last row.
Can this ranking be used directly to choose a technology?
The ranking makes measurements easier to read, it does not make them more trustworthy. Before choosing, confirm three things: that measurement conditions matched, including input size and concurrency; that the run was not a single pass, since one run is heavily influenced by the environment; and that throughput and latency were kept apart. Without those, a gap in the table may be measurement noise rather than a real difference.
Benchmark results fluctuate a lot between runs?
GC, background tabs and CPU throttling all affect browser timing. Use the same browser, close other tabs and take the median of several runs to narrow the spread. Cross-device numbers are not comparable; only same-environment comparisons mean anything.