🪢 Langfuse 图解教程Langfuse Visual Guide 第四部分 · 查询链路Part 4 · The Read Path 24 / 55
第四部分 · 查询链路Part 4 · The Read Path

列表与表格Lists & tables

🧭 读前Before you start
先读 第22课 仓储层与 第23课 的过滤,本课讲列表与表格如何高效渲染。
Read Lesson 22 (repository) and Lesson 23 (filtering); this lesson covers how lists and tables render efficiently.

前两课讲了查询怎么拼、怎么跑。这一课看 Langfuse 的旗舰列表——trace 表,它凭什么能秒开。秘诀有二:一是一个通用函数服务四种「形状」 (计数 / 行 / 指标 / 标识),二是把「便宜的行」和「昂贵的指标」拆开——表格先把行画出来,成本/延迟/评分这些要 JOIN 的指标稍后流入、客户端再拼。 再加上一招按需 FINAL的查询纪律,让默认视图只读最新分区。看懂这一课,你就懂了大数据表「既要全、又要快」的全部门道。

🍽️ 生活类比
把列表加载想成餐厅分批上菜。如果非要等整桌大餐(行 + 所有指标)一次端上,你得干坐很久。聪明的厨房先上面包(紧凑行——便宜、人人都要),让你立刻开吃; 那些费工夫的硬菜(指标:成本、延迟、评分,每样都要现做现拼)做好一道端一道,悄悄添到你桌上。你的体验是「一坐下就有得吃」,而不是「盯着空桌等二十分钟」。 Langfuse 的表格正是这么干的:能立刻给的先给,要算的边算边补——这就是「紧凑列表模型」。

紧凑行 vs 指标:两路并发、客户端再拼

打开 trace 列表时,UI 同时发两路 tRPC 调用:traces.all 取紧凑行(约 12 个永远要看的列),traces.metrics 取指标(成本、延迟、评分聚合——要 JOIN 两张表)。 谁先回谁先用:行一回来表格立刻渲染,指标回来后按 id 拼进去。

紧凑行先画,指标后补——表格秒开 traces.all(行)~12 列 · 便宜 · 快 traces.metrics(指标)成本/延迟/评分 · 要 2 JOIN · 慢 ↑ 两路并发发出 ↑ joinTableCoreAndMetrics按 id 把行与指标拼起来指标缺席也返回 success→ 行先渲染,不空等 ① 表格立刻画出行指标列先留空/转圈 ② 指标到,按 id 填进对应行无闪烁、无整表重渲 关键:紧凑行不依赖指标,所以表格在指标算完之前就能用——感知延迟从「最慢一路」变成「最快一路」
拆开「行」与「指标」:UI 并行发 traces.all(行)+ traces.metrics(指标);joinTableCoreAndMetrics 按 id 合并、即使指标缺席也返回 success,所以表格先用行渲染、指标后到再填。源码:web/src/components/table/utils/joinTableCoreAndMetrics.ts:1、services/traces-ui-table-service.ts:206。
示例:trace 列表长什么样 过滤:env = prodscore ≥ 0.5 时间 名称 用户 延迟 成本 Tokens 分数 12:00:01 chat-support u_42 1.93s $0.004 600 0.9 ✓ 11:58:40 summarize u_17 3.10s $0.011 1.2k 0.7 11:55:02 classify u_42 0.42s $0.000 120 1.0 ✓ 11:51:30 agent-run u_88 6.30s $0.028 3.4k 0.4 ✗ 1–4 / 12,480 traces‹ ›
宽表的「紧凑表示」(列对齐 web 的列定义;值为示例):列表页把 ClickHouse 宽行投影成几列关键信息(时间/名称/用户/延迟/成本/tokens/分数),配顶部过滤芯片(来自第 23 课的 FilterState)和分页。海量 trace 不全拉,只取当前页的列与行——这正是仓储层 LIMIT + 列投影的用户侧呈现。
packages/shared/src/server/services/traces-ui-table-service.tsgetTracesTableGeneric :206
// 一个函数,四种「形状」——靠 select 区分(类型安全重载)
function getTracesTableGeneric(props: { select: "count" | "rows" | "metrics" | "identifiers" })

// 只在「真的需要」时才 LEFT JOIN——默认浏览行时省掉两次 JOIN
const requiresScoresJoin = /* 有评分过滤/排序,或 select==="metrics" */;
const requiresObservationsJoin = /* 同理 */;
...
FROM traces t ${defaultOrder ? "" : "FINAL"}        // 默认排序不用 FINAL(见下)
${requiresObservationsJoin ? "LEFT JOIN observations_stats o ..." : ""}
${requiresScoresJoin ? "LEFT JOIN scores_avg s ..." : ""}

按需 FINAL:默认视图只读最新分区

这里藏着一个 ClickHouse 老手才懂的优化。回想第 8 课:traces 是 ReplacingMergeTree,同一 id 可能有多行(create/update 各一行),靠后台合并去重。 查询时若加 FINAL,ClickHouse 会当场把所有分区读出来、去重,结果正确但慢。Langfuse 的取舍是——能不用 FINAL 就不用:

按需 FINAL:默认路径快,非默认路径才付全量代价 默认排序(按时间)· 不用 FINAL ORDER BY toDate(timestamp), event_ts DESC LIMIT 1 BY id(内存里取每个 id 最新一行) ✅ CH 只从磁盘读「最新那天」的分区 不必为去重把一个月的数据全捞出来——又对又快 非默认排序 · 用 FINAL 如按成本/延迟排序时 FROM traces t FINAL(全量去重) ⚠️ 必须读全、去重才能保证正确 慢一些,但只在你主动换排序时才付这代价
对与快兼得:默认按时间排序时用 toDate(timestamp), event_ts DESC + LIMIT 1 BY id 代替 FINAL,CH 只读最新分区、在内存里取每个 id 的最新行;只有当你按非时间列排序时才退回 FROM traces FINAL 全量去重。源码注释见 traces-ui-table-service.ts:443-455。

🟢 默认路径(最常走)

按时间排序 + 不需指标 → 不 FINAL、不 JOIN,只读最新分区。这是 80% 的「打开列表扫一眼」场景,做到了又对又飞快。

🟡 重路径(按需付费)

按成本排序、或要看指标 → 才加 FINAL、才 LEFT JOIN observations/scores。复杂度只在你主动要时才被引入,不拖累常见路径。

select 形状取什么给谁用
rows~12 个紧凑列表格主体,立刻渲染
metrics成本/延迟/评分聚合(要 2 JOIN)指标列,后到补入
countuniqExact(id)分页总数(去重计数)
identifiers只要 id 列表批量操作、跨页选择

表格状态:URL 是真源,三层持久化

列表不只是「画一堆行」。你调了列顺序、设了过滤、排了序、存成一个「视图预设」——这些表格状态该存哪?Langfuse 的答案是分三层、以 URL 为真源:

URL · 真源 分享 + 深度链接 过滤/排序/搜索/视图id → 发链接即原样复现 时效:此刻可分享 session 存储 导航记忆 列宽/可见列/滚动位置 → 跳转间不丢 时效:关标签即清 数据库 永久预设 saved view 跨设备 · 团队共享 → 失效则优雅降级 时效:永久沉淀 时效递增 →:URL(此刻可分享)· session(这次导航)· DB(永久沉淀)
URL分享与真源
过滤、排序、搜索、当前视图 id 都编码进 URL。于是你把链接发给同事,他打开看到的和你一模一样——URL 是「此刻这张表长什么样」的单一真源(呼应第 23 课 FilterState)。
session 存储导航记忆
在表之间来回跳时,用会话存储记住你刚才的列宽、可见列、滚动位置等,免得每次回来都被重置——只在本次浏览会话内有效,关掉标签页即清。
数据库永久预设
「视图预设」(saved view)存进 DB,永久保留、可跨设备、可团队共享。删了某个预设、或它引用的列已不存在?优雅降级:丢掉失效部分 + 提示,绝不白屏。

这三层各管一段时效——URL 管「此刻可分享」、session 管「这次导航」、DB 管「永久保存」——共同让大表格既可深度链接、又在跳转间不丢状态、还能长期沉淀团队的常用视图。 配合一个全局时间范围(Zustand 默认 ⊕ URL 显式),它会变成那条强制的 timestamp 过滤,正好喂给第 22 课的回看窗、把扫描范围钉死。状态分层,是大型列表「快」之外的另一半功夫——「稳」(跳转间不丢)与「可分享」(一个链接复现全貌)。

🎯 设计取舍
为什么不一次查全(行 + 所有指标),非要拆成两路、还搞一堆「按需」开关? 因为列表的体验目标是「秒开」,而指标天生昂贵。 成本、延迟、评分这些要 JOIN 两张大表才能算,若和行绑在一起,整张表就得等最慢的那路才能显示——用户盯着空白干等。把它们拆开后, 紧凑行(便宜、人人要)立刻就到,指标作为「附加信息」边算边补;感知延迟从「最慢一路」降到「最快一路」。同理,按需 FINAL、按需 JOIN 都是同一种智慧: 为最常见、最简单的路径极致优化,把复杂度与代价推迟到「你真的要了」才引入。这是高频列表界面性能的黄金法则——别让 1% 的高级需求(按成本排序、看全指标)拖慢 99% 的日常浏览。
🎯 本课要点
  • 一个 getTracesTableGeneric 服务四种形状(rows / metrics / count / identifiers),靠 select 区分、类型安全重载。
  • 紧凑行 vs 指标拆开:UI 并行发 traces.all(行)+ traces.metrics(指标);joinTableCoreAndMetrics 按 id 合并、指标缺席也返回 success,表格先用行渲染。
  • 按需 JOIN:只在过滤/排序需要或 select==="metrics" 时才 LEFT JOIN observations/scores,默认浏览省掉两次 JOIN。
  • 按需 FINAL:默认按时间排序用 toDate(timestamp),event_ts DESC + LIMIT 1 BY id 只读最新分区;非默认排序才退回 FROM traces FINAL 全量去重。
  • 黄金法则:为最常见路径极致优化,把复杂度/代价推迟到「真的要了」才引入——别让 1% 的高级需求拖慢 99% 的日常浏览。
  • 表格状态分三层、以 URL 为真源:URL(可分享/真源)⊕ session(导航记忆)⊕ DB(永久视图预设,失效部分优雅降级);全局时间范围变成喂给第 22 课回看窗的强制 timestamp 过滤。

🧪 自测 · 想一想为什么这么设计

1. 打开 trace 列表时,Langfuse 并行发 traces.all(行)和 traces.metrics(指标)两路,而不是一次查全。这样设计为了什么?
  1. 因为 ClickHouse 不能一次查两类数据
  2. 为了让指标更准确
  3. 为了多发请求把服务器压垮
  4. 紧凑行便宜、立刻就到,先把表画出来;成本/延迟/评分等指标要 JOIN 两张表、较慢,作为附加信息后到再按 id 合并。感知延迟从「最慢一路」降到「最快一路」
看答案与解析 点击展开
答案:D。列表的体验目标是秒开,而指标天生昂贵(2 JOIN)。把便宜的行和昂贵的指标拆开,joinTableCoreAndMetrics 按 id 合并、指标缺席也返回 success,于是表格先用行渲染、指标后到补入。这是「紧凑列表模型」——能立刻给的先给,要算的边算边补。
2. traces 是 ReplacingMergeTree(同 id 可能多行)。默认按时间排序时,Langfuse 不用 FINAL,而是 ORDER BY toDate(timestamp),event_ts DESC + LIMIT 1 BY id。为什么这样更好?
  1. 因为 LIMIT 1 BY id 更省内存
  2. 因为 FINAL 会返回错误结果
  3. 因为默认排序不需要去重
  4. FINAL 会当场读全部分区去重、很慢;而按时间排序 + LIMIT 1 BY id 让 CH 只从磁盘读最新那天的分区、在内存里取每个 id 的最新行——既对又快,不必为去重捞一个月的数据
看答案与解析 点击展开
答案:D。FINAL 正确但慢(读全量去重)。默认按时间排序时,用 event_ts DESC + LIMIT 1 BY id 在内存里取每个 id 最新行,CH 只读最新分区。只有按非时间列(如成本)排序时才退回 FROM traces FINAL 全量去重——按需付费,常见路径不被拖累。
3. Langfuse 的表格状态(过滤、排序、列设置、视图预设)分三层存储,以 URL 为真源。这样分层最直接的好处是?
  1. 为了隐藏过滤条件
  2. 为了减少数据库查询
  3. 让表格渲染更快
  4. URL 编码当前视图 → 把链接发给同事,他看到的和你一模一样(可分享/可深链);session 记导航间状态不丢;DB 存永久预设、可跨设备共享,失效列优雅降级
看答案与解析 点击展开
答案:D。三层各管一段时效:URL「此刻可分享」(深链、一个链接复现全貌,呼应第 23 课 FilterState)、session「这次导航」(跳转间不丢列宽/可见列)、DB「永久」(saved view 跨设备团队共享,失效部分丢弃+提示不白屏)。这让大表格既快又稳又可分享。
💭 发散思考(没有标准答案,动手或动脑想想)
  • 「为最常见路径极致优化,把复杂度/代价推迟到真的要了才引入」——紧凑行 vs 指标、按需 JOIN、按需 FINAL 都是这条原则。你做过的列表/详情界面里,有没有「为了 1% 的高级需求,拖慢了 99% 的日常浏览」的地方?你会怎么拆?

The last two lessons covered how queries are built and run. This one looks at Langfuse's flagship list — the trace table — and how it opens instantly. Two secrets: one, a single generic function serves four "shapes" (count / rows / metrics / identifiers); two, it splits the cheap rows from the expensive metrics — the table paints rows first, while cost/latency/score metrics needing JOINs stream in later and merge client-side. Plus a conditional-FINAL query discipline that keeps the default view reading only the latest partition. Get this lesson and you've got the whole art of a big-data table being "complete yet fast".

🍽️ Analogy
Think of list loading as a restaurant serving in courses. Insisting the whole elaborate meal (rows + all metrics) arrive at once means you sit waiting a long time. A smart kitchen brings the bread first (compact rows — cheap, everyone wants them) so you start eating immediately; the labor-intensive mains (metrics: cost, latency, scores, each made and assembled to order) arrive dish by dish, quietly added to your table. Your experience is "something to eat the moment you sit down", not "staring at an empty table for twenty minutes". Langfuse's table does exactly this: give what you can instantly, fill in what you must compute as it comes — that's the "compact list model".

Compact rows vs metrics: two parallel calls, merged client-side

Opening the trace list, the UI fires two tRPC calls at once: traces.all for the compact rows (~12 always-wanted columns), and traces.metrics for the metrics (cost, latency, score aggregates — needing 2 JOINs). Whoever returns first is used: rows back, the table renders immediately; metrics back, they're merged in by id.

Compact rows paint first, metrics fill in — instant table traces.all (rows)~12 cols · cheap · fast traces.metricscost/latency/scores · 2 JOINs · slow ↑ fired in parallel ↑ joinTableCoreAndMetricsmerge rows + metrics by idreturns success even without metrics→ rows render, no idle wait ① table paints rows nowmetric cols blank/spinner first ② metrics arrive, fill rows by idno flicker, no full re-render key: compact rows don't depend on metrics, so the table is usable before metrics finish — perceived latency goes from "slowest call" to "fastest call"
Splitting "rows" from "metrics": the UI fires traces.all (rows) + traces.metrics (metrics) in parallel; joinTableCoreAndMetrics merges by id and returns success even when metrics are absent, so the table renders from rows and fills metrics later. Source: web/src/components/table/utils/joinTableCoreAndMetrics.ts:1, services/traces-ui-table-service.ts:206.
Example: what the trace list looks like filter:env = prodscore ≥ 0.5 Time Name User Latency Cost Tokens Scores 12:00:01 chat-support u_42 1.93s $0.004 600 0.9 ✓ 11:58:40 summarize u_17 3.10s $0.011 1.2k 0.7 11:55:02 classify u_42 0.42s $0.000 120 1.0 ✓ 11:51:30 agent-run u_88 6.30s $0.028 3.4k 0.4 ✗ 1–4 of 12,480 traces‹ ›
The wide table's "compact representation" (columns per the web column definitions; values illustrative): the list page projects ClickHouse wide rows into a few key columns (time/name/user/latency/cost/tokens/scores), with filter chips on top (the Lesson 23 FilterState) and pagination. Huge trace volumes aren't fully fetched — only the current page's columns and rows, the user-facing side of the repository's LIMIT + column projection.
packages/shared/src/server/services/traces-ui-table-service.tsgetTracesTableGeneric :206
// one function, four "shapes" — distinguished by select (type-safe overloads)
function getTracesTableGeneric(props: { select: "count" | "rows" | "metrics" | "identifiers" })

// LEFT JOIN only when really needed — default row browsing skips two JOINs
const requiresScoresJoin = /* score filter/sort, or select==="metrics" */;
const requiresObservationsJoin = /* likewise */;
...
FROM traces t ${defaultOrder ? "" : "FINAL"}        // default ordering skips FINAL (below)
${requiresObservationsJoin ? "LEFT JOIN observations_stats o ..." : ""}
${requiresScoresJoin ? "LEFT JOIN scores_avg s ..." : ""}

Conditional FINAL: the default view reads only the latest partition

Here hides an optimization only ClickHouse veterans appreciate. Recall Lesson 8: traces is a ReplacingMergeTree, where one id may have multiple rows (create/update each a row), deduped by background merges. Add FINAL to a query and ClickHouse reads all partitions and dedups on the spot — correct but slow. Langfuse's trade-off: avoid FINAL whenever possible:

Conditional FINAL: fast default path, full cost only on the non-default path default ordering (by time) · no FINAL ORDER BY toDate(timestamp), event_ts DESC LIMIT 1 BY id (latest row per id, in memory) ✅ CH reads only the "latest day" partition from disk no need to pull a month of data just to dedup — correct AND fast non-default ordering · use FINAL e.g. ordering by cost/latency FROM traces t FINAL (full dedup) ⚠️ must read all & dedup to be correct slower, but paid only when you actively change the sort
Correct AND fast: default time-ordering uses toDate(timestamp), event_ts DESC + LIMIT 1 BY id instead of FINAL, so CH reads only the latest partition and takes each id's latest row in memory; only when you sort by a non-time column does it fall back to FROM traces FINAL full dedup. Source comment: traces-ui-table-service.ts:443-455.

🟢 default path (most common)

time-ordered + no metrics needed → no FINAL, no JOINs, read only the latest partition. This is the 80% "open the list and glance" case — correct and blazing fast.

🟡 heavy path (pay on demand)

sort by cost, or want metrics → only then add FINAL and LEFT JOIN observations/scores. Complexity is introduced only when you actively ask, never burdening the common path.

select shapewhat it fetchesused for
rows~12 compact columnsthe table body, rendered immediately
metricscost/latency/score aggregates (2 JOINs)metric columns, filled in later
countuniqExact(id)pagination total (deduped count)
identifiersjust the id listbatch actions, cross-page selection

Table state: URL is the source of truth, three layers of persistence

A list isn't just "draw some rows". You tweaked column order, set filters, sorted, saved a "view preset" — where should this table state live? Langfuse's answer is three layers, with the URL as the source of truth:

URL · source of truth sharing + deep link filter/sort/search/view id → send link, reproduce scope: shareable now session storage navigation memory widths/columns/scroll → kept across jumps scope: cleared on close database permanent saved view cross-device · team-shared → graceful degrade scope: kept forever increasing lifetime →: URL (shareable now) · session (this navigation) · DB (permanent)
URLsharing & source of truth
Filters, sort, search, current view id are all encoded into the URL. So you send a colleague the link and they see exactly the same thing — the URL is the single source of truth for "what this table looks like right now" (echoing Lesson 23's FilterState).
session storagenavigation memory
Hopping between tables, session storage remembers your recent column widths, visible columns, scroll position so you aren't reset each time you return — valid only within this browsing session.
databasepermanent presets
"View presets" (saved views) go into the DB, permanent, cross-device, team-shareable. Deleted a preset, or a column it referenced no longer exists? Graceful degradation: drop the invalid part + warn, never a blank screen.

The three layers each own a timescale — URL "shareable right now", session "this navigation", DB "permanent" — together letting a big table be deep-linkable, state-preserving across navigation, and a long-term home for the team's go-to views. Paired with a global time range (Zustand default ⊕ URL explicit), it becomes the mandatory timestamp filter feeding Lesson 22's look-back windows, nailing down the scan range. State layering is the other half of a big list's craft beyond "fast" — "stable" (no loss across navigation) and "shareable" (one link reproduces the whole view).

🎯 Design trade-off
Why not fetch it all at once (rows + all metrics), instead of two calls and a pile of "on-demand" switches? Because the list's experience goal is "instant", while metrics are inherently expensive. Cost, latency, scores need 2 big-table JOINs to compute; bound to the rows, the whole table must wait for the slowest call to show — the user stares at blank space. Split them and the compact rows (cheap, everyone wants) arrive instantly, metrics fill in as "extra info" as computed; perceived latency drops from "slowest call" to "fastest call". Likewise, conditional FINAL and conditional JOIN are the same wisdom: optimize ruthlessly for the most common, simplest path, deferring complexity and cost until "you actually ask". This is the golden rule of high-frequency list performance — don't let the 1% advanced need (sort by cost, see all metrics) slow the 99% daily browse.
🎯 Key points
  • One getTracesTableGeneric serves four shapes (rows / metrics / count / identifiers), distinguished by select with type-safe overloads.
  • Compact rows vs metrics, split: the UI fires traces.all (rows) + traces.metrics (metrics) in parallel; joinTableCoreAndMetrics merges by id and returns success even without metrics, so the table renders from rows first.
  • Conditional JOIN: LEFT JOIN observations/scores only when filter/sort needs it or select==="metrics", saving two JOINs on default browsing.
  • Conditional FINAL: default time-ordering uses toDate(timestamp),event_ts DESC + LIMIT 1 BY id to read only the latest partition; non-default ordering falls back to FROM traces FINAL full dedup.
  • Golden rule: optimize for the most common path, defer complexity/cost until "actually asked". Table state lives in three layers, URL as source of truth (URL ⊕ session ⊕ DB presets with graceful degradation); the global time range becomes the mandatory timestamp filter feeding Lesson 22's look-back windows.

🧪 Self-test - think about the design

1. Opening the trace list, Langfuse fires traces.all (rows) and traces.metrics (metrics) in parallel rather than one combined query. Why?
  1. because ClickHouse can't query two kinds at once
  2. to make metrics more accurate
  3. to flood the server with more requests
  4. compact rows are cheap and arrive instantly so the table paints first; cost/latency/score metrics need 2 JOINs and are slower, merged in by id later as extra info. Perceived latency drops from 'slowest call' to 'fastest call'
Show answer & explanation click to expand
Answer: D. The list's goal is instant open, but metrics are inherently expensive (2 JOINs). Splitting cheap rows from costly metrics, joinTableCoreAndMetrics merges by id and returns success even without metrics, so the table renders from rows first and fills metrics later. The 'compact list model' — give what you can instantly, fill in what you compute as it comes.
2. traces is a ReplacingMergeTree (one id may have multiple rows). For default time ordering, Langfuse skips FINAL and uses ORDER BY toDate(timestamp),event_ts DESC + LIMIT 1 BY id. Why is this better?
  1. because LIMIT 1 BY id saves memory
  2. because FINAL returns wrong results
  3. because default ordering needs no dedup
  4. FINAL reads all partitions and dedups on the spot, slow; time ordering + LIMIT 1 BY id lets CH read only the latest day's partition from disk and take each id's latest row in memory — correct and fast, no pulling a month of data just to dedup
Show answer & explanation click to expand
Answer: D. FINAL is correct but slow (reads all to dedup). For default time ordering, event_ts DESC + LIMIT 1 BY id takes each id's latest row in memory, CH reading only the latest partition. Only sorting by a non-time column (e.g. cost) falls back to FROM traces FINAL full dedup — pay on demand, the common path unburdened.
3. Langfuse stores table state (filters, sort, column settings, view presets) in three layers, with the URL as the source of truth. The most direct benefit?
  1. to hide filter conditions
  2. to reduce database queries
  3. to render the table faster
  4. the URL encodes the current view → send a colleague the link and they see exactly what you do (shareable/deep-linkable); session preserves state across navigation; DB stores permanent presets, cross-device shareable, with graceful degradation for invalid columns
Show answer & explanation click to expand
Answer: D. Three layers each own a timescale: URL 'shareable now' (deep links, one link reproduces the whole view, echoing L23's FilterState), session 'this navigation' (column widths/visible columns survive hops), DB 'permanent' (saved views shared cross-device/team, invalid parts dropped+warned, no blank screen). This makes big tables fast, stable, and shareable.
💭 Open questions (no single right answer - just think or try)
  • 'Optimize for the most common path, defer complexity/cost until actually asked' — compact rows vs metrics, conditional JOIN, conditional FINAL all follow it. In your own list/detail UIs, is there a place where 'the 1% advanced need slows the 99% daily browse'? How would you split it?