diff --git a/apps/dashboard/app/(main)/settings/notifications/_components/alarm-sheet.tsx b/apps/dashboard/app/(main)/settings/notifications/_components/alarm-sheet.tsx
new file mode 100644
index 000000000..80997ffc7
--- /dev/null
+++ b/apps/dashboard/app/(main)/settings/notifications/_components/alarm-sheet.tsx
@@ -0,0 +1,646 @@
+"use client";
+
+import type { AlarmForm } from "@databuddy/shared/alarms";
+import { alarmFormSchema } from "@databuddy/shared/alarms";
+import { zodResolver } from "@hookform/resolvers/zod";
+import {
+	BellIcon,
+	EnvelopeIcon,
+	PlusIcon,
+	SpinnerGapIcon,
+	TrashIcon,
+	WebhookLogoIcon,
+} from "@phosphor-icons/react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	Form,
+	FormControl,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import {
+	Sheet,
+	SheetBody,
+	SheetContent,
+	SheetDescription,
+	SheetFooter,
+	SheetHeader,
+	SheetTitle,
+} from "@/components/ui/sheet";
+import { Switch } from "@/components/ui/switch";
+import { Textarea } from "@/components/ui/textarea";
+import { orpc } from "@/lib/orpc";
+import { cn } from "@/lib/utils";
+import type { Alarm } from "./types";
+
+interface AlarmSheetProps {
+	isOpen: boolean;
+	onCloseAction: () => void;
+	organizationId: string;
+	alarm?: Alarm | null;
+}
+
+const TRIGGER_TYPES = [
+	{ value: "uptime", label: "Uptime", description: "Site goes down" },
+	{
+		value: "traffic_spike",
+		label: "Traffic Spike",
+		description: "Unusual traffic",
+	},
+	{
+		value: "error_rate",
+		label: "Error Rate",
+		description: "Errors exceed threshold",
+	},
+	{ value: "goal", label: "Goal", description: "Goal completed" },
+	{ value: "custom", label: "Custom", description: "Custom condition" },
+] as const;
+
+const CHANNELS = [
+	{ value: "slack", label: "Slack" },
+	{ value: "discord", label: "Discord" },
+	{ value: "email", label: "Email" },
+	{ value: "webhook", label: "Webhook" },
+] as const;
+
+export function AlarmSheet({
+	isOpen,
+	onCloseAction,
+	organizationId,
+	alarm,
+}: AlarmSheetProps) {
+	const queryClient = useQueryClient();
+	const isEditing = Boolean(alarm);
+	const [emailInput, setEmailInput] = useState("");
+	const [headerKey, setHeaderKey] = useState("");
+	const [headerValue, setHeaderValue] = useState("");
+
+	const form = useForm<AlarmForm>({
+		resolver: zodResolver(alarmFormSchema),
+		defaultValues: {
+			name: "",
+			description: "",
+			enabled: true,
+			notificationChannels: [],
+			slackWebhookUrl: "",
+			discordWebhookUrl: "",
+			emailAddresses: [],
+			webhookUrl: "",
+			webhookHeaders: {},
+			triggerType: "uptime",
+			triggerConditions: {},
+		},
+	});
+
+	const createMutation = useMutation({
+		...orpc.alarms.create.mutationOptions(),
+	});
+	const updateMutation = useMutation({
+		...orpc.alarms.update.mutationOptions(),
+	});
+
+	const resetForm = useCallback(() => {
+		if (alarm && isEditing) {
+			form.reset({
+				name: alarm.name,
+				description: alarm.description || "",
+				enabled: alarm.enabled,
+				notificationChannels:
+					(alarm.notificationChannels as AlarmForm["notificationChannels"]) ||
+					[],
+				slackWebhookUrl: alarm.slackWebhookUrl || "",
+				discordWebhookUrl: alarm.discordWebhookUrl || "",
+				emailAddresses: (alarm.emailAddresses as string[]) || [],
+				webhookUrl: alarm.webhookUrl || "",
+				webhookHeaders: (alarm.webhookHeaders as Record<string, string>) || {},
+				triggerType:
+					(alarm.triggerType as AlarmForm["triggerType"]) || "uptime",
+				triggerConditions:
+					(alarm.triggerConditions as Record<string, unknown>) || {},
+			});
+		} else {
+			form.reset({
+				name: "",
+				description: "",
+				enabled: true,
+				notificationChannels: [],
+				slackWebhookUrl: "",
+				discordWebhookUrl: "",
+				emailAddresses: [],
+				webhookUrl: "",
+				webhookHeaders: {},
+				triggerType: "uptime",
+				triggerConditions: {},
+			});
+		}
+		setEmailInput("");
+		setHeaderKey("");
+		setHeaderValue("");
+	}, [alarm, isEditing, form]);
+
+	useEffect(() => {
+		if (isOpen) {
+			resetForm();
+		}
+	}, [alarm?.id, isOpen, resetForm]);
+
+	const handleOpenChange = (open: boolean) => {
+		if (!open) {
+			onCloseAction();
+		}
+	};
+
+	const watchedChannels = form.watch("notificationChannels") || [];
+	const watchedEmails = form.watch("emailAddresses") || [];
+	const watchedHeaders = form.watch("webhookHeaders") || {};
+
+	const toggleChannel = (
+		channel: AlarmForm["notificationChannels"][number]
+	) => {
+		const current = form.getValues("notificationChannels") || [];
+		if (current.includes(channel)) {
+			form.setValue(
+				"notificationChannels",
+				current.filter((c) => c !== channel)
+			);
+		} else {
+			form.setValue("notificationChannels", [...current, channel]);
+		}
+	};
+
+	const addEmail = () => {
+		const trimmed = emailInput.trim();
+		if (!trimmed) {
+			return;
+		}
+		const current = form.getValues("emailAddresses") || [];
+		if (!current.includes(trimmed)) {
+			form.setValue("emailAddresses", [...current, trimmed]);
+		}
+		setEmailInput("");
+	};
+
+	const removeEmail = (email: string) => {
+		const current = form.getValues("emailAddresses") || [];
+		form.setValue(
+			"emailAddresses",
+			current.filter((e) => e !== email)
+		);
+	};
+
+	const addHeader = () => {
+		const key = headerKey.trim();
+		const value = headerValue.trim();
+		if (!key) {
+			return;
+		}
+		const current = form.getValues("webhookHeaders") || {};
+		form.setValue("webhookHeaders", { ...current, [key]: value });
+		setHeaderKey("");
+		setHeaderValue("");
+	};
+
+	const removeHeader = (key: string) => {
+		const current = { ...(form.getValues("webhookHeaders") || {}) };
+		delete current[key];
+		form.setValue("webhookHeaders", current);
+	};
+
+	const onSubmit = async (formData: AlarmForm) => {
+		try {
+			if (isEditing && alarm) {
+				await updateMutation.mutateAsync({
+					id: alarm.id,
+					name: formData.name,
+					description: formData.description || null,
+					enabled: formData.enabled,
+					notificationChannels: formData.notificationChannels,
+					slackWebhookUrl: formData.slackWebhookUrl || null,
+					discordWebhookUrl: formData.discordWebhookUrl || null,
+					emailAddresses: formData.emailAddresses,
+					webhookUrl: formData.webhookUrl || null,
+					webhookHeaders: formData.webhookHeaders,
+					triggerType: formData.triggerType,
+					triggerConditions: formData.triggerConditions,
+				});
+			} else {
+				await createMutation.mutateAsync({
+					organizationId,
+					...formData,
+				});
+			}
+
+			toast.success(`Alarm ${isEditing ? "updated" : "created"} successfully`);
+
+			queryClient.invalidateQueries({
+				queryKey: orpc.alarms.list.key({
+					input: { organizationId },
+				}),
+			});
+
+			onCloseAction();
+		} catch {
+			toast.error(`Failed to ${isEditing ? "update" : "create"} alarm`);
+		}
+	};
+
+	const isLoading = createMutation.isPending || updateMutation.isPending;
+
+	return (
+		<Sheet onOpenChange={handleOpenChange} open={isOpen}>
+			<SheetContent className="sm:max-w-xl" side="right">
+				<SheetHeader>
+					<div className="flex items-center gap-4">
+						<div className="flex size-11 items-center justify-center rounded border bg-secondary">
+							<BellIcon className="text-primary" size={20} weight="fill" />
+						</div>
+						<div>
+							<SheetTitle className="text-lg">
+								{isEditing ? "Edit Alarm" : "Create Alarm"}
+							</SheetTitle>
+							<SheetDescription>
+								{isEditing
+									? `Editing ${alarm?.name}`
+									: "Set up a new notification alarm"}
+							</SheetDescription>
+						</div>
+					</div>
+				</SheetHeader>
+
+				<Form {...form}>
+					<form
+						className="flex flex-1 flex-col overflow-hidden"
+						onSubmit={form.handleSubmit(onSubmit)}
+					>
+						<SheetBody className="space-y-6">
+							{/* Basic Info */}
+							<div className="space-y-4">
+								<FormField
+									control={form.control}
+									name="name"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>
+												Name <span className="text-destructive">*</span>
+											</FormLabel>
+											<FormControl>
+												<Input placeholder="My alarm..." {...field} />
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+
+								<FormField
+									control={form.control}
+									name="description"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel className="text-muted-foreground">
+												Description (optional)
+											</FormLabel>
+											<FormControl>
+												<Textarea
+													className="min-h-16 resize-none"
+													placeholder="What does this alarm monitor?"
+													{...field}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							</div>
+
+							<div className="h-px bg-border" />
+
+							{/* Trigger Type */}
+							<div className="space-y-3">
+								<div className="space-y-0.5">
+									<span className="font-medium text-foreground text-sm">
+										Trigger Type
+									</span>
+									<p className="text-muted-foreground text-xs">
+										What condition triggers this alarm
+									</p>
+								</div>
+								<div className="flex flex-wrap gap-2">
+									{TRIGGER_TYPES.map((type) => {
+										const isSelected = form.watch("triggerType") === type.value;
+										return (
+											<button
+												className={cn(
+													"min-w-[120px] flex-1 cursor-pointer rounded border py-2 text-center transition-all",
+													isSelected
+														? "border-primary bg-primary/5 text-foreground"
+														: "border-transparent bg-secondary text-muted-foreground hover:border-border hover:bg-secondary/80 hover:text-foreground"
+												)}
+												key={type.value}
+												onClick={() => form.setValue("triggerType", type.value)}
+												type="button"
+											>
+												<span className="block font-medium text-sm">
+													{type.label}
+												</span>
+												<span className="block text-muted-foreground text-xs">
+													{type.description}
+												</span>
+											</button>
+										);
+									})}
+								</div>
+							</div>
+
+							<div className="h-px bg-border" />
+
+							{/* Notification Channels */}
+							<div className="space-y-3">
+								<div className="space-y-0.5">
+									<span className="font-medium text-foreground text-sm">
+										Notification Channels
+									</span>
+									<p className="text-muted-foreground text-xs">
+										How you want to be notified
+									</p>
+								</div>
+								<div className="flex flex-wrap gap-2">
+									{CHANNELS.map((channel) => {
+										const isSelected = watchedChannels.includes(
+											channel.value as AlarmForm["notificationChannels"][number]
+										);
+										return (
+											<button
+												className={cn(
+													"cursor-pointer rounded border px-4 py-2 transition-all",
+													isSelected
+														? "border-primary bg-primary/5 text-foreground"
+														: "border-transparent bg-secondary text-muted-foreground hover:border-border hover:bg-secondary/80 hover:text-foreground"
+												)}
+												key={channel.value}
+												onClick={() =>
+													toggleChannel(
+														channel.value as AlarmForm["notificationChannels"][number]
+													)
+												}
+												type="button"
+											>
+												<span className="font-medium text-sm">
+													{channel.label}
+												</span>
+											</button>
+										);
+									})}
+								</div>
+
+								{/* Channel-specific configuration */}
+								{watchedChannels.includes("slack") && (
+									<div className="space-y-2 rounded border p-3">
+										<div className="flex items-center gap-2">
+											<WebhookLogoIcon
+												className="text-muted-foreground"
+												size={16}
+											/>
+											<span className="font-medium text-sm">
+												Slack Configuration
+											</span>
+										</div>
+										<FormField
+											control={form.control}
+											name="slackWebhookUrl"
+											render={({ field }) => (
+												<FormItem>
+													<FormControl>
+														<Input
+															placeholder="https://hooks.slack.com/services/..."
+															{...field}
+														/>
+													</FormControl>
+													<FormMessage />
+												</FormItem>
+											)}
+										/>
+									</div>
+								)}
+
+								{watchedChannels.includes("discord") && (
+									<div className="space-y-2 rounded border p-3">
+										<div className="flex items-center gap-2">
+											<WebhookLogoIcon
+												className="text-muted-foreground"
+												size={16}
+											/>
+											<span className="font-medium text-sm">
+												Discord Configuration
+											</span>
+										</div>
+										<FormField
+											control={form.control}
+											name="discordWebhookUrl"
+											render={({ field }) => (
+												<FormItem>
+													<FormControl>
+														<Input
+															placeholder="https://discord.com/api/webhooks/..."
+															{...field}
+														/>
+													</FormControl>
+													<FormMessage />
+												</FormItem>
+											)}
+										/>
+									</div>
+								)}
+
+								{watchedChannels.includes("email") && (
+									<div className="space-y-3 rounded border p-3">
+										<div className="flex items-center gap-2">
+											<EnvelopeIcon
+												className="text-muted-foreground"
+												size={16}
+											/>
+											<span className="font-medium text-sm">
+												Email Recipients
+											</span>
+										</div>
+										<div className="flex gap-2">
+											<Input
+												className="flex-1"
+												onChange={(e) => setEmailInput(e.target.value)}
+												onKeyDown={(e) => {
+													if (e.key === "Enter") {
+														e.preventDefault();
+														addEmail();
+													}
+												}}
+												placeholder="user@example.com"
+												value={emailInput}
+											/>
+											<Button
+												onClick={addEmail}
+												size="sm"
+												type="button"
+												variant="outline"
+											>
+												<PlusIcon size={16} />
+											</Button>
+										</div>
+										{watchedEmails.length > 0 && (
+											<div className="flex flex-wrap gap-1.5">
+												{watchedEmails.map((email) => (
+													<Badge
+														className="gap-1"
+														key={email}
+														variant="secondary"
+													>
+														{email}
+														<button
+															className="ml-1 hover:text-destructive"
+															onClick={() => removeEmail(email)}
+															type="button"
+														>
+															<TrashIcon size={12} />
+														</button>
+													</Badge>
+												))}
+											</div>
+										)}
+									</div>
+								)}
+
+								{watchedChannels.includes("webhook") && (
+									<div className="space-y-3 rounded border p-3">
+										<div className="flex items-center gap-2">
+											<WebhookLogoIcon
+												className="text-muted-foreground"
+												size={16}
+											/>
+											<span className="font-medium text-sm">
+												Webhook Configuration
+											</span>
+										</div>
+										<FormField
+											control={form.control}
+											name="webhookUrl"
+											render={({ field }) => (
+												<FormItem>
+													<FormLabel className="text-xs">Webhook URL</FormLabel>
+													<FormControl>
+														<Input
+															placeholder="https://api.example.com/webhooks/..."
+															{...field}
+														/>
+													</FormControl>
+													<FormMessage />
+												</FormItem>
+											)}
+										/>
+										<div className="space-y-2">
+											<span className="text-muted-foreground text-xs">
+												Custom Headers (optional)
+											</span>
+											<div className="flex gap-2">
+												<Input
+													className="flex-1"
+													onChange={(e) => setHeaderKey(e.target.value)}
+													placeholder="Header name"
+													value={headerKey}
+												/>
+												<Input
+													className="flex-1"
+													onChange={(e) => setHeaderValue(e.target.value)}
+													placeholder="Header value"
+													value={headerValue}
+												/>
+												<Button
+													onClick={addHeader}
+													size="sm"
+													type="button"
+													variant="outline"
+												>
+													<PlusIcon size={16} />
+												</Button>
+											</div>
+											{Object.keys(watchedHeaders).length > 0 && (
+												<div className="space-y-1">
+													{Object.entries(watchedHeaders).map(
+														([key, value]) => (
+															<div
+																className="flex items-center justify-between rounded bg-secondary px-2 py-1"
+																key={key}
+															>
+																<span className="font-mono text-xs">
+																	{key}: {value}
+																</span>
+																<button
+																	className="hover:text-destructive"
+																	onClick={() => removeHeader(key)}
+																	type="button"
+																>
+																	<TrashIcon size={12} />
+																</button>
+															</div>
+														)
+													)}
+												</div>
+											)}
+										</div>
+									</div>
+								)}
+							</div>
+
+							<div className="h-px bg-border" />
+
+							{/* Enabled toggle */}
+							<FormField
+								control={form.control}
+								name="enabled"
+								render={({ field }) => (
+									<div className="flex items-center justify-between">
+										<div className="space-y-0.5">
+											<span className="font-medium text-foreground text-sm">
+												Enabled
+											</span>
+											<p className="text-muted-foreground text-xs">
+												When disabled, this alarm will not trigger notifications
+											</p>
+										</div>
+										<Switch
+											checked={field.value}
+											onCheckedChange={field.onChange}
+										/>
+									</div>
+								)}
+							/>
+						</SheetBody>
+
+						<SheetFooter>
+							<Button onClick={onCloseAction} type="button" variant="ghost">
+								Cancel
+							</Button>
+							<Button className="min-w-28" disabled={isLoading} type="submit">
+								{isLoading ? (
+									<>
+										<SpinnerGapIcon className="animate-spin" size={16} />
+										{isEditing ? "Saving..." : "Creating..."}
+									</>
+								) : isEditing ? (
+									"Save Changes"
+								) : (
+									"Create Alarm"
+								)}
+							</Button>
+						</SheetFooter>
+					</form>
+				</Form>
+			</SheetContent>
+		</Sheet>
+	);
+}
diff --git a/apps/dashboard/app/(main)/settings/notifications/_components/alarms-list.tsx b/apps/dashboard/app/(main)/settings/notifications/_components/alarms-list.tsx
new file mode 100644
index 000000000..020bb9110
--- /dev/null
+++ b/apps/dashboard/app/(main)/settings/notifications/_components/alarms-list.tsx
@@ -0,0 +1,293 @@
+"use client";
+
+import {
+	BellIcon,
+	DotsThreeIcon,
+	PencilSimpleIcon,
+	PlayIcon,
+	TrashIcon,
+} from "@phosphor-icons/react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuSeparator,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Switch } from "@/components/ui/switch";
+import { orpc } from "@/lib/orpc";
+import { cn } from "@/lib/utils";
+import type { Alarm } from "./types";
+
+const TRIGGER_LABELS: Record<string, string> = {
+	uptime: "Uptime",
+	traffic_spike: "Traffic Spike",
+	error_rate: "Error Rate",
+	goal: "Goal",
+	custom: "Custom",
+};
+
+interface AlarmsListProps {
+	alarms: Alarm[];
+	organizationId: string;
+	onEdit: (alarm: Alarm) => void;
+	onDelete: (alarmId: string) => void;
+}
+
+function EnableToggle({
+	alarm,
+	organizationId,
+}: {
+	alarm: Alarm;
+	organizationId: string;
+}) {
+	const queryClient = useQueryClient();
+
+	const updateMutation = useMutation({
+		...orpc.alarms.update.mutationOptions(),
+		onSuccess: () => {
+			queryClient.invalidateQueries({
+				queryKey: orpc.alarms.list.key({
+					input: { organizationId },
+				}),
+			});
+		},
+	});
+
+	const handleChange = (checked: boolean) => {
+		updateMutation.mutate({ id: alarm.id, enabled: checked });
+	};
+
+	return (
+		<div className="flex items-center gap-2">
+			<Switch
+				aria-label={alarm.enabled ? "Disable alarm" : "Enable alarm"}
+				checked={alarm.enabled}
+				className={cn(
+					updateMutation.isPending && "pointer-events-none opacity-60"
+				)}
+				disabled={updateMutation.isPending}
+				onCheckedChange={handleChange}
+			/>
+			<span
+				className={cn(
+					"font-medium text-xs",
+					alarm.enabled
+						? "text-green-600 dark:text-green-400"
+						: "text-muted-foreground"
+				)}
+			>
+				{alarm.enabled ? "On" : "Off"}
+			</span>
+		</div>
+	);
+}
+
+function AlarmActions({
+	alarm,
+	onEdit,
+	onDelete,
+}: {
+	alarm: Alarm;
+	onEdit: (alarm: Alarm) => void;
+	onDelete: (alarmId: string) => void;
+}) {
+	const testMutation = useMutation({
+		...orpc.alarms.test.mutationOptions(),
+		onSuccess: (data) => {
+			if (data.success) {
+				toast.success("Test notification sent successfully");
+			} else {
+				const errors = data.results
+					.filter((r: { success: boolean; error?: string }) => !r.success)
+					.map(
+						(r: { channel: string; error?: string }) =>
+							`${r.channel}: ${r.error}`
+					)
+					.join(", ");
+				toast.error(`Test notification failed: ${errors}`);
+			}
+		},
+		onError: () => {
+			toast.error("Failed to send test notification");
+		},
+	});
+
+	return (
+		<DropdownMenu>
+			<DropdownMenuTrigger asChild>
+				<Button
+					aria-label="Alarm actions"
+					className="size-8 opacity-50 hover:opacity-100 data-[state=open]:opacity-100"
+					size="icon"
+					variant="ghost"
+				>
+					<DotsThreeIcon className="size-5" weight="bold" />
+				</Button>
+			</DropdownMenuTrigger>
+			<DropdownMenuContent align="end" className="w-44">
+				<DropdownMenuItem className="gap-2" onClick={() => onEdit(alarm)}>
+					<PencilSimpleIcon className="size-4" weight="duotone" />
+					Edit Alarm
+				</DropdownMenuItem>
+				<DropdownMenuItem
+					className="gap-2"
+					disabled={testMutation.isPending}
+					onClick={() => testMutation.mutate({ id: alarm.id })}
+				>
+					<PlayIcon className="size-4" weight="duotone" />
+					{testMutation.isPending ? "Sending..." : "Test Notification"}
+				</DropdownMenuItem>
+				<DropdownMenuSeparator />
+				<DropdownMenuItem
+					className="gap-2 text-destructive focus:text-destructive"
+					onClick={() => onDelete(alarm.id)}
+					variant="destructive"
+				>
+					<TrashIcon className="size-4 fill-destructive" weight="duotone" />
+					Delete Alarm
+				</DropdownMenuItem>
+			</DropdownMenuContent>
+		</DropdownMenu>
+	);
+}
+
+function AlarmRow({
+	alarm,
+	organizationId,
+	onEdit,
+	onDelete,
+}: {
+	alarm: Alarm;
+	organizationId: string;
+	onEdit: (alarm: Alarm) => void;
+	onDelete: (alarmId: string) => void;
+}) {
+	const channels = (alarm.notificationChannels as string[]) || [];
+
+	return (
+		<button
+			className="group flex min-h-[60px] w-full cursor-pointer items-center gap-4 border-b px-4 py-3 text-left transition-colors hover:bg-accent/50"
+			onClick={() => onEdit(alarm)}
+			type="button"
+		>
+			{/* Icon + Name */}
+			<div className="flex min-w-[200px] flex-1 items-center gap-3">
+				<div className="shrink-0 rounded bg-accent p-1.5 text-primary">
+					<BellIcon className="size-4" weight="duotone" />
+				</div>
+				<div className="flex flex-col items-start gap-0.5">
+					<p className="truncate font-medium text-foreground text-sm">
+						{alarm.name}
+					</p>
+					{alarm.description && (
+						<p className="line-clamp-1 text-muted-foreground text-xs">
+							{alarm.description}
+						</p>
+					)}
+				</div>
+			</div>
+
+			{/* Trigger Type */}
+			<div className="hidden w-[100px] shrink-0 sm:block">
+				<Badge className="font-normal" variant="secondary">
+					{TRIGGER_LABELS[alarm.triggerType] || alarm.triggerType}
+				</Badge>
+			</div>
+
+			{/* Channels */}
+			<div className="hidden w-[140px] shrink-0 md:block">
+				<div className="flex flex-wrap gap-1">
+					{channels.map((channel) => (
+						<Badge
+							className="font-normal text-xs"
+							key={channel}
+							variant="outline"
+						>
+							{channel}
+						</Badge>
+					))}
+				</div>
+			</div>
+
+			{/* Enable/Disable */}
+			<div
+				className="w-[100px] shrink-0"
+				onClick={(e) => e.stopPropagation()}
+				onKeyDown={(e) => e.stopPropagation()}
+				role="presentation"
+			>
+				<EnableToggle alarm={alarm} organizationId={organizationId} />
+			</div>
+
+			{/* Actions */}
+			<div
+				className="w-[50px] shrink-0"
+				onClick={(e) => e.stopPropagation()}
+				onKeyDown={(e) => e.stopPropagation()}
+				role="presentation"
+			>
+				<AlarmActions alarm={alarm} onDelete={onDelete} onEdit={onEdit} />
+			</div>
+		</button>
+	);
+}
+
+export function AlarmsList({
+	alarms,
+	organizationId,
+	onEdit,
+	onDelete,
+}: AlarmsListProps) {
+	return (
+		<div className="w-full overflow-x-auto">
+			{alarms.map((alarm) => (
+				<AlarmRow
+					alarm={alarm}
+					key={alarm.id}
+					onDelete={onDelete}
+					onEdit={onEdit}
+					organizationId={organizationId}
+				/>
+			))}
+		</div>
+	);
+}
+
+export function AlarmsListSkeleton() {
+	return (
+		<div className="w-full overflow-x-auto">
+			{Array.from({ length: 3 }).map((_, i) => (
+				<div
+					className="flex h-15 items-center gap-4 border-b px-4"
+					key={`skeleton-${i + 1}`}
+				>
+					<div className="flex min-w-[200px] flex-1 items-center gap-3">
+						<Skeleton className="size-7 rounded" />
+						<div className="space-y-1">
+							<Skeleton className="h-4 w-28" />
+							<Skeleton className="h-3 w-40" />
+						</div>
+					</div>
+					<div className="hidden w-[100px] shrink-0 sm:block">
+						<Skeleton className="h-5 w-16" />
+					</div>
+					<div className="hidden w-[140px] shrink-0 md:block">
+						<Skeleton className="h-5 w-20" />
+					</div>
+					<div className="w-[100px] shrink-0">
+						<Skeleton className="h-5 w-14" />
+					</div>
+					<div className="w-[50px] shrink-0">
+						<Skeleton className="size-8 rounded" />
+					</div>
+				</div>
+			))}
+		</div>
+	);
+}
diff --git a/apps/dashboard/app/(main)/settings/notifications/_components/types.ts b/apps/dashboard/app/(main)/settings/notifications/_components/types.ts
new file mode 100644
index 000000000..e084a2633
--- /dev/null
+++ b/apps/dashboard/app/(main)/settings/notifications/_components/types.ts
@@ -0,0 +1,21 @@
+export interface Alarm {
+	id: string;
+	name: string;
+	description: string | null;
+	enabled: boolean;
+	notificationChannels: unknown;
+	slackWebhookUrl: string | null;
+	discordWebhookUrl: string | null;
+	emailAddresses: unknown;
+	webhookUrl: string | null;
+	webhookHeaders: unknown;
+	triggerType: string;
+	triggerConditions: unknown;
+	websiteId: string | null;
+	organizationId: string | null;
+	userId: string | null;
+	createdBy: string;
+	createdAt: Date | string;
+	updatedAt: Date | string;
+	deletedAt: Date | string | null;
+}
diff --git a/apps/dashboard/app/(main)/settings/notifications/page.tsx b/apps/dashboard/app/(main)/settings/notifications/page.tsx
index cbc5a65b4..ed4c393b0 100644
--- a/apps/dashboard/app/(main)/settings/notifications/page.tsx
+++ b/apps/dashboard/app/(main)/settings/notifications/page.tsx
@@ -1,39 +1,199 @@
 "use client";
 
-import { BellIcon } from "@phosphor-icons/react";
+import { BellIcon, PlusIcon, SirenIcon } from "@phosphor-icons/react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useState } from "react";
+import { toast } from "sonner";
+import { useOrganizationsContext } from "@/components/providers/organizations-provider";
 import { RightSidebar } from "@/components/right-sidebar";
-import { ComingSoon } from "../_components/settings-section";
+import { Button } from "@/components/ui/button";
+import { DeleteDialog } from "@/components/ui/delete-dialog";
+import { orpc } from "@/lib/orpc";
+import { AlarmSheet } from "./_components/alarm-sheet";
+import { AlarmsList, AlarmsListSkeleton } from "./_components/alarms-list";
+import type { Alarm } from "./_components/types";
 
 export default function NotificationsSettingsPage() {
+	const { activeOrganization } = useOrganizationsContext();
+	const queryClient = useQueryClient();
+	const organizationId = activeOrganization?.id ?? "";
+
+	const [sheetOpen, setSheetOpen] = useState(false);
+	const [editingAlarm, setEditingAlarm] = useState<Alarm | null>(null);
+	const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+	const [deletingAlarmId, setDeletingAlarmId] = useState<string | null>(null);
+
+	const { data: alarmsList, isLoading } = useQuery({
+		...orpc.alarms.list.queryOptions({
+			input: { organizationId },
+		}),
+		enabled: Boolean(organizationId),
+	});
+
+	const deleteMutation = useMutation({
+		...orpc.alarms.delete.mutationOptions(),
+		onSuccess: () => {
+			toast.success("Alarm deleted successfully");
+			queryClient.invalidateQueries({
+				queryKey: orpc.alarms.list.key({
+					input: { organizationId },
+				}),
+			});
+			setDeleteDialogOpen(false);
+			setDeletingAlarmId(null);
+		},
+		onError: () => {
+			toast.error("Failed to delete alarm");
+		},
+	});
+
+	const handleCreate = () => {
+		setEditingAlarm(null);
+		setSheetOpen(true);
+	};
+
+	const handleEdit = (alarm: Alarm) => {
+		setEditingAlarm(alarm);
+		setSheetOpen(true);
+	};
+
+	const handleDelete = (alarmId: string) => {
+		setDeletingAlarmId(alarmId);
+		setDeleteDialogOpen(true);
+	};
+
+	const confirmDelete = () => {
+		if (deletingAlarmId) {
+			deleteMutation.mutate({ id: deletingAlarmId });
+		}
+	};
+
+	const alarms = (alarmsList as Alarm[] | undefined) ?? [];
+
+	if (!organizationId) {
+		return (
+			<div className="flex flex-1 flex-col items-center justify-center p-12 text-center">
+				<div className="mb-4 flex size-16 items-center justify-center rounded-full bg-accent">
+					<BellIcon className="size-8 text-muted-foreground" weight="duotone" />
+				</div>
+				<h2 className="font-semibold text-lg">No Workspace Selected</h2>
+				<p className="mt-1 max-w-sm text-muted-foreground text-sm">
+					Select a workspace to manage notification alarms.
+				</p>
+			</div>
+		);
+	}
+
 	return (
 		<div className="h-full lg:grid lg:grid-cols-[1fr_18rem]">
 			<div className="flex flex-col">
-				<ComingSoon
-					description="Configure email alerts, push notifications, and weekly reports. Stay informed about your analytics and account activity."
-					icon={
-						<BellIcon
-							className="size-8 text-muted-foreground"
-							weight="duotone"
-						/>
-					}
-					title="Notifications Coming Soon"
-				/>
+				{/* Header */}
+				<div className="flex items-center justify-between border-b px-5 py-4">
+					<div>
+						<h2 className="font-semibold text-lg">Notification Alarms</h2>
+						<p className="text-muted-foreground text-sm">
+							Configure alerts for traffic spikes, errors, uptime, and more.
+						</p>
+					</div>
+					<Button onClick={handleCreate} size="sm">
+						<PlusIcon className="mr-1.5" size={16} />
+						New Alarm
+					</Button>
+				</div>
+
+				{/* Content */}
+				{isLoading ? (
+					<AlarmsListSkeleton />
+				) : alarms.length === 0 ? (
+					<div className="flex flex-1 flex-col items-center justify-center p-12 text-center">
+						<div className="mb-4 flex size-16 items-center justify-center rounded-full bg-accent">
+							<SirenIcon
+								className="size-8 text-muted-foreground"
+								weight="duotone"
+							/>
+						</div>
+						<h2 className="font-semibold text-lg">No Alarms Yet</h2>
+						<p className="mt-1 max-w-sm text-muted-foreground text-sm">
+							Create your first alarm to get notified when something important
+							happens on your website.
+						</p>
+						<Button className="mt-4" onClick={handleCreate} size="sm">
+							<PlusIcon className="mr-1.5" size={16} />
+							Create Alarm
+						</Button>
+					</div>
+				) : (
+					<AlarmsList
+						alarms={alarms}
+						onDelete={handleDelete}
+						onEdit={handleEdit}
+						organizationId={organizationId}
+					/>
+				)}
 			</div>
 
 			<RightSidebar className="gap-0 p-0">
-				<RightSidebar.Section border title="Planned Alerts">
+				<RightSidebar.Section border title="Alert Types">
+					<div className="space-y-2 text-muted-foreground text-sm">
+						<p>
+							<span className="font-medium text-foreground">Uptime</span> - Get
+							alerted when your site goes down
+						</p>
+						<p>
+							<span className="font-medium text-foreground">Traffic Spike</span>{" "}
+							- Detect unusual traffic patterns
+						</p>
+						<p>
+							<span className="font-medium text-foreground">Error Rate</span> -
+							Monitor error rate thresholds
+						</p>
+						<p>
+							<span className="font-medium text-foreground">Goal</span> -
+							Notifications when goals are met
+						</p>
+						<p>
+							<span className="font-medium text-foreground">Custom</span> -
+							Define your own conditions
+						</p>
+					</div>
+				</RightSidebar.Section>
+
+				<RightSidebar.Section border title="Channels">
 					<div className="space-y-2 text-muted-foreground text-sm">
-						<p>• Traffic spike alerts</p>
-						<p>• Goal completion notifications</p>
-						<p>• Error rate warnings</p>
-						<p>• Weekly digest emails</p>
+						<p>
+							Send notifications via Slack, Discord, Email, or custom Webhooks.
+						</p>
 					</div>
 				</RightSidebar.Section>
 
 				<RightSidebar.Section>
-					<RightSidebar.Tip description="Soon you'll be able to receive alerts when traffic spikes, goals are met, or errors occur." />
+					<RightSidebar.Tip description="Create alarms to receive real-time notifications when important events occur on your website." />
 				</RightSidebar.Section>
 			</RightSidebar>
+
+			{/* Sheet for create/edit */}
+			<AlarmSheet
+				alarm={editingAlarm}
+				isOpen={sheetOpen}
+				onCloseAction={() => {
+					setSheetOpen(false);
+					setEditingAlarm(null);
+				}}
+				organizationId={organizationId}
+			/>
+
+			{/* Delete confirmation */}
+			<DeleteDialog
+				description="Are you sure you want to delete this alarm? It will stop sending notifications."
+				isDeleting={deleteMutation.isPending}
+				isOpen={deleteDialogOpen}
+				onClose={() => {
+					setDeleteDialogOpen(false);
+					setDeletingAlarmId(null);
+				}}
+				onConfirm={confirmDelete}
+				title="Delete Alarm"
+			/>
 		</div>
 	);
 }
diff --git a/packages/db/src/drizzle/relations.ts b/packages/db/src/drizzle/relations.ts
index c7cd62913..0408b3f60 100644
--- a/packages/db/src/drizzle/relations.ts
+++ b/packages/db/src/drizzle/relations.ts
@@ -1,6 +1,7 @@
 import { relations } from "drizzle-orm/relations";
 import {
 	account,
+	alarms,
 	apikey,
 	flags,
 	flagsToTargetGroups,
@@ -202,6 +203,26 @@ export const linksRelations = relations(links, ({ one }) => ({
 	}),
 }));
 
+export const alarmsRelations = relations(alarms, ({ one }) => ({
+	website: one(websites, {
+		fields: [alarms.websiteId],
+		references: [websites.id],
+	}),
+	organization: one(organization, {
+		fields: [alarms.organizationId],
+		references: [organization.id],
+	}),
+	user: one(user, {
+		fields: [alarms.userId],
+		references: [user.id],
+	}),
+	creator: one(user, {
+		fields: [alarms.createdBy],
+		references: [user.id],
+		relationName: "alarms_createdBy",
+	}),
+}));
+
 export const revenueConfigRelations = relations(revenueConfig, ({ one }) => ({
 	website: one(websites, {
 		fields: [revenueConfig.websiteId],
diff --git a/packages/db/src/drizzle/schema.ts b/packages/db/src/drizzle/schema.ts
index eab294446..5a7b7fff4 100644
--- a/packages/db/src/drizzle/schema.ts
+++ b/packages/db/src/drizzle/schema.ts
@@ -954,6 +954,78 @@ export const usageAlertLog = pgTable(
 	]
 );
 
+export const alarms = pgTable(
+	"alarms",
+	{
+		id: text().primaryKey().notNull(),
+		name: text().notNull(),
+		description: text(),
+		enabled: boolean().default(true).notNull(),
+		notificationChannels: jsonb("notification_channels").default([]),
+		slackWebhookUrl: text("slack_webhook_url"),
+		discordWebhookUrl: text("discord_webhook_url"),
+		emailAddresses: jsonb("email_addresses").default([]),
+		webhookUrl: text("webhook_url"),
+		webhookHeaders: jsonb("webhook_headers").default({}),
+		triggerType: text("trigger_type").notNull(),
+		triggerConditions: jsonb("trigger_conditions").default({}),
+		websiteId: text("website_id"),
+		organizationId: text("organization_id"),
+		userId: text("user_id"),
+		createdBy: text("created_by").notNull(),
+		createdAt: timestamp("created_at").defaultNow().notNull(),
+		updatedAt: timestamp("updated_at").defaultNow().notNull(),
+		deletedAt: timestamp("deleted_at"),
+	},
+	(table) => [
+		index("alarms_user_id_idx").using(
+			"btree",
+			table.userId.asc().nullsLast().op("text_ops")
+		),
+		index("alarms_organization_id_idx").using(
+			"btree",
+			table.organizationId.asc().nullsLast().op("text_ops")
+		),
+		index("alarms_website_id_idx").using(
+			"btree",
+			table.websiteId.asc().nullsLast().op("text_ops")
+		),
+		index("alarms_enabled_idx").using("btree", table.enabled.asc().nullsLast()),
+		index("alarms_created_by_idx").using(
+			"btree",
+			table.createdBy.asc().nullsLast().op("text_ops")
+		),
+		foreignKey({
+			columns: [table.websiteId],
+			foreignColumns: [websites.id],
+			name: "alarms_website_id_fkey",
+		})
+			.onUpdate("cascade")
+			.onDelete("cascade"),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organization.id],
+			name: "alarms_organization_id_fkey",
+		})
+			.onUpdate("cascade")
+			.onDelete("cascade"),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [user.id],
+			name: "alarms_user_id_fkey",
+		})
+			.onUpdate("cascade")
+			.onDelete("cascade"),
+		foreignKey({
+			columns: [table.createdBy],
+			foreignColumns: [user.id],
+			name: "alarms_created_by_fkey",
+		})
+			.onUpdate("cascade")
+			.onDelete("restrict"),
+	]
+);
+
 export const revenueConfig = pgTable(
 	"revenue_config",
 	{
diff --git a/packages/rpc/src/root.ts b/packages/rpc/src/root.ts
index 3451864cb..27d71d40e 100644
--- a/packages/rpc/src/root.ts
+++ b/packages/rpc/src/root.ts
@@ -1,4 +1,5 @@
 import { agentRouter } from "./routers/agent";
+import { alarmsRouter } from "./routers/alarms";
 import { annotationsRouter } from "./routers/annotations";
 import { apikeysRouter } from "./routers/apikeys";
 import { autocompleteRouter } from "./routers/autocomplete";
@@ -20,6 +21,7 @@ import { uptimeRouter } from "./routers/uptime";
 import { websitesRouter } from "./routers/websites";
 
 export const appRouter = {
+	alarms: alarmsRouter,
 	annotations: annotationsRouter,
 	websites: websitesRouter,
 	miniCharts: miniChartsRouter,
diff --git a/packages/rpc/src/routers/alarms.test.ts b/packages/rpc/src/routers/alarms.test.ts
new file mode 100644
index 000000000..8a9a2c37d
--- /dev/null
+++ b/packages/rpc/src/routers/alarms.test.ts
@@ -0,0 +1,200 @@
+import { describe, expect, it } from "bun:test";
+import {
+	alarmFormSchema,
+	createAlarmSchema,
+	updateAlarmSchema,
+	listAlarmsSchema,
+	triggerTypeSchema,
+	notificationChannelSchema,
+} from "@databuddy/shared/alarms";
+
+describe("Alarm validation schemas", () => {
+	describe("notificationChannelSchema", () => {
+		it("accepts valid channels", () => {
+			expect(notificationChannelSchema.parse("slack")).toBe("slack");
+			expect(notificationChannelSchema.parse("discord")).toBe("discord");
+			expect(notificationChannelSchema.parse("email")).toBe("email");
+			expect(notificationChannelSchema.parse("webhook")).toBe("webhook");
+		});
+
+		it("rejects invalid channels", () => {
+			expect(() => notificationChannelSchema.parse("sms")).toThrow();
+			expect(() => notificationChannelSchema.parse("")).toThrow();
+		});
+	});
+
+	describe("triggerTypeSchema", () => {
+		it("accepts valid trigger types", () => {
+			expect(triggerTypeSchema.parse("uptime")).toBe("uptime");
+			expect(triggerTypeSchema.parse("traffic_spike")).toBe("traffic_spike");
+			expect(triggerTypeSchema.parse("error_rate")).toBe("error_rate");
+			expect(triggerTypeSchema.parse("goal")).toBe("goal");
+			expect(triggerTypeSchema.parse("custom")).toBe("custom");
+		});
+
+		it("rejects invalid trigger types", () => {
+			expect(() => triggerTypeSchema.parse("invalid")).toThrow();
+		});
+	});
+
+	describe("alarmFormSchema", () => {
+		it("validates a minimal valid alarm", () => {
+			const result = alarmFormSchema.parse({
+				name: "Test Alarm",
+				triggerType: "uptime",
+			});
+			expect(result.name).toBe("Test Alarm");
+			expect(result.triggerType).toBe("uptime");
+			expect(result.enabled).toBe(true);
+			expect(result.notificationChannels).toEqual([]);
+		});
+
+		it("validates a full alarm form", () => {
+			const result = alarmFormSchema.parse({
+				name: "Full Alarm",
+				description: "A complete alarm",
+				enabled: false,
+				notificationChannels: ["slack", "email"],
+				slackWebhookUrl: "https://hooks.slack.com/services/test",
+				discordWebhookUrl: "",
+				emailAddresses: ["user@example.com"],
+				webhookUrl: "",
+				webhookHeaders: { Authorization: "Bearer token" },
+				triggerType: "traffic_spike",
+				triggerConditions: { threshold: 1000 },
+			});
+			expect(result.name).toBe("Full Alarm");
+			expect(result.notificationChannels).toEqual(["slack", "email"]);
+			expect(result.emailAddresses).toEqual(["user@example.com"]);
+		});
+
+		it("rejects empty name", () => {
+			expect(() =>
+				alarmFormSchema.parse({
+					name: "",
+					triggerType: "uptime",
+				})
+			).toThrow();
+		});
+
+		it("rejects name exceeding 100 characters", () => {
+			expect(() =>
+				alarmFormSchema.parse({
+					name: "a".repeat(101),
+					triggerType: "uptime",
+				})
+			).toThrow();
+		});
+
+		it("rejects invalid email addresses", () => {
+			expect(() =>
+				alarmFormSchema.parse({
+					name: "Test",
+					triggerType: "uptime",
+					emailAddresses: ["not-an-email"],
+				})
+			).toThrow();
+		});
+
+		it("rejects invalid webhook URLs", () => {
+			expect(() =>
+				alarmFormSchema.parse({
+					name: "Test",
+					triggerType: "uptime",
+					webhookUrl: "not-a-url",
+				})
+			).toThrow();
+		});
+	});
+
+	describe("createAlarmSchema", () => {
+		it("requires websiteId or organizationId", () => {
+			expect(() =>
+				createAlarmSchema.parse({
+					name: "Test",
+					triggerType: "uptime",
+				})
+			).toThrow("Either websiteId or organizationId must be provided");
+		});
+
+		it("accepts valid input with organizationId", () => {
+			const result = createAlarmSchema.parse({
+				name: "Test Alarm",
+				triggerType: "uptime",
+				organizationId: "org-123",
+			});
+			expect(result.organizationId).toBe("org-123");
+		});
+
+		it("accepts valid input with websiteId", () => {
+			const result = createAlarmSchema.parse({
+				name: "Test Alarm",
+				triggerType: "error_rate",
+				websiteId: "web-123",
+			});
+			expect(result.websiteId).toBe("web-123");
+		});
+	});
+
+	describe("updateAlarmSchema", () => {
+		it("requires id", () => {
+			expect(() => updateAlarmSchema.parse({})).toThrow();
+		});
+
+		it("allows partial updates", () => {
+			const result = updateAlarmSchema.parse({
+				id: "alarm-123",
+				name: "Updated Name",
+			});
+			expect(result.id).toBe("alarm-123");
+			expect(result.name).toBe("Updated Name");
+			expect(result.description).toBeUndefined();
+		});
+
+		it("validates optional fields when provided", () => {
+			const result = updateAlarmSchema.parse({
+				id: "alarm-123",
+				enabled: false,
+				notificationChannels: ["discord"],
+				triggerType: "goal",
+			});
+			expect(result.enabled).toBe(false);
+			expect(result.notificationChannels).toEqual(["discord"]);
+			expect(result.triggerType).toBe("goal");
+		});
+
+		it("allows nullable fields", () => {
+			const result = updateAlarmSchema.parse({
+				id: "alarm-123",
+				description: null,
+				slackWebhookUrl: null,
+				discordWebhookUrl: null,
+				webhookUrl: null,
+			});
+			expect(result.description).toBeNull();
+			expect(result.slackWebhookUrl).toBeNull();
+		});
+	});
+
+	describe("listAlarmsSchema", () => {
+		it("requires websiteId or organizationId", () => {
+			expect(() => listAlarmsSchema.parse({})).toThrow(
+				"Either websiteId or organizationId must be provided"
+			);
+		});
+
+		it("accepts organizationId", () => {
+			const result = listAlarmsSchema.parse({
+				organizationId: "org-123",
+			});
+			expect(result.organizationId).toBe("org-123");
+		});
+
+		it("accepts websiteId", () => {
+			const result = listAlarmsSchema.parse({
+				websiteId: "web-123",
+			});
+			expect(result.websiteId).toBe("web-123");
+		});
+	});
+});
diff --git a/packages/rpc/src/routers/alarms.ts b/packages/rpc/src/routers/alarms.ts
new file mode 100644
index 000000000..90637ac76
--- /dev/null
+++ b/packages/rpc/src/routers/alarms.ts
@@ -0,0 +1,501 @@
+import { websitesApi } from "@databuddy/auth";
+import { alarms, and, desc, eq, isNull, member, websites } from "@databuddy/db";
+import {
+	sendDiscordWebhook,
+	sendSlackWebhook,
+	sendWebhook,
+} from "@databuddy/notifications";
+import {
+	createAlarmSchema,
+	deleteAlarmSchema,
+	getAlarmSchema,
+	listAlarmsSchema,
+	testAlarmSchema,
+	updateAlarmSchema,
+} from "@databuddy/shared/alarms";
+import { ORPCError } from "@orpc/server";
+import { randomUUIDv7 } from "bun";
+import { z } from "zod";
+import type { Context } from "../orpc";
+import { protectedProcedure } from "../orpc";
+import { authorizeWebsiteAccess } from "../utils/auth";
+
+const authorizeScope = async (
+	context: Context,
+	websiteId?: string,
+	organizationId?: string,
+	permission: "read" | "update" | "delete" = "read"
+) => {
+	if (websiteId) {
+		await authorizeWebsiteAccess(context, websiteId, permission);
+	} else if (organizationId) {
+		const headersObj: Record<string, string> = {};
+		context.headers.forEach((value, key) => {
+			headersObj[key] = value;
+		});
+		const perm = permission === "read" ? "read" : "create";
+		try {
+			const { success } = await websitesApi.hasPermission({
+				headers: headersObj,
+				body: {
+					organizationId,
+					permissions: { website: [perm] },
+				},
+			});
+			if (!success) {
+				throw new ORPCError("FORBIDDEN", {
+					message: "Missing organization permissions.",
+				});
+			}
+		} catch (error) {
+			if (error instanceof ORPCError) {
+				throw error;
+			}
+			throw new ORPCError("FORBIDDEN", {
+				message: "Missing organization permissions.",
+			});
+		}
+	}
+};
+
+const successOutputSchema = z.object({ success: z.literal(true) });
+const alarmOutputSchema = z.record(z.string(), z.unknown());
+
+export const alarmsRouter = {
+	list: protectedProcedure
+		.route({
+			description: "Returns all alarms for a website or organization.",
+			method: "POST",
+			path: "/alarms/list",
+			summary: "List alarms",
+			tags: ["Alarms"],
+		})
+		.input(listAlarmsSchema)
+		.output(z.array(alarmOutputSchema))
+		.handler(async ({ context, input }) => {
+			await authorizeScope(
+				context,
+				input.websiteId,
+				input.organizationId,
+				"read"
+			);
+
+			const conditions = [isNull(alarms.deletedAt)];
+
+			if (input.websiteId) {
+				conditions.push(eq(alarms.websiteId, input.websiteId));
+			} else if (input.organizationId) {
+				conditions.push(eq(alarms.organizationId, input.organizationId));
+			}
+
+			const alarmsList = await context.db
+				.select()
+				.from(alarms)
+				.where(and(...conditions))
+				.orderBy(desc(alarms.createdAt));
+
+			return alarmsList;
+		}),
+
+	get: protectedProcedure
+		.route({
+			description: "Returns a single alarm by ID.",
+			method: "POST",
+			path: "/alarms/get",
+			summary: "Get alarm",
+			tags: ["Alarms"],
+		})
+		.input(getAlarmSchema)
+		.output(alarmOutputSchema)
+		.handler(async ({ context, input }) => {
+			const alarm = await context.db
+				.select()
+				.from(alarms)
+				.where(and(eq(alarms.id, input.id), isNull(alarms.deletedAt)))
+				.limit(1);
+
+			if (alarm.length === 0) {
+				throw new ORPCError("NOT_FOUND", {
+					message: "Alarm not found",
+				});
+			}
+
+			const found = alarm[0];
+
+			if (found.websiteId) {
+				await authorizeWebsiteAccess(context, found.websiteId, "read");
+			} else if (found.organizationId) {
+				await authorizeScope(context, undefined, found.organizationId, "read");
+			}
+
+			return found;
+		}),
+
+	create: protectedProcedure
+		.route({
+			description: "Creates a new alarm.",
+			method: "POST",
+			path: "/alarms/create",
+			summary: "Create alarm",
+			tags: ["Alarms"],
+		})
+		.input(createAlarmSchema)
+		.output(alarmOutputSchema)
+		.handler(async ({ context, input }) => {
+			await authorizeScope(
+				context,
+				input.websiteId,
+				input.organizationId,
+				"update"
+			);
+
+			let createdBy: string;
+			if (context.user) {
+				createdBy = context.user.id;
+			} else if (context.apiKey) {
+				const orgId =
+					input.organizationId ??
+					(input.websiteId
+						? (
+								await context.db
+									.select({ organizationId: websites.organizationId })
+									.from(websites)
+									.where(eq(websites.id, input.websiteId))
+									.limit(1)
+							)[0]?.organizationId
+						: null);
+				if (!orgId) {
+					throw new ORPCError("FORBIDDEN", {
+						message: "Scope must belong to a workspace",
+					});
+				}
+				const resolvedOrgId = context.apiKey.organizationId ?? orgId;
+				const [ownerRow] = await context.db
+					.select({ userId: member.userId })
+					.from(member)
+					.where(
+						and(
+							eq(member.organizationId, resolvedOrgId),
+							eq(member.role, "owner")
+						)
+					)
+					.limit(1);
+				if (!ownerRow) {
+					throw new ORPCError("FORBIDDEN", {
+						message: "Could not resolve organization owner for API key",
+					});
+				}
+				createdBy = ownerRow.userId;
+			} else {
+				throw new ORPCError("UNAUTHORIZED", {
+					message: "Authentication is required",
+				});
+			}
+
+			const alarmId = randomUUIDv7();
+
+			const [newAlarm] = await context.db
+				.insert(alarms)
+				.values({
+					id: alarmId,
+					name: input.name,
+					description: input.description || null,
+					enabled: input.enabled ?? true,
+					notificationChannels: input.notificationChannels || [],
+					slackWebhookUrl: input.slackWebhookUrl || null,
+					discordWebhookUrl: input.discordWebhookUrl || null,
+					emailAddresses: input.emailAddresses || [],
+					webhookUrl: input.webhookUrl || null,
+					webhookHeaders: input.webhookHeaders || {},
+					triggerType: input.triggerType,
+					triggerConditions: input.triggerConditions || {},
+					websiteId: input.websiteId || null,
+					organizationId: input.organizationId || null,
+					userId: context.user?.id || null,
+					createdBy,
+				})
+				.returning();
+
+			return newAlarm;
+		}),
+
+	update: protectedProcedure
+		.route({
+			description: "Updates an existing alarm.",
+			method: "POST",
+			path: "/alarms/update",
+			summary: "Update alarm",
+			tags: ["Alarms"],
+		})
+		.input(updateAlarmSchema)
+		.output(alarmOutputSchema)
+		.handler(async ({ context, input }) => {
+			const existing = await context.db
+				.select()
+				.from(alarms)
+				.where(and(eq(alarms.id, input.id), isNull(alarms.deletedAt)))
+				.limit(1);
+
+			if (existing.length === 0) {
+				throw new ORPCError("NOT_FOUND", {
+					message: "Alarm not found",
+				});
+			}
+
+			const alarm = existing[0];
+
+			if (alarm.websiteId) {
+				await authorizeWebsiteAccess(context, alarm.websiteId, "update");
+			} else if (alarm.organizationId) {
+				await authorizeScope(
+					context,
+					undefined,
+					alarm.organizationId,
+					"update"
+				);
+			}
+
+			const { id, ...updates } = input;
+
+			// Clean up empty string URLs to null
+			const cleanedUpdates: Record<string, unknown> = { ...updates };
+			for (const key of [
+				"slackWebhookUrl",
+				"discordWebhookUrl",
+				"webhookUrl",
+			]) {
+				if (key in cleanedUpdates && cleanedUpdates[key] === "") {
+					cleanedUpdates[key] = null;
+				}
+			}
+
+			const [updatedAlarm] = await context.db
+				.update(alarms)
+				.set({
+					...cleanedUpdates,
+					updatedAt: new Date(),
+				})
+				.where(and(eq(alarms.id, id), isNull(alarms.deletedAt)))
+				.returning();
+
+			return updatedAlarm;
+		}),
+
+	delete: protectedProcedure
+		.route({
+			description: "Soft-deletes an alarm.",
+			method: "POST",
+			path: "/alarms/delete",
+			summary: "Delete alarm",
+			tags: ["Alarms"],
+		})
+		.input(deleteAlarmSchema)
+		.output(successOutputSchema)
+		.handler(async ({ context, input }) => {
+			const existing = await context.db
+				.select({
+					websiteId: alarms.websiteId,
+					organizationId: alarms.organizationId,
+				})
+				.from(alarms)
+				.where(and(eq(alarms.id, input.id), isNull(alarms.deletedAt)))
+				.limit(1);
+
+			if (existing.length === 0) {
+				throw new ORPCError("NOT_FOUND", {
+					message: "Alarm not found",
+				});
+			}
+
+			const alarm = existing[0];
+
+			if (alarm.websiteId) {
+				await authorizeWebsiteAccess(context, alarm.websiteId, "delete");
+			} else if (alarm.organizationId) {
+				await authorizeScope(
+					context,
+					undefined,
+					alarm.organizationId,
+					"delete"
+				);
+			}
+
+			await context.db
+				.update(alarms)
+				.set({
+					deletedAt: new Date(),
+					enabled: false,
+				})
+				.where(and(eq(alarms.id, input.id), isNull(alarms.deletedAt)));
+
+			return { success: true as const };
+		}),
+
+	test: protectedProcedure
+		.route({
+			description: "Sends a test notification for an alarm.",
+			method: "POST",
+			path: "/alarms/test",
+			summary: "Test alarm notification",
+			tags: ["Alarms"],
+		})
+		.input(testAlarmSchema)
+		.output(
+			z.object({
+				success: z.boolean(),
+				results: z.array(
+					z.object({
+						channel: z.string(),
+						success: z.boolean(),
+						error: z.string().optional(),
+					})
+				),
+			})
+		)
+		.handler(async ({ context, input }) => {
+			const existing = await context.db
+				.select()
+				.from(alarms)
+				.where(and(eq(alarms.id, input.id), isNull(alarms.deletedAt)))
+				.limit(1);
+
+			if (existing.length === 0) {
+				throw new ORPCError("NOT_FOUND", {
+					message: "Alarm not found",
+				});
+			}
+
+			const alarm = existing[0];
+
+			if (alarm.websiteId) {
+				await authorizeWebsiteAccess(context, alarm.websiteId, "update");
+			} else if (alarm.organizationId) {
+				await authorizeScope(
+					context,
+					undefined,
+					alarm.organizationId,
+					"update"
+				);
+			}
+
+			const channels = (alarm.notificationChannels as string[]) || [];
+			const testPayload = {
+				title: `Test Alert: ${alarm.name}`,
+				message: `This is a test notification from your alarm "${alarm.name}". If you receive this, your notification channel is configured correctly.`,
+				priority: "normal" as const,
+			};
+
+			const results: Array<{
+				channel: string;
+				success: boolean;
+				error?: string;
+			}> = [];
+
+			for (const channel of channels) {
+				try {
+					switch (channel) {
+						case "slack": {
+							if (alarm.slackWebhookUrl) {
+								const result = await sendSlackWebhook(
+									alarm.slackWebhookUrl,
+									testPayload
+								);
+								results.push({
+									channel: "slack",
+									success: result.success,
+									error: result.error,
+								});
+							} else {
+								results.push({
+									channel: "slack",
+									success: false,
+									error: "No Slack webhook URL configured",
+								});
+							}
+							break;
+						}
+						case "discord": {
+							if (alarm.discordWebhookUrl) {
+								const result = await sendDiscordWebhook(
+									alarm.discordWebhookUrl,
+									testPayload
+								);
+								results.push({
+									channel: "discord",
+									success: result.success,
+									error: result.error,
+								});
+							} else {
+								results.push({
+									channel: "discord",
+									success: false,
+									error: "No Discord webhook URL configured",
+								});
+							}
+							break;
+						}
+						case "webhook": {
+							if (alarm.webhookUrl) {
+								const result = await sendWebhook(
+									alarm.webhookUrl,
+									testPayload,
+									{
+										headers:
+											(alarm.webhookHeaders as Record<string, string>) ||
+											undefined,
+									}
+								);
+								results.push({
+									channel: "webhook",
+									success: result.success,
+									error: result.error,
+								});
+							} else {
+								results.push({
+									channel: "webhook",
+									success: false,
+									error: "No webhook URL configured",
+								});
+							}
+							break;
+						}
+						case "email": {
+							// Email sending requires an email provider configured at app level
+							results.push({
+								channel: "email",
+								success: false,
+								error:
+									"Email notifications require server-side email configuration",
+							});
+							break;
+						}
+						default:
+							results.push({
+								channel,
+								success: false,
+								error: `Unknown channel: ${channel}`,
+							});
+					}
+				} catch (err) {
+					results.push({
+						channel,
+						success: false,
+						error: err instanceof Error ? err.message : String(err),
+					});
+				}
+			}
+
+			if (channels.length === 0) {
+				results.push({
+					channel: "none",
+					success: false,
+					error: "No notification channels configured for this alarm",
+				});
+			}
+
+			return {
+				success: results.some((r) => r.success),
+				results,
+			};
+		}),
+};
diff --git a/packages/shared/package.json b/packages/shared/package.json
index 1478adedb..1e7461a8e 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -31,6 +31,7 @@
     "./types/sessions": "./src/types/sessions.ts",
     "./types/vercel": "./src/types/vercel.ts",
     "./types/website": "./src/types/website.ts",
+    "./alarms": "./src/alarms/index.ts",
     "./flags": "./src/flags/index.ts",
     "./flags/utils": "./src/flags/utils.ts",
     "./utils/date-utils": "./src/utils/date-utils.ts",
diff --git a/packages/shared/src/alarms/index.ts b/packages/shared/src/alarms/index.ts
new file mode 100644
index 000000000..7122e5747
--- /dev/null
+++ b/packages/shared/src/alarms/index.ts
@@ -0,0 +1,99 @@
+import { z } from "zod";
+
+export const notificationChannelSchema = z.enum([
+	"slack",
+	"discord",
+	"email",
+	"webhook",
+]);
+
+export type NotificationChannel = z.infer<typeof notificationChannelSchema>;
+
+export const triggerTypeSchema = z.enum([
+	"uptime",
+	"traffic_spike",
+	"error_rate",
+	"goal",
+	"custom",
+]);
+
+export type TriggerType = z.infer<typeof triggerTypeSchema>;
+
+export const alarmFormSchema = z.object({
+	name: z.string().min(1, "Name is required").max(100, "Name too long"),
+	description: z.string().max(500).optional(),
+	enabled: z.boolean().default(true),
+	notificationChannels: z.array(notificationChannelSchema).default([]),
+	slackWebhookUrl: z
+		.string()
+		.url("Invalid Slack webhook URL")
+		.optional()
+		.or(z.literal("")),
+	discordWebhookUrl: z
+		.string()
+		.url("Invalid Discord webhook URL")
+		.optional()
+		.or(z.literal("")),
+	emailAddresses: z
+		.array(z.string().email("Invalid email address"))
+		.default([]),
+	webhookUrl: z
+		.string()
+		.url("Invalid webhook URL")
+		.optional()
+		.or(z.literal("")),
+	webhookHeaders: z.record(z.string(), z.string()).default({}),
+	triggerType: triggerTypeSchema,
+	triggerConditions: z.record(z.string(), z.unknown()).default({}),
+	websiteId: z.string().optional(),
+});
+
+export type AlarmForm = z.infer<typeof alarmFormSchema>;
+
+export const createAlarmSchema = z
+	.object({
+		websiteId: z.string().optional(),
+		organizationId: z.string().optional(),
+		...alarmFormSchema.shape,
+	})
+	.refine((data) => data.websiteId || data.organizationId, {
+		message: "Either websiteId or organizationId must be provided",
+		path: ["websiteId"],
+	});
+
+export const updateAlarmSchema = z.object({
+	id: z.string(),
+	name: z.string().min(1).max(100).optional(),
+	description: z.string().max(500).optional().nullable(),
+	enabled: z.boolean().optional(),
+	notificationChannels: z.array(notificationChannelSchema).optional(),
+	slackWebhookUrl: z.string().url().optional().or(z.literal("")).nullable(),
+	discordWebhookUrl: z.string().url().optional().or(z.literal("")).nullable(),
+	emailAddresses: z.array(z.string().email()).optional(),
+	webhookUrl: z.string().url().optional().or(z.literal("")).nullable(),
+	webhookHeaders: z.record(z.string(), z.string()).optional(),
+	triggerType: triggerTypeSchema.optional(),
+	triggerConditions: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const listAlarmsSchema = z
+	.object({
+		websiteId: z.string().optional(),
+		organizationId: z.string().optional(),
+	})
+	.refine((data) => data.websiteId || data.organizationId, {
+		message: "Either websiteId or organizationId must be provided",
+		path: ["websiteId"],
+	});
+
+export const getAlarmSchema = z.object({
+	id: z.string(),
+});
+
+export const deleteAlarmSchema = z.object({
+	id: z.string(),
+});
+
+export const testAlarmSchema = z.object({
+	id: z.string(),
+});