@@ -500,7 +500,7 @@ table with `sketch_bench_e2e/sketch_bench_e2e_configs.py`.
 - **Example**: `"--concurrency 32"`
 
 #### `experiment_params.dataset.paced_feeder` (dict, optional; `experiment_run_clickhouse.py`)
-- **Description**: The same keys as `exporters.exporter_list.paced_feeder`, for the ClickHouse runner. In place of the bulk load of `dataset.local_data_file`, each mode runs `dataset.init_sql_file`, then feeds every listed metric (records metrics too) from the ClickHouse node into the table named after it while its queries run. In `sketchdb` mode the engine ingests over remote write (`streaming.remote_write.base_port`/`path`) instead of `dataset.local_data_file`, and the same feed (one start, one seed) also goes to ClickHouse, which answers the queries ASAPQuery forwards; it waits for no `flow.steady_state_wait` and needs `controller.prebuilt_output_dir` (a fed dataset has no `dataset.precompute` to build the planner's input from). `duration_secs` must cover the startup check, the query client's startup (30 s) and the query groups' running time; after the queries each mode waits for the feeders to finish, so they write their `--stats-out`. Requires `dataset.name: custom` and `dataset.init_sql_file`
+- **Description**: The same keys as `exporters.exporter_list.paced_feeder`, for the ClickHouse runner. In place of the bulk load of `dataset.local_data_file`, each mode runs `dataset.init_sql_file`, then feeds every listed metric (records metrics too) from the ClickHouse node into the table named after it while its queries run. In `sketchdb` mode the engine ingests over remote write (`streaming.remote_write.base_port`/`path`) instead of `dataset.local_data_file`, and the feed goes to ASAPQuery only, so it forwards no unsupported queries to ClickHouse (whose copy of the data would load the measured node); it waits for no `flow.steady_state_wait` and needs `controller.prebuilt_output_dir` (a fed dataset has no `dataset.precompute` to build the planner's input from). `duration_secs` must cover the startup check, the query client's startup (30 s) and the query groups' running time; after the queries each mode waits for the feeders to finish, so they write their `--stats-out`. Requires `dataset.name: custom` and `dataset.init_sql_file`
 - **Example**: `{workload_table: /path/to/table.json, metrics: [data, data_total], seed: 42, duration_secs: 4000}`
 
 ### Query Group Configuration
 
@@ -92,17 +92,17 @@
 A sketch-bench workload table (sketch_bench_workloads.py configs) is fed in
 real time instead, one paced feeder per metric table, when
 experiment_params.dataset.paced_feeder is set. Each mode then recreates the
-tables and starts its own feed; sketchdb's feed goes to the engine's
-remote-write ingest as well as ClickHouse (which answers forwarded queries),
-from one start, and needs controller.prebuilt_output_dir.
+tables and starts its own feed. sketchdb's feed goes only to the engine's
+remote-write ingest, so it forwards no queries to ClickHouse, and it needs
+controller.prebuilt_output_dir.
 """
 
 import atexit
 import functools
 import json
 import os
 import time
-from typing import Callable, List, Optional
+from typing import Callable, Dict, List, Optional
 from urllib.parse import urlparse
 
 import hydra
@@ -358,7 +358,21 @@ def _check_clickhouse_paced_feeder(
     return aligned_interval_lcm(client_config)
 
 
-def _start_clickhouse_feed(
+def _feed_sinks(
+    experiment_mode: str, clickhouse_http_port: int, query_engine_url: str
+) -> Dict[str, str]:
+    """The sinks a mode's feed writes to. sketchdb feeds only ASAPQuery: it
+    forwards no queries, and a ClickHouse copy would only load the node its
+    CPU and latency are measured on. Every other mode reads ClickHouse."""
+    if experiment_mode == constants.SKETCHDB_EXPERIMENT_NAME:
+        return {SINK_QUERY_ENGINE: query_engine_url}
+    return {
+        SINK_CLICKHOUSE: f"http://localhost:{clickhouse_http_port}/"
+        f"?database={CLICKHOUSE_DATABASE}"
+    }
+
+
+def _start_feed(
     *,
     provider,
     node_offset: int,
@@ -368,20 +382,14 @@ def _start_clickhouse_feed(
     feeder_align_secs: int,
     dataset_name: str,
     init_sql_file: str,
-    clickhouse_http_port: int,
+    sinks: Dict[str, str],
     experiment_mode: str,
     experiment_root_output_dir: str,
     local_experiment_root_dir: str,
-    query_engine_url: Optional[str] = None,
 ) -> int:
     """Recreate the metric tables, start one feeder per (sink, metric), and
     point the mode's aligned query groups at the feed's start; returns that
-    start in epoch ms.
-
-    ClickHouse is always fed; with `query_engine_url` (sketchdb) so is
-    ASAPQuery's remote-write ingest, from the same start and seed, so the
-    queries it forwards to ClickHouse read the same data.
-    """
+    start in epoch ms; `sinks` from _feed_sinks."""
     # An earlier mode's feeders (left running by no_teardown, or with an
     # INSERT in flight) would write into the recreated tables.
     feeder_service.stop()
@@ -392,12 +400,6 @@ def _start_clickhouse_feed(
         )
     # Before any data arrives: views only see rows inserted after they exist.
     data_loader.run_init_sql(dataset_name, init_sql_file)
-    sinks = {
-        SINK_CLICKHOUSE: f"http://localhost:{clickhouse_http_port}/"
-        f"?database={CLICKHOUSE_DATABASE}"
-    }
-    if query_engine_url is not None:
-        sinks[SINK_QUERY_ENGINE] = query_engine_url
     start_ms = feeder_service.start(
         config=feeder_config,
         sinks=sinks,
@@ -707,7 +709,7 @@ def main(cfg: DictConfig) -> None:
     remote_monitor_service = RemoteMonitorService(provider, node_offset=node_offset)
     if paced_feeder_service is not None:
         start_feed = functools.partial(
-            _start_clickhouse_feed,
+            _start_feed,
             provider=provider,
             node_offset=node_offset,
             data_loader=data_loader,
@@ -716,10 +718,13 @@ def main(cfg: DictConfig) -> None:
             feeder_align_secs=paced_feeder_align_secs,
             dataset_name=dataset_name,
             init_sql_file=init_sql_file,
-            clickhouse_http_port=clickhouse_http_port,
             experiment_root_output_dir=experiment_root_output_dir,
             local_experiment_root_dir=local_experiment_root_dir,
         )
+        query_engine_url = (
+            f"http://localhost:{int(cfg.streaming.remote_write.base_port)}"
+            f"{cfg.streaming.remote_write.path}"
+        )
     else:
         ingest_mode = _ingest_mode(experiment_modes)
         ingest_client_config = os.path.join(
@@ -866,7 +871,9 @@ def generate_controller_output() -> None:
                     "type": "clickhouse",
                     "url": clickhouse_url,
                     "database": CLICKHOUSE_DATABASE,
-                    "forward_unsupported_queries": True,
+                    # A fed run feeds ClickHouse only in the baseline modes,
+                    # so it would answer a forwarded query from no data.
+                    "forward_unsupported_queries": paced_feeder_service is None,
                 },
                 http_port=asap_http_port,
                 spill=cfg.query_engine.spill,
@@ -885,8 +892,9 @@ def generate_controller_output() -> None:
                 # arrive.
                 feed_start_ms = start_feed(
                     experiment_mode=experiment_mode,
-                    query_engine_url=f"http://localhost:{remote_write_port}"
-                    f"{cfg.streaming.remote_write.path}",
+                    sinks=_feed_sinks(
+                        experiment_mode, clickhouse_http_port, query_engine_url
+                    ),
                 )
                 pre_query_wait_seconds = 0
             else:
@@ -948,7 +956,12 @@ def generate_controller_output() -> None:
         else:
             # --- baseline mode ---
             if paced_feeder_service is not None:
-                feed_start_ms = start_feed(experiment_mode=experiment_mode)
+                feed_start_ms = start_feed(
+                    experiment_mode=experiment_mode,
+                    sinks=_feed_sinks(
+                        experiment_mode, clickhouse_http_port, query_engine_url
+                    ),
+                )
             controller_client_config = os.path.join(
                 experiment_root_output_dir,
                 "controller_client_configs",
 
@@ -18,7 +18,8 @@
     _prepare_clickhouse_controller_output,
     _start_clickhouse_controller,
     _finish_clickhouse_feed,
-    _start_clickhouse_feed,
+    _feed_sinks,
+    _start_feed,
 )
 from experiment_utils.config import validate_experiment_config
 from experiment_utils.services.paced_feeder import PACED_FEEDER_STARTUP_CHECK_SECS
@@ -163,8 +164,25 @@ def test_feed_must_outlast_the_query_client_startup(self):
         )
 
 
-class StartClickHouseFeedTest(unittest.TestCase):
-    def start(self, calls, exited=True, mode="baseline", query_engine_url=None):
+class FeedSinksTest(unittest.TestCase):
+    def test_baseline_modes_feed_clickhouse(self):
+        for mode in ("baseline", "baseline_mv"):
+            self.assertEqual(
+                _feed_sinks(mode, 8123, "http://localhost:8080/api/v1/write"),
+                {"clickhouse": "http://localhost:8123/?database=default"},
+            )
+
+    def test_sketchdb_feeds_only_the_engine(self):
+        # It forwards no queries, so a ClickHouse copy would only load the
+        # node its CPU and latency are measured on.
+        self.assertEqual(
+            _feed_sinks("sketchdb", 8123, "http://localhost:8080/api/v1/write"),
+            {"query_engine": "http://localhost:8080/api/v1/write"},
+        )
+
+
+class StartFeedTest(unittest.TestCase):
+    def start(self, calls, exited=True, mode="baseline"):
         calls.feeder.start.return_value = 1700000060000
         calls.feeder.wait_for_exit.return_value = exited
         with tempfile.TemporaryDirectory() as root, patch(
@@ -176,7 +194,7 @@ def start(self, calls, exited=True, mode="baseline", query_engine_url=None):
             with open(config_path, "w") as f:
                 yaml.safe_dump(aligned_client_config(60), f)
 
-            start_ms = _start_clickhouse_feed(
+            start_ms = _start_feed(
                 provider=Mock(),
                 node_offset=0,
                 data_loader=calls.loader,
@@ -185,11 +203,10 @@ def start(self, calls, exited=True, mode="baseline", query_engine_url=None):
                 feeder_align_secs=60,
                 dataset_name="custom",
                 init_sql_file="init.sql",
-                clickhouse_http_port=8123,
+                sinks={"clickhouse": "http://localhost:8123/?database=default"},
                 experiment_mode=mode,
                 experiment_root_output_dir="/exp",
                 local_experiment_root_dir=root,
-                query_engine_url=query_engine_url,
             )
             with open(config_path) as f:
                 self.client_config = yaml.safe_load(f)
@@ -223,24 +240,10 @@ def test_tables_are_created_before_the_feed_and_queries_follow_it(self):
         )
         self.rsync.assert_called_once()
 
-    def test_sketchdb_feeds_the_engine_and_clickhouse_from_one_start(self):
-        # ClickHouse answers the queries ASAPQuery forwards, so it gets the
-        # same data from the same start.
+    def test_sketchdb_queries_follow_its_own_feed(self):
         calls = Mock()
-        self.start(
-            calls,
-            mode="sketchdb",
-            query_engine_url="http://localhost:8080/api/v1/write",
-        )
-        calls.feeder.start.assert_called_once()
+        self.start(calls, mode="sketchdb")
         start_kwargs = calls.feeder.start.call_args.kwargs
-        self.assertEqual(
-            start_kwargs["sinks"],
-            {
-                "clickhouse": "http://localhost:8123/?database=default",
-                "query_engine": "http://localhost:8080/api/v1/write",
-            },
-        )
         self.assertEqual(start_kwargs["experiment_output_dir"], "/exp/sketchdb")
         self.assertEqual(
             self.client_config["query_groups"][0]["client_options"]["data_start_time"],