diff --git a/tests/ui-testing/pages/alertsPages/alertManagement.js b/tests/ui-testing/pages/alertsPages/alertManagement.js
index 0dba53e417..a5870ff06b 100644
--- a/tests/ui-testing/pages/alertsPages/alertManagement.js
+++ b/tests/ui-testing/pages/alertsPages/alertManagement.js
@@ -37,9 +37,15 @@ export class AlertManagement {
         const operatorDropdown = this.page.locator(this.locators.operatorSelect).first();
         await expect(operatorDropdown).toBeVisible({ timeout: 15000 });
         await operatorDropdown.click();
-        await this.page.waitForTimeout(500);
-        await this.page.getByText('=', { exact: true }).click();
-        await this.page.waitForTimeout(1000);
+        // The operator control is an OSelect: it renders an aria-hidden native
+        // <select><option>=</option> alongside the visible popover item, so an unscoped
+        // getByText('=', {exact}) matches BOTH nodes and trips a strict-mode violation.
+        // Scope the click to the popover and match by role so the hidden native select is
+        // excluded, and gate on the popover's open/close state instead of hard waits.
+        const operatorPopover = this.page.locator('[data-test="alert-conditions-operator-select-popover"]');
+        await expect(operatorPopover).toBeVisible({ timeout: 10000 });
+        await operatorPopover.getByRole('option', { name: '=', exact: true }).click();
+        await expect(operatorPopover).toBeHidden({ timeout: 10000 });
         testLogger.info('Changed operator from Contains to =');
 
         await this.page.locator(this.locators.alertSubmitButton).click();
diff --git a/tests/ui-testing/pages/generalPages/ingestionPage.js b/tests/ui-testing/pages/generalPages/ingestionPage.js
index 1ae3cd7033..3ed862eb1d 100644
--- a/tests/ui-testing/pages/generalPages/ingestionPage.js
+++ b/tests/ui-testing/pages/generalPages/ingestionPage.js
@@ -19,7 +19,17 @@ async function fetchWithRetry(url, options, maxRetries = 3) {
   const requestOpts = { ...options, compress: false, agent: selectAgent };
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
-      return await nodeFetch(url, requestOpts);
+      const response = await nodeFetch(url, requestOpts);
+      // Retry transient 5xx (alpha returns 503/502 on ingestion during load spikes) —
+      // a bare fetch treats those as success and the caller throws on the first one.
+      // A persistent 5xx still returns after maxRetries, so nothing is masked.
+      if (response.status >= 500 && attempt < maxRetries) {
+        const backoffMs = 800 * (attempt + 1);
+        testLogger.warn('Transient 5xx from ingestion, retrying', { url, status: response.status, attempt: attempt + 1, maxRetries, backoffMs });
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        continue;
+      }
+      return response;
     } catch (err) {
       const message = String(err && err.message ? err.message : err);
       const isTransient = /premature close|ECONNRESET|socket hang up|network|EPIPE|other side closed/i.test(message);
diff --git a/tests/ui-testing/pages/pipelinesPages/pipelinesPage.js b/tests/ui-testing/pages/pipelinesPages/pipelinesPage.js
index cb071b4a5b..1717c7bf99 100644
--- a/tests/ui-testing/pages/pipelinesPages/pipelinesPage.js
+++ b/tests/ui-testing/pages/pipelinesPages/pipelinesPage.js
@@ -38,7 +38,20 @@ async function fetchWithRetry(url, options, maxRetries = 3) {
     };
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
-            return await fetch(url, requestOpts);
+            const response = await fetch(url, requestOpts);
+            // A 5xx is a transient backend blip, not a client error — alpha returns
+            // 503 Service Unavailable / 502 Bad Gateway on ingestion during load spikes,
+            // and a bare fetch treats those as a "successful" response so the caller threw
+            // on the first one (pipelines:180 hard-failed on a run with 4x 503 + 1x 502).
+            // Retry 5xx with backoff like a network error; a persistent 5xx still returns
+            // after maxRetries and the caller throws — nothing is masked.
+            if (response.status >= 500 && attempt < maxRetries) {
+                const backoffMs = 800 * (attempt + 1);
+                testLogger.warn('Transient 5xx from ingestion, retrying', { url, status: response.status, attempt: attempt + 1, maxRetries, backoffMs });
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                continue;
+            }
+            return response;
         } catch (err) {
             const message = String(err && err.message ? err.message : err);
             const isTransient = /premature close|ECONNRESET|socket hang up|network|EPIPE|other side closed/i.test(message);
@@ -367,19 +380,19 @@ export class PipelinesPage {
 
     // Methods from PipelinePage
     async openPipelineMenu() {
-        await openNavFlyoutChild(this.page, 'pipeline');
-        // openNavFlyoutChild navigates via a hover-flyout force-click that can
-        // intermittently miss (the flyout self-closes on settle), leaving us on the
-        // previous page. That was the dominant Pipelines-shard flake: the follow-up
-        // pipelineTab.click() then timed out at the 45s action timeout because the
-        // streamPipelines tab only exists on the pipeline list page. Confirm we
-        // actually landed; if not, navigate directly — a goto is deterministic and
-        // needs no flyout.
-        const onPipelinePage = await this.page.locator('[data-test="pipeline-list-page"]')
-            .waitFor({ state: 'visible', timeout: 15000 })
-            .then(() => true)
-            .catch(() => false);
-        if (!onPipelinePage) {
+        // Navigate straight to the pipeline list via goto — deterministic and fast.
+        // The left-nav flyout (openNavFlyoutChild) is a hover-reveal that self-closes on
+        // settle and, under concurrent cloud load, burns up to ~30s retrying to open
+        // before its goto-fallback even fires. A heavy condition test calls this twice,
+        // and that wasted time tipped pipeline-conditions:82 over the 180s test timeout
+        // (validated against alpha at --workers=5). The flyout adds no coverage here — we
+        // only need to land on the pipeline list page — so skip it. goto is already the
+        // proven fallback path; promoting it to primary removes the flake source.
+        // (Auth is safe: with the stored session, a goto to a list route boots the SPA
+        // with the existing token — unlike a reload of the unsaved /pipelines/add editor,
+        // which re-triggers the Dex callback.)
+        if (!(await this.page.locator('[data-test="pipeline-list-page"]')
+            .isVisible({ timeout: 3000 }).catch(() => false))) {
             await this.page.goto(
                 `${process.env.ZO_BASE_URL}/web/pipeline/pipelines?org_identifier=${process.env["ORGNAME"]}`
             );
@@ -394,14 +407,31 @@ export class PipelinesPage {
 
     async addPipeline() {
         // Wait for the add pipeline button to be visible.
-        // Reduced from 30s to 15s — slowMo:500 in serial mode amplifies
-        // cascading delays when the page doesn't load, and 15s is still
-        // generous enough for CI variance.
         await this.addPipelineButton.waitFor({ state: 'visible', timeout: 15000 });
         await this.addPipelineButton.click();
+        // Confirm the editor actually mounted: the NodeSidebar's stream-input button is the
+        // first thing every pipeline flow needs (selectStream/dragStreamToTarget). Under
+        // concurrent cloud load the route change + VueFlow/NodeSidebar mount can lag, or the
+        // add click can be dropped before navigation starts. If the button hasn't rendered
+        // and we're still on the list page (add button still visible), re-click to re-trigger
+        // navigation. This is NON-DESTRUCTIVE — no page.reload(): a reload here trips the
+        // editor's onBeforeRouteLeave unsaved-changes guard, bounces off the editor route,
+        // and stalls every downstream test (regressed the shard to 18 failed).
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            if (await this.streamButton.isVisible({ timeout: 15000 }).catch(() => false)) {
+                return;
+            }
+            if (await this.addPipelineButton.isVisible({ timeout: 2000 }).catch(() => false)) {
+                await this.addPipelineButton.click().catch(() => {});
+            }
+        }
+        await this.streamButton.waitFor({ state: 'visible', timeout: 15000 });
     }
 
     async selectStream() {
+        // addPipeline() already confirms the editor + NodeSidebar mounted; just synchronise
+        // on the button being actionable before clicking (no reload — see addPipeline note).
+        await this.streamButton.waitFor({ state: 'visible', timeout: 30000 });
         await this.streamButton.click();
     }
 
@@ -1226,15 +1256,18 @@ export class PipelinesPage {
         // once navigation stopped failing earlier). Re-run the query until a row
         // appears instead of clicking into an empty table.
         const runQueryBtn = this.page.locator('[data-test="logs-search-bar-refresh-btn"]');
-        for (let attempt = 1; attempt <= 6; attempt++) {
-            if (await this.timestampColumnMenu.isVisible({ timeout: 10000 }).catch(() => false)) {
+        // ~10 attempts (~120s) not 6 (~78s): on a contended alpha the destination stream's
+        // first row routinely lands past 90s (pipeline-dynamic 72/97/113 flake at this step).
+        // Comfortably inside the 5-min CI test timeout.
+        for (let attempt = 1; attempt <= 10; attempt++) {
+            if (await this.timestampColumnMenu.isVisible({ timeout: 9000 }).catch(() => false)) {
                 break;
             }
             // Re-trigger the search so newly-indexed rows are picked up.
             await runQueryBtn.first().click({ timeout: 5000 }).catch(() => {});
             await this.page.waitForTimeout(3000);
         }
-        await this.timestampColumnMenu.waitFor({ state: 'visible', timeout: 15000 });
+        await this.timestampColumnMenu.waitFor({ state: 'visible', timeout: 20000 });
         await this.timestampColumnMenu.click();
     }
 
@@ -2572,7 +2605,10 @@ export class PipelinesPage {
      * Wait for query node to be visible
      * @param {number} timeout - Timeout in ms (default: 30000)
      */
-    async waitForQueryNodeVisible(timeout = 30000) {
+    async waitForQueryNodeVisible(timeout = 45000) {
+        // 45s (was 30s): under sustained full-shard load the query node's canvas render
+        // lags past 30s after saveQuery (pipelines:180 hard-failed on cloud but passes
+        // solo — a heavy-load render lag, not a missing node). Matches the CI actionTimeout.
         await this.queryNode.first().waitFor({ state: 'visible', timeout });
     }
 
diff --git a/tests/ui-testing/pages/streamsPages/streamAssociationPage.js b/tests/ui-testing/pages/streamsPages/streamAssociationPage.js
index d5d2075014..3783609554 100644
--- a/tests/ui-testing/pages/streamsPages/streamAssociationPage.js
+++ b/tests/ui-testing/pages/streamsPages/streamAssociationPage.js
@@ -80,49 +80,41 @@ export class StreamAssociationPage {
     }
     testLogger.info(`Found stream cell for: ${streamName}`);
 
-    // Navigate to parent row
-    const streamRow = streamCell.locator('..');
-    testLogger.info('Got parent row');
-
-    // Wait for the row to be fully rendered
-    await this.page.waitForTimeout(500);
-
-    // Find the Stream Detail button in that row - try multiple times
-    let detailButton = streamRow.getByRole('button', { name: 'Stream Detail' });
-    let buttonCount = await detailButton.count();
-    testLogger.info(`Stream Detail button count (by role): ${buttonCount}`);
-
-    // If not found, wait and retry up to 3 times
-    for (let retry = 0; retry < 3 && buttonCount === 0; retry++) {
-      testLogger.info(`Waiting 1 second and retrying (attempt ${retry + 2})...`);
-      await this.page.waitForTimeout(1000);
-      detailButton = streamRow.getByRole('button', { name: 'Stream Detail' });
-      buttonCount = await detailButton.count();
-      testLogger.info(`Stream Detail button count (after wait ${retry + 1}): ${buttonCount}`);
-    }
-
-    if (buttonCount === 0) {
-      testLogger.error('Stream Detail button not found! Taking screenshot...');
-      await this.page.screenshot({ path: `test-results/no-stream-detail-button-${Date.now()}.png` });
-      throw new Error('Stream Detail button not found in the row');
-    }
-
     const updateSettingsButton = this.page.locator('[data-test="schema-update-settings-button"]');
 
-    // The revamped Reka-based streams table re-renders/detaches rows mid-animation,
-    // so a one-shot Playwright `click()` can spin on actionability until the 45s
-    // actionTimeout, and a single JS click can race the sidebar-open on a slow cloud.
-    // Re-resolve the row's Stream Detail button FRESH each attempt (the row may have
-    // detached), fire a native DOM click (no actionability polling to hang on), and
-    // verify the detail sidebar actually opened — retry the whole sequence until it
-    // does. Deterministic: keyed to the real "sidebar open" signal, not blind waits.
-    await expect(async () => {
-      const btn = streamRow.getByRole('button', { name: 'Stream Detail' }).first();
-      await expect(btn).toBeVisible({ timeout: 5000 });
-      await btn.evaluate((el) => el.scrollIntoView({ block: 'center', inline: 'nearest' })).catch(() => {});
-      await btn.evaluate((el) => el.click());
-      await expect(updateSettingsButton).toBeVisible({ timeout: 5000 });
-    }).toPass({ timeout: 45000 });
+    // Open the stream's detail sidebar. Two changes vs. the old approach that dead-waited
+    // the 45s actionTimeout under cloud load (SDR multipleSDRPatterns:165 hard fail +
+    // ingestionTimeHash:93 flake):
+    //   1) Resolve the action button by its stable data-test (log-stream-schema-btn) rather
+    //      than the icon button's title text — the revamped OTable can render the name cell
+    //      before its action buttons, so a title-name match intermittently resolves nothing.
+    //   2) When the button stays absent / the sidebar doesn't open, RELOAD + re-search the
+    //      streams list (the missing recovery — the previous toPass only re-clicked the same
+    //      possibly-detached row) so a stuck or half-rendered row is forced to re-render.
+    // Keyed to the real "detail sidebar open" signal (schema-update-settings-button visible).
+    let opened = false;
+    for (let attempt = 1; attempt <= 4 && !opened; attempt++) {
+      const streamRow = this.page.getByRole('cell', { name: streamName }).first().locator('..');
+      const detailBtn = streamRow.locator('[data-test="log-stream-schema-btn"]').first();
+      opened = await (async () => {
+        await expect(detailBtn).toBeVisible({ timeout: 10000 });
+        await detailBtn.evaluate((el) => el.scrollIntoView({ block: 'center', inline: 'nearest' })).catch(() => {});
+        await detailBtn.evaluate((el) => el.click());
+        await expect(updateSettingsButton).toBeVisible({ timeout: 8000 });
+        return true;
+      })().catch(() => false);
+      if (!opened && attempt < 4) {
+        testLogger.info(`Stream Detail did not open for "${streamName}" (attempt ${attempt}) — reloading + re-searching streams list`);
+        await this.navigateToStreams();
+        await this.searchForStream(streamName);
+      }
+    }
+
+    if (!opened) {
+      testLogger.error('Stream Detail sidebar never opened! Taking screenshot...');
+      await this.page.screenshot({ path: `test-results/no-stream-detail-button-${Date.now()}.png` });
+      throw new Error(`openStreamDetail: could not open Stream Detail for "${streamName}" after reload + re-search retries`);
+    }
 
     testLogger.info('Stream detail sidebar opened successfully');
   }