Skip to content
ferroseekdocumentation homemain, packages at version v0.1.0
Ferroseek on GitHub

Performance

These are measurements of the proof of concept, taken with the generated 100,000-product sample catalog. They describe what was observed under the conditions given, not a guarantee. Your catalog, queries, traffic and region will give different numbers; measure your own before relying on them.

The production figures are of the read-only build with a static index, deployed to Cloudflare on 2026-10-04. The indexing API (writes) is not deployed to Cloudflare yet; its figures, in Writes, measured locally, come from wrangler dev on one machine.

Measure Result Where
CPU time per request, p50 1.4 ms Production, Cloudflare analytics
CPU time per request, p75 2.1 ms Production, Cloudflare analytics
CPU time per request, p99 8.3 ms Production, Cloudflare analytics
Round trip, median about 19 to 20 ms Production, from a client about 10 ms of network away
Faceted search, engine time, median about 0.26 to 0.33 ms Native, locally
Round trip about 1.5 ms Local wrangler dev
Index load (cold start) 226 to 313 ms Production
First request in a new isolate about 0.84 to 1.35 s Production
Memory after load about 62 MB of 128 MB Production
Index size 58.3 MiB in three files On disk
Single-document write about 1.3 to 1.5 ms median Local wrangler dev only
Write visible in another isolate about 1.4 s Local wrangler dev only

The catalog is data/generated/products-100k.ndjson: 100,000 generated products of roughly 400 to 500 bytes of JSON each, with text, keyword, numeric, boolean and date fields (see Quick start).

The “faceted search” is the reference query of the project contract, conformance/queries/100-shop-text-filters-facets.json: a two-word multi_match over name^3 and description with operator and, two filters (in_stock and a price range), five terms aggregations and one range aggregation, sorted by score then sku, 24 hits.

Measured natively with npm run engine:bench (the engine without a Worker), median engine time per query on the 100k index:

Query Median
Faceted search (the reference query above) about 0.26 to 0.33 ms
Phrase (match_phrase on description) about 0.02 ms
Typo-tolerant single word (match with fuzziness: "AUTO") about 0.02 ms
Typo-tolerant shop query: two misspelled words with fuzziness, filters, a post_filter and three facets about 0.6 ms

A full HTTP round trip to a local wrangler dev Worker took about 1.5 ms.

Inside workerd, performance.now() is coarsened to whole milliseconds, so engine time cannot be read reliably from one request; average over many. The repository’s tools for this are worker/scripts/measure.ts (cold load, engine time, HTTP latency and memory of a running Worker), npm run bench (a seeded mix of query templates at several concurrency levels) and npm run engine:bench (the engine natively, without a Worker).

A Ferroseek Worker with the 100k index as static assets (the read-only build, without the indexing API) was deployed to Cloudflare on 2026-10-04 and sent about 2,800 mixed search requests.

CPU time per request, from Cloudflare’s analytics: p50 1.4 ms, p75 2.1 ms, p99 8.3 ms. This is the time the Worker spent computing; it excludes time spent waiting on the network.

Round trip from a client about 10 ms of network away: median about 19 to 20 ms. Most of that is network, not search.

A new isolate loads the index on its first request: it fetches the three part files from static assets and copies them into WebAssembly memory.

  • Index load: 226 to 313 ms. The loader streams the three parts concurrently; loading them one after another took 390 to 461 ms.
  • First request in total: about 0.84 to 1.35 s.
  • The first request after new index files had been uploaded took 4.5 s.

After loading the 100k index, the isolate used about 62 MB of its 128 MB limit. The rest is shared by your application and by request-time working memory, which the engine keeps to roughly 16 MiB per request with the limits in Limits and differences. WebAssembly memory never shrinks, so the figure to watch is the peak.

The indexing API is new, and nothing of its write path has been measured on Cloudflare yet. These figures come from npm run live:write (see How it is verified) and related runs under wrangler dev, with the local emulation of R2 and Durable Objects on one machine, on the 100k catalog. They contain no network latency to R2 or to the writer Durable Object, so production numbers will differ.

Measure Result
Single-document write, refresh=false about 1.3 to 1.5 ms median
_bulk of 1,000 items about 45 to 50 ms
A write without a refresh parameter, visible in a different Worker process about 1.4 s (the 1 s refresh interval, then up to the 1 s freshness window)
refresh=true about 1 s (publish plus the freshness window)
Compaction of the 100k index with 4,800 changes about 0.9 s, with a peak of 84 MB of WebAssembly memory
Base swap after a compaction about 300 ms, during which requests for that index wait; none failed
Cold load of the 100k index 91 to 327 ms from local R2, 97 to 209 ms from local static assets, across runs on a loaded machine

Deploy to Cloudflare lists the individual runs with their percentiles.

Each refresh adds a delta segment, and until a compaction merges them a search runs over the base and every delta: the term dictionaries are scanned once per segment. Measured natively on the 100k index with five delta segments pending:

Query Single segment Five deltas pending
Faceted search about 0.26 to 0.33 ms 0.29 ms
Typo-tolerant shop query about 0.6 ms 1.7 ms

The faceted search barely changes. The typo-tolerant query scans the term dictionary of every segment, so it slows down with the number of segments. Compaction restores the single-segment figures. The writer compacts on its own when the deltas reach half of the delta allowance (see Compaction).

The project contract set these targets at 100,000 documents:

Metric Budget Measured
Engine time, faceted query p50 under 5 ms, p95 under 20 ms about 0.26 to 0.33 ms median natively; production CPU p50 1.4 ms, p99 8.3 ms per request
Cold start: fetch parts, make the index queryable under 500 ms 226 to 313 ms in production from static assets; from R2 measured locally only (91 to 327 ms)
Peak memory in the isolate, including load under 100 MB about 62 MB after load