diff --git a/clientlibs/java/CLAUDE.md b/clientlibs/java/CLAUDE.md
index feea73a24..883fbc7f4 100644
--- a/clientlibs/java/CLAUDE.md
+++ b/clientlibs/java/CLAUDE.md
@@ -73,7 +73,18 @@ TestNG is the test framework but there is no `src/test/java` directory — `Quic
 To run a manual integration test:
 ```bash
 mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest"                    # localhost:3030
+mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="local:3031"   # another local port
 mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="qa"   # or staging
+mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="https://..."  # any base URL
+```
+
+`QuickTestBurst` takes the same values via `--env` (`--env local:3031`), or a base URL via `--url`.
+
+`QuickTestBurstUi` serves a local form for `QuickTestBurst` at http://localhost:8090: it starts each run as a separate `QuickTestBurst` process, streams the output to the page, and shows the equivalent command line. Its page is `src/main/resources/org/upgradeplatform/client/quicktest-burst-ui.html`. From the repo root, `yarn quickburst:ui` (`scripts/quickburst-ui.sh`) compiles and starts it:
+
+```bash
+yarn quickburst:ui                 # http://localhost:8090
+yarn quickburst:ui --port 8091     # another port
 ```
 
 Only localhost is in the code. `qa` / `staging` (here and in `QuickTestBurst --env`) read the base URL from `UPGRADE_QA_URL` / `UPGRADE_STAGING_URL`, which you export yourself (e.g. in your shell profile) — hosted environments' URLs stay out of this public repo. See `QuickTestHosts`.
diff --git a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTest.java b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTest.java
index 582cbbf3e..572b5cb3a 100644
--- a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTest.java
+++ b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTest.java
@@ -20,12 +20,24 @@
  *
  * <pre>
  * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest"
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="local:3031"
  * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="qa"
  * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="staging"
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTest" -Dexec.args="https://some-host.example.com"
  * </pre>
  *
- * The optional argument is local (default, http://localhost:3030), qa or staging; qa and staging read
- * UPGRADE_QA_URL / UPGRADE_STAGING_URL from the environment (see QuickTestHosts).
+ * The optional argument is local (default, http://localhost:3030), local:&lt;port&gt; for localhost on another port,
+ * qa, staging, or a base URL starting with http:// or https://.
+ * <p>
+ * <b>qa and staging are not built in.</b> Their URLs come from environment variables you set on your own machine,
+ * which you need to add to your shell profile (e.g. {@code ~/.zshrc}) once:
+ *
+ * <pre>
+ * export UPGRADE_QA_URL=https://&lt;qa backend host&gt;
+ * export UPGRADE_STAGING_URL=https://&lt;staging backend host&gt;
+ * </pre>
+ *
+ * See QuickTestHosts for details. Passing a base URL directly needs no variables.
  */
 public class QuickTest {
     private static final String userId = "quicktest_user_" + System.currentTimeMillis();
@@ -56,9 +68,13 @@ public class QuickTest {
         logRequest.add(logEntry);
     }
 
-    /** Optional first argument: local (default), qa or staging; see QuickTestHosts for the env vars qa/staging need. */
+    /**
+     * Optional first argument: local (default), local:&lt;port&gt;, qa, staging, or a base URL; see QuickTestHosts for
+     * the env vars qa/staging need.
+     */
     public static void main(String[] args) throws InterruptedException, ExecutionException {
-        String hostUrl = QuickTestHosts.forEnv(args.length > 0 ? args[0] : "local");
+        String host = args.length > 0 ? args[0] : "local";
+        String hostUrl = host.startsWith("http://") || host.startsWith("https://") ? host : QuickTestHosts.forEnv(host);
         System.out.println("host: " + hostUrl);
         System.out.println("client_session_id: " + sessionId);
         ExperimentClient client = new ExperimentClient(userId, context, "BearerToken", sessionId, hostUrl,
diff --git a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurst.java b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurst.java
index 0de526122..ccaf20007 100644
--- a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurst.java
+++ b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurst.java
@@ -2,13 +2,22 @@
 
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Random;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.eclipse.jdt.annotation.NonNull;
@@ -37,6 +46,12 @@
  * aliases) is not counted in any timing. Bursts never overlap. The sizes and waits come from {@code --seed}
  * (printed on every run), so a run can be repeated exactly, e.g. to compare two backend builds.
  *
+ * With {@code --ratePerSecond}, bursts overlap instead: a new user (setup, then its burst) starts every 1/rate
+ * seconds on average, whether or not earlier users have finished, the way users arrive in production. {@code --loops}
+ * is then the number of users started (e.g. 360 at 6/s is about a minute). Gaps between starts are random
+ * (exponential, i.e. Poisson arrivals) and come from {@code --seed}, or exactly 1/rate with {@code --evenArrivals}.
+ * The summary adds the arrival rate actually achieved and the peak users and pairs in flight at once.
+ *
  * Pairs are streamed: a new pair starts only when one of the {@code --concurrency} slots frees up, and nothing is
  * kept per pair once it finishes except its latency samples, so memory stays flat however many loops run.
  *
@@ -46,20 +61,57 @@
  *   -Dexec.args="185 --concurrency 50 --env qa --context assign-prog"
  * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurst" \
  *   -Dexec.args="--loops 50 --minBurst 10 --maxBurst 180 --minBurstWait 100 --maxBurstWait 1000 --seed 42"
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurst" \
+ *   -Dexec.args="--loops 360 --minBurst 1 --maxBurst 50 --ratePerSecond 6 --seed 42 --env qa"
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurst" \
+ *   -Dexec.args="--loops 360 --burstTiers 90:1,8:2-10,1:11-30,1:31-200 --ratePerSecond 6 --seed 42 --env qa"
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurst" \
+ *   -Dexec.args="185 --url https://some-host.example.com"
+ * </pre>
+ *
+ * <b>{@code --env qa} and {@code --env staging} are not built in.</b> Their URLs come from environment variables you
+ * set on your own machine, which you need to add to your shell profile (e.g. {@code ~/.zshrc}) once:
+ *
+ * <pre>
+ * export UPGRADE_QA_URL=https://&lt;qa backend host&gt;
+ * export UPGRADE_STAGING_URL=https://&lt;staging backend host&gt;
  * </pre>
  *
- * Options (give either {@code <count>} or both {@code --minBurst} and {@code --maxBurst}):
+ * See QuickTestHosts for details. {@code --url} takes a base URL directly and needs no variables.
+ *
+ * QuickTestBurstUi is a local web page for the same options, if you'd rather fill in a form than write the command.
+ *
+ * Options (give {@code <count>}, both {@code --minBurst} and {@code --maxBurst}, or {@code --burstTiers}):
  * <ul>
  * <li>{@code <count>} number of alias assign/mark pairs per burst (first argument; same as
  * {@code --minBurst <count> --maxBurst <count>})</li>
  * <li>{@code --loops N} number of bursts (default 1)</li>
  * <li>{@code --minBurst N --maxBurst N} alias pairs per burst, picked at random in this range (inclusive)</li>
+ * <li>{@code --burstMean N} pick burst sizes on an exponential curve instead of uniformly: {@code --minBurst} is the
+ * most common size and each larger size is a little less likely than the one before, with the curve's steepness set
+ * so sizes average N (above {@code --minBurst}, below the range's middle). The percentiles this gives are printed at
+ * the start of the run.</li>
+ * <li>{@code --burstTiers P:SIZE,P:LOW-HIGH,...} pick burst sizes by tier instead, e.g.
+ * {@code 90:1,8:2-10,1:11-30,1:31-200}: 90% of bursts are 1 pair, 8% are 2-10, and so on, with every size inside a
+ * tier equally likely. The percents must add up to 100 and the ranges must not overlap. Sets the size range itself, so
+ * it replaces {@code <count>}, {@code --minBurst / --maxBurst} and {@code --burstMean}. The mean and percentiles this
+ * gives are printed at the start of the run.</li>
  * <li>{@code --minBurstWait MS --maxBurstWait MS} wait after each burst, picked at random in this range
  * (inclusive; default 0)</li>
  * <li>{@code --seed N} seed for the burst sizes and waits (default: random, printed so it can be reused)</li>
- * <li>{@code --concurrency N} pairs in flight at once (default 50)</li>
- * <li>{@code --env local|qa|staging} (default local; qa and staging read UPGRADE_QA_URL / UPGRADE_STAGING_URL, see
- * QuickTestHosts), or {@code --url <base url>}</li>
+ * <li>{@code --ratePerSecond N} start users at this average rate, overlapping, instead of one burst after another
+ * (decimals allowed; can't be combined with {@code --minBurstWait / --maxBurstWait})</li>
+ * <li>{@code --evenArrivals} with {@code --ratePerSecond}, start users exactly 1/rate seconds apart instead of at
+ * random gaps</li>
+ * <li>{@code --percentEnroll N} mark against the mock data instead: each alias (a coin flip from {@code --seed})
+ * enrolls N% of the time, marking one of the expected targets (ws_site/ws_target_1..45, site/target_group_1,
+ * test_site/test_target_1) that its /assign returned, with the condition /assign gave it. Every other alias marks
+ * ws_site/ws_target_none with no condition. Other targets /assign returns are never marked. Without this flag, each
+ * alias marks one of whatever decision points /assign returned.</li>
+ * <li>{@code --concurrency N} pairs in flight at once, per burst (default 50)</li>
+ * <li>{@code --env local|local:<port>|qa|staging} (default local, which is localhost:3030; {@code local:3031} uses
+ * another port; qa and staging read UPGRADE_QA_URL / UPGRADE_STAGING_URL from your environment, see above), or
+ * {@code --url <base url>} to give the URL directly</li>
  * <li>{@code --context <app context>} (default assign-prog)</li>
  * <li>{@code --user <id>} use an already-initialized user for every burst instead of creating one per burst</li>
  * <li>{@code --group-type <type> --group-id <id>} group and working group for a new user (default schoolId /
@@ -85,6 +137,24 @@ public class QuickTestBurst {
     private static String groupId = "test_class_group";
     private static String authToken = "BearerToken";
     private static boolean verbose = false;
+    private static double ratePerSecond = 0;
+    private static boolean evenArrivals = false;
+    private static double burstMean = 0;
+    private static String burstTiers = null;
+    // Cumulative probability of each burst size from minBurst up; null means uniform. Set from --burstMean or
+    // --burstTiers.
+    private static double[] burstSizeCdf = null;
+    // Null means marks work as before --percentEnroll existed (see markFromAssignments).
+    private static Double percentEnroll = null;
+    // The mock data's decision points an enrolling alias may mark, as decisionPointKey(site, target).
+    private static final Set<String> ENROLL_DECISION_POINTS = enrollDecisionPoints();
+    // Every non-enrolling alias marks this, with no condition. It isn't one of the mock data's targets, and being a
+    // single fixed decision point it doesn't add a new monitored decision point for every alias.
+    private static final String NULL_MARK_SITE = "ws_site";
+    private static final String NULL_MARK_TARGET = "ws_target_none";
+    // Across every user's burst, so overlapping bursts in --ratePerSecond mode show their combined load.
+    private static final AtomicInteger pairsInFlight = new AtomicInteger();
+    private static final AtomicInteger peakPairsInFlight = new AtomicInteger();
     private static final String sessionId = "quicktest_burst_session_" + System.currentTimeMillis();
 
     /** Timings and failures, collected per burst and for the whole run. */
@@ -95,6 +165,10 @@ private static final class Stats {
         final List<Long> burstMs = Collections.synchronizedList(new ArrayList<>());
         final List<String> errors = Collections.synchronizedList(new ArrayList<>());
         final AtomicInteger emptyAssignments = new AtomicInteger();
+        // --percentEnroll only: marks by kind, and enrolling aliases that fell back to a null mark.
+        final AtomicInteger enrollMarks = new AtomicInteger();
+        final AtomicInteger nullMarks = new AtomicInteger();
+        final AtomicInteger enrollFallbacks = new AtomicInteger();
 
         void addAll(Stats other) {
             assignMs.addAll(other.assignMs);
@@ -103,6 +177,9 @@ void addAll(Stats other) {
             burstMs.addAll(other.burstMs);
             errors.addAll(other.errors);
             emptyAssignments.addAndGet(other.emptyAssignments.get());
+            enrollMarks.addAndGet(other.enrollMarks.get());
+            nullMarks.addAndGet(other.nullMarks.get());
+            enrollFallbacks.addAndGet(other.enrollFallbacks.get());
         }
     }
 
@@ -111,14 +188,38 @@ public static void main(String[] args) throws Exception {
         Random random = new Random(seed);
         String runId = "quicktest_burst_" + System.currentTimeMillis();
 
-        System.out.printf("%d burst(s) of %s assign/mark pairs, %s ms between, %d in flight, context %s, host %s%n",
-                loops, range(minBurst, maxBurst), range(minBurstWait, maxBurstWait), concurrency, context, hostUrl);
+        if (ratePerSecond > 0) {
+            System.out.printf(
+                    "%d burst(s) of %s assign/mark pairs, starting %s users/s (%s arrivals), %d in flight per user,"
+                            + " context %s, host %s%n",
+                    loops, range(minBurst, maxBurst), ratePerSecond, evenArrivals ? "even" : "random", concurrency,
+                    context, hostUrl);
+        } else {
+            System.out.printf("%d burst(s) of %s assign/mark pairs, %s ms between, %d in flight, context %s, host %s%n",
+                    loops, range(minBurst, maxBurst), range(minBurstWait, maxBurstWait), concurrency, context, hostUrl);
+        }
         System.out.println("client_session_id: " + sessionId);
         System.out.println("seed: " + seed);
+        if (minBurst != maxBurst) {
+            System.out.println(describeBurstSizes());
+        }
+        if (percentEnroll != null) {
+            System.out.printf("marks: %s%% enroll on one of the %d expected targets /assign returns,"
+                    + " the rest mark %s/%s with no condition%n", percentEnroll, ENROLL_DECISION_POINTS.size(),
+                    NULL_MARK_SITE, NULL_MARK_TARGET);
+        }
+
+        Stats total = ratePerSecond > 0 ? runAtRate(random, runId) : runSequentially(random, runId);
 
+        printSummary(total);
+        System.exit(total.errors.isEmpty() ? 0 : 1);
+    }
+
+    /** Bursts one after another: the next user's setup starts only after the previous burst and its wait. */
+    private static Stats runSequentially(Random random, String runId) throws InterruptedException {
         Stats total = new Stats();
         for (int loop = 1; loop <= loops; loop++) {
-            int count = between(random, minBurst, maxBurst);
+            int count = nextBurstSize(random);
             int waitMs = between(random, minBurstWait, maxBurstWait);
             String userId = existingUserId != null ? existingUserId : runId + "_" + loop;
 
@@ -130,9 +231,72 @@ public static void main(String[] args) throws Exception {
                 Thread.sleep(waitMs);
             }
         }
+        return total;
+    }
 
-        printSummary(total);
-        System.exit(total.errors.isEmpty() ? 0 : 1);
+    /**
+     * Bursts that overlap: a new user (setup, then its burst) starts every 1/ratePerSecond seconds on average,
+     * whether or not earlier users have finished, the way users arrive in production. A slow server therefore
+     * means more users in flight, not fewer users started. Each start is scheduled against the run's start time, so
+     * one late start doesn't push every later one back.
+     */
+    private static Stats runAtRate(Random random, String runId) throws Exception {
+        // Daemon threads, so an unexpected failure in one user ends the run instead of idle pool threads holding the
+        // JVM open.
+        ExecutorService users = Executors.newCachedThreadPool(task -> {
+            Thread thread = new Thread(task);
+            thread.setDaemon(true);
+            return thread;
+        });
+        List<Future<Stats>> results = new ArrayList<>();
+        AtomicInteger usersInFlight = new AtomicInteger();
+        AtomicInteger peakUsersInFlight = new AtomicInteger();
+
+        long runStart = System.nanoTime();
+        double nextStartNanos = 0;
+        long lastStart = runStart;
+        for (int loop = 1; loop <= loops; loop++) {
+            int count = nextBurstSize(random);
+            if (loop > 1) {
+                nextStartNanos += arrivalGapNanos(random);
+            }
+            long sleepNanos = runStart + (long) nextStartNanos - System.nanoTime();
+            if (sleepNanos > 0) {
+                TimeUnit.NANOSECONDS.sleep(sleepNanos);
+            }
+            lastStart = System.nanoTime();
+
+            int user = loop;
+            String userId = existingUserId != null ? existingUserId : runId + "_" + loop;
+            results.add(users.submit(() -> {
+                peakUsersInFlight.accumulateAndGet(usersInFlight.incrementAndGet(), Math::max);
+                try {
+                    Stats burst = runBurst(user, userId, count);
+                    printBurstLine(user, count, burst);
+                    return burst;
+                } finally {
+                    usersInFlight.decrementAndGet();
+                }
+            }));
+        }
+        double startedOverSeconds = (lastStart - runStart) / 1e9;
+
+        Stats total = new Stats();
+        for (Future<Stats> result : results) {
+            total.addAll(result.get());
+        }
+        users.shutdown();
+
+        String achieved = loops > 1 ? String.format("%.2f users/s", (loops - 1) / startedOverSeconds) : "n/a";
+        System.out.printf("%n%d users started over %.1f s: %s (target %s), peak %d users and %d pairs in flight%n",
+                loops, startedOverSeconds, achieved, ratePerSecond, peakUsersInFlight.get(), peakPairsInFlight.get());
+        return total;
+    }
+
+    /** Time until the next user starts: exponential (Poisson arrivals), or exactly 1/rate with --evenArrivals. */
+    private static double arrivalGapNanos(Random random) {
+        double gapSeconds = evenArrivals ? 1 / ratePerSecond : -Math.log(1 - random.nextDouble()) / ratePerSecond;
+        return gapSeconds * 1e9;
     }
 
     /** One burst: set up the user and its aliases, then send every alias's assign/mark pair. */
@@ -156,11 +320,16 @@ private static Stats runBurst(int loop, String userId, int count) throws Interru
         Semaphore inFlight = new Semaphore(concurrency);
         AtomicInteger completed = new AtomicInteger();
         List<CompletableFuture<Void>> closes = Collections.synchronizedList(new ArrayList<>());
+        // Separate from the run's Random, so the burst sizes and waits a seed gives don't change, and drawn here in
+        // alias order rather than as responses arrive, so each alias gets the same enroll/pick on every run.
+        Random markRandom = new Random(seed ^ (loop * 0x9E3779B97F4A7C15L));
         long burstStart = System.nanoTime();
         for (int i = 0; i < count; i++) {
+            boolean enroll = percentEnroll != null && markRandom.nextDouble() * 100 < percentEnroll;
+            double pick = markRandom.nextDouble();
             inFlight.acquire();
             try {
-                runPair(i, aliases.get(i), count, stats, completed, closes)
+                runPair(i, aliases.get(i), count, enroll, pick, stats, completed, closes)
                         .whenComplete((v, e) -> inFlight.release());
             } catch (RuntimeException e) {
                 // runPair failed before its future existed, so nothing else will give this slot back.
@@ -206,13 +375,87 @@ private static void setUpUser(String userId, List<String> aliases) {
         }
     }
 
+    /**
+     * Without --percentEnroll: mark one of the decision points /assign returned (spread across aliases by index),
+     * with its assigned condition, or a placeholder target with no condition if /assign returned none.
+     */
+    private static MarkExperimentRequestData markFromAssignments(int index, List<ExperimentsResponse> assignments,
+            Stats stats) {
+        if (assignments.isEmpty()) {
+            stats.emptyAssignments.incrementAndGet();
+            return new MarkExperimentRequestData("SelectSection", "quicktest_burst_target_" + index,
+                    new Condition(null, null));
+        }
+        ExperimentsResponse dp = assignments.get(index % assignments.size());
+        Condition[] conditions = dp.getAssignedCondition();
+        Condition markedCondition = conditions != null && conditions.length > 0
+                ? new Condition(conditions[0].getConditionCode(), conditions[0].getExperimentId())
+                : new Condition(null, null);
+        return new MarkExperimentRequestData(dp.getSite(), dp.getTarget(), markedCondition);
+    }
+
+    /**
+     * With --percentEnroll. A non-enrolling alias marks NULL_MARK_SITE/NULL_MARK_TARGET, which isn't in the mock
+     * data, with no condition. An enrolling alias marks one of the ENROLL_DECISION_POINTS that /assign returned with a
+     * condition, picked by {@code pick}, with that condition; if /assign returned none of them, it falls back to the
+     * null mark.
+     */
+    private static MarkExperimentRequestData markEnrollOrNull(List<ExperimentsResponse> assignments, boolean enroll,
+            double pick, Stats stats) {
+        if (enroll) {
+            List<ExperimentsResponse> enrollable = new ArrayList<>();
+            for (ExperimentsResponse dp : assignments) {
+                if (ENROLL_DECISION_POINTS.contains(decisionPointKey(dp.getSite(), dp.getTarget()))
+                        && assignedCondition(dp) != null) {
+                    enrollable.add(dp);
+                }
+            }
+            if (!enrollable.isEmpty()) {
+                // Sorted, so the same pick lands on the same decision point whatever order /assign listed them in.
+                enrollable.sort(Comparator.comparing(dp -> decisionPointKey(dp.getSite(), dp.getTarget())));
+                ExperimentsResponse dp = enrollable.get((int) (pick * enrollable.size()));
+                Condition condition = assignedCondition(dp);
+                stats.enrollMarks.incrementAndGet();
+                return new MarkExperimentRequestData(dp.getSite(), dp.getTarget(),
+                        new Condition(condition.getConditionCode(), condition.getExperimentId()));
+            }
+            stats.enrollFallbacks.incrementAndGet();
+        }
+        stats.nullMarks.incrementAndGet();
+        return new MarkExperimentRequestData(NULL_MARK_SITE, NULL_MARK_TARGET, new Condition(null, null));
+    }
+
+    /** The decision point's assigned condition, or null if /assign gave it none. */
+    private static Condition assignedCondition(ExperimentsResponse dp) {
+        Condition[] conditions = dp.getAssignedCondition();
+        return conditions != null && conditions.length > 0 && conditions[0].getConditionCode() != null
+                ? conditions[0]
+                : null;
+    }
+
+    private static String decisionPointKey(String site, String target) {
+        // Lower-cased: the client matches site and target case-insensitively.
+        return (site + "/" + target).toLowerCase(Locale.ROOT);
+    }
+
+    private static Set<String> enrollDecisionPoints() {
+        Set<String> keys = new HashSet<>();
+        for (int i = 1; i <= 45; i++) {
+            keys.add(decisionPointKey("ws_site", "ws_target_" + i));
+        }
+        keys.add(decisionPointKey("site", "target_group_1"));
+        keys.add(decisionPointKey("test_site", "test_target_1"));
+        return Collections.unmodifiableSet(keys);
+    }
+
     /** One alias: /assign, then /mark on one of the decision points it was assigned. */
-    private static CompletableFuture<Void> runPair(int index, String alias, int count, Stats stats,
-            AtomicInteger completed, List<CompletableFuture<Void>> closes) {
+    private static CompletableFuture<Void> runPair(int index, String alias, int count, boolean enroll, double pick,
+            Stats stats, AtomicInteger completed, List<CompletableFuture<Void>> closes) {
         ExperimentClient client = new ExperimentClient(alias, context, authToken, sessionId, hostUrl,
                 Collections.emptyMap());
         long pairStart = System.nanoTime();
         long assignStart = System.nanoTime();
+        peakPairsInFlight.accumulateAndGet(pairsInFlight.incrementAndGet(), Math::max);
 
         return call("assign", (ResponseCallback<List<ExperimentsResponse>> cb) -> client
                 .getAllExperimentConditions(true, cb))
@@ -223,24 +466,11 @@ private static CompletableFuture<Void> runPair(int index, String alias, int coun
                         System.out.printf("[%d] assign %d ms, %d decision points%n", index, ms, assignments.size());
                     }
 
-                    String site;
-                    String target;
-                    Condition markedCondition;
-                    if (assignments.isEmpty()) {
-                        stats.emptyAssignments.incrementAndGet();
-                        site = "SelectSection";
-                        target = "quicktest_burst_target_" + index;
-                        markedCondition = new Condition(null, null);
-                    } else {
-                        ExperimentsResponse dp = assignments.get(index % assignments.size());
-                        Condition[] conditions = dp.getAssignedCondition();
-                        site = dp.getSite();
-                        target = dp.getTarget();
-                        markedCondition = conditions != null && conditions.length > 0
-                                ? new Condition(conditions[0].getConditionCode(), conditions[0].getExperimentId())
-                                : new Condition(null, null);
-                    }
-                    MarkExperimentRequestData markData = new MarkExperimentRequestData(site, target, markedCondition);
+                    MarkExperimentRequestData markData = percentEnroll == null
+                            ? markFromAssignments(index, assignments, stats)
+                            : markEnrollOrNull(assignments, enroll, pick, stats);
+                    String site = markData.getSite();
+                    String target = markData.getTarget();
 
                     long markStart = System.nanoTime();
                     return call("mark", (ResponseCallback<MarkDecisionPoint> cb) -> client.markDecisionPoint(STATUS,
@@ -254,6 +484,7 @@ private static CompletableFuture<Void> runPair(int index, String alias, int coun
                             });
                 })
                 .handle((v, e) -> {
+                    pairsInFlight.decrementAndGet();
                     if (e != null) {
                         stats.errors.add("[" + index + "] " + rootMessage(e));
                     } else {
@@ -315,6 +546,15 @@ private static void printSummary(Stats total) {
             System.out.printf("%d aliases got no assignments; their /mark used a placeholder target%n",
                     total.emptyAssignments.get());
         }
+        if (percentEnroll != null) {
+            int marks = total.enrollMarks.get() + total.nullMarks.get();
+            System.out.printf("marks: %d enroll, %d null (%.1f%% enrolled, target %s%%)%n", total.enrollMarks.get(),
+                    total.nullMarks.get(), marks == 0 ? 0.0 : 100.0 * total.enrollMarks.get() / marks, percentEnroll);
+            if (total.enrollFallbacks.get() > 0) {
+                System.out.printf("%d enrolling aliases got none of the expected targets with a condition from"
+                        + " /assign, so made the null mark instead%n", total.enrollFallbacks.get());
+            }
+        }
         printLatency("assign", total.assignMs);
         printLatency("mark", total.markMs);
         printLatency("pair", total.pairMs);
@@ -385,6 +625,10 @@ private static void parseArgs(String[] args) {
                 verbose = true;
                 continue;
             }
+            if (flag.equals("--evenArrivals")) {
+                evenArrivals = true;
+                continue;
+            }
             if (i + 1 >= args.length) {
                 usage("missing value for " + flag);
             }
@@ -402,6 +646,10 @@ private static void parseArgs(String[] args) {
                         usage("--seed must be a number, got " + value);
                     }
                 }
+                case "--ratePerSecond" -> ratePerSecond = parseDouble(flag, value);
+                case "--burstMean" -> burstMean = parseDouble(flag, value);
+                case "--burstTiers" -> burstTiers = value;
+                case "--percentEnroll" -> percentEnroll = parseDouble(flag, value);
                 case "--concurrency" -> concurrency = parseInt(flag, value);
                 case "--env" -> {
                     try {
@@ -419,8 +667,15 @@ private static void parseArgs(String[] args) {
                 default -> usage("unknown option " + flag);
             }
         }
+        if (burstTiers != null) {
+            if (minBurst != 0 || maxBurst != 0 || burstMean != 0) {
+                usage("--burstTiers sets the burst sizes, so it can't be combined with <count>, --minBurst /"
+                        + " --maxBurst or --burstMean");
+            }
+            burstSizeCdf = tieredCdf(burstTiers);
+        }
         if (minBurst < 1 || maxBurst < 1) {
-            usage("give <count>, or both --minBurst and --maxBurst, of at least 1");
+            usage("give <count>, both --minBurst and --maxBurst (of at least 1), or --burstTiers");
         }
         if (maxBurst < minBurst || maxBurstWait < minBurstWait) {
             usage("--maxBurst / --maxBurstWait must be at least --minBurst / --minBurstWait");
@@ -428,6 +683,169 @@ private static void parseArgs(String[] args) {
         if (loops < 1 || concurrency < 1 || minBurstWait < 0) {
             usage("--loops and --concurrency must be at least 1, and --minBurstWait at least 0");
         }
+        if (ratePerSecond < 0) {
+            usage("--ratePerSecond must be more than 0");
+        }
+        if (ratePerSecond > 0 && maxBurstWait > 0) {
+            usage("--ratePerSecond sets when each burst starts, so it can't be combined with"
+                    + " --minBurstWait / --maxBurstWait");
+        }
+        if (evenArrivals && ratePerSecond == 0) {
+            usage("--evenArrivals needs --ratePerSecond");
+        }
+        if (percentEnroll != null && (percentEnroll < 0 || percentEnroll > 100)) {
+            usage("--percentEnroll must be from 0 to 100, got " + percentEnroll);
+        }
+        if (burstMean != 0) {
+            double midpoint = (minBurst + maxBurst) / 2.0;
+            if (!(burstMean > minBurst && burstMean < midpoint)) {
+                usage(String.format("--burstMean must be above --minBurst (%d) and below the middle of the range (%s),"
+                        + " where sizes would be uniform; got %s", minBurst, midpoint, burstMean));
+            }
+            burstSizeCdf = geometricCdfWithMean(maxBurst - minBurst + 1, burstMean - minBurst);
+        }
+    }
+
+    /** Alias pairs in the next burst: uniform in [minBurst, maxBurst], or from --burstMean's or --burstTiers' table. */
+    private static int nextBurstSize(Random random) {
+        if (burstSizeCdf == null) {
+            return between(random, minBurst, maxBurst);
+        }
+        return minBurst + sizeIndexAt(random.nextDouble());
+    }
+
+    /** The smallest size offset whose cumulative probability reaches {@code p}. */
+    private static int sizeIndexAt(double p) {
+        // Searching just below p, so a p that falls exactly on a tier boundary (e.g. 0.98 after a 90% and an 8% tier)
+        // lands on that tier's last size, not the next tier's first, despite the cumulative sums' rounding.
+        int i = Arrays.binarySearch(burstSizeCdf, p - 1e-9);
+        return i >= 0 ? i : -i - 1;
+    }
+
+    /**
+     * Cumulative probabilities for sizes minBurst..maxBurst from a --burstTiers spec such as
+     * "90:1,8:2-10,1:11-30,1:31-200": each tier is a percent of bursts and a size or inclusive size range, and its
+     * percent is spread evenly over its sizes. Sets minBurst and maxBurst to the smallest and largest size covered.
+     * The percents must add up to 100 and the ranges must not overlap; sizes no tier covers never come up.
+     */
+    private static double[] tieredCdf(String spec) {
+        List<int[]> ranges = new ArrayList<>();
+        List<Double> percents = new ArrayList<>();
+        double totalPercent = 0;
+        for (String tier : spec.split(",")) {
+            String[] parts = tier.trim().split(":");
+            String[] bounds = parts.length == 2 ? parts[1].trim().split("-") : new String[0];
+            if (bounds.length < 1 || bounds.length > 2) {
+                usage("--burstTiers: each tier is <percent>:<size> or <percent>:<low>-<high>, got \"" + tier + "\"");
+            }
+            double percent = parseDouble("--burstTiers percent", parts[0].trim());
+            int low = parseInt("--burstTiers size", bounds[0].trim());
+            int high = bounds.length == 2 ? parseInt("--burstTiers size", bounds[1].trim()) : low;
+            if (percent <= 0 || low < 1 || high < low) {
+                usage("--burstTiers: each tier needs a percent above 0 and sizes of at least 1, low to high, got \""
+                        + tier + "\"");
+            }
+            ranges.add(new int[] { low, high });
+            percents.add(percent);
+            totalPercent += percent;
+        }
+        if (Math.abs(totalPercent - 100) > 1e-6) {
+            usage("--burstTiers percents must add up to 100, got " + totalPercent);
+        }
+
+        minBurst = ranges.stream().mapToInt(r -> r[0]).min().getAsInt();
+        maxBurst = ranges.stream().mapToInt(r -> r[1]).max().getAsInt();
+        double[] weights = new double[maxBurst - minBurst + 1];
+        for (int t = 0; t < ranges.size(); t++) {
+            int[] r = ranges.get(t);
+            for (int size = r[0]; size <= r[1]; size++) {
+                if (weights[size - minBurst] > 0) {
+                    usage("--burstTiers ranges overlap at size " + size);
+                }
+                weights[size - minBurst] = percents.get(t) / (r[1] - r[0] + 1);
+            }
+        }
+
+        double[] cdf = new double[weights.length];
+        double cumulative = 0;
+        for (int k = 0; k < weights.length; k++) {
+            cumulative += weights[k];
+            cdf[k] = cumulative / totalPercent;
+        }
+        // Exactly 1, so every random.nextDouble() (always below 1) lands inside the table despite rounding.
+        cdf[cdf.length - 1] = 1.0;
+        return cdf;
+    }
+
+    /**
+     * Cumulative probabilities for offsets 0..sizes-1 from minBurst, each offset {@code ratio} times as likely as the
+     * one before it (a geometric distribution, the whole-number form of an exponential curve, cut off at maxBurst).
+     * The ratio is found by bisection so the mean offset comes out at {@code meanOffset}: the mean rises steadily
+     * from 0 (ratio near 0, every burst minBurst) to the range's midpoint (ratio 1, uniform).
+     */
+    private static double[] geometricCdfWithMean(int sizes, double meanOffset) {
+        double low = 0;
+        double high = 1;
+        double[] cdf = null;
+        for (int i = 0; i < 100; i++) {
+            double ratio = (low + high) / 2;
+            cdf = geometricCdf(sizes, ratio);
+            if (meanOffset(cdf) < meanOffset) {
+                low = ratio;
+            } else {
+                high = ratio;
+            }
+        }
+        return cdf;
+    }
+
+    private static double[] geometricCdf(int sizes, double ratio) {
+        double[] cdf = new double[sizes];
+        double weight = 1;
+        double total = 0;
+        for (int k = 0; k < sizes; k++) {
+            total += weight;
+            cdf[k] = total;
+            weight *= ratio;
+        }
+        for (int k = 0; k < sizes; k++) {
+            cdf[k] /= total;
+        }
+        // Exactly 1, so every random.nextDouble() (always below 1) lands inside the table despite rounding.
+        cdf[sizes - 1] = 1.0;
+        return cdf;
+    }
+
+    private static double meanOffset(double[] cdf) {
+        double mean = 0;
+        for (int k = 1; k < cdf.length; k++) {
+            mean += k * (cdf[k] - cdf[k - 1]);
+        }
+        return mean;
+    }
+
+    private static String describeBurstSizes() {
+        if (burstSizeCdf == null) {
+            return "burst sizes: uniform " + range(minBurst, maxBurst);
+        }
+        String shape = burstTiers != null ? "tiers " + burstTiers : "exponential curve";
+        return String.format("burst sizes: %s, %s: mean %.2f, p50=%d p90=%d p95=%d p99=%d p99.9=%d",
+                range(minBurst, maxBurst), shape, minBurst + meanOffset(burstSizeCdf), minBurst + sizeIndexAt(0.50),
+                minBurst + sizeIndexAt(0.90), minBurst + sizeIndexAt(0.95), minBurst + sizeIndexAt(0.99),
+                minBurst + sizeIndexAt(0.999));
+    }
+
+    private static double parseDouble(String name, String value) {
+        try {
+            double parsed = Double.parseDouble(value);
+            if (Double.isNaN(parsed) || Double.isInfinite(parsed)) {
+                usage(name + " must be a number, got " + value);
+            }
+            return parsed;
+        } catch (NumberFormatException e) {
+            usage(name + " must be a number, got " + value);
+            return 0;
+        }
     }
 
     private static int parseInt(String name, String value) {
@@ -442,8 +860,10 @@ private static int parseInt(String name, String value) {
     private static void usage(String problem) {
         System.err.println(problem);
         System.err.println("usage: QuickTestBurst [<count>] [--loops 1] [--minBurst N --maxBurst N]"
-                + " [--minBurstWait 0 --maxBurstWait 0] [--seed N] [--concurrency 50]"
-                + " [--env local|qa|staging | --url <url>] [--context assign-prog] [--user <existing user id>]"
+                + " [--minBurstWait 0 --maxBurstWait 0 | --ratePerSecond N [--evenArrivals]] [--seed N]"
+                + " [--burstMean N | --burstTiers 90:1,8:2-10,...] [--percentEnroll N] [--concurrency 50]"
+                + " [--env local|local:<port>|qa|staging | --url <url>] [--context assign-prog]"
+                + " [--user <existing user id>]"
                 + " [--group-type schoolId] [--group-id test_class_group] [--token BearerToken] [--verbose]");
         System.exit(2);
     }
diff --git a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurstUi.java b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurstUi.java
new file mode 100644
index 000000000..1b15a05c3
--- /dev/null
+++ b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestBurstUi.java
@@ -0,0 +1,283 @@
+package org.upgradeplatform.client;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpServer;
+
+/**
+ * A basic local web page for QuickTestBurst: fill in the options, start a run, watch its output, stop it.
+ *
+ * <pre>
+ * yarn quickburst:ui                  (from the repo root; compiles first, see scripts/quickburst-ui.sh)
+ * yarn quickburst:ui --port 8091
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurstUi"
+ * mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurstUi" -Dexec.args="--port 8091"
+ * </pre>
+ *
+ * then open http://localhost:8090 (or the port given). Ctrl-C stops it, along with any run in progress.
+ *
+ * Each run is its own QuickTestBurst process, started with this one's classpath and environment, so {@code qa} and
+ * {@code staging} need UPGRADE_QA_URL / UPGRADE_STAGING_URL set (see QuickTestHosts) before this starts; the page
+ * shows which are missing. One run at a time. The page shows the command line for the options it sends, so any run
+ * can be repeated from a terminal. It listens on localhost only.
+ */
+public class QuickTestBurstUi {
+    private static final int DEFAULT_PORT = 8090;
+    // Every POST must carry this. A page on another site can't add it without a CORS preflight, which this never
+    // answers, so another site can't start runs.
+    private static final String REQUEST_HEADER = "X-QuickTestBurst";
+    // Older lines are dropped past this, so a long --verbose run doesn't grow without bound. The summary is printed
+    // last, so it's always kept.
+    private static final int MAX_LINES = 20_000;
+    private static final String JSON = "application/json; charset=utf-8";
+
+    private static int port = DEFAULT_PORT;
+    private static String page;
+    private static int runCount = 0;
+    private static Run current = null;
+
+    /** One QuickTestBurst process and the output it has printed so far. */
+    private static final class Run {
+        final int id;
+        final List<String> args;
+        final Process process;
+        // These three are guarded by this Run.
+        final List<String> lines = new ArrayList<>();
+        int droppedLines = 0;
+        Integer exitCode = null;
+
+        Run(int id, List<String> args, Process process) {
+            this.id = id;
+            this.args = args;
+            this.process = process;
+        }
+
+        synchronized void add(String line) {
+            lines.add(line);
+            if (lines.size() > MAX_LINES) {
+                int drop = MAX_LINES / 2;
+                lines.subList(0, drop).clear();
+                droppedLines += drop;
+            }
+        }
+
+        synchronized void finish(int code) {
+            exitCode = code;
+        }
+
+        /** Status as JSON, with the lines from line number {@code from} on. */
+        synchronized String status(int from) {
+            int start = Math.max(from, droppedLines);
+            int next = droppedLines + lines.size();
+            List<String> newLines = start >= next ? List.of() : lines.subList(start - droppedLines, lines.size());
+            return "{\"id\":" + id + ",\"running\":" + (exitCode == null) + ",\"exitCode\":" + exitCode + ",\"args\":"
+                    + json(args) + ",\"from\":" + start + ",\"next\":" + next + ",\"lines\":" + json(newLines) + "}";
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        if (args.length == 2 && args[0].equals("--port")) {
+            port = Integer.parseInt(args[1]);
+        } else if (args.length != 0) {
+            System.err.println("usage: QuickTestBurstUi [--port " + DEFAULT_PORT + "]");
+            System.exit(2);
+        }
+        try (InputStream in = QuickTestBurstUi.class.getResourceAsStream("quicktest-burst-ui.html")) {
+            page = new String(in.readAllBytes(), StandardCharsets.UTF_8);
+        }
+
+        HttpServer server = HttpServer.create(new InetSocketAddress(InetAddress.getLoopbackAddress(), port), 0);
+        server.createContext("/", QuickTestBurstUi::handle);
+        server.start();
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            Run run = currentRun();
+            if (run != null) {
+                run.process.destroy();
+            }
+        }));
+        System.out.println("QuickTestBurst UI at http://localhost:" + port);
+    }
+
+    private static void handle(HttpExchange exchange) throws IOException {
+        try {
+            if (!allowed(exchange)) {
+                send(exchange, 403, "text/plain", "forbidden");
+                return;
+            }
+            String route = exchange.getRequestMethod() + " " + exchange.getRequestURI().getPath();
+            switch (route) {
+                case "GET /" -> send(exchange, 200, "text/html; charset=utf-8", page);
+                case "GET /config" -> send(exchange, 200, JSON, "{\"qa\":" + isSet("UPGRADE_QA_URL") + ",\"staging\":"
+                        + isSet("UPGRADE_STAGING_URL") + "}");
+                case "GET /status" -> status(exchange);
+                case "POST /run" -> run(exchange);
+                case "POST /stop" -> stop(exchange);
+                default -> send(exchange, 404, "text/plain", "not found");
+            }
+        } catch (Exception e) {
+            send(exchange, 500, "text/plain", String.valueOf(e.getMessage()));
+        } finally {
+            exchange.close();
+        }
+    }
+
+    /**
+     * Only requests addressed to localhost, so another site can't reach this by pointing its own name at 127.0.0.1,
+     * and only POSTs with {@link #REQUEST_HEADER}.
+     */
+    private static boolean allowed(HttpExchange exchange) {
+        String host = exchange.getRequestHeaders().getFirst("Host");
+        boolean local = ("localhost:" + port).equals(host) || ("127.0.0.1:" + port).equals(host);
+        boolean post = exchange.getRequestMethod().equals("POST");
+        return local && (!post || exchange.getRequestHeaders().containsKey(REQUEST_HEADER));
+    }
+
+    /** {@code ?id=N&from=M}: the current run, with its output from line M on, or all of it if N isn't this run. */
+    private static void status(HttpExchange exchange) throws IOException {
+        Run run = currentRun();
+        if (run == null) {
+            send(exchange, 200, JSON, "{\"id\":null,\"running\":false}");
+            return;
+        }
+        int id = -1;
+        int from = 0;
+        String query = exchange.getRequestURI().getQuery();
+        for (String pair : query == null ? new String[0] : query.split("&")) {
+            String[] parts = pair.split("=", 2);
+            try {
+                if (parts[0].equals("id")) {
+                    id = Integer.parseInt(parts[1]);
+                } else if (parts[0].equals("from")) {
+                    from = Integer.parseInt(parts[1]);
+                }
+            } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
+                // Ignored: the run's whole output is sent.
+            }
+        }
+        send(exchange, 200, JSON, run.status(id == run.id ? from : 0));
+    }
+
+    /** Starts QuickTestBurst with the request body's lines as its arguments, unless a run is already going. */
+    private static void run(HttpExchange exchange) throws IOException {
+        List<String> args = Arrays.stream(new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8)
+                .split("\r?\n")).filter(arg -> !arg.isEmpty()).toList();
+        Run run;
+        synchronized (QuickTestBurstUi.class) {
+            if (current != null && current.process.isAlive()) {
+                send(exchange, 409, "text/plain", "a run is already going; stop it first");
+                return;
+            }
+            List<String> command = new ArrayList<>(List.of(
+                    Path.of(System.getProperty("java.home"), "bin", "java").toString(), "-cp", classpath(),
+                    QuickTestBurst.class.getName()));
+            command.addAll(args);
+            Process process = new ProcessBuilder(command).redirectErrorStream(true).start();
+            run = new Run(++runCount, args, process);
+            current = run;
+        }
+        Thread reader = new Thread(() -> readOutput(run), "quicktest-burst-output-" + run.id);
+        reader.setDaemon(true);
+        reader.start();
+        System.out.println("run " + run.id + ": QuickTestBurst " + String.join(" ", args));
+        send(exchange, 200, JSON, "{\"id\":" + run.id + "}");
+    }
+
+    private static void readOutput(Run run) {
+        try (BufferedReader in = new BufferedReader(
+                new InputStreamReader(run.process.getInputStream(), StandardCharsets.UTF_8))) {
+            for (String line = in.readLine(); line != null; line = in.readLine()) {
+                run.add(line);
+            }
+        } catch (IOException e) {
+            run.add("(stopped reading output: " + e.getMessage() + ")");
+        }
+        try {
+            run.finish(run.process.waitFor());
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private static void stop(HttpExchange exchange) throws IOException {
+        Run run = currentRun();
+        if (run != null && run.process.isAlive()) {
+            run.add("(stopped from the page)");
+            run.process.destroy();
+        }
+        send(exchange, 200, JSON, "{}");
+    }
+
+    private static synchronized Run currentRun() {
+        return current;
+    }
+
+    /**
+     * The classpath this class came from, for the QuickTestBurst process. Under mvn exec:java that's the exec plugin's
+     * class loader; java.class.path is Maven's own there.
+     */
+    private static String classpath() {
+        if (QuickTestBurstUi.class.getClassLoader() instanceof URLClassLoader loader) {
+            List<String> entries = new ArrayList<>();
+            for (URL url : loader.getURLs()) {
+                try {
+                    entries.add(Path.of(url.toURI()).toString());
+                } catch (URISyntaxException e) {
+                    throw new IllegalStateException("can't use classpath entry " + url, e);
+                }
+            }
+            return String.join(File.pathSeparator, entries);
+        }
+        return System.getProperty("java.class.path");
+    }
+
+    private static boolean isSet(String name) {
+        String value = System.getenv(name);
+        return value != null && !value.isBlank();
+    }
+
+    private static void send(HttpExchange exchange, int code, String contentType, String body) throws IOException {
+        byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
+        exchange.getResponseHeaders().set("Content-Type", contentType);
+        exchange.getResponseHeaders().set("Cache-Control", "no-store");
+        exchange.sendResponseHeaders(code, bytes.length);
+        try (OutputStream out = exchange.getResponseBody()) {
+            out.write(bytes);
+        }
+    }
+
+    private static String json(List<String> values) {
+        return values.stream().map(QuickTestBurstUi::json).collect(Collectors.joining(",", "[", "]"));
+    }
+
+    private static String json(String value) {
+        StringBuilder out = new StringBuilder("\"");
+        for (char c : value.toCharArray()) {
+            switch (c) {
+                case '"' -> out.append("\\\"");
+                case '\\' -> out.append("\\\\");
+                case '\n' -> out.append("\\n");
+                case '\r' -> out.append("\\r");
+                case '\t' -> out.append("\\t");
+                default -> out.append(c < 0x20 ? String.format("\\u%04x", (int) c) : String.valueOf(c));
+            }
+        }
+        return out.append('"').toString();
+    }
+}
diff --git a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestHosts.java b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestHosts.java
index 3eeb79087..caeb1643a 100644
--- a/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestHosts.java
+++ b/clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestHosts.java
@@ -2,29 +2,65 @@
 
 /**
  * Base URLs for QuickTest and QuickTestBurst. Only localhost is in the code; the hosted environments' URLs come
- * from environment variables so they stay out of this public repo:
+ * from environment variables on your own machine so they stay out of this public repo:
  * <ul>
  * <li>{@code UPGRADE_QA_URL} for {@code qa}</li>
  * <li>{@code UPGRADE_STAGING_URL} for {@code staging}</li>
  * </ul>
- * e.g. {@code export UPGRADE_QA_URL=https://...} in your shell profile.
+ * Add these to your shell profile (e.g. {@code ~/.zshrc}), with each environment's backend base URL:
+ *
+ * <pre>
+ * export UPGRADE_QA_URL=https://&lt;qa backend host&gt;
+ * export UPGRADE_STAGING_URL=https://&lt;staging backend host&gt;
+ * </pre>
+ *
+ * then open a new terminal (or {@code source ~/.zshrc}). An IDE reads your profile only when it starts, so restart it
+ * before running from there. To skip the variables entirely, pass the base URL itself instead of an env name.
+ * <p>
+ * {@code local} is localhost on port 3030; {@code local:<port>} (e.g. {@code local:3031}) uses another port, such as a
+ * worktree's backend.
  */
 final class QuickTestHosts {
-    static final String LOCAL_URL = "http://localhost:3030";
+    static final String LOCAL_URL = localUrl(3030);
+
+    private static final String LOCAL_WITH_PORT = "local:";
 
     private QuickTestHosts() {
     }
 
-    /** The base URL for {@code local}, {@code qa} or {@code staging}; throws with a usable message otherwise. */
+    /**
+     * The base URL for {@code local}, {@code local:<port>}, {@code qa} or {@code staging}; throws with a usable message
+     * otherwise.
+     */
     static String forEnv(String env) {
+        if (env.startsWith(LOCAL_WITH_PORT)) {
+            return localUrl(parsePort(env.substring(LOCAL_WITH_PORT.length())));
+        }
         return switch (env) {
             case "local" -> LOCAL_URL;
             case "qa" -> requireEnv("UPGRADE_QA_URL");
             case "staging" -> requireEnv("UPGRADE_STAGING_URL");
-            default -> throw new IllegalArgumentException("unknown env " + env + " (local, qa, staging)");
+            default -> throw new IllegalArgumentException("unknown env " + env + " (local, local:<port>, qa, staging)");
         };
     }
 
+    private static String localUrl(int port) {
+        return "http://localhost:" + port;
+    }
+
+    private static int parsePort(String value) {
+        int port;
+        try {
+            port = Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("port must be a number, got " + value);
+        }
+        if (port < 1 || port > 65535) {
+            throw new IllegalArgumentException("port must be 1-65535, got " + port);
+        }
+        return port;
+    }
+
     private static String requireEnv(String name) {
         String value = System.getenv(name);
         if (value == null || value.isBlank()) {
diff --git a/clientlibs/java/src/main/resources/org/upgradeplatform/client/quicktest-burst-ui.html b/clientlibs/java/src/main/resources/org/upgradeplatform/client/quicktest-burst-ui.html
new file mode 100644
index 000000000..4493fa391
--- /dev/null
+++ b/clientlibs/java/src/main/resources/org/upgradeplatform/client/quicktest-burst-ui.html
@@ -0,0 +1,548 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>QuickTestBurst</title>
+<style>
+  :root {
+    --bg: #f5f6f8;
+    --panel: #ffffff;
+    --text: #1c2230;
+    --muted: #5c6578;
+    --border: #d8dce4;
+    --field: #ffffff;
+    --accent: #2b59c3;
+    --accent-text: #ffffff;
+    --ok: #1d7348;
+    --bad: #b3261e;
+    --code-bg: #eef0f4;
+    --out-bg: #12161d;
+    --out-text: #d5dae3;
+    --out-muted: #8a93a3;
+    --out-bad: #ff8a80;
+    color-scheme: light;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #0f1218;
+      --panel: #171b23;
+      --text: #e3e7ee;
+      --muted: #98a1b2;
+      --border: #2c3340;
+      --field: #10141b;
+      --accent: #6d97f2;
+      --accent-text: #0f1218;
+      --ok: #5fc48d;
+      --bad: #ff8a80;
+      --code-bg: #10141b;
+      --out-bg: #0a0d12;
+      color-scheme: dark;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    background: var(--bg);
+    color: var(--text);
+    font: 14px/1.4 system-ui, -apple-system, "Segoe UI", sans-serif;
+  }
+  code, pre, .flag { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+  header { padding: 16px 20px 0; display: flex; align-items: baseline; gap: 12px; flex-wrap: wrap; }
+  h1 { font-size: 18px; margin: 0; }
+  header p { margin: 0; color: var(--muted); }
+  .layout {
+    display: grid;
+    grid-template-columns: minmax(300px, 420px) minmax(0, 1fr);
+    gap: 20px;
+    padding: 16px 20px 20px;
+    align-items: start;
+  }
+  fieldset {
+    margin: 0 0 12px;
+    padding: 10px 12px 12px;
+    background: var(--panel);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+  }
+  legend { font-weight: 600; padding: 0 4px; }
+  .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 8px 12px; }
+  .wide { grid-column: 1 / -1; }
+  label { display: flex; flex-direction: column; gap: 3px; font-size: 13px; min-width: 0; }
+  label.check { flex-direction: row; align-items: center; gap: 6px; }
+  .flag { color: var(--muted); font-size: 11px; font-weight: normal; }
+  input, select {
+    font: inherit;
+    color: var(--text);
+    background: var(--field);
+    border: 1px solid var(--border);
+    border-radius: 5px;
+    padding: 5px 7px;
+    width: 100%;
+    min-width: 0;
+  }
+  input[type="checkbox"] { width: auto; }
+  [hidden] { display: none !important; }
+  .run { position: sticky; top: 16px; display: flex; flex-direction: column; gap: 10px; min-width: 0; }
+  .command {
+    display: flex;
+    gap: 8px;
+    align-items: flex-start;
+    background: var(--code-bg);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 8px 10px;
+  }
+  .command code { flex: 1; font-size: 12px; overflow-wrap: anywhere; }
+  .actions { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+  button {
+    font: inherit;
+    color: var(--text);
+    background: var(--panel);
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    padding: 6px 14px;
+    cursor: pointer;
+  }
+  button.small { padding: 2px 8px; font-size: 12px; }
+  button.primary {
+    background: var(--accent);
+    border-color: var(--accent);
+    color: var(--accent-text);
+    font-weight: 600;
+  }
+  button:disabled { opacity: 0.45; cursor: default; }
+  #state { color: var(--muted); }
+  #state.running { color: var(--accent); }
+  #state.ok { color: var(--ok); }
+  #state.bad { color: var(--bad); }
+  #ran { color: var(--muted); font-size: 12px; overflow-wrap: anywhere; }
+  pre#output {
+    margin: 0;
+    background: var(--out-bg);
+    color: var(--out-text);
+    border-radius: 8px;
+    padding: 10px 12px;
+    font-size: 12px;
+    line-height: 1.45;
+    height: calc(100vh - 200px);
+    min-height: 320px;
+    overflow: auto;
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+  }
+  pre#output .error { color: var(--out-bad); }
+  pre#output .note { color: var(--out-muted); font-style: italic; }
+  @media (max-width: 860px) {
+    .layout { grid-template-columns: minmax(0, 1fr); padding: 12px 16px 16px; }
+    header { padding: 12px 16px 0; }
+    .run { position: static; }
+    pre#output { height: 60vh; }
+  }
+</style>
+</head>
+<body>
+<header>
+  <h1>QuickTestBurst</h1>
+  <p>Runs QuickTestBurst with these options. One run at a time.</p>
+</header>
+<main class="layout">
+  <form id="form" autocomplete="off">
+    <fieldset>
+      <legend>Target</legend>
+      <div class="grid">
+        <label>Host <span class="flag">--env / --url</span>
+          <select name="host">
+            <option value="local">local</option>
+            <option value="qa">qa</option>
+            <option value="staging">staging</option>
+            <option value="url">URL</option>
+          </select>
+        </label>
+        <label data-show="host:local">Port <span class="flag">local:&lt;port&gt;</span>
+          <input name="port" type="number" min="1" max="65535" value="3030">
+        </label>
+        <label data-show="host:url">Base URL <span class="flag">--url</span>
+          <input name="url" type="text" placeholder="https://…">
+        </label>
+        <p id="hostNote" class="wide flag" hidden></p>
+        <label>Context <span class="flag">--context</span>
+          <input name="context" type="text" value="assign-prog">
+        </label>
+        <label>Existing user <span class="flag">--user</span>
+          <input name="user" type="text" placeholder="new user each burst">
+        </label>
+        <label>Group type <span class="flag">--group-type</span>
+          <input name="groupType" type="text" value="schoolId">
+        </label>
+        <label>Group id <span class="flag">--group-id</span>
+          <input name="groupId" type="text" value="test_class_group">
+        </label>
+        <label class="wide">Token <span class="flag">--token</span>
+          <input name="token" type="text" value="BearerToken">
+        </label>
+      </div>
+    </fieldset>
+
+    <fieldset>
+      <legend>Burst sizes (alias pairs per burst)</legend>
+      <div class="grid">
+        <label class="wide">Sizes
+          <select name="sizeMode">
+            <option value="fixed">Same size every burst</option>
+            <option value="uniform">Random in a range, evenly</option>
+            <option value="exponential">Random in a range, mostly small</option>
+            <option value="tiers">Random by tier</option>
+          </select>
+        </label>
+        <label data-show="sizeMode:fixed">Pairs <span class="flag">&lt;count&gt;</span>
+          <input name="count" type="number" min="1" value="10">
+        </label>
+        <label data-show="sizeMode:uniform,exponential">Min <span class="flag">--minBurst</span>
+          <input name="minBurst" type="number" min="1" value="1">
+        </label>
+        <label data-show="sizeMode:uniform,exponential">Max <span class="flag">--maxBurst</span>
+          <input name="maxBurst" type="number" min="1" value="50">
+        </label>
+        <label data-show="sizeMode:exponential">Mean <span class="flag">--burstMean</span>
+          <input name="burstMean" type="number" min="1" step="any" value="5">
+        </label>
+        <label class="wide" data-show="sizeMode:tiers">Tiers, percent:size <span class="flag">--burstTiers</span>
+          <input name="burstTiers" type="text" value="90:1,8:2-10,1:11-30,1:31-200">
+        </label>
+      </div>
+    </fieldset>
+
+    <fieldset>
+      <legend>Pacing</legend>
+      <div class="grid">
+        <label>Bursts <span class="flag">--loops</span>
+          <input name="loops" type="number" min="1" value="1">
+        </label>
+        <label>Pairs in flight per burst <span class="flag">--concurrency</span>
+          <input name="concurrency" type="number" min="1" value="50">
+        </label>
+        <label class="wide">Bursts run
+          <select name="paceMode">
+            <option value="sequential">One after another</option>
+            <option value="rate">Overlapping, at a rate</option>
+          </select>
+        </label>
+        <label data-show="paceMode:sequential">Min wait, ms <span class="flag">--minBurstWait</span>
+          <input name="minBurstWait" type="number" min="0" value="0">
+        </label>
+        <label data-show="paceMode:sequential">Max wait, ms <span class="flag">--maxBurstWait</span>
+          <input name="maxBurstWait" type="number" min="0" value="0">
+        </label>
+        <label data-show="paceMode:rate">Users per second <span class="flag">--ratePerSecond</span>
+          <input name="ratePerSecond" type="number" min="0" step="any" value="6">
+        </label>
+        <label class="check" data-show="paceMode:rate">
+          <input name="evenArrivals" type="checkbox"> Even gaps <span class="flag">--evenArrivals</span>
+        </label>
+      </div>
+    </fieldset>
+
+    <fieldset>
+      <legend>Other</legend>
+      <div class="grid">
+        <label>Seed <span class="flag">--seed</span>
+          <input name="seed" type="text" inputmode="numeric" placeholder="random">
+        </label>
+        <label>Percent enrolling <span class="flag">--percentEnroll</span>
+          <input name="percentEnroll" type="number" min="0" max="100" step="any" placeholder="off">
+        </label>
+        <label class="check wide">
+          <input name="verbose" type="checkbox"> Print every call <span class="flag">--verbose</span>
+        </label>
+      </div>
+    </fieldset>
+    <button type="button" id="reset" class="small">Reset to defaults</button>
+  </form>
+
+  <section class="run">
+    <div class="command">
+      <code id="command"></code>
+      <button type="button" id="copy" class="small">Copy</button>
+    </div>
+    <div class="actions">
+      <button type="button" id="run" class="primary">Run</button>
+      <button type="button" id="stop" disabled>Stop</button>
+      <span id="state">Connecting…</span>
+    </div>
+    <div id="ran"></div>
+    <pre id="output"></pre>
+  </section>
+</main>
+
+<script>
+  // QuickTestBurst's own defaults. A field left at its default isn't passed, to keep the command short.
+  const DEFAULTS = {
+    port: '3030',
+    context: 'assign-prog',
+    groupType: 'schoolId',
+    groupId: 'test_class_group',
+    token: 'BearerToken',
+    loops: '1',
+    concurrency: '50',
+    minBurstWait: '0',
+    maxBurstWait: '0',
+  };
+
+  /** The QuickTestBurst arguments for the form's values, given as a plain object of field name to value. */
+  function buildArgs(v) {
+    const args = [];
+    const val = (key) => String(v[key] ?? '').trim();
+    const add = (flag, key) => {
+      if (val(key) !== '') args.push(flag, val(key));
+    };
+    const addChanged = (flag, key) => {
+      if (val(key) !== '' && val(key) !== DEFAULTS[key]) args.push(flag, val(key));
+    };
+
+    if (v.sizeMode === 'fixed') {
+      if (val('count') !== '') args.push(val('count'));
+    } else if (v.sizeMode === 'tiers') {
+      add('--burstTiers', 'burstTiers');
+    } else {
+      add('--minBurst', 'minBurst');
+      add('--maxBurst', 'maxBurst');
+      if (v.sizeMode === 'exponential') add('--burstMean', 'burstMean');
+    }
+    addChanged('--loops', 'loops');
+    addChanged('--concurrency', 'concurrency');
+    if (v.paceMode === 'rate') {
+      add('--ratePerSecond', 'ratePerSecond');
+      if (v.evenArrivals) args.push('--evenArrivals');
+    } else {
+      addChanged('--minBurstWait', 'minBurstWait');
+      addChanged('--maxBurstWait', 'maxBurstWait');
+    }
+    add('--seed', 'seed');
+    add('--percentEnroll', 'percentEnroll');
+    if (v.host === 'url') {
+      add('--url', 'url');
+    } else if (v.host === 'local') {
+      if (val('port') !== '' && val('port') !== DEFAULTS.port) args.push('--env', 'local:' + val('port'));
+    } else {
+      args.push('--env', v.host);
+    }
+    addChanged('--context', 'context');
+    add('--user', 'user');
+    addChanged('--group-type', 'groupType');
+    addChanged('--group-id', 'groupId');
+    addChanged('--token', 'token');
+    if (v.verbose) args.push('--verbose');
+    return args;
+  }
+
+  /** The terminal command for these arguments, run from clientlibs/java. */
+  function commandLine(args) {
+    const joined = args.map((arg) => (/^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg}'`)).join(' ');
+    return 'mvn exec:java -Dexec.mainClass="org.upgradeplatform.client.QuickTestBurst" -Dexec.args="'
+      + joined.replace(/(["$`\\])/g, '\\$1') + '"';
+  }
+
+  const form = document.getElementById('form');
+  const commandEl = document.getElementById('command');
+  const runButton = document.getElementById('run');
+  const stopButton = document.getElementById('stop');
+  const stateEl = document.getElementById('state');
+  const ranEl = document.getElementById('ran');
+  const output = document.getElementById('output');
+  const STORAGE_KEY = 'quicktest-burst-ui';
+
+  function formValues() {
+    return Object.fromEntries(new FormData(form));
+  }
+
+  function save() {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(formValues()));
+    } catch (e) {
+      // Not remembered; the form still works.
+    }
+  }
+
+  function restore() {
+    let saved = null;
+    try {
+      saved = JSON.parse(localStorage.getItem(STORAGE_KEY));
+    } catch (e) {
+      return;
+    }
+    if (!saved) return;
+    for (const el of form.elements) {
+      if (!el.name) continue;
+      if (el.type === 'checkbox') el.checked = el.name in saved;
+      else if (el.name in saved) el.value = saved[el.name];
+    }
+  }
+
+  function update() {
+    const v = formValues();
+    for (const el of form.querySelectorAll('[data-show]')) {
+      const [name, values] = el.dataset.show.split(':');
+      el.hidden = !values.split(',').includes(v[name]);
+    }
+    commandEl.textContent = commandLine(buildArgs(v));
+  }
+
+  form.addEventListener('input', () => {
+    update();
+    save();
+  });
+  form.addEventListener('submit', (e) => e.preventDefault());
+
+  document.getElementById('reset').addEventListener('click', () => {
+    form.reset();
+    update();
+    save();
+  });
+
+  document.getElementById('copy').addEventListener('click', async (e) => {
+    try {
+      await navigator.clipboard.writeText(commandEl.textContent);
+      e.target.textContent = 'Copied';
+    } catch (err) {
+      e.target.textContent = 'Copy failed';
+    }
+    setTimeout(() => (e.target.textContent = 'Copy'), 1500);
+  });
+
+  // Polling: every half second while a run is going, every two seconds otherwise (to pick up a run started from
+  // another tab).
+  let runId = null;
+  let next = 0;
+  let pollTimer = null;
+  let polling = false;
+  let pollAgain = false;
+
+  function pollSoon() {
+    if (polling) {
+      pollAgain = true;
+    } else {
+      clearTimeout(pollTimer);
+      poll();
+    }
+  }
+
+  async function poll() {
+    polling = true;
+    let running = false;
+    try {
+      const res = await fetch(`status?id=${runId ?? -1}&from=${next}`, { cache: 'no-store' });
+      const s = await res.json();
+      running = s.running;
+      if (s.id !== null) showRun(s);
+      showState(s);
+    } catch (e) {
+      setState('Can’t reach the QuickTestBurstUi server. Is it still running?', 'bad');
+      runButton.disabled = true;
+      stopButton.disabled = true;
+    }
+    polling = false;
+    pollTimer = setTimeout(poll, pollAgain ? 0 : running ? 500 : 2000);
+    pollAgain = false;
+  }
+
+  function showRun(s) {
+    if (s.id !== runId) {
+      runId = s.id;
+      next = 0;
+      output.textContent = '';
+      ranEl.textContent = `Run ${s.id}: QuickTestBurst ${s.args.join(' ')}`;
+    }
+    const atBottom = output.scrollHeight - output.scrollTop - output.clientHeight < 40;
+    const lines = document.createDocumentFragment();
+    if (s.from > next) appendLine(lines, `(${s.from - next} earlier lines dropped to save memory)`, 'note');
+    for (const line of s.lines) {
+      const cls = /^\(.*\)$/.test(line) ? 'note' : /\berror\b|^usage:/i.test(line) ? 'error' : null;
+      appendLine(lines, line, cls);
+    }
+    output.appendChild(lines);
+    next = s.next;
+    if (atBottom) output.scrollTop = output.scrollHeight;
+  }
+
+  function appendLine(parent, text, cls) {
+    if (cls) {
+      const span = document.createElement('span');
+      span.className = cls;
+      span.textContent = text + '\n';
+      parent.appendChild(span);
+    } else {
+      parent.appendChild(document.createTextNode(text + '\n'));
+    }
+  }
+
+  function showState(s) {
+    runButton.disabled = s.running;
+    stopButton.disabled = !s.running;
+    if (s.id === null) setState('Ready');
+    else if (s.running) setState('Running…', 'running');
+    else if (s.exitCode === 0) setState('Finished, exit 0', 'ok');
+    else if (s.exitCode === 1) setState('Finished with errors, exit 1', 'bad');
+    else if (s.exitCode === 2) setState('Options rejected, exit 2; see the output', 'bad');
+    else setState(`Stopped, exit ${s.exitCode}`, 'bad');
+  }
+
+  function setState(text, cls) {
+    stateEl.textContent = text;
+    stateEl.className = cls ?? '';
+  }
+
+  async function post(path, body) {
+    return fetch(path, { method: 'POST', headers: { 'X-QuickTestBurst': '1' }, body: body ?? '' });
+  }
+
+  runButton.addEventListener('click', async () => {
+    const values = formValues();
+    if (values.host === 'url' && !values.url.trim()) {
+      setState('Enter a base URL before starting a run.', 'bad');
+      return;
+    }
+    runButton.disabled = true;
+    const res = await post('run', buildArgs(values).join('\n'));
+    if (!res.ok) setState(await res.text(), 'bad');
+    pollSoon();
+  });
+
+  stopButton.addEventListener('click', async () => {
+    stopButton.disabled = true;
+    await post('stop');
+    pollSoon();
+  });
+
+  // Marks qa / staging unavailable when their URL variable isn't set where the server was started.
+  async function loadConfig() {
+    const hostNote = document.getElementById('hostNote');
+    try {
+      const config = await (await fetch('config')).json();
+      const missing = [];
+      for (const [env, variable] of [['qa', 'UPGRADE_QA_URL'], ['staging', 'UPGRADE_STAGING_URL']]) {
+        if (config[env]) continue;
+        const option = form.elements.host.querySelector(`option[value="${env}"]`);
+        option.disabled = true;
+        option.textContent = `${env} (${variable} not set)`;
+        missing.push(variable);
+      }
+      if (missing.length) {
+        const one = missing.length === 1;
+        hostNote.textContent = `${missing.join(' and ')} ${one ? 'wasn’t' : 'weren’t'} set in the shell that `
+          + `started this server. Export ${one ? 'it' : 'them'} (see QuickTestHosts) and restart the server to use `
+          + `${one ? 'that host' : 'those hosts'}.`;
+        hostNote.hidden = false;
+      }
+    } catch (e) {
+      // The run's own output will say if a host is missing.
+    }
+  }
+
+  restore();
+  update();
+  loadConfig();
+  poll();
+</script>
+</body>
+</html>
diff --git a/package.json b/package.json
index 2a26a6221..4a9824cee 100644
--- a/package.json
+++ b/package.json
@@ -37,7 +37,8 @@
     "build:all": "yarn types build && concurrently \"yarn backend build\" \"yarn js-clientlib build\" \"yarn frontend build\"",
     "launch": "concurrently -p \"[{name}]\" -n \"types,backend,frontend\" -c \"blue,magenta,cyan\" \"yarn types build\" \"yarn backend dev\" \"yarn frontend start\"",
     "clean-launch": "yarn clean && yarn install:all && yarn build:all && yarn launch",
-    "cache-demo": "./scripts/cache-demo.sh"
+    "cache-demo": "./scripts/cache-demo.sh",
+    "quickburst:ui": "./scripts/quickburst-ui.sh"
   },
   "lint-staged": {
     "./packages/frontend/projects/upgrade/src/**/*.{ts,js,html,json,scss}": [
diff --git a/scripts/quickburst-ui.sh b/scripts/quickburst-ui.sh
new file mode 100755
index 000000000..b1191037e
--- /dev/null
+++ b/scripts/quickburst-ui.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+#
+# Starts QuickTestBurstUi, the local web page for QuickTestBurst runs (clientlibs/java).
+#
+#   yarn quickburst:ui               serve it at http://localhost:8090
+#   yarn quickburst:ui --port 8091   on another port, e.g. when one is already running in another worktree
+#
+# Compiles the Java client first, so the page always runs the current code. Needs Maven and a JDK (17+).
+# --env qa / staging need UPGRADE_QA_URL / UPGRADE_STAGING_URL exported in the shell this runs from; see
+# clientlibs/java/src/main/java/org/upgradeplatform/client/QuickTestHosts.java. Ctrl-C stops it, along with any run in
+# progress.
+
+set -euo pipefail
+
+cd "$(dirname "$0")/../clientlibs/java"
+exec mvn -q compile exec:java -Dexec.mainClass=org.upgradeplatform.client.QuickTestBurstUi ${1:+"-Dexec.args=$*"}