diff --git a/Taskfile.yml b/Taskfile.yml
index 13d3db2d..728872bd 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -39,6 +39,11 @@ tasks:
       - git config core.hooksPath .github/hooks
       - echo "Git hooks configured successfully."
 
+  gen-vapid:
+    desc: Generate a VAPID keypair for push notifications (prints to stdout; copy into .env)
+    cmds:
+      - go run ./cmd/genvapid
+
   test:
     desc: Run all Go tests
     cmds:
diff --git a/client/web/src/components/PushPromptHost.tsx b/client/web/src/components/PushPromptHost.tsx
new file mode 100644
index 00000000..777ddd3c
--- /dev/null
+++ b/client/web/src/components/PushPromptHost.tsx
@@ -0,0 +1,39 @@
+import { useEffect } from "react";
+import { toast } from "sonner";
+
+import { usePushPrompt } from "@/shared/push/usePushPrompt";
+
+const TOAST_ID = "push-prompt";
+
+export function PushPromptHost() {
+  const { shouldPrompt, accept, dismiss } = usePushPrompt();
+
+  useEffect(() => {
+    if (!shouldPrompt) return;
+
+    toast("Get notified about your application status", {
+      id: TOAST_ID,
+      description:
+        "Allow push notifications so we can let you know when reviews and announcements drop.",
+      duration: Infinity,
+      action: {
+        label: "Enable",
+        onClick: () => {
+          void accept();
+        },
+      },
+      cancel: {
+        label: "Not now",
+        onClick: () => {
+          dismiss();
+        },
+      },
+    });
+
+    return () => {
+      toast.dismiss(TOAST_ID);
+    };
+  }, [shouldPrompt, accept, dismiss]);
+
+  return null;
+}
diff --git a/client/web/src/pages/admin/_shared/AppSidebar.tsx b/client/web/src/pages/admin/_shared/AppSidebar.tsx
index 6f31e781..60412b39 100644
--- a/client/web/src/pages/admin/_shared/AppSidebar.tsx
+++ b/client/web/src/pages/admin/_shared/AppSidebar.tsx
@@ -1,6 +1,7 @@
 "use client";
 
 import {
+  Bell,
   Calendar,
   ClipboardList,
   Handshake,
@@ -75,6 +76,11 @@ const superAdminNav = [
     url: "/admin/sa/application",
     icon: ClipboardList,
   },
+  {
+    name: "Notifications",
+    url: "/admin/sa/notifications",
+    icon: Bell,
+  },
 ];
 
 export function AppSidebar({ ...props }: React.ComponentProps<typeof Sidebar>) {
diff --git a/client/web/src/pages/superadmin/notifications/NotificationsPage.tsx b/client/web/src/pages/superadmin/notifications/NotificationsPage.tsx
new file mode 100644
index 00000000..cd04a4d0
--- /dev/null
+++ b/client/web/src/pages/superadmin/notifications/NotificationsPage.tsx
@@ -0,0 +1,54 @@
+import { useEffect } from "react";
+
+import { Card, CardContent, CardHeader } from "@/components/ui/card";
+import { Skeleton } from "@/components/ui/skeleton";
+
+import { NotificationsTable } from "./components/NotificationsTable";
+import { useNotificationsStore } from "./store";
+
+export default function NotificationsPage() {
+  const {
+    notifications,
+    loading,
+    saving,
+    fetch: fetchNotifications,
+    create,
+    update,
+    remove,
+  } = useNotificationsStore();
+
+  useEffect(() => {
+    const controller = new AbortController();
+    fetchNotifications(controller.signal);
+    return () => controller.abort();
+  }, [fetchNotifications]);
+
+  if (loading && notifications.length === 0) {
+    return (
+      <div className="space-y-6 overflow-auto">
+        <Card>
+          <CardHeader>
+            <Skeleton className="h-5 w-40" />
+          </CardHeader>
+          <CardContent className="space-y-3">
+            {[...Array(3)].map((_, i) => (
+              <Skeleton key={i} className="h-14 w-full" />
+            ))}
+          </CardContent>
+        </Card>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full min-h-0 flex-col overflow-hidden">
+      <NotificationsTable
+        notifications={notifications}
+        saving={saving}
+        onCreate={create}
+        onUpdate={update}
+        onDelete={remove}
+      />
+    </div>
+  );
+}
diff --git a/client/web/src/pages/superadmin/notifications/api.ts b/client/web/src/pages/superadmin/notifications/api.ts
new file mode 100644
index 00000000..49c0a3c6
--- /dev/null
+++ b/client/web/src/pages/superadmin/notifications/api.ts
@@ -0,0 +1,59 @@
+import {
+  deleteRequest,
+  getRequest,
+  patchRequest,
+  postRequest,
+} from "@/shared/lib/api";
+import type { ApiResponse } from "@/types";
+
+import type {
+  ScheduledNotification,
+  ScheduledNotificationListResponse,
+  ScheduledNotificationPayload,
+} from "./types";
+
+export async function fetchScheduledNotifications(
+  signal?: AbortSignal,
+): Promise<ApiResponse<ScheduledNotificationListResponse>> {
+  return getRequest<ScheduledNotificationListResponse>(
+    "/superadmin/notifications",
+    "scheduled notifications",
+    signal,
+  );
+}
+
+export async function createScheduledNotification(
+  payload: ScheduledNotificationPayload,
+  signal?: AbortSignal,
+): Promise<ApiResponse<ScheduledNotification>> {
+  return postRequest<ScheduledNotification>(
+    "/superadmin/notifications",
+    payload,
+    "scheduled notification",
+    signal,
+  );
+}
+
+export async function updateScheduledNotification(
+  id: string,
+  payload: ScheduledNotificationPayload,
+  signal?: AbortSignal,
+): Promise<ApiResponse<ScheduledNotification>> {
+  return patchRequest<ScheduledNotification>(
+    `/superadmin/notifications/${id}`,
+    payload,
+    "scheduled notification",
+    signal,
+  );
+}
+
+export async function deleteScheduledNotification(
+  id: string,
+  signal?: AbortSignal,
+): Promise<ApiResponse<unknown>> {
+  return deleteRequest<unknown>(
+    `/superadmin/notifications/${id}`,
+    "scheduled notification",
+    signal,
+  );
+}
diff --git a/client/web/src/pages/superadmin/notifications/components/NotificationFormDialog.tsx b/client/web/src/pages/superadmin/notifications/components/NotificationFormDialog.tsx
new file mode 100644
index 00000000..f8cbd6b8
--- /dev/null
+++ b/client/web/src/pages/superadmin/notifications/components/NotificationFormDialog.tsx
@@ -0,0 +1,216 @@
+import { Loader2 } from "lucide-react";
+import { useState } from "react";
+
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
+import type { UserRole } from "@/types";
+
+import type {
+  ScheduledNotification,
+  ScheduledNotificationPayload,
+} from "../types";
+
+const TARGET_ALL = "__all";
+type TargetOption = UserRole | typeof TARGET_ALL;
+
+const ROLE_OPTIONS: { value: TargetOption; label: string }[] = [
+  { value: TARGET_ALL, label: "All users" },
+  { value: "hacker", label: "Hackers" },
+  { value: "admin", label: "Admins" },
+  { value: "super_admin", label: "Super Admins" },
+];
+
+function defaultScheduledLocal(): string {
+  const now = new Date(Date.now() + 5 * 60 * 1000);
+  now.setSeconds(0, 0);
+  return toLocalInputValue(now.toISOString());
+}
+
+function toLocalInputValue(iso: string): string {
+  const d = new Date(iso);
+  const tzOffsetMs = d.getTimezoneOffset() * 60_000;
+  const local = new Date(d.getTime() - tzOffsetMs);
+  return local.toISOString().slice(0, 16);
+}
+
+interface NotificationFormProps {
+  notification: ScheduledNotification | null;
+  saving: boolean;
+  onSubmit: (payload: ScheduledNotificationPayload) => Promise<boolean>;
+  onCancel: () => void;
+}
+
+function NotificationForm({
+  notification,
+  saving,
+  onSubmit,
+  onCancel,
+}: NotificationFormProps) {
+  const [title, setTitle] = useState(notification?.title ?? "");
+  const [body, setBody] = useState(notification?.body ?? "");
+  const [url, setUrl] = useState(notification?.url ?? "");
+  const [target, setTarget] = useState<TargetOption>(
+    notification?.target_role ?? TARGET_ALL,
+  );
+  const [scheduledAt, setScheduledAt] = useState<string>(
+    notification?.scheduled_at
+      ? toLocalInputValue(notification.scheduled_at)
+      : defaultScheduledLocal(),
+  );
+
+  const submit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!title.trim() || !body.trim() || !scheduledAt) return;
+
+    const isoScheduled = new Date(scheduledAt).toISOString();
+    const ok = await onSubmit({
+      title: title.trim(),
+      body: body.trim(),
+      url: url.trim() === "" ? null : url.trim(),
+      target_role: target === TARGET_ALL ? null : (target as UserRole),
+      scheduled_at: isoScheduled,
+    });
+    if (ok) {
+      onCancel();
+    }
+  };
+
+  return (
+    <form onSubmit={submit} className="space-y-4">
+      <div className="space-y-2">
+        <Label htmlFor="notif-title">Title</Label>
+        <Input
+          id="notif-title"
+          value={title}
+          onChange={(e) => setTitle(e.target.value)}
+          maxLength={100}
+          placeholder="Applications close in 1 hour"
+          required
+        />
+      </div>
+      <div className="space-y-2">
+        <Label htmlFor="notif-body">Body</Label>
+        <Textarea
+          id="notif-body"
+          value={body}
+          onChange={(e) => setBody(e.target.value)}
+          maxLength={300}
+          rows={3}
+          placeholder="Submit your application before midnight to be considered."
+          required
+        />
+      </div>
+      <div className="space-y-2">
+        <Label htmlFor="notif-url">Click-through URL (optional)</Label>
+        <Input
+          id="notif-url"
+          type="url"
+          value={url}
+          onChange={(e) => setUrl(e.target.value)}
+          placeholder="https://harp.hackutd.co/app"
+        />
+      </div>
+      <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+        <div className="space-y-2">
+          <Label htmlFor="notif-target">Target audience</Label>
+          <Select
+            value={target}
+            onValueChange={(v) => setTarget(v as TargetOption)}
+          >
+            <SelectTrigger id="notif-target">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              {ROLE_OPTIONS.map((opt) => (
+                <SelectItem key={opt.value} value={opt.value}>
+                  {opt.label}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+        <div className="space-y-2">
+          <Label htmlFor="notif-time">Scheduled time</Label>
+          <Input
+            id="notif-time"
+            type="datetime-local"
+            value={scheduledAt}
+            onChange={(e) => setScheduledAt(e.target.value)}
+            required
+          />
+        </div>
+      </div>
+      <DialogFooter>
+        <Button
+          type="button"
+          variant="outline"
+          onClick={onCancel}
+          className="cursor-pointer"
+        >
+          Cancel
+        </Button>
+        <Button
+          type="submit"
+          disabled={saving || !title.trim() || !body.trim()}
+          className="cursor-pointer"
+        >
+          {saving && <Loader2 className="mr-2 size-4 animate-spin" />}
+          {notification ? "Save" : "Schedule"}
+        </Button>
+      </DialogFooter>
+    </form>
+  );
+}
+
+interface NotificationFormDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  notification: ScheduledNotification | null;
+  saving: boolean;
+  onSubmit: (payload: ScheduledNotificationPayload) => Promise<boolean>;
+}
+
+export function NotificationFormDialog({
+  open,
+  onOpenChange,
+  notification,
+  saving,
+  onSubmit,
+}: NotificationFormDialogProps) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-lg">
+        <DialogHeader>
+          <DialogTitle>
+            {notification ? "Edit notification" : "Schedule notification"}
+          </DialogTitle>
+        </DialogHeader>
+        {open && (
+          <NotificationForm
+            key={notification?.id ?? "new"}
+            notification={notification}
+            saving={saving}
+            onSubmit={onSubmit}
+            onCancel={() => onOpenChange(false)}
+          />
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/client/web/src/pages/superadmin/notifications/components/NotificationsTable.tsx b/client/web/src/pages/superadmin/notifications/components/NotificationsTable.tsx
new file mode 100644
index 00000000..df3cc219
--- /dev/null
+++ b/client/web/src/pages/superadmin/notifications/components/NotificationsTable.tsx
@@ -0,0 +1,212 @@
+import { Pencil, Plus, Trash2 } from "lucide-react";
+import { useState } from "react";
+
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+} from "@/components/ui/card";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+
+import type {
+  ScheduledNotification,
+  ScheduledNotificationPayload,
+} from "../types";
+import { NotificationFormDialog } from "./NotificationFormDialog";
+
+interface NotificationsTableProps {
+  notifications: ScheduledNotification[];
+  saving: boolean;
+  onCreate: (payload: ScheduledNotificationPayload) => Promise<boolean>;
+  onUpdate: (
+    id: string,
+    payload: ScheduledNotificationPayload,
+  ) => Promise<boolean>;
+  onDelete: (id: string) => Promise<boolean>;
+}
+
+function formatTarget(role: string | null): string {
+  if (!role) return "All users";
+  if (role === "super_admin") return "Super Admins";
+  return role.charAt(0).toUpperCase() + role.slice(1) + "s";
+}
+
+function formatDateTime(iso: string): string {
+  const d = new Date(iso);
+  return d.toLocaleString();
+}
+
+export function NotificationsTable({
+  notifications,
+  saving,
+  onCreate,
+  onUpdate,
+  onDelete,
+}: NotificationsTableProps) {
+  const [formOpen, setFormOpen] = useState(false);
+  const [editing, setEditing] = useState<ScheduledNotification | null>(null);
+  const [deleteTarget, setDeleteTarget] =
+    useState<ScheduledNotification | null>(null);
+
+  const openCreate = () => {
+    setEditing(null);
+    setFormOpen(true);
+  };
+
+  const openEdit = (n: ScheduledNotification) => {
+    setEditing(n);
+    setFormOpen(true);
+  };
+
+  return (
+    <Card className="flex h-full flex-col overflow-hidden">
+      <CardHeader className="flex flex-row items-start justify-between gap-4">
+        <div>
+          <CardDescription>
+            Schedule push notifications to be delivered at a specific time.
+          </CardDescription>
+        </div>
+        <Button onClick={openCreate} className="cursor-pointer">
+          <Plus className="mr-1 size-4" />
+          Schedule
+        </Button>
+      </CardHeader>
+      <CardContent className="flex-1 overflow-auto">
+        {notifications.length === 0 ? (
+          <div className="flex h-32 items-center justify-center text-sm text-muted-foreground">
+            No scheduled notifications yet.
+          </div>
+        ) : (
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>Title</TableHead>
+                <TableHead>Target</TableHead>
+                <TableHead>Scheduled</TableHead>
+                <TableHead>Status</TableHead>
+                <TableHead className="w-32 text-right">Actions</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {notifications.map((n) => {
+                const sent = !!n.sent_at;
+                return (
+                  <TableRow key={n.id}>
+                    <TableCell className="max-w-xs">
+                      <div className="font-medium">{n.title}</div>
+                      <div className="truncate text-xs text-muted-foreground">
+                        {n.body}
+                      </div>
+                    </TableCell>
+                    <TableCell>{formatTarget(n.target_role)}</TableCell>
+                    <TableCell>{formatDateTime(n.scheduled_at)}</TableCell>
+                    <TableCell>
+                      {sent ? (
+                        <Badge
+                          variant="secondary"
+                          className="bg-green-100 text-green-800"
+                        >
+                          Sent · {n.recipient_count}
+                        </Badge>
+                      ) : (
+                        <Badge variant="outline">Pending</Badge>
+                      )}
+                    </TableCell>
+                    <TableCell className="text-right">
+                      <div className="flex justify-end gap-1">
+                        <Button
+                          variant="ghost"
+                          size="icon-sm"
+                          disabled={sent}
+                          onClick={() => openEdit(n)}
+                          className="cursor-pointer"
+                          aria-label="Edit"
+                        >
+                          <Pencil className="size-4" />
+                        </Button>
+                        <Button
+                          variant="ghost"
+                          size="icon-sm"
+                          disabled={sent}
+                          onClick={() => setDeleteTarget(n)}
+                          className="cursor-pointer text-destructive hover:text-destructive"
+                          aria-label="Delete"
+                        >
+                          <Trash2 className="size-4" />
+                        </Button>
+                      </div>
+                    </TableCell>
+                  </TableRow>
+                );
+              })}
+            </TableBody>
+          </Table>
+        )}
+      </CardContent>
+
+      <NotificationFormDialog
+        open={formOpen}
+        onOpenChange={setFormOpen}
+        notification={editing}
+        saving={saving}
+        onSubmit={async (payload) => {
+          if (editing) {
+            return onUpdate(editing.id, payload);
+          }
+          return onCreate(payload);
+        }}
+      />
+
+      <AlertDialog
+        open={deleteTarget !== null}
+        onOpenChange={(open) => !open && setDeleteTarget(null)}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Delete notification?</AlertDialogTitle>
+            <AlertDialogDescription>
+              This will permanently remove &ldquo;{deleteTarget?.title}&rdquo;.
+              Already-sent notifications cannot be deleted.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel className="cursor-pointer">
+              Cancel
+            </AlertDialogCancel>
+            <AlertDialogAction
+              className="cursor-pointer bg-destructive text-destructive-foreground hover:bg-destructive/90"
+              onClick={async () => {
+                if (deleteTarget) {
+                  await onDelete(deleteTarget.id);
+                }
+                setDeleteTarget(null);
+              }}
+            >
+              Delete
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </Card>
+  );
+}
diff --git a/client/web/src/pages/superadmin/notifications/store.ts b/client/web/src/pages/superadmin/notifications/store.ts
new file mode 100644
index 00000000..4f3d30ef
--- /dev/null
+++ b/client/web/src/pages/superadmin/notifications/store.ts
@@ -0,0 +1,104 @@
+import { toast } from "sonner";
+import { create } from "zustand";
+
+import { errorAlert } from "@/shared/lib/api";
+
+import {
+  createScheduledNotification,
+  deleteScheduledNotification,
+  fetchScheduledNotifications,
+  updateScheduledNotification,
+} from "./api";
+import type {
+  ScheduledNotification,
+  ScheduledNotificationPayload,
+} from "./types";
+
+export interface NotificationsState {
+  notifications: ScheduledNotification[];
+  loading: boolean;
+  saving: boolean;
+
+  fetch: (signal?: AbortSignal) => Promise<void>;
+  create: (payload: ScheduledNotificationPayload) => Promise<boolean>;
+  update: (
+    id: string,
+    payload: ScheduledNotificationPayload,
+  ) => Promise<boolean>;
+  remove: (id: string) => Promise<boolean>;
+}
+
+export const useNotificationsStore = create<NotificationsState>((set) => ({
+  notifications: [],
+  loading: false,
+  saving: false,
+
+  fetch: async (signal?: AbortSignal) => {
+    set({ loading: true });
+    const res = await fetchScheduledNotifications(signal);
+    if (signal?.aborted) return;
+
+    if (res.status === 200 && res.data) {
+      set({ notifications: res.data.notifications, loading: false });
+    } else {
+      set({ loading: false });
+      if (res.status !== 0) errorAlert(res, "Failed to load notifications");
+    }
+  },
+
+  create: async (payload) => {
+    set({ saving: true });
+    const res = await createScheduledNotification(payload);
+    if (res.status === 201 && res.data) {
+      const created = res.data;
+      set((state) => ({
+        notifications: [created, ...state.notifications],
+        saving: false,
+      }));
+      toast.success("Notification scheduled");
+      return true;
+    }
+    set({ saving: false });
+    errorAlert(res, "Failed to schedule notification");
+    return false;
+  },
+
+  update: async (id, payload) => {
+    set({ saving: true });
+    const res = await updateScheduledNotification(id, payload);
+    if (res.status === 200 && res.data) {
+      // patchRequest returns the raw envelope; unwrap if present.
+      const raw = res.data as
+        | ScheduledNotification
+        | { data: ScheduledNotification };
+      const updated = "data" in raw ? raw.data : (raw as ScheduledNotification);
+      set((state) => ({
+        notifications: state.notifications.map((n) =>
+          n.id === id ? updated : n,
+        ),
+        saving: false,
+      }));
+      toast.success("Notification updated");
+      return true;
+    }
+    set({ saving: false });
+    errorAlert(res, "Failed to update notification");
+    return false;
+  },
+
+  remove: async (id) => {
+    set({ saving: true });
+    const res = await deleteScheduledNotification(id);
+    if (res.status === 204) {
+      set((state) => ({
+        notifications: state.notifications.filter((n) => n.id !== id),
+        saving: false,
+      }));
+      toast.success("Notification deleted");
+      return true;
+    }
+    set({ saving: false });
+    errorAlert(res, "Failed to delete notification");
+    return false;
+  },
+}));
diff --git a/client/web/src/pages/superadmin/notifications/types.ts b/client/web/src/pages/superadmin/notifications/types.ts
new file mode 100644
index 00000000..0da4de30
--- /dev/null
+++ b/client/web/src/pages/superadmin/notifications/types.ts
@@ -0,0 +1,27 @@
+import type { UserRole } from "@/types";
+
+export interface ScheduledNotification {
+  id: string;
+  title: string;
+  body: string;
+  url: string | null;
+  target_role: UserRole | null;
+  scheduled_at: string;
+  sent_at: string | null;
+  recipient_count: number;
+  created_by: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ScheduledNotificationPayload {
+  title: string;
+  body: string;
+  url: string | null;
+  target_role: UserRole | null;
+  scheduled_at: string;
+}
+
+export interface ScheduledNotificationListResponse {
+  notifications: ScheduledNotification[];
+}
diff --git a/client/web/src/providers.tsx b/client/web/src/providers.tsx
index c44ad61c..72593fa3 100644
--- a/client/web/src/providers.tsx
+++ b/client/web/src/providers.tsx
@@ -1,5 +1,6 @@
 import { SuperTokensWrapper } from "supertokens-auth-react";
 
+import { PushPromptHost } from "@/components/PushPromptHost";
 import { Toaster } from "@/components/ui/sonner";
 
 interface ProvidersProps {
@@ -11,6 +12,7 @@ export function Providers({ children }: ProvidersProps) {
     <SuperTokensWrapper>
       {children}
       <Toaster />
+      <PushPromptHost />
     </SuperTokensWrapper>
   );
 }
diff --git a/client/web/src/routes.tsx b/client/web/src/routes.tsx
index 9973d21c..1eadd511 100644
--- a/client/web/src/routes.tsx
+++ b/client/web/src/routes.tsx
@@ -40,6 +40,9 @@ const SuperAdminGradingPage = lazy(
 const SuperAdminScansPage = lazy(
   () => import("@/pages/superadmin/scans/ScansPage"),
 );
+const SuperAdminNotificationsPage = lazy(
+  () => import("@/pages/superadmin/notifications/NotificationsPage"),
+);
 const AdminGradingPage = lazy(
   () => import("@/pages/admin/reviews/grading/GradingPage"),
 );
@@ -214,6 +217,16 @@ export const router = createBrowserRouter([
               </RequireSuperAdmin>
             ),
           },
+          {
+            path: "sa/notifications",
+            element: (
+              <RequireSuperAdmin>
+                <Suspense fallback={<PageLoader />}>
+                  <SuperAdminNotificationsPage />
+                </Suspense>
+              </RequireSuperAdmin>
+            ),
+          },
         ],
       },
       {
diff --git a/client/web/src/shared/push/api.ts b/client/web/src/shared/push/api.ts
new file mode 100644
index 00000000..2b7ca10c
--- /dev/null
+++ b/client/web/src/shared/push/api.ts
@@ -0,0 +1,65 @@
+import { getRequest, postRequest } from "@/shared/lib/api";
+import type { ApiResponse } from "@/types";
+
+export interface VapidPublicKeyResponse {
+  public_key: string;
+}
+
+export interface SubscribePushPayload {
+  endpoint: string;
+  p256dh: string;
+  auth: string;
+  user_agent?: string;
+}
+
+export async function getVapidPublicKey(
+  signal?: AbortSignal,
+): Promise<ApiResponse<VapidPublicKeyResponse>> {
+  return getRequest<VapidPublicKeyResponse>(
+    "/notifications/vapid-public-key",
+    "VAPID public key",
+    signal,
+  );
+}
+
+export async function subscribePush(
+  payload: SubscribePushPayload,
+  signal?: AbortSignal,
+): Promise<ApiResponse<unknown>> {
+  return postRequest<unknown>(
+    "/notifications/subscribe",
+    payload,
+    "push subscription",
+    signal,
+  );
+}
+
+export async function unsubscribePush(
+  endpoint: string,
+  signal?: AbortSignal,
+): Promise<ApiResponse<unknown>> {
+  // deleteRequest doesn't take a body, so use fetch directly for the rare DELETE-with-body case.
+  try {
+    const response = await fetch(`/v1/notifications/subscribe`, {
+      method: "DELETE",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ endpoint }),
+      signal,
+    });
+    return {
+      status: response.status,
+      error: response.ok
+        ? undefined
+        : `Failed to unsubscribe (status ${response.status})`,
+    };
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      return { status: 0, error: "Request aborted" };
+    }
+    return {
+      status: 500,
+      error: error instanceof Error ? error.message : "Network error",
+    };
+  }
+}
diff --git a/client/web/src/shared/push/client.ts b/client/web/src/shared/push/client.ts
new file mode 100644
index 00000000..1d895119
--- /dev/null
+++ b/client/web/src/shared/push/client.ts
@@ -0,0 +1,64 @@
+// Web Push browser client helpers — converts VAPID keys, manages subscriptions.
+
+export function urlBase64ToUint8Array(base64: string): Uint8Array {
+  const padding = "=".repeat((4 - (base64.length % 4)) % 4);
+  const normalized = (base64 + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(normalized);
+  const array = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) {
+    array[i] = raw.charCodeAt(i);
+  }
+  return array;
+}
+
+export function isPushSupported(): boolean {
+  return (
+    "serviceWorker" in navigator &&
+    "PushManager" in window &&
+    "Notification" in window
+  );
+}
+
+export async function getCurrentSubscription(): Promise<PushSubscription | null> {
+  if (!isPushSupported()) return null;
+  const reg = await navigator.serviceWorker.ready;
+  return reg.pushManager.getSubscription();
+}
+
+export async function subscribeToPush(
+  vapidPublicKey: string,
+): Promise<PushSubscription> {
+  const reg = await navigator.serviceWorker.ready;
+  const existing = await reg.pushManager.getSubscription();
+  if (existing) return existing;
+
+  const applicationServerKey = urlBase64ToUint8Array(vapidPublicKey);
+  return reg.pushManager.subscribe({
+    userVisibleOnly: true,
+    applicationServerKey: applicationServerKey as BufferSource,
+  });
+}
+
+export async function unsubscribeFromPush(): Promise<string | null> {
+  if (!isPushSupported()) return null;
+  const reg = await navigator.serviceWorker.ready;
+  const sub = await reg.pushManager.getSubscription();
+  if (!sub) return null;
+  const endpoint = sub.endpoint;
+  await sub.unsubscribe();
+  return endpoint;
+}
+
+export function extractKeys(subscription: PushSubscription): {
+  endpoint: string;
+  p256dh: string;
+  auth: string;
+} {
+  const json = subscription.toJSON();
+  const keys = json.keys ?? {};
+  return {
+    endpoint: subscription.endpoint,
+    p256dh: keys.p256dh ?? "",
+    auth: keys.auth ?? "",
+  };
+}
diff --git a/client/web/src/shared/push/index.ts b/client/web/src/shared/push/index.ts
new file mode 100644
index 00000000..b340c4c1
--- /dev/null
+++ b/client/web/src/shared/push/index.ts
@@ -0,0 +1,10 @@
+export type { SubscribePushPayload, VapidPublicKeyResponse } from "./api";
+export { getVapidPublicKey, subscribePush, unsubscribePush } from "./api";
+export {
+  extractKeys,
+  getCurrentSubscription,
+  isPushSupported,
+  subscribeToPush,
+  unsubscribeFromPush,
+  urlBase64ToUint8Array,
+} from "./client";
diff --git a/client/web/src/shared/push/usePushPrompt.ts b/client/web/src/shared/push/usePushPrompt.ts
new file mode 100644
index 00000000..ffd5446b
--- /dev/null
+++ b/client/web/src/shared/push/usePushPrompt.ts
@@ -0,0 +1,91 @@
+import { useCallback, useEffect, useState } from "react";
+
+import { useUserStore } from "@/shared/stores";
+
+import {
+  extractKeys,
+  getVapidPublicKey,
+  isPushSupported,
+  subscribePush,
+  subscribeToPush,
+} from ".";
+
+const PROMPTED_KEY = "push-prompted-v1";
+const ENDPOINT_KEY = "push-endpoint-v1";
+
+function isStandalone(): boolean {
+  if (typeof window === "undefined") return false;
+  if (window.matchMedia("(display-mode: standalone)").matches) return true;
+  const nav = navigator as Navigator & { standalone?: boolean };
+  return Boolean(nav.standalone);
+}
+
+export interface UsePushPromptResult {
+  shouldPrompt: boolean;
+  accept: () => Promise<void>;
+  dismiss: () => void;
+}
+
+export function usePushPrompt(): UsePushPromptResult {
+  const user = useUserStore((s) => s.user);
+  const [installed, setInstalled] = useState(() => isStandalone());
+  const [dismissed, setDismissed] = useState(false);
+
+  useEffect(() => {
+    function handleInstalled() {
+      setInstalled(true);
+    }
+    window.addEventListener("appinstalled", handleInstalled);
+    return () => window.removeEventListener("appinstalled", handleInstalled);
+  }, []);
+
+  const shouldPrompt =
+    !!user &&
+    !dismissed &&
+    isPushSupported() &&
+    installed &&
+    Notification.permission === "default" &&
+    localStorage.getItem(PROMPTED_KEY) !== "1";
+
+  const dismiss = useCallback(() => {
+    localStorage.setItem(PROMPTED_KEY, "1");
+    setDismissed(true);
+  }, []);
+
+  const accept = useCallback(async () => {
+    try {
+      const permission = await Notification.requestPermission();
+      if (permission !== "granted") {
+        localStorage.setItem(PROMPTED_KEY, "1");
+        setDismissed(true);
+        return;
+      }
+
+      const keyRes = await getVapidPublicKey();
+      if (keyRes.status !== 200 || !keyRes.data) {
+        return;
+      }
+
+      const subscription = await subscribeToPush(keyRes.data.public_key);
+      const { endpoint, p256dh, auth } = extractKeys(subscription);
+
+      const subRes = await subscribePush({
+        endpoint,
+        p256dh,
+        auth,
+        user_agent: navigator.userAgent,
+      });
+
+      if (subRes.status === 204 || subRes.status === 200) {
+        localStorage.setItem(ENDPOINT_KEY, endpoint);
+      }
+      localStorage.setItem(PROMPTED_KEY, "1");
+      setDismissed(true);
+    } catch {
+      localStorage.setItem(PROMPTED_KEY, "1");
+      setDismissed(true);
+    }
+  }, []);
+
+  return { shouldPrompt, accept, dismiss };
+}
diff --git a/client/web/src/sw.ts b/client/web/src/sw.ts
new file mode 100644
index 00000000..09ee16cb
--- /dev/null
+++ b/client/web/src/sw.ts
@@ -0,0 +1,66 @@
+/// <reference lib="webworker" />
+import { precacheAndRoute } from "workbox-precaching";
+
+declare const self: ServiceWorkerGlobalScope;
+
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+precacheAndRoute(self.__WB_MANIFEST);
+
+interface PushPayload {
+  id?: string;
+  title?: string;
+  body?: string;
+  url?: string;
+}
+
+self.addEventListener("push", (event) => {
+  let data: PushPayload = {};
+  if (event.data) {
+    try {
+      data = event.data.json() as PushPayload;
+    } catch {
+      data = { body: event.data.text() };
+    }
+  }
+
+  const title = data.title ?? "HARP";
+  const options: NotificationOptions = {
+    body: data.body ?? "",
+    data: { url: data.url ?? "/app", id: data.id },
+    icon: "/pwa-192x192.png",
+    badge: "/pwa-192x192.png",
+  };
+
+  event.waitUntil(self.registration.showNotification(title, options));
+});
+
+self.addEventListener("notificationclick", (event) => {
+  event.notification.close();
+  const data = event.notification.data as { url?: string } | undefined;
+  const url = data?.url ?? "/app";
+
+  event.waitUntil(
+    (async () => {
+      const allClients = await self.clients.matchAll({
+        type: "window",
+        includeUncontrolled: true,
+      });
+
+      for (const client of allClients) {
+        if ("focus" in client) {
+          await (client as WindowClient).navigate(url).catch(() => undefined);
+          return (client as WindowClient).focus();
+        }
+      }
+
+      return self.clients.openWindow(url);
+    })(),
+  );
+});
diff --git a/client/web/tsconfig.app.json b/client/web/tsconfig.app.json
index 32276cdd..daeb4a45 100644
--- a/client/web/tsconfig.app.json
+++ b/client/web/tsconfig.app.json
@@ -29,5 +29,6 @@
       "@/*": ["./src/*"]
     }
   },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/sw.ts"]
 }
diff --git a/client/web/tsconfig.json b/client/web/tsconfig.json
index 7f5926d5..95008eed 100644
--- a/client/web/tsconfig.json
+++ b/client/web/tsconfig.json
@@ -2,7 +2,8 @@
   "files": [],
   "references": [
     { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" }
+    { "path": "./tsconfig.node.json" },
+    { "path": "./tsconfig.sw.json" }
   ],
   "compilerOptions": {
     "baseUrl": ".",
diff --git a/client/web/tsconfig.sw.json b/client/web/tsconfig.sw.json
new file mode 100644
index 00000000..3b41bace
--- /dev/null
+++ b/client/web/tsconfig.sw.json
@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.sw.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2022", "WebWorker"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "types": ["vite/client"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/sw.ts"]
+}
diff --git a/client/web/vite.config.ts b/client/web/vite.config.ts
index ba1aff60..c681ecb5 100644
--- a/client/web/vite.config.ts
+++ b/client/web/vite.config.ts
@@ -13,6 +13,18 @@ export default defineConfig({
     tailwindcss(),
     VitePWA({
       registerType: "autoUpdate",
+      strategies: "injectManifest",
+      srcDir: "src",
+      filename: "sw.ts",
+      injectManifest: {
+        globPatterns: ["**/*.{js,css,html,png,svg,ico,webp,woff,woff2}"],
+      },
+      // Serve the service worker during `vite dev` so push notifications can be
+      // tested without a production build. Has no effect on prod builds.
+      devOptions: {
+        enabled: true,
+        type: "module",
+      },
       manifest: {
         name: "HARP - HackUTD Portal",
         short_name: "HARP",
@@ -41,20 +53,6 @@ export default defineConfig({
           },
         ],
       },
-      workbox: {
-        globPatterns: ["**/*.{js,css,html,png,svg,ico,webp,woff,woff2}"],
-        navigateFallbackDenylist: [/^\/v1\//, /^\/auth\//],
-        runtimeCaching: [
-          {
-            urlPattern: /\/v1\//,
-            handler: "NetworkOnly",
-          },
-          {
-            urlPattern: /\/auth\//,
-            handler: "NetworkOnly",
-          },
-        ],
-      },
     }),
   ],
   server: {
diff --git a/cmd/api/api.go b/cmd/api/api.go
index 76296357..2923bd05 100644
--- a/cmd/api/api.go
+++ b/cmd/api/api.go
@@ -23,12 +23,13 @@ import (
 )
 
 type application struct {
-	config      config
-	store       store.Storage
-	logger      *zap.SugaredLogger
-	mailer      mailer.Client
-	gcsClient   gcs.Client
-	rateLimiter ratelimiter.Limiter
+	config           config
+	store            store.Storage
+	logger           *zap.SugaredLogger
+	mailer           mailer.Client
+	gcsClient        gcs.Client
+	rateLimiter      ratelimiter.Limiter
+	dispatcherCancel context.CancelFunc
 }
 
 type config struct {
@@ -44,6 +45,13 @@ type config struct {
 	rateLimiter       ratelimiter.Config
 	supertokens       supertokensConfig
 	publicCORSOrigin  string
+	vapid             vapidConfig
+}
+
+type vapidConfig struct {
+	publicKey  string
+	privateKey string
+	subject    string
 }
 
 type supertokensConfig struct {
@@ -166,6 +174,13 @@ func (app *application) mount() http.Handler {
 		r.Group(func(r chi.Router) {
 			r.Use(app.AuthRequiredMiddleware)
 
+			// Push notifications (any authenticated user)
+			r.Route("/notifications", func(r chi.Router) {
+				r.Get("/vapid-public-key", app.getVapidPublicKeyHandler)
+				r.Post("/subscribe", app.subscribePushHandler)
+				r.Delete("/subscribe", app.unsubscribePushHandler)
+			})
+
 			// Hacker Routes
 			r.Route("/applications", func(r chi.Router) {
 				r.Get("/me", app.getOrCreateApplicationHandler)
@@ -271,6 +286,14 @@ func (app *application) mount() http.Handler {
 						r.Get("/", app.searchUsersHandler)
 						r.Patch("/{userID}/role", app.updateUserRoleHandler)
 					})
+
+					// Scheduled push notifications
+					r.Route("/notifications", func(r chi.Router) {
+						r.Get("/", app.listScheduledNotificationsHandler)
+						r.Post("/", app.createScheduledNotificationHandler)
+						r.Patch("/{notificationID}", app.updateScheduledNotificationHandler)
+						r.Delete("/{notificationID}", app.deleteScheduledNotificationHandler)
+					})
 				})
 			})
 		})
@@ -306,6 +329,10 @@ func (app *application) run(mux http.Handler) error {
 
 		app.logger.Infow("server caught", "signal", s.String())
 
+		if app.dispatcherCancel != nil {
+			app.dispatcherCancel()
+		}
+
 		shutdown <- server.Shutdown(ctx)
 	}()
 
diff --git a/cmd/api/dispatcher.go b/cmd/api/dispatcher.go
new file mode 100644
index 00000000..0d79e2bb
--- /dev/null
+++ b/cmd/api/dispatcher.go
@@ -0,0 +1,132 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"time"
+
+	webpush "github.com/SherClockHolmes/webpush-go"
+	"github.com/hackutd/portal/internal/store"
+)
+
+const (
+	dispatcherTickInterval = 15 * time.Second
+	dispatcherClaimLimit   = 10
+)
+
+type pushPayload struct {
+	ID    string  `json:"id"`
+	Title string  `json:"title"`
+	Body  string  `json:"body"`
+	URL   *string `json:"url,omitempty"`
+}
+
+func (app *application) runNotificationDispatcher(ctx context.Context) {
+	if app.config.vapid.publicKey == "" || app.config.vapid.privateKey == "" {
+		app.logger.Infow("push dispatcher disabled (VAPID not configured)")
+		return
+	}
+
+	app.logger.Infow("push dispatcher started", "interval", dispatcherTickInterval)
+
+	ticker := time.NewTicker(dispatcherTickInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			app.logger.Infow("push dispatcher stopped")
+			return
+		case <-ticker.C:
+			app.dispatchDueNotifications(ctx)
+		}
+	}
+}
+
+func (app *application) dispatchDueNotifications(ctx context.Context) {
+	due, err := app.store.ScheduledNotifications.ClaimDue(ctx, time.Now(), dispatcherClaimLimit)
+	if err != nil {
+		app.logger.Errorw("failed to claim due notifications", "error", err)
+		return
+	}
+
+	if len(due) == 0 {
+		return
+	}
+
+	app.logger.Infow("dispatching due notifications", "count", len(due))
+
+	options := &webpush.Options{
+		VAPIDPublicKey:  app.config.vapid.publicKey,
+		VAPIDPrivateKey: app.config.vapid.privateKey,
+		Subscriber:      app.config.vapid.subject,
+		TTL:             60 * 60, // 1 hour
+	}
+
+	for _, n := range due {
+		count := app.deliverNotification(ctx, n, options)
+		app.logger.Infow("notification dispatched", "id", n.ID, "title", n.Title, "recipients", count)
+		if err := app.store.ScheduledNotifications.MarkSent(ctx, n.ID, count); err != nil {
+			app.logger.Errorw("failed to record recipient count", "id", n.ID, "error", err)
+		}
+	}
+}
+
+func (app *application) deliverNotification(ctx context.Context, n store.ScheduledNotification, options *webpush.Options) int {
+	subs, err := app.store.PushSubscriptions.ListByRole(ctx, n.TargetRole)
+	if err != nil {
+		app.logger.Errorw("failed to list subscriptions", "id", n.ID, "error", err)
+		return 0
+	}
+
+	if len(subs) == 0 {
+		return 0
+	}
+
+	payloadURL := n.URL
+	body, err := json.Marshal(pushPayload{
+		ID:    n.ID,
+		Title: n.Title,
+		Body:  n.Body,
+		URL:   payloadURL,
+	})
+	if err != nil {
+		app.logger.Errorw("failed to marshal push payload", "id", n.ID, "error", err)
+		return 0
+	}
+
+	delivered := 0
+	for _, sub := range subs {
+		webpushSub := &webpush.Subscription{
+			Endpoint: sub.Endpoint,
+			Keys: webpush.Keys{
+				Auth:   sub.Auth,
+				P256dh: sub.P256dh,
+			},
+		}
+
+		resp, err := webpush.SendNotificationWithContext(ctx, body, webpushSub, options)
+		if err != nil {
+			app.logger.Warnw("push send failed", "endpoint", sub.Endpoint, "error", err)
+			continue
+		}
+
+		_, _ = io.Copy(io.Discard, resp.Body)
+		resp.Body.Close()
+
+		switch {
+		case resp.StatusCode >= 200 && resp.StatusCode < 300:
+			delivered++
+		case resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusGone:
+			if err := app.store.PushSubscriptions.DeleteByEndpointAdmin(ctx, sub.Endpoint); err != nil {
+				app.logger.Warnw("failed to delete dead subscription", "endpoint", sub.Endpoint, "error", err)
+			}
+		default:
+			app.logger.Warnw("push send returned unexpected status", "endpoint", sub.Endpoint, "status", resp.StatusCode)
+		}
+	}
+
+	return delivered
+}
diff --git a/cmd/api/main.go b/cmd/api/main.go
index b4996b25..f8cf9cb4 100644
--- a/cmd/api/main.go
+++ b/cmd/api/main.go
@@ -89,6 +89,11 @@ func main() {
 			googleClientID:     env.GetString("GOOGLE_CLIENT_ID", ""),
 			googleClientSecret: env.GetString("GOOGLE_CLIENT_SECRET", ""),
 		},
+		vapid: vapidConfig{
+			publicKey:  env.GetString("VAPID_PUBLIC_KEY", ""),
+			privateKey: env.GetString("VAPID_PRIVATE_KEY", ""),
+			subject:    env.GetString("VAPID_SUBJECT", "mailto:noreply@hackportal.com"),
+		},
 	}
 
 	if _, err := time.LoadLocation(cfg.hackathonTimeZone); err != nil {
@@ -175,5 +180,9 @@ func main() {
 
 	mux := app.mount()
 
+	dispatcherCtx, cancelDispatcher := context.WithCancel(context.Background())
+	app.dispatcherCancel = cancelDispatcher
+	go app.runNotificationDispatcher(dispatcherCtx)
+
 	log.Fatal(app.run(mux))
 }
diff --git a/cmd/api/notifications.go b/cmd/api/notifications.go
new file mode 100644
index 00000000..1bb9cb03
--- /dev/null
+++ b/cmd/api/notifications.go
@@ -0,0 +1,141 @@
+package main
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/hackutd/portal/internal/store"
+)
+
+type VapidPublicKeyResponse struct {
+	PublicKey string `json:"public_key"`
+}
+
+type SubscribePushPayload struct {
+	Endpoint  string `json:"endpoint" validate:"required,url"`
+	P256dh    string `json:"p256dh" validate:"required"`
+	Auth      string `json:"auth" validate:"required"`
+	UserAgent string `json:"user_agent"`
+}
+
+type UnsubscribePushPayload struct {
+	Endpoint string `json:"endpoint" validate:"required"`
+}
+
+// getVapidPublicKeyHandler returns the VAPID public key for push subscription.
+//
+//	@Summary		Get VAPID public key
+//	@Description	Returns the server's VAPID public key for push notification subscription
+//	@Tags			hackers
+//	@Produce		json
+//	@Success		200	{object}	VapidPublicKeyResponse
+//	@Failure		401	{object}	object{error=string}
+//	@Failure		503	{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/notifications/vapid-public-key [get]
+func (app *application) getVapidPublicKeyHandler(w http.ResponseWriter, r *http.Request) {
+	if app.config.vapid.publicKey == "" {
+		writeJSONError(w, http.StatusServiceUnavailable, "push notifications not configured")
+		return
+	}
+
+	if err := app.jsonResponse(w, http.StatusOK, VapidPublicKeyResponse{PublicKey: app.config.vapid.publicKey}); err != nil {
+		app.internalServerError(w, r, err)
+	}
+}
+
+// subscribePushHandler registers a push subscription for the current user.
+//
+//	@Summary		Subscribe to push notifications
+//	@Description	Stores a Web Push subscription for the authenticated user
+//	@Tags			hackers
+//	@Accept			json
+//	@Produce		json
+//	@Param			subscription	body	SubscribePushPayload	true	"Push subscription"
+//	@Success		204
+//	@Failure		400	{object}	object{error=string}
+//	@Failure		401	{object}	object{error=string}
+//	@Failure		503	{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/notifications/subscribe [post]
+func (app *application) subscribePushHandler(w http.ResponseWriter, r *http.Request) {
+	if app.config.vapid.publicKey == "" {
+		writeJSONError(w, http.StatusServiceUnavailable, "push notifications not configured")
+		return
+	}
+
+	user := getUserFromContext(r.Context())
+	if user == nil {
+		app.unauthorizedErrorResponse(w, r, errors.New("user not in context"))
+		return
+	}
+
+	var payload SubscribePushPayload
+	if err := readJSON(w, r, &payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	if err := Validate.Struct(payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	sub := &store.PushSubscription{
+		UserID:    user.ID,
+		Endpoint:  payload.Endpoint,
+		P256dh:    payload.P256dh,
+		Auth:      payload.Auth,
+		UserAgent: payload.UserAgent,
+	}
+
+	if err := app.store.PushSubscriptions.Upsert(r.Context(), sub); err != nil {
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// unsubscribePushHandler removes a push subscription owned by the current user.
+//
+//	@Summary		Unsubscribe from push notifications
+//	@Description	Removes the given Web Push subscription for the authenticated user
+//	@Tags			hackers
+//	@Accept			json
+//	@Param			subscription	body	UnsubscribePushPayload	true	"Subscription to remove"
+//	@Success		204
+//	@Failure		400	{object}	object{error=string}
+//	@Failure		401	{object}	object{error=string}
+//	@Failure		404	{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/notifications/subscribe [delete]
+func (app *application) unsubscribePushHandler(w http.ResponseWriter, r *http.Request) {
+	user := getUserFromContext(r.Context())
+	if user == nil {
+		app.unauthorizedErrorResponse(w, r, errors.New("user not in context"))
+		return
+	}
+
+	var payload UnsubscribePushPayload
+	if err := readJSON(w, r, &payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	if err := Validate.Struct(payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	if err := app.store.PushSubscriptions.DeleteByEndpoint(r.Context(), user.ID, payload.Endpoint); err != nil {
+		if errors.Is(err, store.ErrNotFound) {
+			app.notFoundResponse(w, r, errors.New("subscription not found"))
+			return
+		}
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
diff --git a/cmd/api/notifications_test.go b/cmd/api/notifications_test.go
new file mode 100644
index 00000000..3c8b9b07
--- /dev/null
+++ b/cmd/api/notifications_test.go
@@ -0,0 +1,136 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/hackutd/portal/internal/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetVapidPublicKey(t *testing.T) {
+	t.Run("returns public key when configured", func(t *testing.T) {
+		app := newTestApplication(t)
+		app.config.vapid.publicKey = "test-public-key"
+
+		req, err := http.NewRequest(http.MethodGet, "/", nil)
+		require.NoError(t, err)
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.getVapidPublicKeyHandler))
+		checkResponseCode(t, http.StatusOK, rr.Code)
+
+		var body struct {
+			Data VapidPublicKeyResponse `json:"data"`
+		}
+		err = json.NewDecoder(rr.Body).Decode(&body)
+		require.NoError(t, err)
+		assert.Equal(t, "test-public-key", body.Data.PublicKey)
+	})
+
+	t.Run("returns 503 when not configured", func(t *testing.T) {
+		app := newTestApplication(t)
+
+		req, err := http.NewRequest(http.MethodGet, "/", nil)
+		require.NoError(t, err)
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.getVapidPublicKeyHandler))
+		checkResponseCode(t, http.StatusServiceUnavailable, rr.Code)
+	})
+}
+
+func TestSubscribePush(t *testing.T) {
+	t.Run("upserts the subscription on happy path", func(t *testing.T) {
+		app := newTestApplication(t)
+		app.config.vapid.publicKey = "test-public-key"
+		mockSubs := app.store.PushSubscriptions.(*store.MockPushSubscriptionsStore)
+
+		mockSubs.On("Upsert", mock.AnythingOfType("*store.PushSubscription")).Run(func(args mock.Arguments) {
+			sub := args.Get(0).(*store.PushSubscription)
+			assert.Equal(t, "user-1", sub.UserID)
+			assert.Equal(t, "https://fcm.googleapis.com/fcm/send/abc", sub.Endpoint)
+		}).Return(nil).Once()
+
+		body := `{"endpoint":"https://fcm.googleapis.com/fcm/send/abc","p256dh":"key","auth":"auth-secret","user_agent":"Chrome"}`
+		req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.subscribePushHandler))
+		checkResponseCode(t, http.StatusNoContent, rr.Code)
+
+		mockSubs.AssertExpectations(t)
+	})
+
+	t.Run("returns 400 on missing endpoint", func(t *testing.T) {
+		app := newTestApplication(t)
+		app.config.vapid.publicKey = "test-public-key"
+
+		body := `{"p256dh":"key","auth":"auth-secret"}`
+		req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.subscribePushHandler))
+		checkResponseCode(t, http.StatusBadRequest, rr.Code)
+	})
+
+	t.Run("returns 503 when not configured", func(t *testing.T) {
+		app := newTestApplication(t)
+
+		body := `{"endpoint":"https://example.com/x","p256dh":"key","auth":"a"}`
+		req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.subscribePushHandler))
+		checkResponseCode(t, http.StatusServiceUnavailable, rr.Code)
+	})
+}
+
+func TestUnsubscribePush(t *testing.T) {
+	t.Run("deletes the subscription on happy path", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockSubs := app.store.PushSubscriptions.(*store.MockPushSubscriptionsStore)
+
+		endpoint := "https://fcm.googleapis.com/fcm/send/abc"
+		mockSubs.On("DeleteByEndpoint", "user-1", endpoint).Return(nil).Once()
+
+		body := `{"endpoint":"` + endpoint + `"}`
+		req, err := http.NewRequest(http.MethodDelete, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.unsubscribePushHandler))
+		checkResponseCode(t, http.StatusNoContent, rr.Code)
+
+		mockSubs.AssertExpectations(t)
+	})
+
+	t.Run("returns 404 when missing", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockSubs := app.store.PushSubscriptions.(*store.MockPushSubscriptionsStore)
+
+		mockSubs.On("DeleteByEndpoint", "user-1", "https://example.com/missing").Return(store.ErrNotFound).Once()
+
+		body := `{"endpoint":"https://example.com/missing"}`
+		req, err := http.NewRequest(http.MethodDelete, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newTestUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.unsubscribePushHandler))
+		checkResponseCode(t, http.StatusNotFound, rr.Code)
+
+		mockSubs.AssertExpectations(t)
+	})
+}
diff --git a/cmd/api/scheduled_notifications.go b/cmd/api/scheduled_notifications.go
new file mode 100644
index 00000000..e58287ca
--- /dev/null
+++ b/cmd/api/scheduled_notifications.go
@@ -0,0 +1,206 @@
+package main
+
+import (
+	"errors"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi"
+	"github.com/hackutd/portal/internal/store"
+)
+
+type ScheduledNotificationPayload struct {
+	Title       string    `json:"title" validate:"required,min=1,max=100"`
+	Body        string    `json:"body" validate:"required,min=1,max=300"`
+	URL         *string   `json:"url" validate:"omitempty,url"`
+	TargetRole  *string   `json:"target_role" validate:"omitempty,oneof=hacker admin super_admin"`
+	ScheduledAt time.Time `json:"scheduled_at" validate:"required"`
+}
+
+type ScheduledNotificationListResponse struct {
+	Notifications []store.ScheduledNotification `json:"notifications"`
+}
+
+// listScheduledNotificationsHandler returns all scheduled notifications.
+//
+//	@Summary		List scheduled notifications (Super Admin)
+//	@Description	Returns all scheduled notifications ordered by scheduled time descending
+//	@Tags			superadmin/notifications
+//	@Produce		json
+//	@Success		200	{object}	ScheduledNotificationListResponse
+//	@Failure		401	{object}	object{error=string}
+//	@Failure		403	{object}	object{error=string}
+//	@Failure		500	{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/superadmin/notifications [get]
+func (app *application) listScheduledNotificationsHandler(w http.ResponseWriter, r *http.Request) {
+	notifications, err := app.store.ScheduledNotifications.List(r.Context())
+	if err != nil {
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	if err := app.jsonResponse(w, http.StatusOK, ScheduledNotificationListResponse{Notifications: notifications}); err != nil {
+		app.internalServerError(w, r, err)
+	}
+}
+
+// createScheduledNotificationHandler schedules a new notification.
+//
+//	@Summary		Create scheduled notification (Super Admin)
+//	@Description	Schedules a push notification for delivery at the specified time
+//	@Tags			superadmin/notifications
+//	@Accept			json
+//	@Produce		json
+//	@Param			notification	body		ScheduledNotificationPayload	true	"Notification to schedule"
+//	@Success		201				{object}	store.ScheduledNotification
+//	@Failure		400				{object}	object{error=string}
+//	@Failure		401				{object}	object{error=string}
+//	@Failure		403				{object}	object{error=string}
+//	@Failure		500				{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/superadmin/notifications [post]
+func (app *application) createScheduledNotificationHandler(w http.ResponseWriter, r *http.Request) {
+	user := getUserFromContext(r.Context())
+	if user == nil {
+		app.unauthorizedErrorResponse(w, r, errors.New("user not in context"))
+		return
+	}
+
+	var payload ScheduledNotificationPayload
+	if err := readJSON(w, r, &payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	if err := Validate.Struct(payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	n := &store.ScheduledNotification{
+		Title:       payload.Title,
+		Body:        payload.Body,
+		URL:         payload.URL,
+		TargetRole:  toUserRolePtr(payload.TargetRole),
+		ScheduledAt: payload.ScheduledAt,
+		CreatedBy:   user.ID,
+	}
+
+	if err := app.store.ScheduledNotifications.Create(r.Context(), n); err != nil {
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	if err := app.jsonResponse(w, http.StatusCreated, n); err != nil {
+		app.internalServerError(w, r, err)
+	}
+}
+
+// updateScheduledNotificationHandler updates a pending scheduled notification.
+//
+//	@Summary		Update scheduled notification (Super Admin)
+//	@Description	Updates a pending notification. Returns 409 if already sent.
+//	@Tags			superadmin/notifications
+//	@Accept			json
+//	@Produce		json
+//	@Param			notificationID	path		string							true	"Notification ID"
+//	@Param			notification	body		ScheduledNotificationPayload	true	"Notification updates"
+//	@Success		200				{object}	store.ScheduledNotification
+//	@Failure		400				{object}	object{error=string}
+//	@Failure		401				{object}	object{error=string}
+//	@Failure		403				{object}	object{error=string}
+//	@Failure		404				{object}	object{error=string}
+//	@Failure		409				{object}	object{error=string}
+//	@Failure		500				{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/superadmin/notifications/{notificationID} [patch]
+func (app *application) updateScheduledNotificationHandler(w http.ResponseWriter, r *http.Request) {
+	id := chi.URLParam(r, "notificationID")
+	if id == "" {
+		app.badRequestResponse(w, r, errors.New("missing notification ID"))
+		return
+	}
+
+	var payload ScheduledNotificationPayload
+	if err := readJSON(w, r, &payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	if err := Validate.Struct(payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	n := &store.ScheduledNotification{
+		ID:          id,
+		Title:       payload.Title,
+		Body:        payload.Body,
+		URL:         payload.URL,
+		TargetRole:  toUserRolePtr(payload.TargetRole),
+		ScheduledAt: payload.ScheduledAt,
+	}
+
+	if err := app.store.ScheduledNotifications.Update(r.Context(), n); err != nil {
+		switch {
+		case errors.Is(err, store.ErrNotFound):
+			app.notFoundResponse(w, r, errors.New("notification not found"))
+			return
+		case errors.Is(err, store.ErrConflict):
+			app.conflictResponse(w, r, errors.New("notification already sent"))
+			return
+		}
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	if err := app.jsonResponse(w, http.StatusOK, n); err != nil {
+		app.internalServerError(w, r, err)
+	}
+}
+
+// deleteScheduledNotificationHandler deletes a pending scheduled notification.
+//
+//	@Summary		Delete scheduled notification (Super Admin)
+//	@Description	Deletes a pending notification. Returns 409 if already sent.
+//	@Tags			superadmin/notifications
+//	@Param			notificationID	path	string	true	"Notification ID"
+//	@Success		204
+//	@Failure		401	{object}	object{error=string}
+//	@Failure		403	{object}	object{error=string}
+//	@Failure		404	{object}	object{error=string}
+//	@Failure		409	{object}	object{error=string}
+//	@Failure		500	{object}	object{error=string}
+//	@Security		CookieAuth
+//	@Router			/superadmin/notifications/{notificationID} [delete]
+func (app *application) deleteScheduledNotificationHandler(w http.ResponseWriter, r *http.Request) {
+	id := chi.URLParam(r, "notificationID")
+	if id == "" {
+		app.badRequestResponse(w, r, errors.New("missing notification ID"))
+		return
+	}
+
+	if err := app.store.ScheduledNotifications.Delete(r.Context(), id); err != nil {
+		switch {
+		case errors.Is(err, store.ErrNotFound):
+			app.notFoundResponse(w, r, errors.New("notification not found"))
+			return
+		case errors.Is(err, store.ErrConflict):
+			app.conflictResponse(w, r, errors.New("notification already sent"))
+			return
+		}
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func toUserRolePtr(s *string) *store.UserRole {
+	if s == nil || *s == "" {
+		return nil
+	}
+	r := store.UserRole(*s)
+	return &r
+}
diff --git a/cmd/api/scheduled_notifications_test.go b/cmd/api/scheduled_notifications_test.go
new file mode 100644
index 00000000..874049f0
--- /dev/null
+++ b/cmd/api/scheduled_notifications_test.go
@@ -0,0 +1,235 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/go-chi/chi"
+	"github.com/hackutd/portal/internal/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func withNotificationRouteParam(req *http.Request, id string) *http.Request {
+	rctx := chi.NewRouteContext()
+	rctx.URLParams.Add("notificationID", id)
+	return req.WithContext(context.WithValue(req.Context(), chi.RouteCtxKey, rctx))
+}
+
+func newTestNotification(id string) store.ScheduledNotification {
+	return store.ScheduledNotification{
+		ID:          id,
+		Title:       "Applications closing soon",
+		Body:        "Submit your application before midnight",
+		ScheduledAt: time.Now().Add(time.Hour),
+		CreatedBy:   "superadmin-1",
+		CreatedAt:   time.Now(),
+		UpdatedAt:   time.Now(),
+	}
+}
+
+func TestListScheduledNotifications(t *testing.T) {
+	app := newTestApplication(t)
+	mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+	t.Run("returns all notifications", func(t *testing.T) {
+		notifications := []store.ScheduledNotification{
+			newTestNotification("n-1"),
+			newTestNotification("n-2"),
+		}
+		mockNotifs.On("List").Return(notifications, nil).Once()
+
+		req, err := http.NewRequest(http.MethodGet, "/", nil)
+		require.NoError(t, err)
+		req = setUserContext(req, newSuperAdminUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.listScheduledNotificationsHandler))
+		checkResponseCode(t, http.StatusOK, rr.Code)
+
+		var body struct {
+			Data ScheduledNotificationListResponse `json:"data"`
+		}
+		err = json.NewDecoder(rr.Body).Decode(&body)
+		require.NoError(t, err)
+		assert.Len(t, body.Data.Notifications, 2)
+
+		mockNotifs.AssertExpectations(t)
+	})
+}
+
+func TestCreateScheduledNotification(t *testing.T) {
+	t.Run("creates a notification", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+		mockNotifs.On("Create", mock.AnythingOfType("*store.ScheduledNotification")).Run(func(args mock.Arguments) {
+			n := args.Get(0).(*store.ScheduledNotification)
+			n.ID = "new-notif"
+			assert.Equal(t, "superadmin-1", n.CreatedBy)
+		}).Return(nil).Once()
+
+		body := `{"title":"Test","body":"Hello","scheduled_at":"2030-01-01T00:00:00Z","target_role":"hacker"}`
+		req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newSuperAdminUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.createScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusCreated, rr.Code)
+
+		var respBody struct {
+			Data store.ScheduledNotification `json:"data"`
+		}
+		err = json.NewDecoder(rr.Body).Decode(&respBody)
+		require.NoError(t, err)
+		assert.Equal(t, "new-notif", respBody.Data.ID)
+		require.NotNil(t, respBody.Data.TargetRole)
+		assert.Equal(t, store.RoleHacker, *respBody.Data.TargetRole)
+
+		mockNotifs.AssertExpectations(t)
+	})
+
+	t.Run("rejects invalid target_role", func(t *testing.T) {
+		app := newTestApplication(t)
+
+		body := `{"title":"Test","body":"Hello","scheduled_at":"2030-01-01T00:00:00Z","target_role":"intern"}`
+		req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newSuperAdminUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.createScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusBadRequest, rr.Code)
+	})
+
+	t.Run("rejects missing scheduled_at", func(t *testing.T) {
+		app := newTestApplication(t)
+
+		body := `{"title":"Test","body":"Hello"}`
+		req, err := http.NewRequest(http.MethodPost, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newSuperAdminUser())
+
+		rr := executeRequest(req, http.HandlerFunc(app.createScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusBadRequest, rr.Code)
+	})
+}
+
+func TestUpdateScheduledNotification(t *testing.T) {
+	t.Run("updates a pending notification", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+		mockNotifs.On("Update", mock.AnythingOfType("*store.ScheduledNotification")).Return(nil).Once()
+
+		body := `{"title":"Updated","body":"New body","scheduled_at":"2030-01-01T00:00:00Z"}`
+		req, err := http.NewRequest(http.MethodPatch, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newSuperAdminUser())
+		req = withNotificationRouteParam(req, "n-1")
+
+		rr := executeRequest(req, http.HandlerFunc(app.updateScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusOK, rr.Code)
+
+		mockNotifs.AssertExpectations(t)
+	})
+
+	t.Run("returns 409 if already sent", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+		mockNotifs.On("Update", mock.AnythingOfType("*store.ScheduledNotification")).Return(store.ErrConflict).Once()
+
+		body := `{"title":"Updated","body":"New body","scheduled_at":"2030-01-01T00:00:00Z"}`
+		req, err := http.NewRequest(http.MethodPatch, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newSuperAdminUser())
+		req = withNotificationRouteParam(req, "n-1")
+
+		rr := executeRequest(req, http.HandlerFunc(app.updateScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusConflict, rr.Code)
+
+		mockNotifs.AssertExpectations(t)
+	})
+
+	t.Run("returns 404 if missing", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+		mockNotifs.On("Update", mock.AnythingOfType("*store.ScheduledNotification")).Return(store.ErrNotFound).Once()
+
+		body := `{"title":"Updated","body":"New body","scheduled_at":"2030-01-01T00:00:00Z"}`
+		req, err := http.NewRequest(http.MethodPatch, "/", strings.NewReader(body))
+		require.NoError(t, err)
+		req.Header.Set("Content-Type", "application/json")
+		req = setUserContext(req, newSuperAdminUser())
+		req = withNotificationRouteParam(req, "missing")
+
+		rr := executeRequest(req, http.HandlerFunc(app.updateScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusNotFound, rr.Code)
+
+		mockNotifs.AssertExpectations(t)
+	})
+}
+
+func TestDeleteScheduledNotification(t *testing.T) {
+	t.Run("deletes a pending notification", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+		mockNotifs.On("Delete", "n-1").Return(nil).Once()
+
+		req, err := http.NewRequest(http.MethodDelete, "/", nil)
+		require.NoError(t, err)
+		req = setUserContext(req, newSuperAdminUser())
+		req = withNotificationRouteParam(req, "n-1")
+
+		rr := executeRequest(req, http.HandlerFunc(app.deleteScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusNoContent, rr.Code)
+
+		mockNotifs.AssertExpectations(t)
+	})
+
+	t.Run("returns 409 if already sent", func(t *testing.T) {
+		app := newTestApplication(t)
+		mockNotifs := app.store.ScheduledNotifications.(*store.MockScheduledNotificationsStore)
+
+		mockNotifs.On("Delete", "n-1").Return(store.ErrConflict).Once()
+
+		req, err := http.NewRequest(http.MethodDelete, "/", nil)
+		require.NoError(t, err)
+		req = setUserContext(req, newSuperAdminUser())
+		req = withNotificationRouteParam(req, "n-1")
+
+		rr := executeRequest(req, http.HandlerFunc(app.deleteScheduledNotificationHandler))
+		checkResponseCode(t, http.StatusConflict, rr.Code)
+
+		mockNotifs.AssertExpectations(t)
+	})
+}
+
+func TestRequireRoleMiddleware_Notifications(t *testing.T) {
+	t.Run("admin gets 403 on superadmin notification routes", func(t *testing.T) {
+		app := newTestApplication(t)
+
+		// Mount the role middleware directly with a handler that should never be called
+		handler := app.RequireRoleMiddleware(store.RoleSuperAdmin)(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			t.Error("handler should not be called")
+		}))
+
+		req, err := http.NewRequest(http.MethodGet, "/", nil)
+		require.NoError(t, err)
+		req = setUserContext(req, newAdminUser())
+
+		rr := executeRequest(req, handler)
+		checkResponseCode(t, http.StatusForbidden, rr.Code)
+	})
+}
diff --git a/cmd/genvapid/main.go b/cmd/genvapid/main.go
new file mode 100644
index 00000000..18cf211d
--- /dev/null
+++ b/cmd/genvapid/main.go
@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	webpush "github.com/SherClockHolmes/webpush-go"
+)
+
+func main() {
+	private, public, err := webpush.GenerateVAPIDKeys()
+	if err != nil {
+		log.Fatalf("failed to generate VAPID keys: %v", err)
+	}
+
+	fmt.Printf("VAPID_PUBLIC_KEY=%s\n", public)
+	fmt.Printf("VAPID_PRIVATE_KEY=%s\n", private)
+	fmt.Println("VAPID_SUBJECT=mailto:dev@example.com")
+}
diff --git a/cmd/migrate/migrations/000015_add_push_subscriptions.down.sql b/cmd/migrate/migrations/000015_add_push_subscriptions.down.sql
new file mode 100644
index 00000000..6382698d
--- /dev/null
+++ b/cmd/migrate/migrations/000015_add_push_subscriptions.down.sql
@@ -0,0 +1,2 @@
+DROP TRIGGER IF EXISTS trg_push_subscriptions_updated_at ON push_subscriptions;
+DROP TABLE IF EXISTS push_subscriptions;
diff --git a/cmd/migrate/migrations/000015_add_push_subscriptions.up.sql b/cmd/migrate/migrations/000015_add_push_subscriptions.up.sql
new file mode 100644
index 00000000..8417c03f
--- /dev/null
+++ b/cmd/migrate/migrations/000015_add_push_subscriptions.up.sql
@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS push_subscriptions (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    endpoint TEXT NOT NULL UNIQUE,
+    p256dh TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    user_agent TEXT NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS idx_push_subscriptions_user_id ON push_subscriptions(user_id);
+
+CREATE TRIGGER trg_push_subscriptions_updated_at
+BEFORE UPDATE ON push_subscriptions
+FOR EACH ROW EXECUTE FUNCTION set_updated_at();
diff --git a/cmd/migrate/migrations/000016_add_scheduled_notifications.down.sql b/cmd/migrate/migrations/000016_add_scheduled_notifications.down.sql
new file mode 100644
index 00000000..755fad72
--- /dev/null
+++ b/cmd/migrate/migrations/000016_add_scheduled_notifications.down.sql
@@ -0,0 +1,2 @@
+DROP TRIGGER IF EXISTS trg_scheduled_notifications_updated_at ON scheduled_notifications;
+DROP TABLE IF EXISTS scheduled_notifications;
diff --git a/cmd/migrate/migrations/000016_add_scheduled_notifications.up.sql b/cmd/migrate/migrations/000016_add_scheduled_notifications.up.sql
new file mode 100644
index 00000000..c2f15863
--- /dev/null
+++ b/cmd/migrate/migrations/000016_add_scheduled_notifications.up.sql
@@ -0,0 +1,20 @@
+CREATE TABLE IF NOT EXISTS scheduled_notifications (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title TEXT NOT NULL,
+    body TEXT NOT NULL,
+    url TEXT,
+    target_role user_role,
+    scheduled_at TIMESTAMPTZ NOT NULL,
+    sent_at TIMESTAMPTZ,
+    recipient_count INT NOT NULL DEFAULT 0,
+    created_by UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS idx_scheduled_notifications_pending
+    ON scheduled_notifications(scheduled_at) WHERE sent_at IS NULL;
+
+CREATE TRIGGER trg_scheduled_notifications_updated_at
+BEFORE UPDATE ON scheduled_notifications
+FOR EACH ROW EXECUTE FUNCTION set_updated_at();
diff --git a/docs/docs.go b/docs/docs.go
index b6525316..51c9a29d 100644
--- a/docs/docs.go
+++ b/docs/docs.go
@@ -2397,6 +2397,186 @@ const docTemplate = `{
                 }
             }
         },
+        "/notifications/subscribe": {
+            "post": {
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Stores a Web Push subscription for the authenticated user",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "hackers"
+                ],
+                "summary": "Subscribe to push notifications",
+                "parameters": [
+                    {
+                        "description": "Push subscription",
+                        "name": "subscription",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/main.SubscribePushPayload"
+                        }
+                    }
+                ],
+                "responses": {
+                    "204": {
+                        "description": "No Content"
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "503": {
+                        "description": "Service Unavailable",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Removes the given Web Push subscription for the authenticated user",
+                "consumes": [
+                    "application/json"
+                ],
+                "tags": [
+                    "hackers"
+                ],
+                "summary": "Unsubscribe from push notifications",
+                "parameters": [
+                    {
+                        "description": "Subscription to remove",
+                        "name": "subscription",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/main.UnsubscribePushPayload"
+                        }
+                    }
+                ],
+                "responses": {
+                    "204": {
+                        "description": "No Content"
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/notifications/vapid-public-key": {
+            "get": {
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Returns the server's VAPID public key for push notification subscription",
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "hackers"
+                ],
+                "summary": "Get VAPID public key",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/main.VapidPublicKeyResponse"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "503": {
+                        "description": "Service Unavailable",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "/public/schedule": {
             "get": {
                 "description": "Returns the full event schedule, ordered by start time ascending",
@@ -2420,7 +2600,273 @@ const docTemplate = `{
                     "200": {
                         "description": "OK",
                         "schema": {
-                            "$ref": "#/definitions/main.ScheduleListResponse"
+                            "$ref": "#/definitions/main.ScheduleListResponse"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/public/sponsors": {
+            "get": {
+                "description": "Returns all sponsors, ordered by display order, with public logo URLs",
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "public"
+                ],
+                "summary": "Get sponsors (Public)",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "API Key",
+                        "name": "X-API-Key",
+                        "in": "header",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/main.SponsorListResponse"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/superadmin/applications/assign": {
+            "post": {
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Finds all submitted applications needing more reviews and assigns them to admins using workload balancing",
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "superadmin/applications"
+                ],
+                "summary": "Batch assign reviews (SuperAdmin)",
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/store.BatchAssignmentResult"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "description": "Forbidden",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/superadmin/applications/emails": {
+            "get": {
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Returns a list of applicant emails filtered by application status (accepted, rejected, or waitlisted)",
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "superadmin/applications"
+                ],
+                "summary": "Get applicant emails by status (Super Admin)",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Application status (accepted, rejected, or waitlisted)",
+                        "name": "status",
+                        "in": "query",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/main.EmailListResponse"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "description": "Forbidden",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/superadmin/applications/{applicationID}/status": {
+            "patch": {
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Sets the final status (accepted, rejected, or waitlisted) on an application",
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "superadmin/applications"
+                ],
+                "summary": "Set application status (Super Admin)",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Application ID",
+                        "name": "applicationID",
+                        "in": "path",
+                        "required": true
+                    },
+                    {
+                        "description": "New status",
+                        "name": "status",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/main.SetStatusPayload"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/main.ApplicationResponse"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
                         }
                     },
                     "401": {
@@ -2434,6 +2880,28 @@ const docTemplate = `{
                             }
                         }
                     },
+                    "403": {
+                        "description": "Forbidden",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "Not Found",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
                     "500": {
                         "description": "Internal Server Error",
                         "schema": {
@@ -2448,30 +2916,26 @@ const docTemplate = `{
                 }
             }
         },
-        "/public/sponsors": {
+        "/superadmin/notifications": {
             "get": {
-                "description": "Returns all sponsors, ordered by display order, with public logo URLs",
+                "security": [
+                    {
+                        "CookieAuth": []
+                    }
+                ],
+                "description": "Returns all scheduled notifications ordered by scheduled time descending",
                 "produces": [
                     "application/json"
                 ],
                 "tags": [
-                    "public"
-                ],
-                "summary": "Get sponsors (Public)",
-                "parameters": [
-                    {
-                        "type": "string",
-                        "description": "API Key",
-                        "name": "X-API-Key",
-                        "in": "header",
-                        "required": true
-                    }
+                    "superadmin/notifications"
                 ],
+                "summary": "List scheduled notifications (Super Admin)",
                 "responses": {
                     "200": {
                         "description": "OK",
                         "schema": {
-                            "$ref": "#/definitions/main.SponsorListResponse"
+                            "$ref": "#/definitions/main.ScheduledNotificationListResponse"
                         }
                     },
                     "401": {
@@ -2485,6 +2949,17 @@ const docTemplate = `{
                             }
                         }
                     },
+                    "403": {
+                        "description": "Forbidden",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
                     "500": {
                         "description": "Internal Server Error",
                         "schema": {
@@ -2497,28 +2972,51 @@ const docTemplate = `{
                         }
                     }
                 }
-            }
-        },
-        "/superadmin/applications/assign": {
+            },
             "post": {
                 "security": [
                     {
                         "CookieAuth": []
                     }
                 ],
-                "description": "Finds all submitted applications needing more reviews and assigns them to admins using workload balancing",
+                "description": "Schedules a push notification for delivery at the specified time",
+                "consumes": [
+                    "application/json"
+                ],
                 "produces": [
                     "application/json"
                 ],
                 "tags": [
-                    "superadmin/applications"
+                    "superadmin/notifications"
+                ],
+                "summary": "Create scheduled notification (Super Admin)",
+                "parameters": [
+                    {
+                        "description": "Notification to schedule",
+                        "name": "notification",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/main.ScheduledNotificationPayload"
+                        }
+                    }
                 ],
-                "summary": "Batch assign reviews (SuperAdmin)",
                 "responses": {
-                    "200": {
-                        "description": "OK",
+                    "201": {
+                        "description": "Created",
                         "schema": {
-                            "$ref": "#/definitions/store.BatchAssignmentResult"
+                            "$ref": "#/definitions/store.ScheduledNotification"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
                         }
                     },
                     "401": {
@@ -2557,39 +3055,44 @@ const docTemplate = `{
                 }
             }
         },
-        "/superadmin/applications/emails": {
-            "get": {
+        "/superadmin/notifications/{notificationID}": {
+            "delete": {
                 "security": [
                     {
                         "CookieAuth": []
                     }
                 ],
-                "description": "Returns a list of applicant emails filtered by application status (accepted, rejected, or waitlisted)",
-                "produces": [
-                    "application/json"
-                ],
+                "description": "Deletes a pending notification. Returns 409 if already sent.",
                 "tags": [
-                    "superadmin/applications"
+                    "superadmin/notifications"
                 ],
-                "summary": "Get applicant emails by status (Super Admin)",
+                "summary": "Delete scheduled notification (Super Admin)",
                 "parameters": [
                     {
                         "type": "string",
-                        "description": "Application status (accepted, rejected, or waitlisted)",
-                        "name": "status",
-                        "in": "query",
+                        "description": "Notification ID",
+                        "name": "notificationID",
+                        "in": "path",
                         "required": true
                     }
                 ],
                 "responses": {
-                    "200": {
-                        "description": "OK",
+                    "204": {
+                        "description": "No Content"
+                    },
+                    "401": {
+                        "description": "Unauthorized",
                         "schema": {
-                            "$ref": "#/definitions/main.EmailListResponse"
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
                         }
                     },
-                    "400": {
-                        "description": "Bad Request",
+                    "403": {
+                        "description": "Forbidden",
                         "schema": {
                             "type": "object",
                             "properties": {
@@ -2599,8 +3102,8 @@ const docTemplate = `{
                             }
                         }
                     },
-                    "401": {
-                        "description": "Unauthorized",
+                    "404": {
+                        "description": "Not Found",
                         "schema": {
                             "type": "object",
                             "properties": {
@@ -2610,8 +3113,8 @@ const docTemplate = `{
                             }
                         }
                     },
-                    "403": {
-                        "description": "Forbidden",
+                    "409": {
+                        "description": "Conflict",
                         "schema": {
                             "type": "object",
                             "properties": {
@@ -2633,16 +3136,14 @@ const docTemplate = `{
                         }
                     }
                 }
-            }
-        },
-        "/superadmin/applications/{applicationID}/status": {
+            },
             "patch": {
                 "security": [
                     {
                         "CookieAuth": []
                     }
                 ],
-                "description": "Sets the final status (accepted, rejected, or waitlisted) on an application",
+                "description": "Updates a pending notification. Returns 409 if already sent.",
                 "consumes": [
                     "application/json"
                 ],
@@ -2650,24 +3151,24 @@ const docTemplate = `{
                     "application/json"
                 ],
                 "tags": [
-                    "superadmin/applications"
+                    "superadmin/notifications"
                 ],
-                "summary": "Set application status (Super Admin)",
+                "summary": "Update scheduled notification (Super Admin)",
                 "parameters": [
                     {
                         "type": "string",
-                        "description": "Application ID",
-                        "name": "applicationID",
+                        "description": "Notification ID",
+                        "name": "notificationID",
                         "in": "path",
                         "required": true
                     },
                     {
-                        "description": "New status",
-                        "name": "status",
+                        "description": "Notification updates",
+                        "name": "notification",
                         "in": "body",
                         "required": true,
                         "schema": {
-                            "$ref": "#/definitions/main.SetStatusPayload"
+                            "$ref": "#/definitions/main.ScheduledNotificationPayload"
                         }
                     }
                 ],
@@ -2675,7 +3176,7 @@ const docTemplate = `{
                     "200": {
                         "description": "OK",
                         "schema": {
-                            "$ref": "#/definitions/main.ApplicationResponse"
+                            "$ref": "#/definitions/store.ScheduledNotification"
                         }
                     },
                     "400": {
@@ -2722,6 +3223,17 @@ const docTemplate = `{
                             }
                         }
                     },
+                    "409": {
+                        "description": "Conflict",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "error": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    },
                     "500": {
                         "description": "Internal Server Error",
                         "schema": {
@@ -4200,6 +4712,51 @@ const docTemplate = `{
                 }
             }
         },
+        "main.ScheduledNotificationListResponse": {
+            "type": "object",
+            "properties": {
+                "notifications": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/store.ScheduledNotification"
+                    }
+                }
+            }
+        },
+        "main.ScheduledNotificationPayload": {
+            "type": "object",
+            "required": [
+                "body",
+                "scheduled_at",
+                "title"
+            ],
+            "properties": {
+                "body": {
+                    "type": "string",
+                    "maxLength": 300,
+                    "minLength": 1
+                },
+                "scheduled_at": {
+                    "type": "string"
+                },
+                "target_role": {
+                    "type": "string",
+                    "enum": [
+                        "hacker",
+                        "admin",
+                        "super_admin"
+                    ]
+                },
+                "title": {
+                    "type": "string",
+                    "maxLength": 100,
+                    "minLength": 1
+                },
+                "url": {
+                    "type": "string"
+                }
+            }
+        },
         "main.SetAIPercentPayload": {
             "type": "object",
             "properties": {
@@ -4352,6 +4909,39 @@ const docTemplate = `{
                 }
             }
         },
+        "main.SubscribePushPayload": {
+            "type": "object",
+            "required": [
+                "auth",
+                "endpoint",
+                "p256dh"
+            ],
+            "properties": {
+                "auth": {
+                    "type": "string"
+                },
+                "endpoint": {
+                    "type": "string"
+                },
+                "p256dh": {
+                    "type": "string"
+                },
+                "user_agent": {
+                    "type": "string"
+                }
+            }
+        },
+        "main.UnsubscribePushPayload": {
+            "type": "object",
+            "required": [
+                "endpoint"
+            ],
+            "properties": {
+                "endpoint": {
+                    "type": "string"
+                }
+            }
+        },
         "main.UpdateApplicationPayload": {
             "type": "object"
         },
@@ -4473,6 +5063,14 @@ const docTemplate = `{
                 }
             }
         },
+        "main.VapidPublicKeyResponse": {
+            "type": "object",
+            "properties": {
+                "public_key": {
+                    "type": "string"
+                }
+            }
+        },
         "store.Application": {
             "type": "object",
             "properties": {
@@ -4960,6 +5558,44 @@ const docTemplate = `{
                 }
             }
         },
+        "store.ScheduledNotification": {
+            "type": "object",
+            "properties": {
+                "body": {
+                    "type": "string"
+                },
+                "created_at": {
+                    "type": "string"
+                },
+                "created_by": {
+                    "type": "string"
+                },
+                "id": {
+                    "type": "string"
+                },
+                "recipient_count": {
+                    "type": "integer"
+                },
+                "scheduled_at": {
+                    "type": "string"
+                },
+                "sent_at": {
+                    "type": "string"
+                },
+                "target_role": {
+                    "$ref": "#/definitions/store.UserRole"
+                },
+                "title": {
+                    "type": "string"
+                },
+                "updated_at": {
+                    "type": "string"
+                },
+                "url": {
+                    "type": "string"
+                }
+            }
+        },
         "store.Sponsor": {
             "type": "object",
             "properties": {
diff --git a/go.mod b/go.mod
index 87b2b7de..2a5a3213 100644
--- a/go.mod
+++ b/go.mod
@@ -6,6 +6,7 @@ toolchain go1.24.11
 
 require (
 	cloud.google.com/go/storage v1.60.0
+	github.com/SherClockHolmes/webpush-go v1.4.0
 	github.com/go-chi/chi v1.5.5
 	github.com/go-chi/cors v1.2.2
 	github.com/go-playground/validator/v10 v10.30.1
diff --git a/go.sum b/go.sum
index 85d6756e..2eb2d0e3 100644
--- a/go.sum
+++ b/go.sum
@@ -32,6 +32,8 @@ github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc
 github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
 github.com/MicahParks/keyfunc/v2 v2.1.0 h1:6ZXKb9Rp6qp1bDbJefnG7cTH8yMN1IC/4nf+GVjO99k=
 github.com/MicahParks/keyfunc/v2 v2.1.0/go.mod h1:rW42fi+xgLJ2FRRXAfNx9ZA8WpD4OeE/yHVMteCkw9k=
+github.com/SherClockHolmes/webpush-go v1.4.0 h1:ocnzNKWN23T9nvHi6IfyrQjkIc0oJWv1B1pULsf9i3s=
+github.com/SherClockHolmes/webpush-go v1.4.0/go.mod h1:XSq8pKX11vNV8MJEMwjrlTkxhAj1zKfxmyhdV7Pd6UA=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cncf/xds/go v0.0.0-20251022180443-0feb69152e9f h1:Y8xYupdHxryycyPlc9Y+bSQAYZnetRJ70VMVKm5CKI0=
@@ -85,6 +87,7 @@ github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91
 github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
 github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
 github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
 github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
@@ -92,6 +95,7 @@ github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+Licev
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc=
@@ -172,6 +176,7 @@ github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4
 github.com/twilio/twilio-go v0.26.0 h1:wFW4oTe3/LKt6bvByP7eio8JsjtaLHjMQKOUEzQry7U=
 github.com/twilio/twilio-go v0.26.0/go.mod h1:lz62Hopu4vicpQ056H5TJ0JE4AP0rS3sQ35/ejmgOwE=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
 go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
 go.opentelemetry.io/contrib/detectors/gcp v1.38.0 h1:ZoYbqX7OaA/TAikspPl3ozPI6iY6LiIY9I8cUfm+pJs=
@@ -200,21 +205,44 @@ go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc=
 go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
 golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
 golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
 golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
 golang.org/x/oauth2 v0.35.0 h1:Mv2mzuHuZuY2+bkyWXIHMfhNdJAdwW3FuWeCPYN5GVQ=
 golang.org/x/oauth2 v0.35.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -223,13 +251,36 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
 golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
 golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
 golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
@@ -237,6 +288,10 @@ golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
 golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/internal/store/mock_store.go b/internal/store/mock_store.go
index 0469a60e..57c65ae7 100644
--- a/internal/store/mock_store.go
+++ b/internal/store/mock_store.go
@@ -2,6 +2,7 @@ package store
 
 import (
 	"context"
+	"time"
 
 	"github.com/stretchr/testify/mock"
 )
@@ -416,16 +417,95 @@ func (m *MockSponsorsStore) UpdateLogo(ctx context.Context, id string, logoData
 	return args.Error(0)
 }
 
+// MockPushSubscriptionsStore is a mock implementation of the PushSubscriptions interface
+type MockPushSubscriptionsStore struct {
+	mock.Mock
+}
+
+func (m *MockPushSubscriptionsStore) Upsert(ctx context.Context, sub *PushSubscription) error {
+	args := m.Called(sub)
+	return args.Error(0)
+}
+
+func (m *MockPushSubscriptionsStore) DeleteByEndpoint(ctx context.Context, userID, endpoint string) error {
+	args := m.Called(userID, endpoint)
+	return args.Error(0)
+}
+
+func (m *MockPushSubscriptionsStore) DeleteByEndpointAdmin(ctx context.Context, endpoint string) error {
+	args := m.Called(endpoint)
+	return args.Error(0)
+}
+
+func (m *MockPushSubscriptionsStore) ListByRole(ctx context.Context, role *UserRole) ([]PushSubscription, error) {
+	args := m.Called(role)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).([]PushSubscription), args.Error(1)
+}
+
+// MockScheduledNotificationsStore is a mock implementation of the ScheduledNotifications interface
+type MockScheduledNotificationsStore struct {
+	mock.Mock
+}
+
+func (m *MockScheduledNotificationsStore) Create(ctx context.Context, n *ScheduledNotification) error {
+	args := m.Called(n)
+	return args.Error(0)
+}
+
+func (m *MockScheduledNotificationsStore) GetByID(ctx context.Context, id string) (*ScheduledNotification, error) {
+	args := m.Called(id)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*ScheduledNotification), args.Error(1)
+}
+
+func (m *MockScheduledNotificationsStore) List(ctx context.Context) ([]ScheduledNotification, error) {
+	args := m.Called()
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).([]ScheduledNotification), args.Error(1)
+}
+
+func (m *MockScheduledNotificationsStore) Update(ctx context.Context, n *ScheduledNotification) error {
+	args := m.Called(n)
+	return args.Error(0)
+}
+
+func (m *MockScheduledNotificationsStore) Delete(ctx context.Context, id string) error {
+	args := m.Called(id)
+	return args.Error(0)
+}
+
+func (m *MockScheduledNotificationsStore) ClaimDue(ctx context.Context, now time.Time, limit int) ([]ScheduledNotification, error) {
+	args := m.Called(now, limit)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).([]ScheduledNotification), args.Error(1)
+}
+
+func (m *MockScheduledNotificationsStore) MarkSent(ctx context.Context, id string, recipientCount int) error {
+	args := m.Called(id, recipientCount)
+	return args.Error(0)
+}
+
 // returns a Storage with all mock implementations
 func NewMockStore() Storage {
 	return Storage{
-		Users:              &MockUsersStore{},
-		Application:        &MockApplicationStore{},
-		Settings:           &MockSettingsStore{},
-		Hackathon:          &MockHackathonStore{},
-		ApplicationReviews: &MockApplicationReviewsStore{},
-		Scans:              &MockScansStore{},
-		Schedule:           &MockScheduleStore{},
-		Sponsors:           &MockSponsorsStore{},
+		Users:                  &MockUsersStore{},
+		Application:            &MockApplicationStore{},
+		Settings:               &MockSettingsStore{},
+		Hackathon:              &MockHackathonStore{},
+		ApplicationReviews:     &MockApplicationReviewsStore{},
+		Scans:                  &MockScansStore{},
+		Schedule:               &MockScheduleStore{},
+		Sponsors:               &MockSponsorsStore{},
+		PushSubscriptions:      &MockPushSubscriptionsStore{},
+		ScheduledNotifications: &MockScheduledNotificationsStore{},
 	}
 }
diff --git a/internal/store/push_subscriptions.go b/internal/store/push_subscriptions.go
new file mode 100644
index 00000000..01fb3d42
--- /dev/null
+++ b/internal/store/push_subscriptions.go
@@ -0,0 +1,123 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"time"
+)
+
+type PushSubscription struct {
+	ID        string    `json:"id"`
+	UserID    string    `json:"user_id"`
+	Endpoint  string    `json:"endpoint"`
+	P256dh    string    `json:"p256dh"`
+	Auth      string    `json:"auth"`
+	UserAgent string    `json:"user_agent"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+type PushSubscriptionsStore struct {
+	db *sql.DB
+}
+
+func (s *PushSubscriptionsStore) Upsert(ctx context.Context, sub *PushSubscription) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `
+		INSERT INTO push_subscriptions (user_id, endpoint, p256dh, auth, user_agent)
+		VALUES ($1, $2, $3, $4, $5)
+		ON CONFLICT (endpoint) DO UPDATE
+		SET user_id = EXCLUDED.user_id,
+		    p256dh = EXCLUDED.p256dh,
+		    auth = EXCLUDED.auth,
+		    user_agent = EXCLUDED.user_agent
+		RETURNING id, created_at, updated_at
+	`
+
+	return s.db.QueryRowContext(ctx, query,
+		sub.UserID, sub.Endpoint, sub.P256dh, sub.Auth, sub.UserAgent,
+	).Scan(&sub.ID, &sub.CreatedAt, &sub.UpdatedAt)
+}
+
+func (s *PushSubscriptionsStore) DeleteByEndpoint(ctx context.Context, userID, endpoint string) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `DELETE FROM push_subscriptions WHERE user_id = $1 AND endpoint = $2`
+
+	result, err := s.db.ExecContext(ctx, query, userID, endpoint)
+	if err != nil {
+		return err
+	}
+
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if rows == 0 {
+		return ErrNotFound
+	}
+
+	return nil
+}
+
+func (s *PushSubscriptionsStore) DeleteByEndpointAdmin(ctx context.Context, endpoint string) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `DELETE FROM push_subscriptions WHERE endpoint = $1`
+
+	_, err := s.db.ExecContext(ctx, query, endpoint)
+	return err
+}
+
+func (s *PushSubscriptionsStore) ListByRole(ctx context.Context, role *UserRole) ([]PushSubscription, error) {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	var (
+		rows *sql.Rows
+		err  error
+	)
+
+	if role == nil {
+		query := `
+			SELECT ps.id, ps.user_id, ps.endpoint, ps.p256dh, ps.auth, ps.user_agent, ps.created_at, ps.updated_at
+			FROM push_subscriptions ps
+		`
+		rows, err = s.db.QueryContext(ctx, query)
+	} else {
+		query := `
+			SELECT ps.id, ps.user_id, ps.endpoint, ps.p256dh, ps.auth, ps.user_agent, ps.created_at, ps.updated_at
+			FROM push_subscriptions ps
+			INNER JOIN users u ON u.id = ps.user_id
+			WHERE u.role = $1
+		`
+		rows, err = s.db.QueryContext(ctx, query, *role)
+	}
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var subs []PushSubscription
+	for rows.Next() {
+		var sub PushSubscription
+		if err := rows.Scan(
+			&sub.ID, &sub.UserID, &sub.Endpoint, &sub.P256dh, &sub.Auth,
+			&sub.UserAgent, &sub.CreatedAt, &sub.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		subs = append(subs, sub)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return subs, nil
+}
diff --git a/internal/store/scheduled_notifications.go b/internal/store/scheduled_notifications.go
new file mode 100644
index 00000000..005e6736
--- /dev/null
+++ b/internal/store/scheduled_notifications.go
@@ -0,0 +1,232 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"time"
+)
+
+type ScheduledNotification struct {
+	ID             string     `json:"id"`
+	Title          string     `json:"title"`
+	Body           string     `json:"body"`
+	URL            *string    `json:"url"`
+	TargetRole     *UserRole  `json:"target_role"`
+	ScheduledAt    time.Time  `json:"scheduled_at"`
+	SentAt         *time.Time `json:"sent_at"`
+	RecipientCount int        `json:"recipient_count"`
+	CreatedBy      string     `json:"created_by"`
+	CreatedAt      time.Time  `json:"created_at"`
+	UpdatedAt      time.Time  `json:"updated_at"`
+}
+
+type ScheduledNotificationsStore struct {
+	db *sql.DB
+}
+
+func (s *ScheduledNotificationsStore) Create(ctx context.Context, n *ScheduledNotification) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `
+		INSERT INTO scheduled_notifications (title, body, url, target_role, scheduled_at, created_by)
+		VALUES ($1, $2, $3, $4, $5, $6)
+		RETURNING id, recipient_count, sent_at, created_at, updated_at
+	`
+
+	return s.db.QueryRowContext(ctx, query,
+		n.Title, n.Body, n.URL, n.TargetRole, n.ScheduledAt, n.CreatedBy,
+	).Scan(&n.ID, &n.RecipientCount, &n.SentAt, &n.CreatedAt, &n.UpdatedAt)
+}
+
+func (s *ScheduledNotificationsStore) GetByID(ctx context.Context, id string) (*ScheduledNotification, error) {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `
+		SELECT id, title, body, url, target_role, scheduled_at, sent_at, recipient_count, created_by, created_at, updated_at
+		FROM scheduled_notifications
+		WHERE id = $1
+	`
+
+	var n ScheduledNotification
+	err := s.db.QueryRowContext(ctx, query, id).Scan(
+		&n.ID, &n.Title, &n.Body, &n.URL, &n.TargetRole, &n.ScheduledAt,
+		&n.SentAt, &n.RecipientCount, &n.CreatedBy, &n.CreatedAt, &n.UpdatedAt,
+	)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		return nil, err
+	}
+
+	return &n, nil
+}
+
+func (s *ScheduledNotificationsStore) List(ctx context.Context) ([]ScheduledNotification, error) {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `
+		SELECT id, title, body, url, target_role, scheduled_at, sent_at, recipient_count, created_by, created_at, updated_at
+		FROM scheduled_notifications
+		ORDER BY scheduled_at DESC
+	`
+
+	rows, err := s.db.QueryContext(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	notifications := []ScheduledNotification{}
+	for rows.Next() {
+		var n ScheduledNotification
+		if err := rows.Scan(
+			&n.ID, &n.Title, &n.Body, &n.URL, &n.TargetRole, &n.ScheduledAt,
+			&n.SentAt, &n.RecipientCount, &n.CreatedBy, &n.CreatedAt, &n.UpdatedAt,
+		); err != nil {
+			return nil, err
+		}
+		notifications = append(notifications, n)
+	}
+
+	return notifications, rows.Err()
+}
+
+func (s *ScheduledNotificationsStore) Update(ctx context.Context, n *ScheduledNotification) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	query := `
+		UPDATE scheduled_notifications
+		SET title = $1, body = $2, url = $3, target_role = $4, scheduled_at = $5
+		WHERE id = $6 AND sent_at IS NULL
+		RETURNING sent_at, recipient_count, created_by, created_at, updated_at
+	`
+
+	err := s.db.QueryRowContext(ctx, query,
+		n.Title, n.Body, n.URL, n.TargetRole, n.ScheduledAt, n.ID,
+	).Scan(&n.SentAt, &n.RecipientCount, &n.CreatedBy, &n.CreatedAt, &n.UpdatedAt)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			// Could be not found or already sent — distinguish
+			var exists bool
+			if err := s.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM scheduled_notifications WHERE id = $1)`, n.ID).Scan(&exists); err != nil {
+				return err
+			}
+			if exists {
+				return ErrConflict
+			}
+			return ErrNotFound
+		}
+		return err
+	}
+
+	return nil
+}
+
+func (s *ScheduledNotificationsStore) Delete(ctx context.Context, id string) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	result, err := s.db.ExecContext(ctx, `DELETE FROM scheduled_notifications WHERE id = $1 AND sent_at IS NULL`, id)
+	if err != nil {
+		return err
+	}
+
+	rows, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if rows == 0 {
+		var exists bool
+		if err := s.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM scheduled_notifications WHERE id = $1)`, id).Scan(&exists); err != nil {
+			return err
+		}
+		if exists {
+			return ErrConflict
+		}
+		return ErrNotFound
+	}
+
+	return nil
+}
+
+func (s *ScheduledNotificationsStore) ClaimDue(ctx context.Context, now time.Time, limit int) ([]ScheduledNotification, error) {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	tx, err := s.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	rows, err := tx.QueryContext(ctx, `
+		SELECT id, title, body, url, target_role, scheduled_at, sent_at, recipient_count, created_by, created_at, updated_at
+		FROM scheduled_notifications
+		WHERE scheduled_at <= $1 AND sent_at IS NULL
+		ORDER BY scheduled_at
+		FOR UPDATE SKIP LOCKED
+		LIMIT $2
+	`, now, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	var claimed []ScheduledNotification
+	var ids []string
+	for rows.Next() {
+		var n ScheduledNotification
+		if err := rows.Scan(
+			&n.ID, &n.Title, &n.Body, &n.URL, &n.TargetRole, &n.ScheduledAt,
+			&n.SentAt, &n.RecipientCount, &n.CreatedBy, &n.CreatedAt, &n.UpdatedAt,
+		); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		claimed = append(claimed, n)
+		ids = append(ids, n.ID)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	if len(ids) == 0 {
+		if err := tx.Commit(); err != nil {
+			return nil, err
+		}
+		return nil, nil
+	}
+
+	if _, err := tx.ExecContext(ctx, `
+		UPDATE scheduled_notifications
+		SET sent_at = now()
+		WHERE id = ANY($1::uuid[])
+	`, ids); err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+
+	return claimed, nil
+}
+
+func (s *ScheduledNotificationsStore) MarkSent(ctx context.Context, id string, recipientCount int) error {
+	ctx, cancel := context.WithTimeout(ctx, QueryTimeoutDuration)
+	defer cancel()
+
+	_, err := s.db.ExecContext(ctx, `
+		UPDATE scheduled_notifications
+		SET recipient_count = $1
+		WHERE id = $2
+	`, recipientCount, id)
+	return err
+}
diff --git a/internal/store/storage.go b/internal/store/storage.go
index 7b396d48..f59343c0 100644
--- a/internal/store/storage.go
+++ b/internal/store/storage.go
@@ -88,17 +88,34 @@ type Storage struct {
 		GetByID(ctx context.Context, id string) (*Sponsor, error)
 		UpdateLogo(ctx context.Context, id string, logoData string, logoContentType string) error
 	}
+	PushSubscriptions interface {
+		Upsert(ctx context.Context, sub *PushSubscription) error
+		DeleteByEndpoint(ctx context.Context, userID, endpoint string) error
+		DeleteByEndpointAdmin(ctx context.Context, endpoint string) error
+		ListByRole(ctx context.Context, role *UserRole) ([]PushSubscription, error)
+	}
+	ScheduledNotifications interface {
+		Create(ctx context.Context, n *ScheduledNotification) error
+		GetByID(ctx context.Context, id string) (*ScheduledNotification, error)
+		List(ctx context.Context) ([]ScheduledNotification, error)
+		Update(ctx context.Context, n *ScheduledNotification) error
+		Delete(ctx context.Context, id string) error
+		ClaimDue(ctx context.Context, now time.Time, limit int) ([]ScheduledNotification, error)
+		MarkSent(ctx context.Context, id string, recipientCount int) error
+	}
 }
 
 func NewStorage(db *sql.DB) Storage {
 	return Storage{
-		Users:              &UsersStore{db: db},
-		Application:        &ApplicationsStore{db: db},
-		Settings:           &SettingsStore{db: db},
-		Hackathon:          &HackathonStore{db: db},
-		ApplicationReviews: &ApplicationReviewsStore{db: db},
-		Scans:              &ScansStore{db: db},
-		Schedule:           &ScheduleStore{db: db},
-		Sponsors:           &SponsorsStore{db: db},
+		Users:                  &UsersStore{db: db},
+		Application:            &ApplicationsStore{db: db},
+		Settings:               &SettingsStore{db: db},
+		Hackathon:              &HackathonStore{db: db},
+		ApplicationReviews:     &ApplicationReviewsStore{db: db},
+		Scans:                  &ScansStore{db: db},
+		Schedule:               &ScheduleStore{db: db},
+		Sponsors:               &SponsorsStore{db: db},
+		PushSubscriptions:      &PushSubscriptionsStore{db: db},
+		ScheduledNotifications: &ScheduledNotificationsStore{db: db},
 	}
 }