From d7e0fc264828a8c613b104155c5b6753b4852fa9 Mon Sep 17 00:00:00 2001
From: seungoh-lee <seungoh.lee@myrealtrip.com>
Date: Wed, 25 Mar 2026 20:55:51 +0900
Subject: [PATCH 1/3] feat : refresh cooldwon

add notification
---
 client/app/lib/hooks/useRefreshCooldown.js    | 57 +++++++++++++++++++
 .../dashboards/components/DashboardHeader.jsx | 37 ++++++++++--
 client/app/pages/queries/QuerySource.jsx      | 21 ++++++-
 client/app/pages/queries/QueryView.jsx        | 14 ++++-
 .../GeneralSettings/FeatureFlagsSettings.jsx  | 17 ++++++
 .../settings/hooks/useOrganizationSettings.js |  1 +
 redash/handlers/authentication.py             |  1 +
 redash/handlers/query_results.py              |  6 ++
 redash/settings/organization.py               |  1 +
 9 files changed, 143 insertions(+), 12 deletions(-)
 create mode 100644 client/app/lib/hooks/useRefreshCooldown.js

diff --git a/client/app/lib/hooks/useRefreshCooldown.js b/client/app/lib/hooks/useRefreshCooldown.js
new file mode 100644
index 0000000000..934c161a1f
--- /dev/null
+++ b/client/app/lib/hooks/useRefreshCooldown.js
@@ -0,0 +1,57 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+import { currentUser, clientConfig } from "@/services/auth";
+import notification from "@/services/notification";
+
+export default function useRefreshCooldown(retrievedAt) {
+  const cooldownSeconds = currentUser.isAdmin ? 0 : (clientConfig.nonAdminRefreshCooldown || 0);
+  const [remainingTime, setRemainingTime] = useState(0);
+  const timerRef = useRef(null);
+
+  const calculateRemaining = useCallback(() => {
+    if (cooldownSeconds <= 0 || !retrievedAt) return 0;
+    const retrievedTime = new Date(retrievedAt).getTime();
+    if (!retrievedTime) return 0;
+    const elapsed = Math.floor((Date.now() - retrievedTime) / 1000);
+    return Math.max(0, cooldownSeconds - elapsed);
+  }, [cooldownSeconds, retrievedAt]);
+
+  useEffect(() => {
+    if (timerRef.current) clearInterval(timerRef.current);
+
+    const remaining = calculateRemaining();
+    setRemainingTime(remaining);
+
+    if (remaining > 0) {
+      timerRef.current = setInterval(() => {
+        const r = calculateRemaining();
+        setRemainingTime(r);
+        if (r <= 0) {
+          clearInterval(timerRef.current);
+          timerRef.current = null;
+        }
+      }, 1000);
+    }
+
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+    };
+  }, [calculateRemaining]);
+
+  const isCooldownActive = remainingTime > 0;
+
+  const notifyCooldown = useCallback(() => {
+    if (isCooldownActive) {
+      notification.warning(
+        `Refresh is on cooldown. Please wait ${remainingTime} seconds.`,
+        null,
+        { duration: 3 }
+      );
+    }
+  }, [isCooldownActive, remainingTime]);
+
+  return {
+    isCooldownActive,
+    remainingTime,
+    notifyCooldown,
+  };
+}
diff --git a/client/app/pages/dashboards/components/DashboardHeader.jsx b/client/app/pages/dashboards/components/DashboardHeader.jsx
index 86d7e12aee..95af44a89b 100644
--- a/client/app/pages/dashboards/components/DashboardHeader.jsx
+++ b/client/app/pages/dashboards/components/DashboardHeader.jsx
@@ -1,7 +1,7 @@
-import React from "react";
+import React, { useMemo } from "react";
 import cx from "classnames";
 import PropTypes from "prop-types";
-import { map, includes } from "lodash";
+import { map, includes, compact, max } from "lodash";
 import Button from "antd/lib/button";
 import Dropdown from "antd/lib/dropdown";
 import Menu from "antd/lib/menu";
@@ -18,6 +18,7 @@ import { policy } from "@/services/policy";
 import recordEvent from "@/services/recordEvent";
 import { durationHumanize } from "@/lib/utils";
 import { DashboardStatusEnum } from "../hooks/useDashboard";
+import useRefreshCooldown from "@/lib/hooks/useRefreshCooldown";
 
 import "./DashboardHeader.less";
 
@@ -64,24 +65,48 @@ DashboardPageTitle.propTypes = {
 };
 
 function RefreshButton({ dashboardConfiguration }) {
-  const { refreshRate, setRefreshRate, disableRefreshRate, refreshing, refreshDashboard } = dashboardConfiguration;
+  const { refreshRate, setRefreshRate, disableRefreshRate, refreshing, refreshDashboard, dashboard } = dashboardConfiguration;
+
+  const latestRetrievedAt = useMemo(() => {
+    const timestamps = compact(
+      map(dashboard.widgets, (w) => {
+        const qr = w.getQueryResult();
+        return qr ? qr.getUpdatedAt() : null;
+      })
+    );
+    return timestamps.length > 0 ? max(timestamps) : null;
+  }, [dashboard.widgets, refreshing]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const { isCooldownActive, remainingTime, notifyCooldown } = useRefreshCooldown(latestRetrievedAt);
   const allowedIntervals = policy.getDashboardRefreshIntervals();
   const refreshRateOptions = clientConfig.dashboardRefreshIntervals;
+  const handleRefresh = () => {
+    if (isCooldownActive) {
+      notifyCooldown();
+      return;
+    }
+    refreshDashboard();
+  };
   const onRefreshRateSelected = ({ key }) => {
     const parsedRefreshRate = parseFloat(key);
     if (parsedRefreshRate) {
       setRefreshRate(parsedRefreshRate);
-      refreshDashboard();
+      handleRefresh();
     } else {
       disableRefreshRate();
     }
   };
+  const refreshLabel = isCooldownActive
+    ? `Refresh (${remainingTime}s)`
+    : refreshRate
+      ? durationHumanize(refreshRate)
+      : "Refresh";
   return (
     <Button.Group>
       <Tooltip title={refreshRate ? `Auto Refreshing every ${durationHumanize(refreshRate)}` : null}>
-        <Button type={buttonType(refreshRate)} onClick={() => refreshDashboard()}>
+        <Button type={buttonType(refreshRate)} onClick={handleRefresh}>
           <i className={cx("zmdi zmdi-refresh m-r-5", { "zmdi-hc-spin": refreshing })} aria-hidden="true" />
-          {refreshRate ? durationHumanize(refreshRate) : "Refresh"}
+          {refreshLabel}
         </Button>
       </Tooltip>
       <Dropdown
diff --git a/client/app/pages/queries/QuerySource.jsx b/client/app/pages/queries/QuerySource.jsx
index f492b99324..0ad4042079 100644
--- a/client/app/pages/queries/QuerySource.jsx
+++ b/client/app/pages/queries/QuerySource.jsx
@@ -43,6 +43,8 @@ import useUpdateQuery from "./hooks/useUpdateQuery";
 import useUpdateQueryDescription from "./hooks/useUpdateQueryDescription";
 import useUnsavedChangesAlert from "./hooks/useUnsavedChangesAlert";
 
+import useRefreshCooldown from "@/lib/hooks/useRefreshCooldown";
+
 import "./components/QuerySourceDropdown"; // register QuerySourceDropdown
 import "./QuerySource.less";
 
@@ -76,6 +78,9 @@ function QuerySource(props) {
   } = useQueryExecute(query);
 
   const queryResultData = useQueryResultData(queryResult);
+  const { isCooldownActive, remainingTime, notifyCooldown } = useRefreshCooldown(
+    queryResult ? queryResult.getUpdatedAt() : null
+  );
 
   const editorRef = useRef(null);
   const [autocompleteAvailable, autocompleteEnabled, toggleAutocomplete] = useAutocompleteFlags(schema);
@@ -164,6 +169,10 @@ function QuerySource(props) {
       if (!queryFlags.canExecute || (!skipParametersDirtyFlag && (areParametersDirty || isQueryExecuting))) {
         return;
       }
+      if (isCooldownActive) {
+        notifyCooldown();
+        return;
+      }
       if (isDirty || !isEmpty(selectedText)) {
         executeQuery(null, () => {
           return query.getQueryResultByText(0, selectedText);
@@ -172,7 +181,7 @@ function QuerySource(props) {
         executeQuery();
       }
     },
-    [query, queryFlags.canExecute, areParametersDirty, isQueryExecuting, isDirty, selectedText, executeQuery]
+    [query, queryFlags.canExecute, areParametersDirty, isQueryExecuting, isDirty, selectedText, executeQuery, isCooldownActive, notifyCooldown]
   );
 
   const [isQuerySaving, setIsQuerySaving] = useState(false);
@@ -300,7 +309,13 @@ function QuerySource(props) {
                         shortcut: "mod+enter, alt+enter, ctrl+enter, shift+enter",
                         onClick: doExecuteQuery,
                         text: (
-                          <span className="hidden-xs">{selectedText === null ? "Execute" : "Execute Selected"}</span>
+                          <span className="hidden-xs">
+                            {isCooldownActive
+                              ? `Execute (${remainingTime}s)`
+                              : selectedText === null
+                                ? "Execute"
+                                : "Execute Selected"}
+                          </span>
                         ),
                       }}
                       autocompleteToggleProps={{
@@ -393,7 +408,7 @@ function QuerySource(props) {
                           loading={isQueryExecuting}
                           onClick={doExecuteQuery}>
                           {!isQueryExecuting && <i className="zmdi zmdi-refresh m-r-5" aria-hidden="true" />}
-                          Refresh Now
+                          {isCooldownActive ? `Refresh Now (${remainingTime}s)` : "Refresh Now"}
                         </Button>
                       }
                     />
diff --git a/client/app/pages/queries/QueryView.jsx b/client/app/pages/queries/QueryView.jsx
index cbd582b480..ef7aa11363 100644
--- a/client/app/pages/queries/QueryView.jsx
+++ b/client/app/pages/queries/QueryView.jsx
@@ -37,6 +37,7 @@ import useEditScheduleDialog from "./hooks/useEditScheduleDialog";
 import useEditVisualizationDialog from "./hooks/useEditVisualizationDialog";
 import useDeleteVisualization from "./hooks/useDeleteVisualization";
 import useFullscreenHandler from "../../lib/hooks/useFullscreenHandler";
+import useRefreshCooldown from "@/lib/hooks/useRefreshCooldown";
 
 import "./QueryView.less";
 
@@ -64,6 +65,9 @@ function QueryView(props) {
   } = useQueryExecute(query);
 
   const queryResultData = useQueryResultData(queryResult);
+  const { isCooldownActive, remainingTime, notifyCooldown } = useRefreshCooldown(
+    queryResult ? queryResult.getUpdatedAt() : null
+  );
 
   const updateQueryDescription = useUpdateQueryDescription(query, setQuery);
   const editSchedule = useEditScheduleDialog(query, setQuery);
@@ -79,9 +83,13 @@ function QueryView(props) {
       if (!queryFlags.canExecute || (!skipParametersDirtyFlag && (areParametersDirty || isExecuting))) {
         return;
       }
+      if (isCooldownActive) {
+        notifyCooldown();
+        return;
+      }
       executeQuery();
     },
-    [areParametersDirty, executeQuery, isExecuting, queryFlags.canExecute]
+    [areParametersDirty, executeQuery, isExecuting, queryFlags.canExecute, isCooldownActive, notifyCooldown]
   );
 
   useEffect(() => {
@@ -113,7 +121,7 @@ function QueryView(props) {
                   shortcut="mod+enter, alt+enter, ctrl+enter"
                   disabled={!queryFlags.canExecute || isExecuting || areParametersDirty}
                   onClick={doExecuteQuery}>
-                  Refresh
+                  {isCooldownActive ? `Refresh (${remainingTime}s)` : "Refresh"}
                 </QueryViewButton>
               )}
             </DynamicComponent>
@@ -179,7 +187,7 @@ function QueryView(props) {
                     loading={isExecuting}
                     onClick={doExecuteQuery}>
                     {!isExecuting && <i className="zmdi zmdi-refresh m-r-5" aria-hidden="true" />}
-                    Refresh Now
+                    {isCooldownActive ? `Refresh Now (${remainingTime}s)` : "Refresh Now"}
                   </Button>
                 )
               }
diff --git a/client/app/pages/settings/components/GeneralSettings/FeatureFlagsSettings.jsx b/client/app/pages/settings/components/GeneralSettings/FeatureFlagsSettings.jsx
index 72568d87be..ddb943cf53 100644
--- a/client/app/pages/settings/components/GeneralSettings/FeatureFlagsSettings.jsx
+++ b/client/app/pages/settings/components/GeneralSettings/FeatureFlagsSettings.jsx
@@ -1,6 +1,7 @@
 import React from "react";
 import Checkbox from "antd/lib/checkbox";
 import Form from "antd/lib/form";
+import InputNumber from "antd/lib/input-number";
 import Row from "antd/lib/row";
 import Skeleton from "antd/lib/skeleton";
 import DynamicComponent from "@/components/DynamicComponent";
@@ -49,6 +50,22 @@ export default function FeatureFlagsSettings(props) {
           </>
         )}
       </Form.Item>
+      <Form.Item label="Non-Admin Refresh Cooldown (seconds)">
+        {loading ? (
+          <Skeleton.Input active size="small" />
+        ) : (
+          <>
+            <InputNumber
+              min={0}
+              value={values.non_admin_refresh_cooldown}
+              onChange={value => onChange({ non_admin_refresh_cooldown: value })}
+            />
+            <div className="m-t-5" style={{ color: "#888" }}>
+              Non-admin users cannot refresh queries or dashboards more frequently than this interval. Set to 0 to disable.
+            </div>
+          </>
+        )}
+      </Form.Item>
     </DynamicComponent>
   );
 }
diff --git a/client/app/pages/settings/hooks/useOrganizationSettings.js b/client/app/pages/settings/hooks/useOrganizationSettings.js
index d0f72a9aca..312ecc9b11 100644
--- a/client/app/pages/settings/hooks/useOrganizationSettings.js
+++ b/client/app/pages/settings/hooks/useOrganizationSettings.js
@@ -54,6 +54,7 @@ export default function useOrganizationSettings({ onError }) {
             dateFormat: currentValues.date_format,
             timeFormat: currentValues.time_format,
             dateTimeFormat: `${currentValues.date_format} ${currentValues.time_format}`,
+            nonAdminRefreshCooldown: currentValues.non_admin_refresh_cooldown,
           });
         })
         .catch(handleError)
diff --git a/redash/handlers/authentication.py b/redash/handlers/authentication.py
index ca49382a34..147b0a063f 100644
--- a/redash/handlers/authentication.py
+++ b/redash/handlers/authentication.py
@@ -289,6 +289,7 @@ def client_config():
         "ldapLoginEnabled": settings.LDAP_LOGIN_ENABLED,
         "pageSize": settings.PAGE_SIZE,
         "pageSizeOptions": settings.PAGE_SIZE_OPTIONS,
+        "nonAdminRefreshCooldown": current_org.get_setting("non_admin_refresh_cooldown"),
         "tableCellMaxJSONSize": settings.TABLE_CELL_MAX_JSON_SIZE,
     }
 
diff --git a/redash/handlers/query_results.py b/redash/handlers/query_results.py
index bfc4371d08..f113186147 100644
--- a/redash/handlers/query_results.py
+++ b/redash/handlers/query_results.py
@@ -60,6 +60,12 @@ def run_query(query, parameters, data_source, query_id, should_apply_auto_limit,
     if not data_source:
         return error_messages["no_data_source"]
 
+    # Enforce refresh cooldown for non-admin users
+    if not current_user.has_permission("admin"):
+        cooldown = current_user.org.get_setting("non_admin_refresh_cooldown")
+        if cooldown and cooldown > 0 and (max_age == 0 or (0 < max_age < cooldown)):
+            max_age = cooldown
+
     if data_source.paused:
         if data_source.pause_reason:
             message = "{} is paused ({}). Please try later.".format(data_source.name, data_source.pause_reason)
diff --git a/redash/settings/organization.py b/redash/settings/organization.py
index 4f6de8aacb..4a4c7a18f9 100644
--- a/redash/settings/organization.py
+++ b/redash/settings/organization.py
@@ -73,4 +73,5 @@
     "send_email_on_failed_scheduled_queries": SEND_EMAIL_ON_FAILED_SCHEDULED_QUERIES,
     "hide_plotly_mode_bar": HIDE_PLOTLY_MODE_BAR,
     "disable_public_urls": DISABLE_PUBLIC_URLS,
+    "non_admin_refresh_cooldown": int(os.environ.get("REDASH_NON_ADMIN_REFRESH_COOLDOWN", 300)),
 }

From 7446b4eb591392fbb20874a27c47dc75b3bf14fd Mon Sep 17 00:00:00 2001
From: seungoh-lee <seungoh.lee@myrealtrip.com>
Date: Wed, 27 May 2026 11:20:39 +0900
Subject: [PATCH 2/3] test: cover non-admin refresh cooldown; default to
 disabled

- Default non_admin_refresh_cooldown to 0 (opt-in) so the feature does not
  alter refresh behavior for existing non-admin users unless explicitly
  enabled. Matches the "Set to 0 to disable" hint in the settings UI and
  keeps the existing test_execute_new_query behavior intact.
- Add TestNonAdminRefreshCooldown: disabled-by-default forces a fresh run,
  an enabled cooldown serves a recent cached result to non-admins, and
  admins bypass the cooldown entirely.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 redash/settings/organization.py      |  2 +-
 tests/handlers/test_query_results.py | 68 ++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/redash/settings/organization.py b/redash/settings/organization.py
index 4a4c7a18f9..dfba237c8c 100644
--- a/redash/settings/organization.py
+++ b/redash/settings/organization.py
@@ -73,5 +73,5 @@
     "send_email_on_failed_scheduled_queries": SEND_EMAIL_ON_FAILED_SCHEDULED_QUERIES,
     "hide_plotly_mode_bar": HIDE_PLOTLY_MODE_BAR,
     "disable_public_urls": DISABLE_PUBLIC_URLS,
-    "non_admin_refresh_cooldown": int(os.environ.get("REDASH_NON_ADMIN_REFRESH_COOLDOWN", 300)),
+    "non_admin_refresh_cooldown": int(os.environ.get("REDASH_NON_ADMIN_REFRESH_COOLDOWN", 0)),
 }
diff --git a/tests/handlers/test_query_results.py b/tests/handlers/test_query_results.py
index 1170d6941e..e76e3bc4c0 100644
--- a/tests/handlers/test_query_results.py
+++ b/tests/handlers/test_query_results.py
@@ -10,6 +10,74 @@ def test_run_query_with_no_data_source(self):
         self.assertEqual(status, error_messages["no_data_source"][1])
 
 
+class TestNonAdminRefreshCooldown(BaseTestCase):
+    def _set_cooldown(self, seconds):
+        self.factory.org.set_setting("non_admin_refresh_cooldown", seconds)
+        db.session.add(self.factory.org)
+        db.session.commit()
+
+    def test_disabled_by_default_allows_forced_refresh(self):
+        # With the default cooldown (0) a non-admin's max_age=0 still forces a new execution.
+        self.factory.create_query_result()
+        query = self.factory.create_query()
+
+        rv = self.make_request(
+            "post",
+            "/api/query_results",
+            data={
+                "data_source_id": self.factory.data_source.id,
+                "query": query.query_text,
+                "max_age": 0,
+            },
+        )
+
+        self.assertEqual(rv.status_code, 200)
+        self.assertNotIn("query_result", rv.json)
+        self.assertIn("job", rv.json)
+
+    def test_cooldown_returns_cached_result_for_non_admin(self):
+        # When enabled, the cooldown raises a non-admin's max_age so a recent cached
+        # result is served instead of forcing a new execution.
+        self._set_cooldown(300)
+        query_result = self.factory.create_query_result()
+        query = self.factory.create_query()
+
+        rv = self.make_request(
+            "post",
+            "/api/query_results",
+            data={
+                "data_source_id": self.factory.data_source.id,
+                "query": query.query_text,
+                "max_age": 0,
+            },
+        )
+
+        self.assertEqual(rv.status_code, 200)
+        self.assertEqual(query_result.id, rv.json["query_result"]["id"])
+
+    def test_cooldown_does_not_apply_to_admin(self):
+        # Admins bypass the cooldown entirely and can always force a new execution.
+        self._set_cooldown(300)
+        self.factory.create_query_result()
+        query = self.factory.create_query()
+        admin = self.factory.create_admin()
+
+        rv = self.make_request(
+            "post",
+            "/api/query_results",
+            data={
+                "data_source_id": self.factory.data_source.id,
+                "query": query.query_text,
+                "max_age": 0,
+            },
+            user=admin,
+        )
+
+        self.assertEqual(rv.status_code, 200)
+        self.assertNotIn("query_result", rv.json)
+        self.assertIn("job", rv.json)
+
+
 class TestQueryResultsCacheHeaders(BaseTestCase):
     def test_uses_cache_headers_for_specific_result(self):
         query_result = self.factory.create_query_result()

From 23923f552b8e64818c7e806239c3e0d4352831c8 Mon Sep 17 00:00:00 2001
From: seungoh-lee <seungoh.lee@myrealtrip.com>
Date: Wed, 27 May 2026 16:19:01 +0900
Subject: [PATCH 3/3] perf(refresh-cooldown): scope cooldown countdown to a
 leaf component

The refresh-cooldown countdown state lived at the top of QuerySource and
QueryView, so during an active cooldown setInterval re-rendered the whole
page (editor + visualizations) every second.

Split useRefreshCooldown into a pure click-time gate
(notifyRefreshCooldown / getRefreshCooldownRemaining) and the ticking
display hook. The page now evaluates the cooldown gate at click time and
the per-second countdown lives in a small RefreshCooldownLabel leaf, so
only the button label re-renders while on cooldown. Execution gating
(button, keyboard shortcut, parameter-change paths) is unchanged.

DashboardHeader already scoped the hook to its RefreshButton leaf and is
left untouched.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 client/app/lib/hooks/useRefreshCooldown.js    | 54 ++++++++++++-------
 client/app/pages/queries/QuerySource.jsx      | 24 ++++-----
 client/app/pages/queries/QueryView.jsx        | 21 ++++----
 .../components/RefreshCooldownLabel.jsx       | 21 ++++++++
 4 files changed, 80 insertions(+), 40 deletions(-)
 create mode 100644 client/app/pages/queries/components/RefreshCooldownLabel.jsx

diff --git a/client/app/lib/hooks/useRefreshCooldown.js b/client/app/lib/hooks/useRefreshCooldown.js
index 934c161a1f..cf04f44bad 100644
--- a/client/app/lib/hooks/useRefreshCooldown.js
+++ b/client/app/lib/hooks/useRefreshCooldown.js
@@ -2,28 +2,50 @@ import { useState, useEffect, useRef, useCallback } from "react";
 import { currentUser, clientConfig } from "@/services/auth";
 import notification from "@/services/notification";
 
+function getCooldownSeconds() {
+  return currentUser.isAdmin ? 0 : clientConfig.nonAdminRefreshCooldown || 0;
+}
+
+function warnCooldown(seconds) {
+  notification.warning(`Refresh is on cooldown. Please wait ${seconds} seconds.`, null, { duration: 3 });
+}
+
+// Remaining cooldown in seconds for a given retrieval time. Pure — no React state — so the
+// execution/refresh path can gate on click without subscribing to a per-second timer.
+export function getRefreshCooldownRemaining(retrievedAt) {
+  const cooldownSeconds = getCooldownSeconds();
+  if (cooldownSeconds <= 0 || !retrievedAt) return 0;
+  const retrievedTime = new Date(retrievedAt).getTime();
+  if (!retrievedTime) return 0;
+  const elapsed = Math.floor((Date.now() - retrievedTime) / 1000);
+  return Math.max(0, cooldownSeconds - elapsed);
+}
+
+// Shows the cooldown notification when active. Returns true if on cooldown (caller should abort).
+export function notifyRefreshCooldown(retrievedAt) {
+  const remaining = getRefreshCooldownRemaining(retrievedAt);
+  if (remaining > 0) {
+    warnCooldown(remaining);
+    return true;
+  }
+  return false;
+}
+
+// Ticking countdown for display. Mount inside a small leaf component (see RefreshCooldownLabel)
+// so the per-second state update only re-renders that label, not the whole page.
 export default function useRefreshCooldown(retrievedAt) {
-  const cooldownSeconds = currentUser.isAdmin ? 0 : (clientConfig.nonAdminRefreshCooldown || 0);
-  const [remainingTime, setRemainingTime] = useState(0);
+  const [remainingTime, setRemainingTime] = useState(() => getRefreshCooldownRemaining(retrievedAt));
   const timerRef = useRef(null);
 
-  const calculateRemaining = useCallback(() => {
-    if (cooldownSeconds <= 0 || !retrievedAt) return 0;
-    const retrievedTime = new Date(retrievedAt).getTime();
-    if (!retrievedTime) return 0;
-    const elapsed = Math.floor((Date.now() - retrievedTime) / 1000);
-    return Math.max(0, cooldownSeconds - elapsed);
-  }, [cooldownSeconds, retrievedAt]);
-
   useEffect(() => {
     if (timerRef.current) clearInterval(timerRef.current);
 
-    const remaining = calculateRemaining();
+    const remaining = getRefreshCooldownRemaining(retrievedAt);
     setRemainingTime(remaining);
 
     if (remaining > 0) {
       timerRef.current = setInterval(() => {
-        const r = calculateRemaining();
+        const r = getRefreshCooldownRemaining(retrievedAt);
         setRemainingTime(r);
         if (r <= 0) {
           clearInterval(timerRef.current);
@@ -35,17 +57,13 @@ export default function useRefreshCooldown(retrievedAt) {
     return () => {
       if (timerRef.current) clearInterval(timerRef.current);
     };
-  }, [calculateRemaining]);
+  }, [retrievedAt]);
 
   const isCooldownActive = remainingTime > 0;
 
   const notifyCooldown = useCallback(() => {
     if (isCooldownActive) {
-      notification.warning(
-        `Refresh is on cooldown. Please wait ${remainingTime} seconds.`,
-        null,
-        { duration: 3 }
-      );
+      warnCooldown(remainingTime);
     }
   }, [isCooldownActive, remainingTime]);
 
diff --git a/client/app/pages/queries/QuerySource.jsx b/client/app/pages/queries/QuerySource.jsx
index 0ad4042079..79e0a964fa 100644
--- a/client/app/pages/queries/QuerySource.jsx
+++ b/client/app/pages/queries/QuerySource.jsx
@@ -43,7 +43,8 @@ import useUpdateQuery from "./hooks/useUpdateQuery";
 import useUpdateQueryDescription from "./hooks/useUpdateQueryDescription";
 import useUnsavedChangesAlert from "./hooks/useUnsavedChangesAlert";
 
-import useRefreshCooldown from "@/lib/hooks/useRefreshCooldown";
+import { notifyRefreshCooldown } from "@/lib/hooks/useRefreshCooldown";
+import RefreshCooldownLabel from "./components/RefreshCooldownLabel";
 
 import "./components/QuerySourceDropdown"; // register QuerySourceDropdown
 import "./QuerySource.less";
@@ -78,9 +79,7 @@ function QuerySource(props) {
   } = useQueryExecute(query);
 
   const queryResultData = useQueryResultData(queryResult);
-  const { isCooldownActive, remainingTime, notifyCooldown } = useRefreshCooldown(
-    queryResult ? queryResult.getUpdatedAt() : null
-  );
+  const retrievedAt = queryResult ? queryResult.getUpdatedAt() : null;
 
   const editorRef = useRef(null);
   const [autocompleteAvailable, autocompleteEnabled, toggleAutocomplete] = useAutocompleteFlags(schema);
@@ -169,8 +168,7 @@ function QuerySource(props) {
       if (!queryFlags.canExecute || (!skipParametersDirtyFlag && (areParametersDirty || isQueryExecuting))) {
         return;
       }
-      if (isCooldownActive) {
-        notifyCooldown();
+      if (notifyRefreshCooldown(retrievedAt)) {
         return;
       }
       if (isDirty || !isEmpty(selectedText)) {
@@ -181,7 +179,7 @@ function QuerySource(props) {
         executeQuery();
       }
     },
-    [query, queryFlags.canExecute, areParametersDirty, isQueryExecuting, isDirty, selectedText, executeQuery, isCooldownActive, notifyCooldown]
+    [query, queryFlags.canExecute, areParametersDirty, isQueryExecuting, isDirty, selectedText, executeQuery, retrievedAt]
   );
 
   const [isQuerySaving, setIsQuerySaving] = useState(false);
@@ -310,11 +308,9 @@ function QuerySource(props) {
                         onClick: doExecuteQuery,
                         text: (
                           <span className="hidden-xs">
-                            {isCooldownActive
-                              ? `Execute (${remainingTime}s)`
-                              : selectedText === null
-                                ? "Execute"
-                                : "Execute Selected"}
+                            <RefreshCooldownLabel retrievedAt={retrievedAt} label="Execute">
+                              {selectedText === null ? "Execute" : "Execute Selected"}
+                            </RefreshCooldownLabel>
                           </span>
                         ),
                       }}
@@ -408,7 +404,9 @@ function QuerySource(props) {
                           loading={isQueryExecuting}
                           onClick={doExecuteQuery}>
                           {!isQueryExecuting && <i className="zmdi zmdi-refresh m-r-5" aria-hidden="true" />}
-                          {isCooldownActive ? `Refresh Now (${remainingTime}s)` : "Refresh Now"}
+                          <RefreshCooldownLabel retrievedAt={retrievedAt} label="Refresh Now">
+                            Refresh Now
+                          </RefreshCooldownLabel>
                         </Button>
                       }
                     />
diff --git a/client/app/pages/queries/QueryView.jsx b/client/app/pages/queries/QueryView.jsx
index ef7aa11363..c99ce86f7d 100644
--- a/client/app/pages/queries/QueryView.jsx
+++ b/client/app/pages/queries/QueryView.jsx
@@ -37,7 +37,9 @@ import useEditScheduleDialog from "./hooks/useEditScheduleDialog";
 import useEditVisualizationDialog from "./hooks/useEditVisualizationDialog";
 import useDeleteVisualization from "./hooks/useDeleteVisualization";
 import useFullscreenHandler from "../../lib/hooks/useFullscreenHandler";
-import useRefreshCooldown from "@/lib/hooks/useRefreshCooldown";
+import { notifyRefreshCooldown } from "@/lib/hooks/useRefreshCooldown";
+
+import RefreshCooldownLabel from "./components/RefreshCooldownLabel";
 
 import "./QueryView.less";
 
@@ -65,9 +67,7 @@ function QueryView(props) {
   } = useQueryExecute(query);
 
   const queryResultData = useQueryResultData(queryResult);
-  const { isCooldownActive, remainingTime, notifyCooldown } = useRefreshCooldown(
-    queryResult ? queryResult.getUpdatedAt() : null
-  );
+  const retrievedAt = queryResult ? queryResult.getUpdatedAt() : null;
 
   const updateQueryDescription = useUpdateQueryDescription(query, setQuery);
   const editSchedule = useEditScheduleDialog(query, setQuery);
@@ -83,13 +83,12 @@ function QueryView(props) {
       if (!queryFlags.canExecute || (!skipParametersDirtyFlag && (areParametersDirty || isExecuting))) {
         return;
       }
-      if (isCooldownActive) {
-        notifyCooldown();
+      if (notifyRefreshCooldown(retrievedAt)) {
         return;
       }
       executeQuery();
     },
-    [areParametersDirty, executeQuery, isExecuting, queryFlags.canExecute, isCooldownActive, notifyCooldown]
+    [areParametersDirty, executeQuery, isExecuting, queryFlags.canExecute, retrievedAt]
   );
 
   useEffect(() => {
@@ -121,7 +120,9 @@ function QueryView(props) {
                   shortcut="mod+enter, alt+enter, ctrl+enter"
                   disabled={!queryFlags.canExecute || isExecuting || areParametersDirty}
                   onClick={doExecuteQuery}>
-                  {isCooldownActive ? `Refresh (${remainingTime}s)` : "Refresh"}
+                  <RefreshCooldownLabel retrievedAt={retrievedAt} label="Refresh">
+                    Refresh
+                  </RefreshCooldownLabel>
                 </QueryViewButton>
               )}
             </DynamicComponent>
@@ -187,7 +188,9 @@ function QueryView(props) {
                     loading={isExecuting}
                     onClick={doExecuteQuery}>
                     {!isExecuting && <i className="zmdi zmdi-refresh m-r-5" aria-hidden="true" />}
-                    {isCooldownActive ? `Refresh Now (${remainingTime}s)` : "Refresh Now"}
+                    <RefreshCooldownLabel retrievedAt={retrievedAt} label="Refresh Now">
+                      Refresh Now
+                    </RefreshCooldownLabel>
                   </Button>
                 )
               }
diff --git a/client/app/pages/queries/components/RefreshCooldownLabel.jsx b/client/app/pages/queries/components/RefreshCooldownLabel.jsx
new file mode 100644
index 0000000000..82bd8b6266
--- /dev/null
+++ b/client/app/pages/queries/components/RefreshCooldownLabel.jsx
@@ -0,0 +1,21 @@
+import React from "react";
+import PropTypes from "prop-types";
+import useRefreshCooldown from "@/lib/hooks/useRefreshCooldown";
+
+// Button label that appends a live `(Ns)` countdown while a refresh cooldown is active.
+// It owns the per-second countdown state, so during cooldown only this label re-renders —
+// the surrounding page (editor, visualizations) stays off the 1Hz render path.
+export default function RefreshCooldownLabel({ retrievedAt, label, children }) {
+  const { isCooldownActive, remainingTime } = useRefreshCooldown(retrievedAt);
+  return <React.Fragment>{isCooldownActive ? `${label} (${remainingTime}s)` : children}</React.Fragment>;
+}
+
+RefreshCooldownLabel.propTypes = {
+  retrievedAt: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  label: PropTypes.string.isRequired,
+  children: PropTypes.node.isRequired,
+};
+
+RefreshCooldownLabel.defaultProps = {
+  retrievedAt: null,
+};