diff --git a/openspec/changes/add-svelte-notifications-management/design.md b/openspec/changes/add-svelte-notifications-management/design.md
new file mode 100644
index 0000000000..b61fa8f90f
--- /dev/null
+++ b/openspec/changes/add-svelte-notifications-management/design.md
@@ -0,0 +1,98 @@
+# Design: Add Svelte Notifications Management
+
+## Backend
+
+### NotificationService extraction
+
+Extract shared notification logic from `StatusController` into a service to avoid duplication:
+
+```csharp
+// src/Exceptionless.Core/Services/NotificationService.cs
+public class NotificationService(ICacheClient cacheClient, IMessagePublisher messagePublisher, TimeProvider timeProvider)
+{
+    public Task<SystemNotification?> GetSystemNotificationAsync();
+    public Task<SystemNotification> SetSystemNotificationAsync(string message, bool publish = true);
+    public Task ClearSystemNotificationAsync(bool publish = true);
+    public Task<ReleaseNotification> SendReleaseNotificationAsync(string? message, bool critical);
+}
+```
+
+- Cache key: `system-notification` (unchanged)
+- Publish: via `IMessagePublisher` (unchanged)
+- `StatusController` delegates to this service (behavior unchanged)
+
+### Admin endpoints
+
+Added to `AdminController` (already `[Authorize(Policy = GlobalAdminPolicy)]`):
+
+| Method | Route | Body | Response |
+|--------|-------|------|----------|
+| GET | `admin/notifications` | — | `{ configured_message, system_notification }` |
+| PUT | `admin/notifications/system` | `{ message }` | `SystemNotification` |
+| DELETE | `admin/notifications/system?publish=true` | — | 204 |
+| POST | `admin/notifications/release` | `{ message, critical }` | `ReleaseNotification` |
+| POST | `admin/notifications/force-refresh` | — | `ReleaseNotification` |
+
+DTOs in `src/Exceptionless.Web/Models/Admin/`:
+- `NotificationSettingsResponse` — configured fallback + current persisted notification
+- `SetSystemNotificationRequest` — message string
+- `SendReleaseNotificationRequest` — message + critical flag
+
+### Authorization
+
+All admin endpoints require `GlobalAdminPolicy` (existing controller-level attribute).
+
+## Frontend (Svelte)
+
+### Feature module
+
+`src/Exceptionless.Web/ClientApp/src/lib/features/notifications/`
+
+- `models.ts` — Re-export websocket models + admin DTOs
+- `api.svelte.ts` — TanStack Query wrappers using `useFetchClient`
+- `components/notification-banners.svelte` — Banner rendering component
+
+### Notification banners
+
+Rendered in `src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte`.
+
+Behavior:
+1. On mount: fetch `GET /api/v2/notifications/system` (existing StatusController endpoint)
+2. Fallback: if no persisted notification, use `PUBLIC_SYSTEM_NOTIFICATION_MESSAGE` env var
+3. Listen for `SystemNotification` and `ReleaseNotification` DOM CustomEvents (existing websocket dispatch)
+4. System notification → destructive/danger Alert with `role="alert"` and `aria-live="assertive"`
+5. Release notification → info Alert with `role="status"` and `aria-live="polite"`
+6. Critical release → `window.location.reload()` immediately
+
+Security: Plain text only. No `{@html}`. If sanitization is needed later, use dompurify.
+
+### Admin page
+
+Route: `/system/notifications`
+- Added to system nav in `routes.svelte.ts`, visible to global admins only
+- Card layout showing current state
+- Dialog-based actions: set notification, clear, send release, force refresh
+- Uses shadcn-svelte Alert, Button, Dialog, Input/Textarea, Card
+- Mutations use svelte-sonner for success/error toasts
+- Invalidates queries on mutation success
+
+### Query keys
+
+```typescript
+export const notificationKeys = {
+  settings: ['admin', 'notifications'] as const,
+  current: ['notifications', 'system'] as const,
+};
+```
+
+## Security
+
+- Admin endpoints already behind GlobalAdminPolicy
+- No HTML injection: plain text rendering only
+- No secrets exposed in admin response (only configured message text)
+
+## Accessibility
+
+- Banners use `role="alert"` / `role="status"` with appropriate `aria-live`
+- Dismiss button (if added) is keyboard-accessible
+- Color is not sole indicator (icon + text in banners)
diff --git a/openspec/changes/add-svelte-notifications-management/proposal.md b/openspec/changes/add-svelte-notifications-management/proposal.md
new file mode 100644
index 0000000000..33c7c4427d
--- /dev/null
+++ b/openspec/changes/add-svelte-notifications-management/proposal.md
@@ -0,0 +1,29 @@
+# Proposal: Add Svelte Notifications Management
+
+## Summary
+
+Implement global notification support in the Svelte 5 UI matching the legacy Angular behavior: system notification banners, release notification banners, critical release force-refresh, configuration fallback messages, and a global-admin notification management page.
+
+Additionally, add dedicated admin endpoints under `/api/v2/admin/notifications` to provide a cleaner management interface while preserving the existing `StatusController` notification endpoints for backwards compatibility.
+
+## Classification
+
+- **Type:** Feature + UI migration
+- **Affected areas:** Backend/API, Svelte UI, Redis (cache key `system-notification`), WebSocket messages, tests
+- **OpenSpec justification:** New API endpoints, WebSocket message consumption in new UI, admin authorization, cross-cutting UI/API contract, Angular-to-Svelte behavior migration
+
+## Compatibility Risks
+
+| Risk | Mitigation |
+|------|-----------|
+| Existing `StatusController` notification endpoints | Preserved unchanged; new admin endpoints are additive |
+| WebSocket message format (`SystemNotification`, `ReleaseNotification`) | Consumed as-is; no format changes |
+| Redis cache key `system-notification` | Shared between StatusController and new AdminController endpoints via extracted service |
+| Config key `PUBLIC_SYSTEM_NOTIFICATION_MESSAGE` | Read-only consumption; no changes to how it's set |
+| SDK/client expectations | No SDK changes; WebSocket messages unchanged |
+
+## Rollback Plan
+
+- New admin endpoints are additive; removing them has no impact on existing clients.
+- Frontend notification banners degrade gracefully (no banner shown if fetch fails).
+- Admin page is behind global-admin nav guard; removing it is safe.
diff --git a/openspec/changes/add-svelte-notifications-management/specs/notifications/spec.md b/openspec/changes/add-svelte-notifications-management/specs/notifications/spec.md
new file mode 100644
index 0000000000..885edd5985
--- /dev/null
+++ b/openspec/changes/add-svelte-notifications-management/specs/notifications/spec.md
@@ -0,0 +1,165 @@
+# Spec: Notifications
+
+## ADDED: StatusController notification management endpoints
+
+### Requirement: Admin can read notification settings
+
+Given an authenticated global admin user
+When they send `GET /api/v2/notifications/settings`
+Then the response is 200 with a `NotificationSettingsResponse`:
+- `configured_system_notification_message`: the `AppOptions.NotificationMessage` value (may be null)
+- `system_notification`: the currently cached `SystemNotification` (may be null)
+
+### Requirement: Non-admin cannot access admin notification endpoints
+
+Given an authenticated non-admin user
+When they send any request to `POST/DELETE /api/v2/notifications/*` or `GET /api/v2/notifications/settings`
+Then the response is 403 Forbidden.
+
+### Requirement: Admin can set a system notification
+
+Given an authenticated global admin user
+When they send `POST /api/v2/notifications/system` with body `{ "value": "Maintenance tonight" }`
+Then:
+- The system notification is stored in cache key `system-notification`
+- A `SystemNotification` message is published to the message bus (when `publish=true`, the default)
+- The response is 200 with the `SystemNotification` object
+
+#### Scenario: Empty message is rejected
+
+Given an authenticated global admin user
+When they send `POST /api/v2/notifications/system` with body `{ "value": "" }`
+Then the response is 400 Bad Request.
+
+#### Scenario: Publish suppression
+
+Given an authenticated global admin user
+When they send `POST /api/v2/notifications/system?publish=false` with body `{ "value": "Silent" }`
+Then:
+- The system notification is stored in cache
+- No message is published to the message bus
+- The response is 200 with the `SystemNotification` object
+
+### Requirement: Admin can clear a system notification
+
+Given an authenticated global admin user
+When they send `DELETE /api/v2/notifications/system`
+Then:
+- The `system-notification` cache key is removed
+- A blank `SystemNotification` is published to the message bus (when `publish=true`, the default)
+- The response is 200
+
+#### Scenario: Clear without publish
+
+Given an authenticated global admin user
+When they send `DELETE /api/v2/notifications/system?publish=false`
+Then:
+- The `system-notification` cache key is removed
+- No message is published to the message bus
+- The response is 200
+
+### Requirement: Admin can send a release notification
+
+Given an authenticated global admin user
+When they send `POST /api/v2/notifications/release` with body `{ "value": "v8.0 released" }` and optional `?critical=false`
+Then:
+- A `ReleaseNotification` is published to the message bus
+- The response is 200 with the `ReleaseNotification` object
+
+### Requirement: Admin can force-refresh all clients
+
+Given an authenticated global admin user
+When they send `POST /api/v2/notifications/force-refresh` with optional body `{ "value": "reason" }`
+Then:
+- A `ReleaseNotification` is published with `critical=true` and optional message
+- The response is 200 with the `ReleaseNotification` object
+
+## ADDED: Svelte notification banners (Svelte UI only)
+
+### Requirement: System notification banner displays on page load
+
+Given a system notification is persisted in cache
+When a user loads any authenticated page in the Svelte app
+Then a destructive/danger banner is displayed at the top of the layout with the notification message.
+
+#### Scenario: Fallback to configured message
+
+Given no system notification is persisted in cache
+And `PUBLIC_SYSTEM_NOTIFICATION_MESSAGE` is set to "Scheduled maintenance"
+When a user loads any authenticated page
+Then a destructive/danger banner displays "Scheduled maintenance".
+
+#### Scenario: No notification and no fallback
+
+Given no system notification is persisted in cache
+And `PUBLIC_SYSTEM_NOTIFICATION_MESSAGE` is empty
+When a user loads any authenticated page
+Then no system notification banner is displayed.
+
+### Requirement: Realtime system notification updates via WebSocket
+
+Given a user has the Svelte app open
+When a `SystemNotification` WebSocket message is received with a non-empty message
+Then the system notification banner updates to show the new message.
+
+#### Scenario: Clear notification via WebSocket
+
+Given a user has the Svelte app open with a system notification banner visible
+When a `SystemNotification` WebSocket message is received with an empty/null message
+Then the system notification banner is hidden (falls back to env var if configured).
+
+### Requirement: Release notification banner displays on WebSocket message
+
+Given a user has the Svelte app open
+When a `ReleaseNotification` WebSocket message is received with `critical=false`
+Then an info banner is displayed with the release message.
+
+### Requirement: Critical release notification triggers page reload
+
+Given a user has the Svelte app open
+When a `ReleaseNotification` WebSocket message is received with `critical=true`
+Then `window.location.reload()` is called immediately.
+
+### Requirement: Notification banners use accessible markup
+
+Given a system notification banner is displayed
+Then it has `role="alert"` and `aria-live="assertive"`.
+
+Given a release notification banner is displayed
+Then it has `role="status"` and `aria-live="polite"`.
+
+### Requirement: No unsafe HTML rendering
+
+Given any notification message content
+When it is rendered in the Svelte UI
+Then it is rendered as plain text (no innerHTML or {@html}).
+
+## ADDED: Svelte admin notifications page (Svelte UI only)
+
+### Requirement: System → Notifications page exists for global admins
+
+Given an authenticated global admin user
+When they navigate to `/system/notifications`
+Then they see the notification management page with:
+- Current configured fallback message (read-only)
+- Current persisted system notification (if any)
+- Actions: Set system notification, Clear, Send release notification, Force refresh
+
+### Requirement: Notifications page is hidden from non-admins
+
+Given an authenticated non-admin user
+When they view the system navigation
+Then the "Notifications" link is not visible.
+
+## HTTP test file updates
+
+### Requirement: tests/http files updated for notification endpoints
+
+Given the notification endpoints exist in StatusController
+Then `tests/http/status.http` includes sample requests for:
+- GET notifications/settings
+- POST notifications/system
+- DELETE notifications/system
+- POST notifications/release
+- POST notifications/force-refresh
+
diff --git a/openspec/changes/add-svelte-notifications-management/tasks.md b/openspec/changes/add-svelte-notifications-management/tasks.md
new file mode 100644
index 0000000000..676a724c47
--- /dev/null
+++ b/openspec/changes/add-svelte-notifications-management/tasks.md
@@ -0,0 +1,66 @@
+# Tasks: Add Svelte Notifications Management
+
+## Backend
+
+- [x] **Task 1: Extract NotificationService**
+  - Created `src/Exceptionless.Core/Services/NotificationService.cs`
+  - Methods: `GetSystemNotificationAsync`, `SetSystemNotificationAsync`, `ClearSystemNotificationAsync`, `SendReleaseNotificationAsync`
+  - Registered as singleton in DI (`Bootstrapper.cs`)
+  - Refactored `StatusController` to delegate to `NotificationService` (no behavior change)
+
+- [x] **Task 2: Add new StatusController endpoints**
+  - `GET notifications/settings` — returns configured fallback + current notification (admin only)
+  - `POST notifications/force-refresh` — force reload all clients via critical release notification (admin only)
+  - Added `bool publish = true` query param to POST and DELETE system notification endpoints
+  - All endpoints use existing `ValueFromBody<string>` pattern for backward compatibility
+
+- [x] **Task 3: Update HTTP test samples**
+  - Updated `tests/http/status.http` with force-refresh and settings endpoint samples
+
+- [x] **Task 4: Add backend integration tests**
+  - Added tests to existing `tests/Exceptionless.Tests/Controllers/StatusControllerTests.cs`
+  - Tests: settings (admin/non-admin), force-refresh (with message/without/non-admin), publish flag
+  - All tests follow AAA (Arrange/Act/Assert) pattern
+
+## Frontend — System Notification Banner
+
+- [x] **Task 5: Create system-notifications feature module**
+  - Created `src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/models.ts`
+  - Created `src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/api.svelte.ts`
+  - All API calls target StatusController routes (`notifications/*`)
+
+- [x] **Task 6: Create system-notification-banner component**
+  - Created `src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.svelte`
+  - Three-tier message resolution: realtime WebSocket → persisted API → env fallback
+  - System = destructive Alert with `role="alert"` `aria-live="assertive"`
+  - Release = info Alert with `role="status"` `aria-live="polite"`
+  - Critical release = `window.location.reload()`
+
+- [x] **Task 7: Integrate banner into app layout**
+  - Added `<SystemNotificationBanner />` to `(app)/+layout.svelte`
+
+- [x] **Task 8: Add unit tests**
+  - Created `system-notification-banner.test.ts` with 6 tests covering event handling and message resolution logic
+
+## Frontend — Admin Page
+
+- [x] **Task 9: Add System → Notifications route and nav entry**
+  - Created `src/Exceptionless.Web/ClientApp/src/routes/(app)/system/notifications/+page.svelte`
+  - Added Bell icon + Notifications nav entry in `routes.svelte.ts`, visible only to global admins
+
+- [x] **Task 10: Implement notifications admin page**
+  - Displays current state (configured fallback, persisted notification)
+  - Actions via dialogs: Set system notification, Clear/reset, Send release notification, Force refresh
+  - Uses shadcn-svelte components, svelte-sonner toasts, TanStack Query mutations
+  - Invalidates notification queries on success
+
+## Final Validation
+
+- [x] **Task 11: Full build and test validation**
+  - `dotnet build` ✓
+  - `dotnet test -- --filter-class StatusControllerTests` → 19/19 pass ✓
+  - `npm run check` (svelte-check) → 0 errors ✓
+  - `npm run lint` → clean ✓
+  - `npm run build` → success ✓
+  - `npm run test:unit` → 249/249 pass ✓
+  - UI dogfood via browser → all flows verified ✓
diff --git a/src/Exceptionless.Core/Bootstrapper.cs b/src/Exceptionless.Core/Bootstrapper.cs
index bfd443ef16..751d8e0880 100644
--- a/src/Exceptionless.Core/Bootstrapper.cs
+++ b/src/Exceptionless.Core/Bootstrapper.cs
@@ -198,6 +198,7 @@ public static void RegisterServices(IServiceCollection services, AppOptions appO
         services.AddSingleton<UserAgentParser>();
         services.AddSingleton<ICoreLastReferenceIdManager, NullCoreLastReferenceIdManager>();
 
+        services.AddSingleton<NotificationService>();
         services.AddSingleton<OrganizationService>();
         services.AddStartupAction<OrganizationService>();
         services.AddSingleton<UsageService>();
diff --git a/src/Exceptionless.Core/Models/Messaging/NotificationSettingsResponse.cs b/src/Exceptionless.Core/Models/Messaging/NotificationSettingsResponse.cs
new file mode 100644
index 0000000000..ad7172a25c
--- /dev/null
+++ b/src/Exceptionless.Core/Models/Messaging/NotificationSettingsResponse.cs
@@ -0,0 +1,7 @@
+namespace Exceptionless.Core.Messaging.Models;
+
+public record NotificationSettingsResponse
+{
+    public string? ConfiguredSystemNotificationMessage { get; init; }
+    public SystemNotification? SystemNotification { get; init; }
+}
diff --git a/src/Exceptionless.Core/Services/NotificationService.cs b/src/Exceptionless.Core/Services/NotificationService.cs
new file mode 100644
index 0000000000..10b0f093b6
--- /dev/null
+++ b/src/Exceptionless.Core/Services/NotificationService.cs
@@ -0,0 +1,40 @@
+using Exceptionless.Core.Messaging.Models;
+using Foundatio.Caching;
+using Foundatio.Messaging;
+
+namespace Exceptionless.Core.Services;
+
+public class NotificationService(ICacheClient cacheClient, IMessagePublisher messagePublisher, TimeProvider timeProvider)
+{
+    private const string SystemNotificationCacheKey = "system-notification";
+
+    public async Task<SystemNotification?> GetSystemNotificationAsync()
+    {
+        var result = await cacheClient.GetAsync<SystemNotification>(SystemNotificationCacheKey);
+        return result.HasValue ? result.Value : null;
+    }
+
+    public async Task<SystemNotification> SetSystemNotificationAsync(string message, bool publish = true)
+    {
+        var notification = new SystemNotification { Date = timeProvider.GetUtcNow().UtcDateTime, Message = message };
+        await cacheClient.SetAsync(SystemNotificationCacheKey, notification);
+        if (publish)
+            await messagePublisher.PublishAsync(notification);
+        return notification;
+    }
+
+    public async Task ClearSystemNotificationAsync(bool publish = true)
+    {
+        await cacheClient.RemoveAsync(SystemNotificationCacheKey);
+        if (publish)
+            await messagePublisher.PublishAsync(new SystemNotification { Date = timeProvider.GetUtcNow().UtcDateTime });
+    }
+
+    public async Task<ReleaseNotification> SendReleaseNotificationAsync(string? message, bool critical, bool publish = true)
+    {
+        var notification = new ReleaseNotification { Critical = critical, Date = timeProvider.GetUtcNow().UtcDateTime, Message = message };
+        if (publish)
+            await messagePublisher.PublishAsync(notification);
+        return notification;
+    }
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/api.svelte.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/api.svelte.ts
new file mode 100644
index 0000000000..724be62e69
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/api.svelte.ts
@@ -0,0 +1,93 @@
+import type { ReleaseNotification, SystemNotification } from '$features/websockets/models';
+
+import { type ProblemDetails, useFetchClient } from '@exceptionless/fetchclient';
+import { createMutation, createQuery, useQueryClient } from '@tanstack/svelte-query';
+
+import type { NotificationSettings } from './models';
+
+export const queryKeys = {
+    current: ['notifications', 'system'] as const,
+    settings: ['notifications', 'settings'] as const
+};
+
+export function clearSystemNotificationMutation() {
+    const queryClient = useQueryClient();
+    return createMutation<void, ProblemDetails, { publish?: boolean }>(() => ({
+        mutationFn: async (params: { publish?: boolean }) => {
+            const client = useFetchClient();
+            const publish = params.publish !== false;
+            await client.delete(`notifications/system?publish=${publish}`);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.settings });
+            queryClient.invalidateQueries({ queryKey: queryKeys.current });
+        }
+    }));
+}
+
+export function forceRefreshClientsMutation() {
+    return createMutation<ReleaseNotification, ProblemDetails, undefined | { message?: string }>(() => ({
+        mutationFn: async (params?: { message?: string }) => {
+            const client = useFetchClient();
+            const response = params?.message
+                ? await client.postJSON<ReleaseNotification>('notifications/force-refresh', { value: params.message })
+                : await client.postJSON<ReleaseNotification>('notifications/force-refresh');
+            return response.data!;
+        }
+    }));
+}
+
+export function getCurrentSystemNotificationQuery() {
+    return createQuery<null | SystemNotification, ProblemDetails>(() => ({
+        queryFn: async ({ signal }: { signal: AbortSignal }) => {
+            const client = useFetchClient();
+            const response = await client.getJSON<SystemNotification>('notifications/system', { signal });
+            return response.data ?? null;
+        },
+        queryKey: queryKeys.current,
+        staleTime: 30_000
+    }));
+}
+
+export function getNotificationSettingsQuery() {
+    return createQuery<NotificationSettings, ProblemDetails>(() => ({
+        queryFn: async ({ signal }: { signal: AbortSignal }) => {
+            const client = useFetchClient();
+            const response = await client.getJSON<NotificationSettings>('notifications/settings', { signal });
+            return response.data!;
+        },
+        queryKey: queryKeys.settings,
+        staleTime: 30_000
+    }));
+}
+
+export function sendReleaseNotificationMutation() {
+    return createMutation<ReleaseNotification, ProblemDetails, { critical?: boolean; message?: string }>(() => ({
+        mutationFn: async (params: { critical?: boolean; message?: string }) => {
+            const client = useFetchClient();
+            const critical = params.critical ?? false;
+            const response = await client.postJSON<ReleaseNotification>(`notifications/release?critical=${critical}`, {
+                value: params.message ?? null
+            });
+            return response.data!;
+        }
+    }));
+}
+
+export function setSystemNotificationMutation() {
+    const queryClient = useQueryClient();
+    return createMutation<SystemNotification, ProblemDetails, { message: string; publish?: boolean }>(() => ({
+        mutationFn: async (params: { message: string; publish?: boolean }) => {
+            const client = useFetchClient();
+            const publish = params.publish !== false;
+            const response = await client.postJSON<SystemNotification>(`notifications/system?publish=${publish}`, {
+                value: params.message
+            });
+            return response.data!;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.settings });
+            queryClient.invalidateQueries({ queryKey: queryKeys.current });
+        }
+    }));
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.svelte b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.svelte
new file mode 100644
index 0000000000..ad5aac2e58
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.svelte
@@ -0,0 +1,62 @@
+<script lang="ts">
+    import type { ReleaseNotification, SystemNotification } from '$features/websockets/models';
+
+    import { env } from '$env/dynamic/public';
+    import { Notification, NotificationDescription } from '$features/shared/components/notification';
+    import { getCurrentSystemNotificationQuery } from '$features/system-notifications/api.svelte';
+    import { resolveDisplayMessage } from '$features/system-notifications/resolve-message';
+    import AlertTriangle from '@lucide/svelte/icons/alert-triangle';
+    import Info from '@lucide/svelte/icons/info';
+
+    const currentNotificationQuery = getCurrentSystemNotificationQuery();
+
+    let realtimeSystemMessage = $state<null | string | undefined>(undefined);
+    let releaseMessage = $state<null | string>(null);
+
+    const fallbackMessage = $derived(env.PUBLIC_SYSTEM_NOTIFICATION_MESSAGE || null);
+    const persistedMessage = $derived(currentNotificationQuery.data?.message || null);
+    const displaySystemMessage = $derived(resolveDisplayMessage(realtimeSystemMessage, persistedMessage, fallbackMessage));
+
+    $effect(() => {
+        function onSystemNotification(e: Event) {
+            const detail = (e as CustomEvent<SystemNotification>).detail;
+            realtimeSystemMessage = detail?.message || null;
+        }
+
+        function onReleaseNotification(e: Event) {
+            const detail = (e as CustomEvent<ReleaseNotification>).detail;
+            if (detail?.critical) {
+                window.location.reload();
+                return;
+            }
+
+            releaseMessage = detail?.message || null;
+        }
+
+        document.addEventListener('SystemNotification', onSystemNotification);
+        document.addEventListener('ReleaseNotification', onReleaseNotification);
+
+        return () => {
+            document.removeEventListener('SystemNotification', onSystemNotification);
+            document.removeEventListener('ReleaseNotification', onReleaseNotification);
+        };
+    });
+</script>
+
+{#if displaySystemMessage}
+    <Notification variant="destructive" role="alert" aria-live="assertive" class="mb-4">
+        {#snippet icon()}
+            <AlertTriangle class="size-4" />
+        {/snippet}
+        <NotificationDescription>{displaySystemMessage}</NotificationDescription>
+    </Notification>
+{/if}
+
+{#if releaseMessage}
+    <Notification variant="information" role="status" aria-live="polite" class="mb-4">
+        {#snippet icon()}
+            <Info class="size-4" />
+        {/snippet}
+        <NotificationDescription>{releaseMessage}</NotificationDescription>
+    </Notification>
+{/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.test.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.test.ts
new file mode 100644
index 0000000000..3c6d7be114
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/components/system-notification-banner.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveDisplayMessage } from '../resolve-message';
+
+describe('resolveDisplayMessage', () => {
+    describe('when realtime message has not been received (undefined)', () => {
+        it('returns persisted message over fallback', () => {
+            expect(resolveDisplayMessage(undefined, 'Active outage', 'Scheduled maintenance')).toBe('Active outage');
+        });
+
+        it('returns fallback when no persisted message', () => {
+            expect(resolveDisplayMessage(undefined, null, 'Scheduled maintenance')).toBe('Scheduled maintenance');
+        });
+
+        it('returns null when no persisted or fallback message', () => {
+            expect(resolveDisplayMessage(undefined, null, null)).toBeNull();
+        });
+    });
+
+    describe('when realtime message is received (string)', () => {
+        it('returns the realtime message', () => {
+            expect(resolveDisplayMessage('Realtime alert', 'Old persisted', 'Fallback')).toBe('Realtime alert');
+        });
+
+        it('ignores persisted message', () => {
+            expect(resolveDisplayMessage('New message', 'Stale persisted', null)).toBe('New message');
+        });
+    });
+
+    describe('when realtime message is cleared (null)', () => {
+        it('falls back to fallback message', () => {
+            expect(resolveDisplayMessage(null, 'Persisted', 'Fallback')).toBe('Fallback');
+        });
+
+        it('returns null when no fallback configured', () => {
+            expect(resolveDisplayMessage(null, 'Persisted', null)).toBeNull();
+        });
+    });
+
+    describe('edge cases', () => {
+        it('empty string realtime falls through to fallback', () => {
+            expect(resolveDisplayMessage('', null, 'Fallback')).toBe('Fallback');
+        });
+
+        it('empty string persisted falls through to fallback', () => {
+            expect(resolveDisplayMessage(undefined, '', 'Fallback')).toBe('Fallback');
+        });
+
+        it('all empty/null returns null', () => {
+            expect(resolveDisplayMessage(undefined, null, null)).toBeNull();
+        });
+    });
+});
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/models.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/models.ts
new file mode 100644
index 0000000000..51c5f15097
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/models.ts
@@ -0,0 +1,8 @@
+import type { ReleaseNotification, SystemNotification } from '$features/websockets/models';
+
+export type { ReleaseNotification, SystemNotification };
+
+export interface NotificationSettings {
+    configured_system_notification_message?: null | string;
+    system_notification?: null | SystemNotification;
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/resolve-message.ts b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/resolve-message.ts
new file mode 100644
index 0000000000..72866458fa
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/lib/features/system-notifications/resolve-message.ts
@@ -0,0 +1,21 @@
+/**
+ * Three-tier system notification message resolution.
+ *
+ * Priority (highest to lowest):
+ * 1. realtimeMessage — from WebSocket (undefined = not yet received, null = explicitly cleared)
+ * 2. persistedMessage — from GET /notifications/system on mount
+ * 3. fallbackMessage — from PUBLIC_SYSTEM_NOTIFICATION_MESSAGE env var
+ *
+ * Empty strings are treated as absent (no notification to display).
+ */
+export function resolveDisplayMessage(
+    realtimeMessage: null | string | undefined,
+    persistedMessage: null | string,
+    fallbackMessage: null | string
+): null | string {
+    if (realtimeMessage !== undefined) {
+        return realtimeMessage || fallbackMessage;
+    }
+
+    return persistedMessage || fallbackMessage;
+}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
index a76a8df242..c710816cda 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/+layout.svelte
@@ -24,6 +24,7 @@
     import { savedViewHref } from '$features/saved-views/slugs';
     import { appKeyboardShortcuts, isKeyboardShortcut } from '$features/shared/keyboard-shortcuts';
     import { invalidateStackQueries } from '$features/stacks/api.svelte';
+    import SystemNotificationBanner from '$features/system-notifications/components/system-notification-banner.svelte';
     import { invalidateTokenQueries } from '$features/tokens/api.svelte';
     import { getMeQuery, invalidateUserQueries } from '$features/users/api.svelte';
     import { getGravatarFromCurrentUser } from '$features/users/gravatar.svelte';
@@ -499,6 +500,8 @@
                 />
                 <KeyboardShortcutsDialog bind:open={isKeyboardShortcutsOpen} />
 
+                <SystemNotificationBanner />
+
                 {#if showOrganizationNotifications.current}
                     <OrganizationNotifications {isChatEnabled} {openChat} {requiresPremium} premiumFeatureName={premiumPage.current} class="mb-4" />
                 {/if}
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/notifications/+page.svelte b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/notifications/+page.svelte
new file mode 100644
index 0000000000..222107e443
--- /dev/null
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/notifications/+page.svelte
@@ -0,0 +1,281 @@
+<script lang="ts">
+    import { Button } from '$comp/ui/button';
+    import * as Card from '$comp/ui/card';
+    import { Checkbox } from '$comp/ui/checkbox';
+    import * as Dialog from '$comp/ui/dialog';
+    import { Label } from '$comp/ui/label';
+    import { Textarea } from '$comp/ui/textarea';
+    import {
+        clearSystemNotificationMutation,
+        forceRefreshClientsMutation,
+        getNotificationSettingsQuery,
+        sendReleaseNotificationMutation,
+        setSystemNotificationMutation
+    } from '$features/system-notifications/api.svelte';
+    import AlertTriangle from '@lucide/svelte/icons/alert-triangle';
+    import Bell from '@lucide/svelte/icons/bell';
+    import RefreshCw from '@lucide/svelte/icons/refresh-cw';
+    import Trash2 from '@lucide/svelte/icons/trash-2';
+    import { toast } from 'svelte-sonner';
+
+    const settingsQuery = getNotificationSettingsQuery();
+    const setSystemNotification = setSystemNotificationMutation();
+    const clearSystemNotification = clearSystemNotificationMutation();
+    const sendRelease = sendReleaseNotificationMutation();
+    const forceRefresh = forceRefreshClientsMutation();
+
+    // Dialog state
+    let showSetDialog = $state(false);
+    let showClearDialog = $state(false);
+    let showReleaseDialog = $state(false);
+    let showForceRefreshDialog = $state(false);
+
+    // Form state
+    let systemMessage = $state('');
+    let systemPublish = $state(true);
+    let clearPublish = $state(true);
+    let releaseMessage = $state('');
+    let releaseCritical = $state(false);
+    let forceRefreshMessage = $state('');
+
+    async function handleSetSystemNotification() {
+        try {
+            await setSystemNotification.mutateAsync({ message: systemMessage, publish: systemPublish });
+            toast.success('System notification set successfully.');
+            showSetDialog = false;
+            systemMessage = '';
+            systemPublish = true;
+        } catch {
+            toast.error('Failed to set system notification.');
+        }
+    }
+
+    async function handleClearSystemNotification() {
+        try {
+            await clearSystemNotification.mutateAsync({ publish: clearPublish });
+            toast.success('System notification cleared.');
+            showClearDialog = false;
+            clearPublish = true;
+        } catch {
+            toast.error('Failed to clear system notification.');
+        }
+    }
+
+    async function handleSendReleaseNotification() {
+        try {
+            await sendRelease.mutateAsync({ critical: releaseCritical, message: releaseMessage || undefined });
+            toast.success('Release notification sent.');
+            showReleaseDialog = false;
+            releaseMessage = '';
+            releaseCritical = false;
+        } catch {
+            toast.error('Failed to send release notification.');
+        }
+    }
+
+    async function handleForceRefresh() {
+        try {
+            await forceRefresh.mutateAsync(forceRefreshMessage ? { message: forceRefreshMessage } : undefined);
+            toast.success('Force refresh sent to all clients.');
+            showForceRefreshDialog = false;
+            forceRefreshMessage = '';
+        } catch {
+            toast.error('Failed to send force refresh.');
+        }
+    }
+</script>
+
+<div class="space-y-6">
+    <div>
+        <h2 class="text-2xl font-bold tracking-tight">Notifications</h2>
+        <p class="text-muted-foreground">Manage system notifications, release announcements, and client refresh.</p>
+    </div>
+
+    <Card.Root>
+        <Card.Header>
+            <Card.Title>Current Status</Card.Title>
+            <Card.Description>Active notification configuration and state.</Card.Description>
+        </Card.Header>
+        <Card.Content class="space-y-3">
+            {#if settingsQuery.isLoading}
+                <p class="text-muted-foreground text-sm">Loading...</p>
+            {:else if settingsQuery.isError}
+                <p class="text-destructive text-sm">Failed to load notification settings.</p>
+            {:else if settingsQuery.data}
+                <div class="space-y-2">
+                    <div>
+                        <span class="text-sm font-medium">Configured Fallback Message:</span>
+                        <span class="text-muted-foreground ml-2 text-sm">
+                            {settingsQuery.data.configured_system_notification_message || '(none)'}
+                        </span>
+                    </div>
+                    <div>
+                        <span class="text-sm font-medium">Active System Notification:</span>
+                        {#if settingsQuery.data.system_notification?.message}
+                            <span class="ml-2 text-sm text-red-600 dark:text-red-400">
+                                {settingsQuery.data.system_notification.message}
+                            </span>
+                            <span class="text-muted-foreground ml-2 text-xs">
+                                (set {new Date(settingsQuery.data.system_notification.date).toLocaleString()})
+                            </span>
+                        {:else}
+                            <span class="text-muted-foreground ml-2 text-sm">(none)</span>
+                        {/if}
+                    </div>
+                </div>
+            {/if}
+        </Card.Content>
+    </Card.Root>
+
+    <div class="grid gap-4 md:grid-cols-2">
+        <Card.Root>
+            <Card.Header>
+                <Card.Title class="flex items-center gap-2">
+                    <Bell class="size-4" />
+                    Set System Notification
+                </Card.Title>
+                <Card.Description>Display a persistent notification banner to all users.</Card.Description>
+            </Card.Header>
+            <Card.Content>
+                <Button onclick={() => (showSetDialog = true)} disabled={setSystemNotification.isPending}>Set Notification</Button>
+            </Card.Content>
+        </Card.Root>
+
+        <Card.Root>
+            <Card.Header>
+                <Card.Title class="flex items-center gap-2">
+                    <Trash2 class="size-4" />
+                    Clear System Notification
+                </Card.Title>
+                <Card.Description>Remove the current system notification banner.</Card.Description>
+            </Card.Header>
+            <Card.Content>
+                <Button variant="outline" onclick={() => (showClearDialog = true)} disabled={clearSystemNotification.isPending}>Clear Notification</Button>
+            </Card.Content>
+        </Card.Root>
+
+        <Card.Root>
+            <Card.Header>
+                <Card.Title class="flex items-center gap-2">
+                    <AlertTriangle class="size-4" />
+                    Send Release Notification
+                </Card.Title>
+                <Card.Description>Send a one-time release announcement to all connected clients.</Card.Description>
+            </Card.Header>
+            <Card.Content>
+                <Button variant="outline" onclick={() => (showReleaseDialog = true)} disabled={sendRelease.isPending}>Send Release Notification</Button>
+            </Card.Content>
+        </Card.Root>
+
+        <Card.Root>
+            <Card.Header>
+                <Card.Title class="flex items-center gap-2">
+                    <RefreshCw class="size-4" />
+                    Force Refresh Clients
+                </Card.Title>
+                <Card.Description>Force all connected clients to reload. Use with caution.</Card.Description>
+            </Card.Header>
+            <Card.Content>
+                <Button variant="destructive" onclick={() => (showForceRefreshDialog = true)} disabled={forceRefresh.isPending}>Force Refresh</Button>
+            </Card.Content>
+        </Card.Root>
+    </div>
+</div>
+
+<!-- Set System Notification Dialog -->
+<Dialog.Root bind:open={showSetDialog}>
+    <Dialog.Content>
+        <Dialog.Header>
+            <Dialog.Title>Set System Notification</Dialog.Title>
+            <Dialog.Description>This message will be displayed as a banner to all users.</Dialog.Description>
+        </Dialog.Header>
+        <div class="space-y-4 py-4">
+            <div class="space-y-2">
+                <Label for="system-message">Message</Label>
+                <Textarea id="system-message" bind:value={systemMessage} placeholder="Enter notification message..." rows={3} />
+            </div>
+            <div class="flex items-center gap-2">
+                <Checkbox id="system-publish" bind:checked={systemPublish} />
+                <Label for="system-publish">Publish in realtime via WebSocket</Label>
+            </div>
+        </div>
+        <Dialog.Footer>
+            <Button variant="outline" onclick={() => (showSetDialog = false)}>Cancel</Button>
+            <Button onclick={handleSetSystemNotification} disabled={!systemMessage.trim() || setSystemNotification.isPending}>
+                {setSystemNotification.isPending ? 'Setting...' : 'Set Notification'}
+            </Button>
+        </Dialog.Footer>
+    </Dialog.Content>
+</Dialog.Root>
+
+<!-- Clear System Notification Dialog -->
+<Dialog.Root bind:open={showClearDialog}>
+    <Dialog.Content>
+        <Dialog.Header>
+            <Dialog.Title>Clear System Notification</Dialog.Title>
+            <Dialog.Description>This will remove the current system notification for all users.</Dialog.Description>
+        </Dialog.Header>
+        <div class="space-y-4 py-4">
+            <div class="flex items-center gap-2">
+                <Checkbox id="clear-publish" bind:checked={clearPublish} />
+                <Label for="clear-publish">Publish removal in realtime via WebSocket</Label>
+            </div>
+        </div>
+        <Dialog.Footer>
+            <Button variant="outline" onclick={() => (showClearDialog = false)}>Cancel</Button>
+            <Button variant="destructive" onclick={handleClearSystemNotification} disabled={clearSystemNotification.isPending}>
+                {clearSystemNotification.isPending ? 'Clearing...' : 'Clear Notification'}
+            </Button>
+        </Dialog.Footer>
+    </Dialog.Content>
+</Dialog.Root>
+
+<!-- Send Release Notification Dialog -->
+<Dialog.Root bind:open={showReleaseDialog}>
+    <Dialog.Content>
+        <Dialog.Header>
+            <Dialog.Title>Send Release Notification</Dialog.Title>
+            <Dialog.Description>Send a one-time notification to all connected clients.</Dialog.Description>
+        </Dialog.Header>
+        <div class="space-y-4 py-4">
+            <div class="space-y-2">
+                <Label for="release-message">Message (optional)</Label>
+                <Textarea id="release-message" bind:value={releaseMessage} placeholder="Enter release message..." rows={3} />
+            </div>
+            <div class="flex items-center gap-2">
+                <Checkbox id="release-critical" bind:checked={releaseCritical} />
+                <Label for="release-critical" class="text-destructive font-medium">Critical (forces client reload)</Label>
+            </div>
+        </div>
+        <Dialog.Footer>
+            <Button variant="outline" onclick={() => (showReleaseDialog = false)}>Cancel</Button>
+            <Button onclick={handleSendReleaseNotification} disabled={sendRelease.isPending}>
+                {sendRelease.isPending ? 'Sending...' : 'Send Notification'}
+            </Button>
+        </Dialog.Footer>
+    </Dialog.Content>
+</Dialog.Root>
+
+<!-- Force Refresh Dialog -->
+<Dialog.Root bind:open={showForceRefreshDialog}>
+    <Dialog.Content>
+        <Dialog.Header>
+            <Dialog.Title>Force Refresh All Clients</Dialog.Title>
+            <Dialog.Description class="text-destructive">
+                Warning: This will force ALL connected clients to reload their browser. Any unsaved work will be lost.
+            </Dialog.Description>
+        </Dialog.Header>
+        <div class="space-y-4 py-4">
+            <div class="space-y-2">
+                <Label for="refresh-message">Message (optional)</Label>
+                <Textarea id="refresh-message" bind:value={forceRefreshMessage} placeholder="Reason for force refresh..." rows={2} />
+            </div>
+        </div>
+        <Dialog.Footer>
+            <Button variant="outline" onclick={() => (showForceRefreshDialog = false)}>Cancel</Button>
+            <Button variant="destructive" onclick={handleForceRefresh} disabled={forceRefresh.isPending}>
+                {forceRefresh.isPending ? 'Refreshing...' : 'Force Refresh All Clients'}
+            </Button>
+        </Dialog.Footer>
+    </Dialog.Content>
+</Dialog.Root>
diff --git a/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts
index e41cff7fd6..f039a17022 100644
--- a/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts
+++ b/src/Exceptionless.Web/ClientApp/src/routes/(app)/system/routes.svelte.ts
@@ -1,4 +1,5 @@
 import { resolve } from '$app/paths';
+import Bell from '@lucide/svelte/icons/bell';
 import Database from '@lucide/svelte/icons/database';
 import DatabaseZap from '@lucide/svelte/icons/database-zap';
 import LayoutDashboard from '@lucide/svelte/icons/layout-dashboard';
@@ -29,6 +30,13 @@ export function routes(): NavigationItem[] {
             show: (context) => context.user?.roles?.includes('global') ?? false,
             title: 'Actions'
         },
+        {
+            group: 'System',
+            href: resolve('/(app)/system/notifications'),
+            icon: Bell,
+            show: (context) => context.user?.roles?.includes('global') ?? false,
+            title: 'Notifications'
+        },
         {
             group: 'System',
             href: resolve('/(app)/system/migrations'),
diff --git a/src/Exceptionless.Web/Controllers/StatusController.cs b/src/Exceptionless.Web/Controllers/StatusController.cs
index 2c73d0f2fb..15011f96fc 100644
--- a/src/Exceptionless.Web/Controllers/StatusController.cs
+++ b/src/Exceptionless.Web/Controllers/StatusController.cs
@@ -2,9 +2,8 @@
 using Exceptionless.Core.Authorization;
 using Exceptionless.Core.Messaging.Models;
 using Exceptionless.Core.Queues.Models;
+using Exceptionless.Core.Services;
 using Exceptionless.Web.Models;
-using Foundatio.Caching;
-using Foundatio.Messaging;
 using Foundatio.Queues;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -16,8 +15,7 @@ namespace Exceptionless.Web.Controllers;
 [Authorize(Policy = AuthorizationRoles.UserPolicy)]
 public class StatusController : ExceptionlessApiController
 {
-    private readonly ICacheClient _cacheClient;
-    private readonly IMessagePublisher _messagePublisher;
+    private readonly NotificationService _notificationService;
     private readonly IQueue<EventPost> _eventQueue;
     private readonly IQueue<MailMessage> _mailQueue;
     private readonly IQueue<EventNotification> _notificationQueue;
@@ -26,8 +24,7 @@ public class StatusController : ExceptionlessApiController
     private readonly AppOptions _appOptions;
 
     public StatusController(
-        ICacheClient cacheClient,
-        IMessagePublisher messagePublisher,
+        NotificationService notificationService,
         IQueue<EventPost> eventQueue,
         IQueue<MailMessage> mailQueue,
         IQueue<EventNotification> notificationQueue,
@@ -36,8 +33,7 @@ public StatusController(
         AppOptions appOptions,
         TimeProvider timeProvider) : base(timeProvider)
     {
-        _cacheClient = cacheClient;
-        _messagePublisher = messagePublisher;
+        _notificationService = notificationService;
         _eventQueue = eventQueue;
         _mailQueue = mailQueue;
         _notificationQueue = notificationQueue;
@@ -111,8 +107,7 @@ public async Task<IActionResult> QueueStatsAsync()
     [Authorize(Policy = AuthorizationRoles.GlobalAdminPolicy)]
     public async Task<ActionResult<ReleaseNotification>> PostReleaseNotificationAsync(ValueFromBody<string> message, bool critical = false)
     {
-        var notification = new ReleaseNotification { Critical = critical, Date = _timeProvider.GetUtcNow().UtcDateTime, Message = message.Value };
-        await _messagePublisher.PublishAsync(notification);
+        var notification = await _notificationService.SendReleaseNotificationAsync(message.Value, critical);
         return Ok(notification);
     }
 
@@ -122,34 +117,56 @@ public async Task<ActionResult<ReleaseNotification>> PostReleaseNotificationAsyn
     [HttpGet("notifications/system")]
     public async Task<ActionResult<SystemNotification>> GetSystemNotificationAsync()
     {
-        var notification = await _cacheClient.GetAsync<SystemNotification>("system-notification");
-        if (!notification.HasValue)
+        var notification = await _notificationService.GetSystemNotificationAsync();
+        if (notification is null)
             return Ok();
 
-        return Ok(notification.Value);
+        return Ok(notification);
     }
 
     [HttpPost("notifications/system")]
     [Consumes("application/json")]
     [Authorize(Policy = AuthorizationRoles.GlobalAdminPolicy)]
-    public async Task<ActionResult<SystemNotification>> PostSystemNotificationAsync(ValueFromBody<string> message)
+    public async Task<ActionResult<SystemNotification>> PostSystemNotificationAsync(ValueFromBody<string> message, bool publish = true)
     {
         if (String.IsNullOrWhiteSpace(message?.Value))
-            return NotFound();
-
-        var notification = new SystemNotification { Date = _timeProvider.GetUtcNow().UtcDateTime, Message = message.Value };
-        await _cacheClient.SetAsync("system-notification", notification);
-        await _messagePublisher.PublishAsync(notification);
+            return BadRequest();
 
+        var notification = await _notificationService.SetSystemNotificationAsync(message.Value, publish);
         return Ok(notification);
     }
 
     [HttpDelete("notifications/system")]
     [Authorize(Policy = AuthorizationRoles.GlobalAdminPolicy)]
-    public async Task<IActionResult> RemoveSystemNotificationAsync()
+    public async Task<IActionResult> RemoveSystemNotificationAsync(bool publish = true)
     {
-        await _cacheClient.RemoveAsync("system-notification");
-        await _messagePublisher.PublishAsync(new SystemNotification { Date = _timeProvider.GetUtcNow().UtcDateTime });
+        await _notificationService.ClearSystemNotificationAsync(publish);
         return Ok();
     }
+
+    /// <summary>
+    /// Returns the current notification settings state for the admin management page.
+    /// </summary>
+    [HttpGet("notifications/settings")]
+    [Authorize(Policy = AuthorizationRoles.GlobalAdminPolicy)]
+    public async Task<ActionResult<NotificationSettingsResponse>> GetNotificationSettingsAsync()
+    {
+        var notification = await _notificationService.GetSystemNotificationAsync();
+        return Ok(new NotificationSettingsResponse
+        {
+            ConfiguredSystemNotificationMessage = _appOptions.NotificationMessage,
+            SystemNotification = notification
+        });
+    }
+
+    /// <summary>
+    /// Force all connected clients to reload their browser.
+    /// </summary>
+    [HttpPost("notifications/force-refresh")]
+    [Authorize(Policy = AuthorizationRoles.GlobalAdminPolicy)]
+    public async Task<ActionResult<ReleaseNotification>> ForceRefreshAsync(ValueFromBody<string?>? message)
+    {
+        var notification = await _notificationService.SendReleaseNotificationAsync(message?.Value, critical: true);
+        return Ok(notification);
+    }
 }
diff --git a/tests/Exceptionless.Tests/Controllers/Data/controller-manifest.json b/tests/Exceptionless.Tests/Controllers/Data/controller-manifest.json
index 94e88d48b6..694a4c20a4 100644
--- a/tests/Exceptionless.Tests/Controllers/Data/controller-manifest.json
+++ b/tests/Exceptionless.Tests/Controllers/Data/controller-manifest.json
@@ -914,6 +914,22 @@
     ],
     "ExcludeFromDescription": false
   },
+  {
+    "Controller": "StatusController",
+    "Action": "ForceRefreshAsync",
+    "HttpMethod": "POST",
+    "Route": "/api/v2/notifications/force-refresh",
+    "Authorization": [
+      "Authorize(Policy=GlobalAdminPolicy)",
+      "Authorize(Policy=UserPolicy)"
+    ],
+    "Consumes": [],
+    "Produces": [
+      "application/json",
+      "application/problem\u002Bjson"
+    ],
+    "ExcludeFromDescription": true
+  },
   {
     "Controller": "StatusController",
     "Action": "PostReleaseNotificationAsync",
@@ -932,6 +948,22 @@
     ],
     "ExcludeFromDescription": true
   },
+  {
+    "Controller": "StatusController",
+    "Action": "GetNotificationSettingsAsync",
+    "HttpMethod": "GET",
+    "Route": "/api/v2/notifications/settings",
+    "Authorization": [
+      "Authorize(Policy=GlobalAdminPolicy)",
+      "Authorize(Policy=UserPolicy)"
+    ],
+    "Consumes": [],
+    "Produces": [
+      "application/json",
+      "application/problem\u002Bjson"
+    ],
+    "ExcludeFromDescription": true
+  },
   {
     "Controller": "StatusController",
     "Action": "RemoveSystemNotificationAsync",
diff --git a/tests/Exceptionless.Tests/Controllers/StatusControllerTests.cs b/tests/Exceptionless.Tests/Controllers/StatusControllerTests.cs
index 16b4874146..53e9dd3a69 100644
--- a/tests/Exceptionless.Tests/Controllers/StatusControllerTests.cs
+++ b/tests/Exceptionless.Tests/Controllers/StatusControllerTests.cs
@@ -112,14 +112,14 @@ public async Task PostSystemNotificationAsync_WithMessage_ReturnsNotification()
     }
 
     [Fact]
-    public Task PostSystemNotificationAsync_WithEmptyMessage_ReturnsNotFound()
+    public Task PostSystemNotificationAsync_WithEmptyMessage_ReturnsBadRequest()
     {
         return SendRequestAsync(r => r
             .Post()
             .AsGlobalAdminUser()
             .AppendPath("notifications/system")
             .Content(new ValueFromBody<string>(String.Empty))
-            .StatusCodeShouldBeNotFound());
+            .StatusCodeShouldBeBadRequest());
     }
 
     [Fact]
@@ -169,4 +169,98 @@ public Task RemoveSystemNotificationAsync_AsNonAdmin_ReturnsForbidden()
             .AppendPath("notifications/system")
             .StatusCodeShouldBeForbidden());
     }
+
+    [Fact]
+    public Task GetNotificationSettings_AsGlobalAdmin_ReturnsSettings()
+    {
+        return SendRequestAsync(r => r
+            .AsGlobalAdminUser()
+            .AppendPath("notifications/settings")
+            .StatusCodeShouldBeOk());
+    }
+
+    [Fact]
+    public Task GetNotificationSettings_AsNonAdmin_ReturnsForbidden()
+    {
+        return SendRequestAsync(r => r
+            .AsTestOrganizationUser()
+            .AppendPath("notifications/settings")
+            .StatusCodeShouldBeForbidden());
+    }
+
+    [Fact]
+    public async Task ForceRefresh_AsGlobalAdmin_ReturnsCriticalNotification()
+    {
+        // Arrange
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+
+        // Act
+        var notification = await SendRequestAsAsync<ReleaseNotification>(r => r
+            .Post()
+            .AsGlobalAdminUser()
+            .AppendPath("notifications/force-refresh")
+            .Content(new ValueFromBody<string?>("Deploy v9.0"))
+            .StatusCodeShouldBeOk());
+
+        // Assert
+        Assert.NotNull(notification);
+        Assert.True(notification.Critical);
+        Assert.Equal("Deploy v9.0", notification.Message);
+        Assert.True(notification.Date.IsAfterOrEqual(utcNow));
+    }
+
+    [Fact]
+    public async Task ForceRefresh_WithNoBody_ReturnsCriticalNotificationWithNullMessage()
+    {
+        // Arrange
+        var utcNow = TimeProvider.GetUtcNow().UtcDateTime;
+
+        // Act
+        var notification = await SendRequestAsAsync<ReleaseNotification>(r => r
+            .Post()
+            .AsGlobalAdminUser()
+            .AppendPath("notifications/force-refresh")
+            .StatusCodeShouldBeOk());
+
+        // Assert
+        Assert.NotNull(notification);
+        Assert.True(notification.Critical);
+        Assert.Null(notification.Message);
+        Assert.True(notification.Date.IsAfterOrEqual(utcNow));
+    }
+
+    [Fact]
+    public Task ForceRefresh_AsNonAdmin_ReturnsForbidden()
+    {
+        return SendRequestAsync(r => r
+            .Post()
+            .AsTestOrganizationUser()
+            .AppendPath("notifications/force-refresh")
+            .StatusCodeShouldBeForbidden());
+    }
+
+    [Fact]
+    public async Task PostSystemNotificationAsync_WithPublishFalse_StoresWithoutPublishing()
+    {
+        // Arrange & Act
+        var notification = await SendRequestAsAsync<SystemNotification>(r => r
+            .Post()
+            .AsGlobalAdminUser()
+            .AppendPath("notifications/system")
+            .QueryString("publish", "false")
+            .Content(new ValueFromBody<string>("Silent notification"))
+            .StatusCodeShouldBeOk());
+
+        // Assert — notification is persisted and returned
+        Assert.NotNull(notification);
+        Assert.Equal("Silent notification", notification.Message);
+
+        // Verify it was actually persisted to cache
+        var persisted = await SendRequestAsAsync<SystemNotification>(r => r
+            .AsGlobalAdminUser()
+            .AppendPath("notifications/system")
+            .StatusCodeShouldBeOk());
+        Assert.NotNull(persisted);
+        Assert.Equal("Silent notification", persisted.Message);
+    }
 }
diff --git a/tests/http/status.http b/tests/http/status.http
index dc07e45143..46560ea358 100644
--- a/tests/http/status.http
+++ b/tests/http/status.http
@@ -52,3 +52,18 @@ Authorization: Bearer {{token}}
 Content-Type: application/json
 
 { "value": "We just released a new release!! Check it out <a href=\"blah\">here</a>" }
+
+### Force Refresh All Clients
+POST {{apiUrl}}/notifications/force-refresh
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{ "value": "Deploying breaking changes - forcing client refresh." }
+
+### Force Refresh (no message)
+POST {{apiUrl}}/notifications/force-refresh
+Authorization: Bearer {{token}}
+
+### Notification Settings (admin)
+GET {{apiUrl}}/notifications/settings
+Authorization: Bearer {{token}}