Security Data Works

The Capability Matrix · the benchmark behind the scores

Independent benchmarks. Code in the open

You've read the benchmark slide where the vendor's engine wins by 40× and there's no way to check. Every number on this page runs the other way, with the methodology public, the code public and the corpus synthetic, so you can clone the repo and re-run it on your own hardware before you believe me. The flagship finding is two-regime, and I publish both halves: the schema-on-read index wins the simple indexed lookups, and the lakehouse engines win the hunting-shaped aggregations by 5–62× (Tier B, single host, 10M events, CV-gated, identical answers verified).

These benchmarks are the hard evidence behind the Capability Matrix scores, one product with the lab as its measurement engine. They feed the open research notebook, where each measured result becomes a tracked hypothesis with an evidence tier and a record of what would change the answer.

What's below is twenty-four first-party benchmarks, five published and nineteen shipping as a first pass (plus an FSI compliance human-hours study scaffolded and a Vortex-vs-Parquet first pass that is in the public repo but not yet in the selector). Twenty-three of them have public code you can clone and re-run, and one is held under NDA because its comparison set includes commercial software whose licensing restricts publishing the results. The first nine are written up in full and fifteen more in brief with their code, all in the selector below, and every one is a first-party measurement behind a claim on this site.

The stack, measured together

MOAR stack benchmarks.

Most of the benchmarks on this page measure one open stack from different angles: the same object storage, Iceberg table, swappable catalogs and engines, and OCSF routing the MOAR architecture describes. Taken together they answer one question, whether the architecture actually runs and whether its numbers survive checking. The stack-level results:

Stack-level results for the MOAR architecture: what each measurement covers and what it found.
What's measuredResult
Engine answer-equalityFive engines (DuckDB, Trino, ClickHouse, StarRocks, Dremio), three catalogs (Iceberg REST, Nessie, Lakekeeper), and two table formats (Iceberg, DuckLake) return the identical answer (1,000 rows / 125 RDP) over the same data.
Reader correctnessTwo of thirteen Parquet readers (chDB 4.1.8 and fastparquet; the chDB defect is fixed in 4.1.9) returned a wrong count with no error or warning on a file the others read correctly, which is why answer-equality runs as a standing gate rather than a one-time test.
Query speed vs. SIEMTwo-regime: the lakehouse engines ran the hunting-shaped aggregations on a 10M-event Zeek workload 5–62× faster than a schema-on-read SIEM (46.8× native / 10.1× Iceberg on the five-query average, single-node Tier B), and the index wins the simple lookups, detailed below.
Compression9.0× under ClickHouse blanket ZSTD-22 on the pinned 10M-event Zeek corpus; Iceberg Parquet lands 8.5× against raw JSONL on the same corpus, the anchor for the calculator below.
Storage vs. SIEMAbout 7× smaller than an OpenSearch index on identical OCSF data, answers identical (1.6 vs 11.5 MB at 200,000 events).
Query latency4 to 14 ms at a million rows on a single host across the gated workloads.
Cross-tool data healthThe best single source of record recovers 47.7% of an environment's true state; a freshness-and-authority merge across tools reaches 75.6%, and the residual 24.4% is the blind spot no tool covers (both reproducible across 12 seed re-draws, CV 0.3%).
Normalization fidelityRoutine SOC queries hold under coarse normalization (+0.000); the adversary-relevant tail degrades far more, because coarsening discards the evidence those queries need. The gap is +0.188 on the de-gamed run against real MITRE APT29 telemetry with unmodified SigmaHQ rules (the adversary tail's recall-loss is about 2× that of routine queries, 0.35 vs 0.16) and a larger +0.719 on the gameable synthetic testbed.
Chain of custodyIceberg time-travel returns the exact state as of each immutable snapshot, the lineage a mutable SIEM index can't give you (Reg SCI / SEC 17a-4(f) grade).

Single-host, first-party measurements throughout, several on synthetic but controlled testbeds and graded Tier B (reproducible, first-party); read latency and throughput as architecture rather than cluster-scale promises, since the scale sweeps are separate lab work. The consolidated write-up sits on the MOAR proof page.

The catalog at a glance

Twenty-four benchmarks, one line each.

Every benchmark on this page is Tier B, a reproducible first-party measurement on a single host. Five are marked published, and the other nineteen are first passes that carry their own caveats and name the step that would take them further, which for several is an arm still to build or an outside reviewer. The name opens that benchmark in the selector below, and the last column goes straight to its code.

All twenty-four lab benchmarks with the main finding, the workload, the publication status and evidence tier, and where the code lives.
BenchmarkFindingWorkloadStatus · tierCode
Zeek analytical: lakehouse vs SIEMThe index wins two simple lookups; the lakehouse engines win the hunting-shaped aggregations by 5–62×10M synthetic Zeek conn events, five queriesPublished · BGitHub; PDF
OCSF flattening fidelityAbsence written as NULL drops privilege-escalation recall to 0.00; a five-minute rollup halves beacon-hunt F1Synthetic CloudTrail, beacon and cross-zone corporaPublished · BGitHub
ClickHouse vs DuckDBIdentical answers at 1M and 10M events with modest latency gaps; at 100M the gate caught a chDB 4.1.8 undercount1M–10M OCSF-shaped events, five queriesPublished · BGitHub
Sigma portabilityOpenSearch PPL drops the time window on three of five correlation rules without an errorEleven Sigma rules, four backendsPublished · BGitHub
OCSF field-mapping fidelity46–70% typed coverage across six vendor sources; Okta’s shipped mapper carries 18 of 50 fieldsSix vendor field inventories against OCSF 1.8.0Published · BGitHub
OCSF context-collapseA coarse store degrades adversary queries +0.72 more than routine ones, and +0.71 on a second chainFour-source synthetic intrusion, sixteen queriesFirst pass · BGitHub
OCSF mapping oracleA reasoning discipline cut the invented-path rate from 0.99 to 0.60 on a 3.8B local model; a grounding note did no better than a wrong one141 gold mappings, 3.8B-parameter local modelFirst pass · BGitHub
Semantic-query head-to-headLocal text-to-SQL fails loudly; the OBDA rewrite is exact on the three of eight queries it can expressPlanted-chain store, adversary-tail questionsFirst pass, two of three arms · BGitHub
Hot-tier write contractIceberg writes about four files per small commit against DuckLake’s one, at about 2.3× the commit latencySeeded OCSF stream, small and large batchesFirst pass, two of three arms · BGitHub
Arrow transport: ADBC vs JDBCADBC pulls result sets about 5–10× faster than a native-JVM JDBC clientOCSF result sets, 100k–1M rowsFirst pass · BGitHub
Iceberg metadata and compactionScan planning slows as small appends pile up manifests, and compaction recovers itSmall streaming appends, pyiceberg plannerFirst pass · BGitHub
DuckLake vs Iceberg, large scansIdentical answers; default-setting latency gaps trace to the writers’ codecs and close to parity when matched10M rows in both formats, one engineFirst pass · BGitHub
Sigma rules over the OCSF storeAll four chain stages detected; the SQL backend drops the count rule’s time windowReal Sigma rules on the planted-chain storeFirst pass · BGitHub
DuckLake inlining vs IcebergA hundred small commits leave zero data files with inlining on, against 100 without100 commits of 200 rowsFirst pass · BGitHub
Storage endurance (NVMe)Write amplification of about 0.43 projects to well under one drive-write per day5M synthetic OCSF rowsFirst pass · BGitHub
Harness vs model: OCSF mapperA schema-constrained mapper invents no paths by constructionThe 141-mapping gold keyFirst pass · BGitHub
Notebook format: marimo huntA hunt saved as plain .py re-runs identically headlessOne OCSF hunt notebookFirst pass · BGitHub
Parquet page checksumsAfter a one-byte flip, four of five readers return a wrong sum at default settingsFive readers, one checksummed fileFirst pass · BGitHub
Parquet encoding × library decodeNo silently wrong cells; unsupported encodings fail with an errorSix readers across the encoding gridFirst pass · BGitHub
Does pruning drop the needle?Every engine’s pruning was soundMillion-key file, sorted vs shuffled, five enginesFirst pass · BGitHub
Compute determinism and encryptionThe same float sum lands on three totals that differ in the last bits; in-file encryption reads across engines in one direction onlyFive engines; encrypted Parquet filesFirst pass · BGitHub
NULL, coercion and timezone semanticsNOT IN with a NULL returns no rows on DuckDB and DataFusion and 80 on chDBByte-identical tables, three enginesFirst pass · BGitHub
Batch vs streamingA 5-second micro-batch lands within about a second of Kafka and Flink on a windowed ruleSeeded auth corpus, one detectionFirst pass · BGitHub
Row-level security overheadA tenant filter adds 54–81% to a millisecond count and speeds a top-talkers query by 32–86%1M rows, 100 tenants, DuckDBFirst pass · BGitHub

The benchmarks, one at a time

Nine full write-ups, fifteen more in brief

Pick one from the list to open its write-up. The nine full write-ups each follow the same order, the claim, the result, how far it travels and how to re-run it, and the fifteen briefs after them give the finding in a paragraph with a link to the code. The flagship Zeek result is open by default.

Published benchmark · no. 1

On a 10M-event Zeek workload, the finding is two-regime: the index wins the simple lookups, and the lakehouse engines win the hunting-shaped aggregations by 5–62×.

Identical workload (10M synthetic Zeek conn.log events), identical hardware and identical queries, with every arm’s answers checked against the others before a timing counts. The methodology is public.

The result.

Two regimes, reported both ways. Against an OpenSearch 2.18.0 index as the schema-on-read baseline, ClickHouse wins the hunting-shaped aggregations by 5–62×, depending on the query and on whether it reads its own MergeTree store or an Iceberg table, and across all five queries the average of medians comes out 46.8× native and 10.1× over Iceberg, a figure the 13-second port-scan query dominates (Tier B, single host, 10M events, seven trials per query, CV-gated, identical answers verified). The per-query spread behind that band is top-source-IPs 21× and port-scan 62× on ClickHouse native MergeTree and 5.4× and 14× on ClickHouse-over-Iceberg, while the index takes the protocol distribution by 3.4× and the long-duration lookup by 1.8× over native, and by 8.2× and 20× over the Iceberg arm.

Zeek flagship · per-query speed-up · Tier B, one host

Two regimes on 10M Zeek events: the index wins two lookups, the lakehouse engines win the hunting aggregationsDiverging bar chart on a log scale centred at equal speed. OpenSearch 2.18.0 beats ClickHouse on protocol distribution (3.4 times over native MergeTree, 8.2 times over ClickHouse reading Iceberg) and long-duration connections (1.8 times over native, 20 times over Iceberg). ClickHouse beats OpenSearch on top source IPs by bytes (21 times native, 5.4 times Iceberg) and port-scan detection (62 times native, 14 times Iceberg). The count query is left out because it answers near the timing floor on the index and native arms, with Iceberg adding about 10 milliseconds of planning.Lookups: the index winsProtocol distributionnative3.4×Iceberg8.2×Long-duration connectionsnative1.8×Iceberg20×Hunting aggregations: lakehouse winsTop source IPs by bytesnative21×Iceberg5.4×Port-scan detectionnative62×Iceberg14×← index fasterlakehouse faster →3×3×10×10×1×speed-up over the slower arm, log scale
Each bar is the faster side’s speed-up over the slower one on a log scale, from the median of seven trials per query with identical answers on every arm. OpenSearch 2.18.0 is the index; “native” is ClickHouse reading its own MergeTree store and “Iceberg” is ClickHouse reading the same rows as Iceberg Parquet, so each pair shows the same query against both ClickHouse arms, and on the left the bar is how far the index beat that arm. The count query is left out because it answers near the HTTP client’s timing floor on the index and native arms, with Iceberg adding about 10 ms of planning. Source: sdw-lab-benchmarks, zeek-flagship-rerun/results/comparison.json.

Text search is the index’s other regime, and a follow-up bench shows even that splits three ways: ClickHouse’s full-text index ties OpenSearch on whole-token filtering, the inverted index wins substring-within-a-token, but the columnar engine is the correct one for regex over token-spanning content like base64, where the analyzer’s tokenization fragments the value and the index silently undercounts (it returned 3,159 of 7,946 planted blobs while the columnar scan returned all of them).

On storage, the same 10M events take 3,743 MB as raw JSONL, 1,868 MB in the OpenSearch index (2.0× smaller), 685 MB in ClickHouse’s default-LZ4 MergeTree (5.5×) and 440 MB as Iceberg Parquet (8.5×), so the open format pays its read-latency cost and comes back as the smallest artifact in the comparison. ClickHouse under blanket ZSTD-22 reaches 9.0× in the companion cost-to-serve run, from the columnar layout and the codec together rather than the codec alone.

One scaling note is carried over from the earlier December 2025 run, which used a different schema-on-read baseline: that system’s average went from 3.47 seconds at 1M events to 27.52 seconds at 10M, roughly 8× for 10× the data, while ClickHouse stayed sub-second. The 2026 re-run did not re-measure the slope, so it reads as a direction rather than a curve: the absolute gap grows with volume, and volume is what per-GB-ingested licensing bills for.

The workload.

Zeek conn.log is the per-connection network telemetry record produced by the Zeek (formerly Bro) network security monitor, one of the most common high-volume security data formats in production SOCs. The benchmark loads 10 million synthetic conn.log events with realistic field distributions, pinned by checksum so every arm reads the same data, and runs five standardized queries: a count of all events, the protocol distribution, the ten longest connections over a minute, the top ten source IPs by total bytes, and a port-scan aggregation that counts distinct destination ports and hosts per source.

Each query gets one warmup and seven timed trials per arm, with one engine running at a time on a single host (a Ryzen 7 5800H under WSL2 with 48 GB and 14 threads), and the reported figure is the median. Every arm is timed from the same Python process over HTTP, and nothing was tuned beyond documented defaults apart from two settings OpenSearch needed to return exact rather than approximate answers. The count query answers near the HTTP client’s timing floor on the index and native arms (Iceberg adds about 10 ms of planning), so its ratios are not quoted as findings, and the port-scan query’s threshold never fires on this corpus, so it times the aggregation work rather than a detection.

How far it travels.

Three draws of the benchmark in June 2026 kept the multiples tight: ClickHouse-over-Iceberg’s five-query average advantage over the index came in at 10.1×, 10.6× and 11.3×, and the cost of reading Iceberg instead of ClickHouse’s native store at 4.2–4.6×, while absolute latencies drifted 5–10% from draw to draw. What the result does not license is a blanket “N× faster than your SIEM” claim, because the baseline is a bare OpenSearch index rather than a SIEM product with its pipeline in front of it, and one host at 10M rows says nothing direct about clusters or petabytes.

Reproducibility.

The benchmark repository contains Docker Compose definitions for ClickHouse, the schema-on-read baseline and the additional engines tested (Trino, Dremio, StarRocks), the data generator that reproduces the Zeek conn.log distribution, the Python query runner, the methodology and the analysis JSON.

The repository is shared under NDA with qualifying reviewers, and running it on your hardware should land within statistical variance of the published numbers. If it doesn’t, the discrepancy is a contribution to my understanding and gets folded into a result update with the new evidence. The reference implementation isn’t published openly because the comparison set includes commercial software whose licensing terms restrict third-party publication of comparative test results, and I’d rather respect that constraint than work around it.

Download

The methodology PDF

The dated v1.0 record from 2026-05: hardware, workload definition, query suite, statistical-confidence detail and the documented caveats for the earlier run, kept as written, so its figures predate this re-run and the numbers above supersede them. About nine pages, no email gate.

Download methodology (PDF) →

For NDA-gated reference-implementation access (Docker Compose, data generators, query runner), email jeremy@securitydataworks.com with the subject Benchmark NDA request.

Where it breaks

Architectures fail at an edge, and most edges give warning.

The benchmarks above ask which architecture wins at a fixed point, but the question that decides a migration is inverted: where does the architecture you're running break, how much warning do you get, and what's the reversible next move. Re-reading the whole catalog that way produces a map of three architecture regions, the measured edges between them and the failure shape at each edge, which matters because a graceful edge announces itself in the latency tail quarters ahead while a cliff gives no warning at all.

2D map: hot data scale (1M to 1B events) against concurrent demand. Three regions (embedded single-node, single-node ceiling band, single-host OLAP server) with measured marks: the schema-on-read index's hunt-shaped edge at 10M, the 100M per-workload crossover, DuckDB's shape-dependent 1B crossings, a join cliff and a silent-wrong hazard inside the regions, and retention/ingest as side chips. All coordinates one host, Tier B.

Every edge on the map except the cliffs gives warning, and each one has a signal you can watch for in your own environment, and that's how I'd use one-host coordinates, since what travels to your environment is the ordering and the failure shape more than my absolute numbers. Seven questions you can answer from your own telemetry this week, one per dimension:

  1. Scale: did your slowest routine query's p95 grow faster than your hot table's row count over the last two quarters?
  2. Mix: is scheduled-cycle utilization (total scheduled-search runtime per cycle divided by cycle length) above roughly 0.7 and rising?
  3. Concurrency: is busy-hour p95 more than about 3× off-hours p95, and growing with headcount?
  4. Joins: does any correlation search die while its single-table components return in seconds? This is the one edge that gives no curve: it's a cliff, and the fix is a layout decision rather than a scale threshold.
  5. Retention: what fraction of your data older than 90 days was actually queried last quarter, and at what hot-tier $/GB against an S3-class price?
  6. Ingest: does source-to-queryable lag ever exceed your fastest scheduled detection's interval?
  7. Sources: how many production sources have no owned, tested parser? The map draws this edge dashed, because it's practitioner evidence rather than a lab measurement.

I'd rather you measure these than take my coordinates. The public stack ships a runnable data-health gate (./moar healthcheck), and the public suites behind this map publish their methodology so you can point them at your own environment (the one NDA-held benchmark above is the exception, for the licensing reasons it documents). The data-health methodology walks through the same questions in order, so you can run them without outside help.

Model it for your workload

Storage compression ROI calculator

The 8.5× Iceberg Parquet compression result against raw JSONL on the pinned 10M-event Zeek corpus is the benchmark observation (ClickHouse's blanket-ZSTD-22 store lands 9.0× on the same corpus). Plug in your own daily ingest volume, current per-GB-month storage cost, and retention to see how the result scales. Storage cost only; licensing and compute aren't modeled here.

Pre-compression. Volume that hits storage today.

S3 Standard ≈ $0.023. Splunk indexed ≈ $3–10.

Typical SOC: 12–24. Regulated: 84 (7 yr).

Current

—

monthly storage at steady state

With 8.5×

—

monthly after compression

Annual savings

—

3-yr: —

The 8.5× ratio is Iceberg Parquet against raw JSONL on Zeek-shaped network telemetry. Other log shapes vary: endpoint telemetry and identity events typically compress less, cloud control-plane events typically compress more. The number is directional for your workload, not precise. The bigger gap on Splunk-licensed deployments is per-GB-ingested licensing rather than storage; this calculator doesn't model that.

Compare architectures

The storage line, side by side

The same inputs, run against the two architectures this site examines: indexed-SIEM storage at its list-price rate, and a lakehouse on object storage with the measured columnar compression applied.This models the storage line only; it is not a TCO model. Ingest licensing (usually the bigger line on a SIEM bill), compute, egress, and people aren't in it, so read the output as a single line item on a much larger bill.

Indexed list price runs $3–10 (Tier C).

S3 Standard ≈ $0.023.

Indexed SIEM

—

monthly; raw bytes at the list storage rate (Tier C basis)

Lakehouse on S3

—

monthly; 8.5× columnar compression, then object rates (Tier B measured)

Multiple

—

computed from your inputs; combines the rate gap and compression, storage line only

For calibration against the published figures: the widget combines two effects at once, the list-price rate gap and the 8.5× compression, so at the default inputs its output runs well above either published anchor, which is a fair reading of what list-price economics look like before any discounting. The conservative brackets this site actually carries are the 130–227× list-price multiple on the raw storage line (Tier C, carried conservatively, with compression deliberately excluded) and the lab's measured floor of 14.8–96.7× (Tier B, counting both the fewer bytes an open format writes and its cheaper price per byte), which works out lower than any list-rate comparison because it uses measured SIEM-side economics rather than list rates. The 8.5× compression is the flat-Zeek result and is corpus-dependent (endpoint and identity telemetry typically compress less, cloud control-plane events more), so treat the lakehouse arm as directional.

How the lab runs benchmarks

Five principles. Documented before any tool runs.

Reproducibility before performance.

I treat a result nobody can re-run as an opinion, so every published result ships with the methodology document, the containerized environment definition, the data generators, the query suite, and the analyzed output. A practitioner with the same hardware and same data can re-run the experiment and verify the number independently. Twenty-three of the twenty-four benchmarks publish their code openly on GitHub. The exception is the Zeek flagship, whose comparison set includes commercial software whose licensing terms restrict third-party publication of comparative benchmark results, so its methodology, result and reasoning are public while the executable reference implementation is shared with qualifying reviewers under a one-page NDA.

Identical workload across candidates.

Workload and queries are defined and pinned before any tool is run. No per-tool tuning advantage; the same query suite runs against the same data on every candidate engine. Vendor-recommended configurations are tested as additional rows in the result table, labeled clearly as vendor-recommended, so they never get folded silently into the headline. The aim is to characterize each tool's behavior on the workload, and tuning toward the most flattering possible result for any one of them would defeat that.

Documented caveats.

Every result ships with what was tested, what wasn't, and which workloads the result generalizes to. Every benchmark here is single-node; production environments typically run multi-node, and multi-node behavior is still outside what this suite captures. Single-node joins, though, are no longer an open question. At single-node SOC scale the spread between compliant engines is compressed: every engine answered the SOC join suite in under 1.5 s (Tier B, single host). I don't name a winner at this scale, and TB-scale vendor claims are a different regime this bench neither confirms nor refutes, so engine choice mostly turns on catalog maturity, concurrency behavior, and operational cost. The flagship covers analytical aggregation queries, so full-text-search-dominated workloads generalize less cleanly from it, which is why text search got its own follow-up bench. The flagship also uses one log type (Zeek conn.log); other log shapes (endpoint telemetry, cloud control plane, identity events) carry their own performance characteristics. The caveats are the part that lets a reader know whether the number applies to their environment.

Vendor cooperation invited, not required.

Every vendor whose product appears in a benchmark is invited to review the methodology and propose configuration changes before publication. Vendor-proposed configurations are tested and reported as additional result rows, labeled clearly. The lab doesn't accept funded benchmarks, doesn't allow pre-publication vetoes, and doesn't allow vendors to dictate workload selection, but the methodology review is open, and that openness is part of why the published numbers survive contact with the vendors after release.

External review, published when it completes.

An outside practitioner with the relevant standing (a security data engineer, OCSF contributor, or analyst with quantitative-benchmark expertise) will audit the lab's published results under NDA, with full methodology, full reference implementation and the underlying analysis JSON, and their signoff drives corrections to the public results. A reviewer isn't confirmed yet, so no signoff exists today; the reviewer will be named here, with any flagged issues, once that review is done.

What we changed our mind on

The benchmark headline doesn't carry the cost story alone.

For most of 2025, the operational reading of the benchmark was straightforward: ClickHouse is 145× faster and meaningfully cheaper than the schema-on-read SIEM on equivalent workloads. Both halves of that statement need revising. On speed, the CV-gated re-run replaced the single-run 145× with the two-regime finding: the index wins the simple lookups, and the lakehouse engines win the hunting-shaped aggregations by 5–62×, a 46.8× native / 10.1× Iceberg five-query average, so the advantage is real but query-shaped. On cost, the framing is more complicated than the early write-ups admitted, and I'm revising it here on the lab page itself instead of in a footnote somewhere else.

ClickHouse is cheap versus per-GB-ingested licensing models. Vendor case studies and engineering blogs (Tier C, with Huntress reporting more than 90% at the analytics tier) point the same way, and the direction reproduces in TCO modeling. ClickHouse is comparable to Snowflake or Databricks SQL at sustained TB/day workloads, where the managed pricing converges. ClickHouse is structurally more expensive than Iceberg-on-S3 with a separate query engine, because the MergeTree format duplicates data already storable in open formats on S3, the compute and storage scale together rather than independently, and the replication overhead multiplies storage cost. This is the finding the Capability Matrix accounts for directly, which is why it lowers ClickHouse on the cost-led and federated archetypes rather than on the latency-dominated one, so the high latency ranking under Archetype A and this cost admission are scoring the same engine against different criteria, and they agree.

The updated framing the lab uses today: the benchmark validates the performance claim cleanly. The cost claim only carries when the comparison baseline is named, which means the legacy schema-on-read licensing model specifically. Production deployments that lean ClickHouse-first on hot tier and Iceberg-on-S3 on cold tier are an emerging pattern that captures both the latency advantage and the open-format cost economics. The lab's streaming work in late 2026 measured stream-processor complexity against a batch path, so streaming write maturity into Iceberg, which is what would characterize this hybrid shape, remains unmeasured. It's also why the Capability Matrix ranks ClickHouse first only under the latency-bound Archetype A (the Zeek-heavy SOC, where query speed is weighted 22 and storage cost is not a scored criterion) and reorders toward Iceberg-native engines under the cost-led and federated archetypes; the matrix and this benchmark agree that ClickHouse wins where latency is the design center, not where cost is. The 2026-06 engine-join bench pushes the same direction from the join side: at SOC single-node scale (Tier B, single host, 10M–60M-row tables) every engine answered the SOC join suite in under 1.5 seconds, and the 53.0M-pair large-large correlation join landed in a statistical three-way tie at roughly 0.86s across StarRocks and both ClickHouse arms, so what security teams need from an engine at that scale is manageability, and the choice should ride on catalog maturity, concurrency behavior, and operational cost rather than on the join-latency war.

Cadence and access

Published as ready, and free to use.

I publish each benchmark when it's ready rather than on a fixed schedule, because the runs are pre-registered and some of them take longer than planned once the first results come back. The methodology, code and headline numbers go to GitHub openly, and the result lands on this page with its evidence tier and caveats.

I'm not taking engagements while I work full-time, so the lab doesn't run client-specific benchmarks or sell a synthesized report for now. If a workload you care about isn't covered, a benchmark proposal by email is still welcome, and if it fits the research I'll say so and fold it into the queue.

Turn a published benchmark into a decision for your workload.

The matrix scores these engines against your environment's constraints, and every benchmark here is public and reproducible on your own workload.