diff --git a/ui/apps/pmm/src/api/updates.ts b/ui/apps/pmm/src/api/updates.ts
index 1f3f87aaf2e..7e6f701f962 100644
--- a/ui/apps/pmm/src/api/updates.ts
+++ b/ui/apps/pmm/src/api/updates.ts
@@ -1,4 +1,4 @@
-import { AxiosResponse } from 'axios';
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import {
   GetChangeLogsResponse,
   GetUpdateStatusBody,
@@ -11,9 +11,11 @@ import {
 import { api } from './api';
 
 export const checkForUpdates = async (
-  params: GetUpdatesParams = { force: false }
+  params: GetUpdatesParams = { force: false },
+  config?: AxiosRequestConfig
 ) => {
   const res = await api.get<GetUpdatesResponse>('/server/updates', {
+    ...config,
     params,
   });
   return res.data;
diff --git a/ui/apps/pmm/src/components/footer/Footer.test.tsx b/ui/apps/pmm/src/components/footer/Footer.test.tsx
index 8541f47d2fa..e28fc0eb112 100644
--- a/ui/apps/pmm/src/components/footer/Footer.test.tsx
+++ b/ui/apps/pmm/src/components/footer/Footer.test.tsx
@@ -20,6 +20,27 @@ describe('Footer', () => {
     expect('Last checked: 2024/07/30');
   });
 
+  it('hides the check date when no check has run', () => {
+    render(
+      wrapWithUpdatesProvider(<Footer />, {
+        versionInfo: {
+          lastCheck: null,
+          latest: null,
+          installed: {
+            version: '3.10.0',
+            fullVersion: '3.10.0',
+            timestamp: '2026-07-30T00:00:00Z',
+          },
+          latestNewsUrl: '',
+          updateAvailable: false,
+        },
+      })
+    );
+
+    expect(screen.getByText(Messages.version('3.10.0'))).toBeDefined();
+    expect(screen.queryByText(/Last checked/)).toBeNull();
+  });
+
   it('shows in progress message', () => {
     render(
       wrapWithUpdatesProvider(<Footer />, {
diff --git a/ui/apps/pmm/src/components/footer/Footer.tsx b/ui/apps/pmm/src/components/footer/Footer.tsx
index 5cd0302325b..12f80a95b1a 100644
--- a/ui/apps/pmm/src/components/footer/Footer.tsx
+++ b/ui/apps/pmm/src/components/footer/Footer.tsx
@@ -1,7 +1,7 @@
 import { Stack, Typography } from '@mui/material';
 import { useUpdates } from 'contexts/updates';
 import { FC } from 'react';
-import { formatCheckDate } from './Footer.utils';
+import { getCheckStatus } from './Footer.utils';
 import { Messages } from './Footer.messages';
 
 export const Footer: FC = () => {
@@ -9,16 +9,18 @@ export const Footer: FC = () => {
 
   if (!versionInfo) return null;
 
+  const checkStatus = getCheckStatus(versionInfo, inProgress);
+
   return (
     <Stack direction="row" gap={2} data-testid="pmm-footer">
       <Typography variant="body2">
         {Messages.version(versionInfo.installed.version)}
       </Typography>
-      <Typography variant="body2" color="text.disabled">
-        {inProgress
-          ? Messages.inProgress
-          : Messages.checkedOn(formatCheckDate(versionInfo.lastCheck || 'N/A'))}
-      </Typography>
+      {checkStatus && (
+        <Typography variant="body2" color="text.disabled">
+          {checkStatus}
+        </Typography>
+      )}
     </Stack>
   );
 };
diff --git a/ui/apps/pmm/src/components/footer/Footer.utils.test.ts b/ui/apps/pmm/src/components/footer/Footer.utils.test.ts
new file mode 100644
index 00000000000..0bdbd8027a2
--- /dev/null
+++ b/ui/apps/pmm/src/components/footer/Footer.utils.test.ts
@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { GetUpdatesResponse } from 'types/updates.types';
+import { formatCheckDate, getCheckStatus } from './Footer.utils';
+import { Messages } from './Footer.messages';
+
+const versionInfo = (lastCheck: string | null): GetUpdatesResponse => ({
+  lastCheck,
+  latest: null,
+  installed: {
+    version: '3.10.0',
+    fullVersion: '3.10.0',
+    timestamp: '2024-07-30T00:00:00Z',
+  },
+  latestNewsUrl: '',
+  updateAvailable: false,
+});
+
+describe('formatCheckDate', () => {
+  it('formats a timestamp as UTC', () => {
+    expect(formatCheckDate('2024-07-30T10:34:05.886739003Z')).toBe(
+      'July 30, 2024, 10:34 UTC'
+    );
+  });
+});
+
+describe('getCheckStatus', () => {
+  it('reports an update in progress', () => {
+    expect(getCheckStatus(versionInfo(null), true)).toBe(Messages.inProgress);
+  });
+
+  it('prefers the in progress message over the last check', () => {
+    expect(
+      getCheckStatus(versionInfo('2024-07-30T10:34:05.886739003Z'), true)
+    ).toBe(Messages.inProgress);
+  });
+
+  it('reports the last check date', () => {
+    expect(
+      getCheckStatus(versionInfo('2024-07-30T10:34:05.886739003Z'), false)
+    ).toBe(Messages.checkedOn('July 30, 2024, 10:34 UTC'));
+  });
+
+  it('reports nothing when no check has run', () => {
+    expect(getCheckStatus(versionInfo(null), false)).toBeNull();
+  });
+
+  it('reports nothing without version info', () => {
+    expect(getCheckStatus(undefined, false)).toBeNull();
+  });
+});
diff --git a/ui/apps/pmm/src/components/footer/Footer.utils.ts b/ui/apps/pmm/src/components/footer/Footer.utils.ts
index 2df9d770ee5..9ffbaffd82f 100644
--- a/ui/apps/pmm/src/components/footer/Footer.utils.ts
+++ b/ui/apps/pmm/src/components/footer/Footer.utils.ts
@@ -1,3 +1,6 @@
+import { GetUpdatesResponse } from 'types/updates.types';
+import { Messages } from './Footer.messages';
+
 /**
  * Formats date to "Month Day, Year, HH:MM UTC"
  * @param date
@@ -12,3 +15,18 @@ export const formatCheckDate = (date: string) => {
   const minutes = String(dateObj.getUTCMinutes()).padStart(2, '0');
   return `${month} ${day}, ${year}, ${hours}:${minutes} UTC`;
 };
+
+export const getCheckStatus = (
+  versionInfo: GetUpdatesResponse | undefined,
+  inProgress: boolean
+): string | null => {
+  if (inProgress) {
+    return Messages.inProgress;
+  }
+
+  if (versionInfo?.lastCheck) {
+    return Messages.checkedOn(formatCheckDate(versionInfo.lastCheck));
+  }
+
+  return null;
+};
diff --git a/ui/apps/pmm/src/contexts/updates/updates.provider.test.tsx b/ui/apps/pmm/src/contexts/updates/updates.provider.test.tsx
new file mode 100644
index 00000000000..e514cda8b2d
--- /dev/null
+++ b/ui/apps/pmm/src/contexts/updates/updates.provider.test.tsx
@@ -0,0 +1,211 @@
+import { render, waitFor } from '@testing-library/react';
+import { AxiosError, type InternalAxiosRequestConfig } from 'axios';
+import { UpdatesProvider } from './updates.provider';
+import { SettingsContext, type SettingsContextProps } from 'contexts/settings';
+import {
+  api,
+  addApiErrorInterceptor,
+  removeApiErrorInterceptor,
+} from 'api/api';
+import {
+  wrapWithQueryProvider,
+  wrapWithSettings,
+  wrapWithUserProvider,
+} from 'utils/testUtils';
+
+const { enqueueSnackbar } = vi.hoisted(() => ({
+  enqueueSnackbar: vi.fn(),
+}));
+
+vi.mock('notistack', () => ({
+  enqueueSnackbar,
+}));
+
+// captured verbatim from a live PMM 3.8.0 server with updates disabled
+const DISABLED_ERROR_BODY = {
+  error: 'PMM updates are disabled',
+  code: 9,
+  message: 'PMM updates are disabled',
+  details: [],
+};
+
+const INSTALLED_ONLY_BODY = {
+  installed: {
+    version: '3.8.0',
+    full_version: '3.8.0',
+    timestamp: '2026-05-15T10:11:22Z',
+  },
+  latest: null,
+  update_available: false,
+  latest_news_url: '',
+  last_check: null,
+};
+
+let seenParams: Record<string, unknown>[] = [];
+
+/** Stands in for pmm-managed: refuses a full check, answers the installed-only one. */
+const updatesDisabledAdapter = async (config: InternalAxiosRequestConfig) => {
+  const params = (config.params ?? {}) as Record<string, unknown>;
+
+  if (!config.url?.includes('/server/updates')) {
+    return { data: {}, status: 200, statusText: 'OK', headers: {}, config };
+  }
+
+  seenParams.push(params);
+
+  if (params.only_installed_version) {
+    return {
+      data: INSTALLED_ONLY_BODY,
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+      config,
+    };
+  }
+
+  throw new AxiosError('Request failed', '400', config, {}, {
+    data: DISABLED_ERROR_BODY,
+    status: 400,
+    statusText: 'Bad Request',
+    headers: {},
+    config,
+  } as AxiosError['response']);
+};
+
+const renderProvider = (updatesEnabled: boolean) =>
+  render(
+    wrapWithQueryProvider(
+      wrapWithUserProvider(
+        wrapWithSettings(
+          <UpdatesProvider>
+            <div>content</div>
+          </UpdatesProvider>,
+          { settings: { updatesEnabled } }
+        )
+      )
+    )
+  );
+
+const renderWithSettingsContext = (value: SettingsContextProps) =>
+  render(
+    wrapWithQueryProvider(
+      wrapWithUserProvider(
+        <SettingsContext.Provider value={value}>
+          <UpdatesProvider>
+            <div>content</div>
+          </UpdatesProvider>
+        </SettingsContext.Provider>
+      )
+    )
+  );
+
+describe('UpdatesProvider (PMM-15274)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    seenParams = [];
+    api.defaults.adapter = updatesDisabledAdapter;
+    addApiErrorInterceptor();
+  });
+
+  afterEach(() => {
+    removeApiErrorInterceptor();
+  });
+
+  it('raises no error toast when updates are disabled', async () => {
+    renderProvider(false);
+
+    await waitFor(() => expect(seenParams.length).toBeGreaterThan(0));
+
+    expect(enqueueSnackbar).not.toHaveBeenCalled();
+  });
+
+  it('never asks for a full check when updates are disabled', async () => {
+    renderProvider(false);
+
+    await waitFor(() => expect(seenParams.length).toBeGreaterThan(0));
+
+    expect(seenParams).toEqual([
+      { force: false, only_installed_version: true },
+    ]);
+  });
+
+  it('reports a real failure even though the fallback recovers', async () => {
+    // pmm-managed is up but cannot reach the version service. The fallback
+    // succeeds, so this is the only chance the user has to hear about it.
+    api.defaults.adapter = async (config: InternalAxiosRequestConfig) => {
+      if (!config.url?.includes('/server/updates')) {
+        return { data: {}, status: 200, statusText: 'OK', headers: {}, config };
+      }
+      const params = (config.params ?? {}) as Record<string, unknown>;
+      seenParams.push(params);
+
+      if (params.only_installed_version) {
+        return {
+          data: INSTALLED_ONLY_BODY,
+          status: 200,
+          statusText: 'OK',
+          headers: {},
+          config,
+        };
+      }
+
+      throw new AxiosError('Request failed', '503', config, {}, {
+        data: { message: 'failed to check for updates' },
+        status: 503,
+        statusText: 'Service Unavailable',
+        headers: {},
+        config,
+      } as AxiosError['response']);
+    };
+
+    renderProvider(true);
+
+    await waitFor(() => expect(enqueueSnackbar).toHaveBeenCalled());
+
+    expect(seenParams).toEqual([
+      { force: true },
+      { force: true, only_installed_version: true },
+    ]);
+    expect(enqueueSnackbar).toHaveBeenCalledTimes(1);
+    expect(enqueueSnackbar).toHaveBeenCalledWith(
+      'failed to check for updates',
+      expect.objectContaining({ variant: 'error' })
+    );
+  });
+
+  it('stays quiet if the server reports updates are disabled', async () => {
+    // settings said enabled but the server disagrees, so the toast this ticket
+    // is about must not come back
+    renderProvider(true);
+
+    await waitFor(() => expect(seenParams.length).toBe(2));
+
+    expect(seenParams).toEqual([
+      { force: true },
+      { force: true, only_installed_version: true },
+    ]);
+    expect(enqueueSnackbar).not.toHaveBeenCalled();
+  });
+
+  it('waits for settings before checking', async () => {
+    renderWithSettingsContext({ isLoading: true, settings: null });
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(seenParams).toEqual([]);
+  });
+
+  it('still checks for updates when settings fail to load', async () => {
+    // settings errored, and there is no retry. Blocking here would cost the
+    // footer its version for the rest of the session.
+    renderWithSettingsContext({ isLoading: false, settings: null });
+
+    await waitFor(() => expect(seenParams.length).toBe(2));
+
+    expect(seenParams).toEqual([
+      { force: true },
+      { force: true, only_installed_version: true },
+    ]);
+    expect(enqueueSnackbar).not.toHaveBeenCalled();
+  });
+});
diff --git a/ui/apps/pmm/src/contexts/updates/updates.provider.tsx b/ui/apps/pmm/src/contexts/updates/updates.provider.tsx
index 7850aa7b84b..ee985f8e7b6 100644
--- a/ui/apps/pmm/src/contexts/updates/updates.provider.tsx
+++ b/ui/apps/pmm/src/contexts/updates/updates.provider.tsx
@@ -8,11 +8,19 @@ import { useSettings } from 'contexts/settings';
 import { useUser } from 'contexts/user';
 
 export const UpdatesProvider: FC<PropsWithChildren> = ({ children }) => {
-  const { settings } = useSettings();
+  const { settings, isLoading: isLoadingSettings } = useSettings();
   const [status, setStatus] = useState(UpdateStatus.Pending);
   const { user } = useUser();
   const { isLoading, data, error, isRefetching, refetch } = useCheckUpdates({
-    enabled: !settings?.frontend?.anonymousEnabled && !!user?.isPMMAdmin,
+    // wait for settings to settle, otherwise a full check can fire before we
+    // know whether this deployment allows one. Gate on loading rather than on
+    // success: if settings fail there is no retry, and blocking on that would
+    // cost us the version in the footer for the rest of the session.
+    enabled:
+      !isLoadingSettings &&
+      !settings?.frontend?.anonymousEnabled &&
+      !!user?.isPMMAdmin,
+    onlyInstalledVersion: settings?.updatesEnabled === false,
   });
   const { data: clients } = useAgentVersions({
     enabled: !settings?.frontend?.anonymousEnabled && !!user?.isPMMAdmin,
diff --git a/ui/apps/pmm/src/hooks/api/useUpdates.test.tsx b/ui/apps/pmm/src/hooks/api/useUpdates.test.tsx
new file mode 100644
index 00000000000..4ba2a6956e8
--- /dev/null
+++ b/ui/apps/pmm/src/hooks/api/useUpdates.test.tsx
@@ -0,0 +1,101 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { AxiosError } from 'axios';
+import { useCheckUpdates } from './useUpdates';
+import { wrapWithQueryProvider } from 'utils/testUtils';
+
+const { checkForUpdates } = vi.hoisted(() => ({
+  checkForUpdates: vi.fn(),
+}));
+
+vi.mock('api/updates', () => ({
+  checkForUpdates,
+  getChangeLogs: vi.fn(),
+  startUpdate: vi.fn(),
+}));
+
+const installedOnly = {
+  lastCheck: null,
+  latest: null,
+  installed: {
+    version: '3.10.0',
+    fullVersion: '3.10.0',
+    timestamp: '2026-07-30T00:00:00Z',
+  },
+  latestNewsUrl: '',
+  updateAvailable: false,
+};
+
+const errorWithStatus = (status: number, code?: number, message = 'failed') => {
+  const error = new AxiosError(message);
+  error.response = {
+    status,
+    data: { error: message, message, code },
+  } as AxiosError['response'];
+  return error;
+};
+
+describe('useCheckUpdates', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('asks only for the installed version when updates are disabled', async () => {
+    checkForUpdates.mockResolvedValue(installedOnly);
+
+    const { result } = renderHook(
+      () => useCheckUpdates({ onlyInstalledVersion: true }),
+      { wrapper: ({ children }) => wrapWithQueryProvider(children) }
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(checkForUpdates).toHaveBeenCalledTimes(1);
+    expect(checkForUpdates).toHaveBeenCalledWith({
+      force: false,
+      onlyInstalledVersion: true,
+    });
+  });
+
+  it('suppresses the notification only for a disabled-updates response', async () => {
+    checkForUpdates
+      .mockRejectedValueOnce(
+        errorWithStatus(400, 9, 'PMM updates are disabled')
+      )
+      .mockResolvedValueOnce(installedOnly);
+
+    const { result } = renderHook(() => useCheckUpdates(), {
+      wrapper: ({ children }) => wrapWithQueryProvider(children),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    const [params, config] = checkForUpdates.mock.calls[0];
+    expect(params).toEqual({ force: true });
+    // only FailedPrecondition (9) is the disabled case and stays quiet
+    expect(config.disableNotifications(errorWithStatus(400, 9))).toBe(true);
+    // grpc-gateway also maps InvalidArgument (3) to 400; that must be reported
+    expect(config.disableNotifications(errorWithStatus(400, 3))).toBe(false);
+    expect(config.disableNotifications(errorWithStatus(400))).toBe(false);
+    expect(config.disableNotifications(errorWithStatus(503))).toBe(false);
+    expect(config.disableNotifications(errorWithStatus(500))).toBe(false);
+
+    expect(checkForUpdates).toHaveBeenNthCalledWith(2, {
+      force: true,
+      onlyInstalledVersion: true,
+    });
+  });
+
+  it('rethrows a 401 instead of falling back', async () => {
+    const unauthorized = new AxiosError('unauthorized');
+    unauthorized.response = { status: 401 } as AxiosError['response'];
+    checkForUpdates.mockRejectedValue(unauthorized);
+
+    const { result } = renderHook(() => useCheckUpdates(), {
+      wrapper: ({ children }) => wrapWithQueryProvider(children),
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+
+    expect(checkForUpdates).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/ui/apps/pmm/src/hooks/api/useUpdates.tsx b/ui/apps/pmm/src/hooks/api/useUpdates.tsx
index eb563d805f9..ef4fd9ca050 100644
--- a/ui/apps/pmm/src/hooks/api/useUpdates.tsx
+++ b/ui/apps/pmm/src/hooks/api/useUpdates.tsx
@@ -12,16 +12,43 @@ import {
   StartUpdateResponse,
 } from 'types/updates.types';
 import { AxiosError } from 'axios';
-import { ApiError } from 'types/api.types';
+import { ApiError, ApiErrorResponse } from 'types/api.types';
 
-export const useCheckUpdates = (
-  options?: Partial<UseQueryOptions<GetUpdatesResponse>>
-) =>
+// grpc-gateway maps several gRPC codes onto HTTP 400, so the status alone cannot
+// tell "updates are disabled" apart from a rejected request.
+const GRPC_FAILED_PRECONDITION = 9;
+
+const isUpdatesDisabled = (error: AxiosError) =>
+  error.response?.status === 400 &&
+  (error.response.data as ApiErrorResponse | undefined)?.code ===
+    GRPC_FAILED_PRECONDITION;
+
+export type UseCheckUpdatesOptions = Partial<
+  UseQueryOptions<GetUpdatesResponse>
+> & {
+  // deployments with PMM_ENABLE_UPDATES=0 reject a full check, so ask only for
+  // what the server always answers
+  onlyInstalledVersion?: boolean;
+};
+
+export const useCheckUpdates = ({
+  onlyInstalledVersion = false,
+  ...options
+}: UseCheckUpdatesOptions = {}) =>
   useQuery({
-    queryKey: ['checkUpdates'],
+    queryKey: ['checkUpdates', onlyInstalledVersion],
     queryFn: async () => {
+      if (onlyInstalledVersion) {
+        return checkForUpdates({ force: false, onlyInstalledVersion: true });
+      }
+
       try {
-        return await checkForUpdates({ force: true });
+        // the fallback below handles a disabled deployment. Any other failure
+        // is real and the user needs to hear about it.
+        return await checkForUpdates(
+          { force: true },
+          { disableNotifications: isUpdatesDisabled }
+        );
       } catch (error) {
         if ((error as AxiosError).response?.status !== 401) {
           return await checkForUpdates({