diff --git a/.gitignore b/.gitignore
index 924ba9d16..8ea6e109c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,6 +34,7 @@ packages/db/src/drizzle/meta/0000_snapshot.json
 packages/db/src/drizzle/meta/_journal.json
 packages/db/src/drizzle/meta
 packages/db/src/drizzle/*.sql
+!packages/db/src/drizzle/0001_alarms.sql
 dist
 
 
diff --git a/apps/dashboard/app/(main)/settings/notifications/page.tsx b/apps/dashboard/app/(main)/settings/notifications/page.tsx
index cbc5a65b4..600f598c2 100644
--- a/apps/dashboard/app/(main)/settings/notifications/page.tsx
+++ b/apps/dashboard/app/(main)/settings/notifications/page.tsx
@@ -1,39 +1,263 @@
 "use client";
 
-import { BellIcon } from "@phosphor-icons/react";
+import {
+	BellIcon,
+	CheckCircleIcon,
+	PencilSimpleIcon,
+	PaperPlaneTiltIcon,
+	PlusIcon,
+	TrashIcon,
+	WarningCircleIcon,
+} from "@phosphor-icons/react";
+import { useEffect, useState } from "react";
+import { useSearchParams } from "next/navigation";
+import { toast } from "sonner";
+import { AlarmDialog } from "@/components/alarms/alarm-dialog";
+import { EmptyState } from "@/components/empty-state";
 import { RightSidebar } from "@/components/right-sidebar";
-import { ComingSoon } from "../_components/settings-section";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { DeleteDialog } from "@/components/ui/delete-dialog";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Switch } from "@/components/ui/switch";
+import { useAlarms, useDeleteAlarm, useTestAlarm, useUpdateAlarm } from "@/hooks/use-alarms";
+import { useWebsitesLight } from "@/hooks/use-websites";
+import { SettingsSection } from "../_components/settings-section";
+
+const channelBadgeVariants: Record<string, "default" | "gray" | "green" | "amber"> = {
+	slack: "default",
+	discord: "gray",
+	email: "green",
+	webhook: "amber",
+};
 
 export default function NotificationsSettingsPage() {
+	const { alarms, isLoading } = useAlarms();
+	const { websites } = useWebsitesLight();
+	const updateAlarm = useUpdateAlarm();
+	const deleteAlarm = useDeleteAlarm();
+	const testAlarm = useTestAlarm();
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [editingAlarmId, setEditingAlarmId] = useState<string | null>(null);
+	const [deleteTargetId, setDeleteTargetId] = useState<string | null>(null);
+	const [testingId, setTestingId] = useState<string | null>(null);
+	const searchParams = useSearchParams();
+
+	const editingAlarm = alarms.find((alarm) => alarm.id === editingAlarmId) ?? null;
+	const deleteTarget = alarms.find((alarm) => alarm.id === deleteTargetId) ?? null;
+
+	const websiteLookup = new Map(
+		websites.map((site) => [site.id, site.name || site.domain])
+	);
+
+	const isDialogForcedOpen = searchParams.get("alarmDialog") === "open";
+
+	useEffect(() => {
+		if (isDialogForcedOpen) {
+			setDialogOpen(true);
+		}
+	}, [isDialogForcedOpen]);
+
+	const handleToggle = async (alarmId: string, enabled: boolean) => {
+		try {
+			await updateAlarm.mutateAsync({ id: alarmId, enabled });
+			toast.success(enabled ? "Alarm enabled" : "Alarm disabled");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to update alarm";
+			toast.error(message);
+		}
+	};
+
+	const handleDelete = async () => {
+		if (!deleteTargetId) {
+			return;
+		}
+		try {
+			await deleteAlarm.mutateAsync({ id: deleteTargetId });
+			toast.success("Alarm deleted");
+			setDeleteTargetId(null);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to delete alarm";
+			toast.error(message);
+		}
+	};
+
+	const handleTest = async (alarmId: string) => {
+		setTestingId(alarmId);
+		try {
+			const result = await testAlarm.mutateAsync({ id: alarmId });
+			const successes = result.results.filter((entry) => entry.success).length;
+			if (successes > 0) {
+				toast.success(`Test sent to ${successes} channel(s).`);
+			} else {
+				toast.error("Test notification failed.");
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to send test notification";
+			toast.error(message);
+		} finally {
+			setTestingId(null);
+		}
+	};
+
 	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"
-				/>
+				<SettingsSection
+					title="Alarms"
+					description="Create alarms to notify your team when critical events happen."
+				>
+					<div className="flex flex-col gap-4">
+						<div className="flex flex-wrap items-center justify-between gap-3">
+							<div>
+								<p className="font-medium text-sm">Notification alarms</p>
+								<p className="text-muted-foreground text-xs">
+									Manage your alerting rules and channels.
+								</p>
+							</div>
+							<Button onClick={() => setDialogOpen(true)} size="sm">
+								<PlusIcon className="mr-2 size-4" /> Create alarm
+							</Button>
+						</div>
+
+						{isLoading ? (
+							<div className="space-y-3">
+								{Array.from({ length: 3 }).map((_, index) => (
+									<Skeleton key={`alarm-skeleton-${index}`} className="h-24 w-full rounded" />
+								))}
+							</div>
+						) : alarms.length === 0 ? (
+							<EmptyState
+								action={{ label: "Create alarm", onClick: () => setDialogOpen(true) }}
+								description="Add your first alarm to receive uptime and analytics notifications."
+								icon={<BellIcon className="text-muted-foreground" />}
+								title="No alarms yet"
+								variant="minimal"
+							/>
+						) : (
+							<div className="space-y-4">
+								{alarms.map((alarm) => (
+									<div
+										className="rounded border bg-card p-4"
+										key={alarm.id}
+									>
+										<div className="flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between">
+											<div className="space-y-2">
+												<div className="flex items-center gap-2">
+													<h4 className="font-semibold text-sm">{alarm.name}</h4>
+													{alarm.enabled ? (
+														<CheckCircleIcon className="size-4 text-emerald-500" />
+													) : (
+														<WarningCircleIcon className="size-4 text-muted-foreground" />
+													)}
+												</div>
+												{alarm.description && (
+													<p className="text-muted-foreground text-xs">
+														{alarm.description}
+													</p>
+												)}
+												<div className="flex flex-wrap items-center gap-2">
+													<Badge variant="gray">{alarm.triggerType}</Badge>
+													{alarm.triggerType === "uptime" && alarm.triggerConditions?.failureThreshold && (
+														<Badge variant="gray">
+															{alarm.triggerConditions.failureThreshold} failures
+														</Badge>
+													)}
+													{alarm.websiteId && (
+														<Badge variant="gray">
+															{websiteLookup.get(alarm.websiteId) ?? "Website"}
+														</Badge>
+													)}
+													{alarm.notificationChannels.map((channel) => (
+														<Badge
+															key={`${alarm.id}-${channel}`}
+															variant={channelBadgeVariants[channel] ?? "gray"}
+														>
+															{channel}
+														</Badge>
+													))}
+												</div>
+											</div>
+
+											<div className="flex flex-wrap items-center gap-2">
+												<div className="flex items-center gap-2">
+													<Switch
+														checked={alarm.enabled}
+														onCheckedChange={(checked) => handleToggle(alarm.id, checked)}
+													/>
+													<span className="text-xs text-muted-foreground">
+														{alarm.enabled ? "Enabled" : "Disabled"}
+													</span>
+												</div>
+												<Button
+													disabled={testingId === alarm.id || testAlarm.isPending}
+													onClick={() => handleTest(alarm.id)}
+													size="sm"
+													variant="secondary"
+												>
+													<PaperPlaneTiltIcon className="mr-2 size-4" /> Test
+												</Button>
+												<Button
+													onClick={() => {
+													setEditingAlarmId(alarm.id);
+													setDialogOpen(true);
+												}}
+													size="sm"
+													variant="outline"
+												>
+													<PencilSimpleIcon className="mr-2 size-4" /> Edit
+												</Button>
+												<Button
+													onClick={() => setDeleteTargetId(alarm.id)}
+													size="icon"
+													variant="ghost"
+												>
+													<TrashIcon className="size-4" />
+												</Button>
+											</div>
+										</div>
+									</div>
+								))}
+							</div>
+						)}
+					</div>
+				</SettingsSection>
 			</div>
 
 			<RightSidebar className="gap-0 p-0">
-				<RightSidebar.Section border title="Planned Alerts">
+				<RightSidebar.Section border title="Notification checklist">
 					<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>• Connect Slack, Discord, Email, or webhook channels</p>
+						<p>• Assign alarms to specific websites</p>
+						<p>• Test delivery before enabling</p>
+						<p>• Adjust failure thresholds to avoid noise</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="Uptime alerts trigger only when the failure threshold is met, helping prevent notification spam." />
 				</RightSidebar.Section>
 			</RightSidebar>
+
+			<AlarmDialog
+				alarm={editingAlarm}
+				onOpenChange={(open) => {
+					if (!open) {
+						setEditingAlarmId(null);
+					}
+					setDialogOpen(open);
+				}}
+				onSaved={() => setEditingAlarmId(null)}
+				open={dialogOpen}
+			/>
+
+			<DeleteDialog
+				onClose={() => setDeleteTargetId(null)}
+				onConfirm={handleDelete}
+				isDeleting={deleteAlarm.isPending}
+				isOpen={!!deleteTargetId}
+				title="Delete alarm"
+				itemName={deleteTarget?.name}
+			/>
 		</div>
 	);
 }
diff --git a/apps/dashboard/app/(main)/websites/[id]/pulse/_components/alarm-assignments.tsx b/apps/dashboard/app/(main)/websites/[id]/pulse/_components/alarm-assignments.tsx
new file mode 100644
index 000000000..e5cb0089a
--- /dev/null
+++ b/apps/dashboard/app/(main)/websites/[id]/pulse/_components/alarm-assignments.tsx
@@ -0,0 +1,148 @@
+"use client";
+
+import {
+	BellIcon,
+	CheckCircleIcon,
+	PlusIcon,
+	XCircleIcon,
+} from "@phosphor-icons/react";
+import { useState } from "react";
+import { toast } from "sonner";
+import { AlarmDialog } from "@/components/alarms/alarm-dialog";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { useAlarms, useUpdateAlarm, type Alarm } from "@/hooks/use-alarms";
+
+interface AlarmAssignmentsProps {
+	websiteId: string;
+}
+
+export function AlarmAssignments({ websiteId }: AlarmAssignmentsProps) {
+	const { alarms, isLoading } = useAlarms();
+	const updateAlarm = useUpdateAlarm();
+	const [selectedAlarmId, setSelectedAlarmId] = useState<string>("");
+	const [dialogOpen, setDialogOpen] = useState(false);
+
+	const assigned = alarms.filter((alarm) => alarm.websiteId === websiteId);
+	const available = alarms.filter((alarm) => !alarm.websiteId);
+
+	const handleAssign = async (alarmId: string) => {
+		if (!alarmId) {
+			return;
+		}
+		try {
+			await updateAlarm.mutateAsync({ id: alarmId, websiteId });
+			toast.success("Alarm assigned to website");
+			setSelectedAlarmId("");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to assign alarm";
+			toast.error(message);
+		}
+	};
+
+	const handleUnassign = async (alarm: Alarm) => {
+		try {
+			await updateAlarm.mutateAsync({ id: alarm.id, websiteId: null });
+			toast.success("Alarm removed from website");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to remove alarm";
+			toast.error(message);
+		}
+	};
+
+	return (
+		<div className="space-y-4 rounded border bg-card p-4">
+			<div className="flex flex-wrap items-center justify-between gap-3">
+				<div>
+					<div className="flex items-center gap-2">
+						<BellIcon className="size-4" weight="duotone" />
+						<h3 className="font-semibold text-sm">Assigned alarms</h3>
+					</div>
+					<p className="text-muted-foreground text-xs">
+						Attach alarms to this website to receive uptime notifications.
+					</p>
+				</div>
+				<Button onClick={() => setDialogOpen(true)} size="sm">
+					<PlusIcon className="mr-2 size-4" /> New alarm
+				</Button>
+			</div>
+
+			<div className="flex flex-col gap-3">
+				<Select
+					disabled={isLoading || available.length === 0}
+					onValueChange={(value) => {
+						setSelectedAlarmId(value);
+						void handleAssign(value);
+					}}
+					value={selectedAlarmId}
+				>
+					<SelectTrigger>
+						<SelectValue
+							placeholder={
+								available.length === 0
+									? "No unassigned alarms"
+									: "Quick-assign existing alarm"
+							}
+						/>
+					</SelectTrigger>
+					<SelectContent>
+						{available.map((alarm) => (
+							<SelectItem key={alarm.id} value={alarm.id}>
+								{alarm.name}
+							</SelectItem>
+						))}
+					</SelectContent>
+				</Select>
+
+				{assigned.length === 0 ? (
+					<div className="rounded border border-dashed p-4 text-center text-muted-foreground text-sm">
+						No alarms assigned yet.
+					</div>
+				) : (
+					<div className="space-y-3">
+						{assigned.map((alarm) => (
+							<div
+								className="flex flex-col gap-3 rounded border p-3 sm:flex-row sm:items-center sm:justify-between"
+								key={alarm.id}
+							>
+								<div className="space-y-1">
+									<div className="flex items-center gap-2">
+										<p className="font-medium text-sm">{alarm.name}</p>
+										{alarm.enabled ? (
+											<CheckCircleIcon className="size-4 text-emerald-500" />
+										) : (
+											<XCircleIcon className="size-4 text-muted-foreground" />
+										)}
+									</div>
+									<div className="flex flex-wrap items-center gap-2">
+										{alarm.notificationChannels.map((channel) => (
+											<Badge key={`${alarm.id}-${channel}`} variant="gray">
+												{channel}
+											</Badge>
+										))}
+									</div>
+								</div>
+								<Button
+									onClick={() => handleUnassign(alarm)}
+									size="sm"
+									variant="outline"
+								>
+									Remove
+								</Button>
+							</div>
+						))}
+					</div>
+				)}
+			</div>
+
+			<AlarmDialog
+				defaultWebsiteId={websiteId}
+				lockWebsite
+				onOpenChange={setDialogOpen}
+				onSaved={() => setDialogOpen(false)}
+				open={dialogOpen}
+			/>
+		</div>
+	);
+}
diff --git a/apps/dashboard/app/(main)/websites/[id]/pulse/page.tsx b/apps/dashboard/app/(main)/websites/[id]/pulse/page.tsx
index ae6b67f77..5f79a1962 100644
--- a/apps/dashboard/app/(main)/websites/[id]/pulse/page.tsx
+++ b/apps/dashboard/app/(main)/websites/[id]/pulse/page.tsx
@@ -31,6 +31,7 @@ import { useWebsite } from "@/hooks/use-websites";
 import { orpc } from "@/lib/orpc";
 import { fromNow, localDayjs } from "@/lib/time";
 import { WebsitePageHeader } from "../_components/website-page-header";
+import { AlarmAssignments } from "./_components/alarm-assignments";
 import { RecentActivity } from "./_components/recent-activity";
 import { UptimeHeatmap } from "./_components/uptime-heatmap";
 
@@ -359,6 +360,10 @@ export default function PulsePage() {
 								isLoading={isLoadingUptime}
 							/>
 						</div>
+
+						<div className="bg-sidebar px-4 py-6">
+							<AlarmAssignments websiteId={websiteId as string} />
+						</div>
 					</>
 				) : (
 					<div className="flex h-full items-center justify-center p-4">
diff --git a/apps/dashboard/app/(main)/websites/[id]/uptime/page.tsx b/apps/dashboard/app/(main)/websites/[id]/uptime/page.tsx
new file mode 100644
index 000000000..dad2e4b9a
--- /dev/null
+++ b/apps/dashboard/app/(main)/websites/[id]/uptime/page.tsx
@@ -0,0 +1 @@
+export { default } from "../pulse/page";
diff --git a/apps/dashboard/components/alarms/alarm-dialog.tsx b/apps/dashboard/components/alarms/alarm-dialog.tsx
new file mode 100644
index 000000000..b059465ef
--- /dev/null
+++ b/apps/dashboard/components/alarms/alarm-dialog.tsx
@@ -0,0 +1,644 @@
+"use client";
+
+import { zodResolver } from "@hookform/resolvers/zod";
+import {
+	BellIcon,
+	LightningIcon,
+	PlusIcon,
+	TrashIcon,
+} from "@phosphor-icons/react";
+import { useEffect, useMemo } from "react";
+import { useFieldArray, useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { useOrganizationsContext } from "@/components/providers/organizations-provider";
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+import {
+	Form,
+	FormControl,
+	FormDescription,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { TagsChat } from "@/components/ui/tags";
+import { Textarea } from "@/components/ui/textarea";
+import { useWebsitesLight } from "@/hooks/use-websites";
+import { useCreateAlarm, useUpdateAlarm, type Alarm } from "@/hooks/use-alarms";
+import { cn } from "@/lib/utils";
+
+const alarmChannelOptions = [
+	{ value: "slack", label: "Slack" },
+	{ value: "discord", label: "Discord" },
+	{ value: "email", label: "Email" },
+	{ value: "webhook", label: "Webhook" },
+] as const;
+
+const triggerTypeOptions = [
+	{ value: "uptime", label: "Uptime" },
+	{ value: "traffic_spike", label: "Traffic Spike" },
+	{ value: "error_rate", label: "Error Rate" },
+	{ value: "goal", label: "Goal" },
+	{ value: "custom", label: "Custom" },
+] as const;
+
+const alarmFormSchema = z
+	.object({
+		name: z.string().min(1, "Name is required").max(200),
+		description: z.string().max(500).optional(),
+		enabled: z.boolean(),
+		websiteId: z.string().optional().nullable(),
+		triggerType: z.enum([
+			"uptime",
+			"traffic_spike",
+			"error_rate",
+			"goal",
+			"custom",
+		]),
+		failureThreshold: z
+			.number()
+			.int()
+			.min(1, "Must be at least 1")
+			.max(20, "Must be 20 or fewer")
+			.optional(),
+		notificationChannels: z
+			.array(z.enum(["slack", "discord", "email", "webhook"]))
+			.min(1, "Select at least one notification channel"),
+		slackWebhookUrl: z.string().url().optional().nullable(),
+		discordWebhookUrl: z.string().url().optional().nullable(),
+		emailAddresses: z.array(z.string().email()).default([]),
+		webhookUrl: z.string().url().optional().nullable(),
+		webhookHeaders: z.array(
+			z.object({
+				key: z.string().min(1, "Header key required"),
+				value: z.string().min(1, "Header value required"),
+			})
+		),
+	})
+	.superRefine((data, ctx) => {
+		if (data.notificationChannels.includes("slack") && !data.slackWebhookUrl) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Slack webhook URL is required",
+				path: ["slackWebhookUrl"],
+			});
+		}
+		if (
+			data.notificationChannels.includes("discord") &&
+			!data.discordWebhookUrl
+		) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Discord webhook URL is required",
+				path: ["discordWebhookUrl"],
+			});
+		}
+		if (data.notificationChannels.includes("email") && data.emailAddresses.length === 0) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Add at least one email address",
+				path: ["emailAddresses"],
+			});
+		}
+		if (data.notificationChannels.includes("webhook") && !data.webhookUrl) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Webhook URL is required",
+				path: ["webhookUrl"],
+			});
+		}
+		if (data.triggerType === "uptime" && !data.failureThreshold) {
+			ctx.addIssue({
+				code: "custom",
+				message: "Set a failure threshold for uptime alarms",
+				path: ["failureThreshold"],
+			});
+		}
+	});
+
+type AlarmFormValues = z.infer<typeof alarmFormSchema>;
+
+const defaultValues: AlarmFormValues = {
+	name: "",
+	description: "",
+	enabled: true,
+	websiteId: null,
+	triggerType: "uptime",
+	failureThreshold: 3,
+	notificationChannels: ["email"],
+	slackWebhookUrl: null,
+	discordWebhookUrl: null,
+	emailAddresses: [],
+	webhookUrl: null,
+	webhookHeaders: [],
+};
+
+function mapHeadersToArray(headers: Record<string, string> | null): Array<{ key: string; value: string }> {
+	if (!headers) {
+		return [];
+	}
+	return Object.entries(headers).map(([key, value]) => ({ key, value }));
+}
+
+function mapHeadersToRecord(headers: Array<{ key: string; value: string }>): Record<string, string> {
+	return headers.reduce<Record<string, string>>((acc, header) => {
+		const trimmedKey = header.key.trim();
+		const trimmedValue = header.value.trim();
+		if (trimmedKey && trimmedValue) {
+			acc[trimmedKey] = trimmedValue;
+		}
+		return acc;
+	}, {});
+}
+
+interface AlarmDialogProps {
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+	alarm?: Alarm | null;
+	defaultWebsiteId?: string;
+	lockWebsite?: boolean;
+	onSaved?: () => void;
+}
+
+export function AlarmDialog({
+	open,
+	onOpenChange,
+	alarm,
+	defaultWebsiteId,
+	lockWebsite = false,
+	onSaved,
+}: AlarmDialogProps) {
+	const { activeOrganization } = useOrganizationsContext();
+	const { websites } = useWebsitesLight();
+	const createAlarm = useCreateAlarm();
+	const updateAlarm = useUpdateAlarm();
+
+	const initialValues = useMemo<AlarmFormValues>(() => {
+		if (!alarm) {
+			return {
+				...defaultValues,
+				websiteId: defaultWebsiteId ?? null,
+			};
+		}
+		return {
+			name: alarm.name,
+			description: alarm.description ?? "",
+			enabled: alarm.enabled,
+			websiteId: alarm.websiteId ?? null,
+			triggerType: alarm.triggerType,
+			failureThreshold: alarm.triggerConditions?.failureThreshold ?? 3,
+			notificationChannels: alarm.notificationChannels,
+			slackWebhookUrl: alarm.slackWebhookUrl ?? null,
+			discordWebhookUrl: alarm.discordWebhookUrl ?? null,
+			emailAddresses: alarm.emailAddresses,
+			webhookUrl: alarm.webhookUrl ?? null,
+			webhookHeaders: mapHeadersToArray(alarm.webhookHeaders ?? null),
+		};
+	}, [alarm, defaultWebsiteId]);
+
+	const form = useForm<AlarmFormValues>({
+		resolver: zodResolver(alarmFormSchema),
+		defaultValues: initialValues,
+	});
+
+	const { reset } = form;
+
+	useEffect(() => {
+		if (open) {
+			reset(initialValues);
+		}
+	}, [initialValues, open, reset]);
+
+	const { fields, append, remove } = useFieldArray({
+		control: form.control,
+		name: "webhookHeaders",
+	});
+
+	const channelValues = form.watch("notificationChannels");
+	const triggerType = form.watch("triggerType");
+
+	const isSaving = createAlarm.isPending || updateAlarm.isPending;
+
+	const handleSubmit = async (values: AlarmFormValues) => {
+		if (!activeOrganization?.id) {
+			toast.error("Select a workspace to save alarms.");
+			return;
+		}
+
+		const payload = {
+			organizationId: activeOrganization.id,
+			websiteId: values.websiteId ?? undefined,
+			name: values.name.trim(),
+			description: values.description?.trim() || undefined,
+			enabled: values.enabled,
+			notificationChannels: values.notificationChannels,
+			slackWebhookUrl: values.slackWebhookUrl ?? undefined,
+			discordWebhookUrl: values.discordWebhookUrl ?? undefined,
+			emailAddresses: values.emailAddresses,
+			webhookUrl: values.webhookUrl ?? undefined,
+			webhookHeaders: mapHeadersToRecord(values.webhookHeaders),
+			triggerType: values.triggerType,
+			triggerConditions: {
+				failureThreshold:
+					values.triggerType === "uptime" ? values.failureThreshold : undefined,
+			},
+		};
+
+		try {
+			if (alarm) {
+				await updateAlarm.mutateAsync({ id: alarm.id, ...payload });
+				toast.success("Alarm updated");
+			} else {
+				await createAlarm.mutateAsync(payload);
+				toast.success("Alarm created");
+			}
+			onSaved?.();
+			onOpenChange(false);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Failed to save alarm";
+			toast.error(message);
+		}
+	};
+
+	return (
+		<Dialog onOpenChange={onOpenChange} open={open}>
+			<DialogContent className="max-h-[85vh] overflow-y-auto">
+				<DialogHeader>
+					<DialogTitle>{alarm ? "Edit Alarm" : "Create Alarm"}</DialogTitle>
+					<DialogDescription>
+						Configure notification channels and triggers for this alarm.
+					</DialogDescription>
+				</DialogHeader>
+				<Form {...form}>
+					<form className="space-y-6" onSubmit={form.handleSubmit(handleSubmit)}>
+						<div className="space-y-4">
+							<div className="flex items-center justify-between rounded border bg-secondary px-4 py-3">
+								<div>
+									<p className="font-medium text-sm">Enabled</p>
+									<p className="text-muted-foreground text-xs">
+										Turn alarms on or off.
+									</p>
+								</div>
+								<FormField
+									control={form.control}
+									name="enabled"
+									render={({ field }) => (
+										<FormItem>
+											<FormControl>
+												<Switch
+													checked={field.value}
+													onCheckedChange={field.onChange}
+												/>
+											</FormControl>
+										</FormItem>
+									)}
+								/>
+							</div>
+
+							<FormField
+								control={form.control}
+								name="name"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Alarm name</FormLabel>
+										<FormControl>
+											<Input placeholder="Uptime alert" {...field} />
+										</FormControl>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<FormField
+								control={form.control}
+								name="description"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Description</FormLabel>
+										<FormControl>
+											<Textarea
+												placeholder="Optional details about this alarm"
+												rows={3}
+												{...field}
+											/>
+										</FormControl>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
+							<FormField
+								control={form.control}
+								name="websiteId"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Website</FormLabel>
+										<FormControl>
+											<Select
+												disabled={lockWebsite}
+												onValueChange={(value) =>
+													field.onChange(value === "none" ? null : value)
+												}
+												value={field.value ?? "none"}
+											>
+												<SelectTrigger>
+													<SelectValue placeholder="Assign to a website" />
+												</SelectTrigger>
+												<SelectContent>
+													<SelectItem value="none">No website</SelectItem>
+													{websites.map((site) => (
+														<SelectItem key={site.id} value={site.id}>
+															{site.name || site.domain}
+														</SelectItem>
+													))}
+												</SelectContent>
+											</Select>
+										</FormControl>
+										<FormDescription>
+											Assign alarms to a specific website for uptime triggers.
+										</FormDescription>
+									</FormItem>
+								)}
+							/>
+						</div>
+
+						<div className="space-y-4 rounded border p-4">
+							<div className="flex items-center gap-2">
+								<LightningIcon className="size-4" weight="duotone" />
+								<p className="font-medium text-sm">Trigger</p>
+							</div>
+							<FormField
+								control={form.control}
+								name="triggerType"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Trigger type</FormLabel>
+										<FormControl>
+											<Select
+												onValueChange={field.onChange}
+												value={field.value}
+											>
+												<SelectTrigger>
+													<SelectValue placeholder="Select a trigger" />
+												</SelectTrigger>
+												<SelectContent>
+													{triggerTypeOptions.map((option) => (
+														<SelectItem key={option.value} value={option.value}>
+															{option.label}
+														</SelectItem>
+													))}
+												</SelectContent>
+											</Select>
+										</FormControl>
+									</FormItem>
+								)}
+							/>
+
+							{triggerType === "uptime" && (
+								<FormField
+									control={form.control}
+									name="failureThreshold"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Consecutive failures</FormLabel>
+											<FormControl>
+												<Input
+													min={1}
+													step={1}
+													type="number"
+													value={field.value ?? ""}
+													onChange={(event) =>
+														field.onChange(
+															event.target.value
+																? Number.parseInt(event.target.value, 10)
+																: undefined
+														)
+													}
+												/>
+											</FormControl>
+											<FormDescription>
+												Alert after this many consecutive failures.
+											</FormDescription>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							)}
+						</div>
+
+						<div className="space-y-4 rounded border p-4">
+							<div className="flex items-center gap-2">
+								<BellIcon className="size-4" weight="duotone" />
+								<p className="font-medium text-sm">Notification channels</p>
+							</div>
+							<div className="grid gap-3 sm:grid-cols-2">
+								{alarmChannelOptions.map((channel) => (
+									<div
+										className={cn(
+											"flex items-center gap-2 rounded border p-3",
+											channelValues.includes(channel.value) &&
+												"border-primary/40 bg-primary/5"
+										)}
+										key={channel.value}
+									>
+										<Checkbox
+											checked={channelValues.includes(channel.value)}
+											onCheckedChange={(checked) => {
+												const next = checked
+													? [...channelValues, channel.value]
+													: channelValues.filter(
+															(item) => item !== channel.value
+														);
+												form.setValue("notificationChannels", next, {
+													shouldValidate: true,
+												});
+											}}
+										/>
+										<span className="text-sm">{channel.label}</span>
+									</div>
+								))}
+							</div>
+							{form.formState.errors.notificationChannels?.message && (
+								<p className="text-destructive text-sm">
+									{form.formState.errors.notificationChannels.message}
+								</p>
+							)}
+
+							{channelValues.includes("slack") && (
+								<FormField
+									control={form.control}
+									name="slackWebhookUrl"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Slack webhook URL</FormLabel>
+											<FormControl>
+												<Input
+													placeholder="https://hooks.slack.com/..."
+													value={field.value ?? ""}
+													onChange={(event) => field.onChange(event.target.value)}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							)}
+
+							{channelValues.includes("discord") && (
+								<FormField
+									control={form.control}
+									name="discordWebhookUrl"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Discord webhook URL</FormLabel>
+											<FormControl>
+												<Input
+													placeholder="https://discord.com/api/webhooks/..."
+													value={field.value ?? ""}
+													onChange={(event) => field.onChange(event.target.value)}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							)}
+
+							{channelValues.includes("email") && (
+								<FormField
+									control={form.control}
+									name="emailAddresses"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Email recipients</FormLabel>
+											<FormControl>
+												<TagsChat
+													className="rounded"
+													onChange={field.onChange}
+													placeholder="Type an email and press Enter"
+													values={field.value}
+												/>
+											</FormControl>
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+							)}
+
+							{channelValues.includes("webhook") && (
+								<div className="space-y-4">
+									<FormField
+										control={form.control}
+										name="webhookUrl"
+										render={({ field }) => (
+											<FormItem>
+												<FormLabel>Webhook URL</FormLabel>
+												<FormControl>
+													<Input
+														placeholder="https://example.com/webhooks"
+														value={field.value ?? ""}
+														onChange={(event) => field.onChange(event.target.value)}
+													/>
+												</FormControl>
+												<FormMessage />
+											</FormItem>
+										)}
+									/>
+
+									<div className="space-y-2">
+										<div className="flex items-center justify-between">
+											<Label>Webhook headers</Label>
+											<Button
+												onClick={() => append({ key: "", value: "" })}
+												size="sm"
+												type="button"
+												variant="outline"
+											>
+												<PlusIcon className="mr-2 size-3" /> Add header
+											</Button>
+										</div>
+										{fields.length === 0 ? (
+											<p className="text-muted-foreground text-xs">
+												No headers configured.
+											</p>
+										) : (
+											<div className="space-y-2">
+												{fields.map((field, index) => (
+													<div
+														className="flex flex-col gap-2 sm:flex-row"
+														key={field.id}
+													>
+														<FormField
+															control={form.control}
+															name={`webhookHeaders.${index}.key`}
+															render={({ field: keyField }) => (
+																<FormItem className="flex-1">
+																	<FormControl>
+																		<Input
+																			placeholder="Header name"
+																			{...keyField}
+																		/>
+																	</FormControl>
+																</FormItem>
+															)}
+														/>
+														<FormField
+															control={form.control}
+															name={`webhookHeaders.${index}.value`}
+															render={({ field: valueField }) => (
+																<FormItem className="flex-1">
+																	<FormControl>
+																		<Input
+																			placeholder="Header value"
+																			{...valueField}
+																		/>
+																	</FormControl>
+																</FormItem>
+															)}
+														/>
+														<Button
+															aria-label="Remove header"
+															className="shrink-0"
+															onClick={() => remove(index)}
+															size="icon"
+															type="button"
+															variant="ghost"
+														>
+															<TrashIcon className="size-4" />
+														</Button>
+													</div>
+												))}
+											</div>
+										)}
+									</div>
+								</div>
+							)}
+						</div>
+					</form>
+				</Form>
+				<DialogFooter className="gap-2">
+					<Button onClick={() => onOpenChange(false)} variant="outline">
+						Cancel
+					</Button>
+					<Button disabled={isSaving} onClick={form.handleSubmit(handleSubmit)}>
+						{alarm ? "Save Alarm" : "Create Alarm"}
+					</Button>
+				</DialogFooter>
+			</DialogContent>
+		</Dialog>
+	);
+}
diff --git a/apps/dashboard/hooks/use-alarms.ts b/apps/dashboard/hooks/use-alarms.ts
new file mode 100644
index 000000000..f6531c356
--- /dev/null
+++ b/apps/dashboard/hooks/use-alarms.ts
@@ -0,0 +1,151 @@
+"use client";
+
+import type { InferSelectModel, alarms } from "@databuddy/db";
+import type { QueryKey } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useOrganizationsContext } from "@/components/providers/organizations-provider";
+import { orpc } from "@/lib/orpc";
+
+export type Alarm = InferSelectModel<typeof alarms>;
+
+export const getAlarmsListKey = (
+	organizationId?: string,
+	websiteId?: string
+): QueryKey =>
+	orpc.alarms.list.queryKey({
+		input: {
+			organizationId: organizationId ?? "",
+			websiteId,
+		},
+	});
+
+const addAlarmToList = (old: Alarm[] | undefined, alarm: Alarm): Alarm[] => {
+	if (!old) {
+		return [alarm];
+	}
+	if (old.some((item) => item.id === alarm.id)) {
+		return old;
+	}
+	return [alarm, ...old];
+};
+
+const updateAlarmInList = (old: Alarm[] | undefined, alarm: Alarm): Alarm[] => {
+	if (!old) {
+		return [alarm];
+	}
+	return old.map((item) => (item.id === alarm.id ? alarm : item));
+};
+
+const removeAlarmFromList = (
+	old: Alarm[] | undefined,
+	alarmId: string
+): Alarm[] => {
+	if (!old) {
+		return [];
+	}
+	return old.filter((item) => item.id !== alarmId);
+};
+
+export function useAlarms(options?: { enabled?: boolean; websiteId?: string }) {
+	const { activeOrganization, isLoading: isLoadingOrganization } =
+		useOrganizationsContext();
+
+	const query = useQuery({
+		...orpc.alarms.list.queryOptions({
+			input: {
+				organizationId: activeOrganization?.id ?? "",
+				websiteId: options?.websiteId,
+			},
+		}),
+		enabled:
+			options?.enabled !== false &&
+			!isLoadingOrganization &&
+			!!activeOrganization?.id,
+	});
+
+	return {
+		alarms: query.data ?? [],
+		isLoading: query.isLoading || isLoadingOrganization,
+		isFetching: query.isFetching,
+		isError: query.isError,
+		refetch: query.refetch,
+	};
+}
+
+export function useCreateAlarm() {
+	const queryClient = useQueryClient();
+	const { activeOrganization } = useOrganizationsContext();
+
+	return useMutation({
+		...orpc.alarms.create.mutationOptions(),
+		onSuccess: (alarm: Alarm) => {
+			const listKey = getAlarmsListKey(activeOrganization?.id);
+			queryClient.setQueryData<Alarm[]>(listKey, (old) =>
+				addAlarmToList(old, alarm)
+			);
+			if (alarm.websiteId) {
+				const websiteKey = getAlarmsListKey(
+					activeOrganization?.id,
+					alarm.websiteId
+				);
+				queryClient.setQueryData<Alarm[]>(websiteKey, (old) =>
+					addAlarmToList(old, alarm)
+				);
+			}
+		},
+	});
+}
+
+export function useUpdateAlarm() {
+	const queryClient = useQueryClient();
+	const { activeOrganization } = useOrganizationsContext();
+
+	return useMutation({
+		...orpc.alarms.update.mutationOptions(),
+		onSuccess: (alarm: Alarm) => {
+			const listKey = getAlarmsListKey(activeOrganization?.id);
+			queryClient.setQueryData<Alarm[]>(listKey, (old) =>
+				updateAlarmInList(old, alarm)
+			);
+			if (alarm.websiteId) {
+				const websiteKey = getAlarmsListKey(
+					activeOrganization?.id,
+					alarm.websiteId
+				);
+				queryClient.setQueryData<Alarm[]>(websiteKey, (old) =>
+					updateAlarmInList(old, alarm)
+				);
+			}
+		},
+	});
+}
+
+export function useDeleteAlarm() {
+	const queryClient = useQueryClient();
+	const { activeOrganization } = useOrganizationsContext();
+
+	return useMutation({
+		...orpc.alarms.delete.mutationOptions(),
+		onSuccess: (alarm: Alarm) => {
+			const listKey = getAlarmsListKey(activeOrganization?.id);
+			queryClient.setQueryData<Alarm[]>(listKey, (old) =>
+				removeAlarmFromList(old, alarm.id)
+			);
+			if (alarm.websiteId) {
+				const websiteKey = getAlarmsListKey(
+					activeOrganization?.id,
+					alarm.websiteId
+				);
+				queryClient.setQueryData<Alarm[]>(websiteKey, (old) =>
+					removeAlarmFromList(old, alarm.id)
+				);
+			}
+		},
+	});
+}
+
+export function useTestAlarm() {
+	return useMutation({
+		...orpc.alarms.test.mutationOptions(),
+	});
+}
diff --git a/apps/uptime/package.json b/apps/uptime/package.json
index 204e96adc..b33c62337 100644
--- a/apps/uptime/package.json
+++ b/apps/uptime/package.json
@@ -7,6 +7,8 @@
   },
   "dependencies": {
     "@databuddy/db": "workspace:*",
+    "@databuddy/notifications": "workspace:*",
+    "@databuddy/shared": "workspace:*",
     "@databuddy/services": "workspace:*",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.208.0",
@@ -15,8 +17,10 @@
     "@opentelemetry/sdk-trace-node": "^2.2.0",
     "@opentelemetry/semantic-conventions": "^1.38.0",
     "@upstash/qstash": "^2.8.4",
+    "dayjs": "^1.11.19",
     "elysia": "^1.4.18",
     "kafkajs": "^2.2.4",
+    "resend": "^4.2.0",
     "zod": "^4.2.0"
   }
 }
diff --git a/apps/uptime/src/alarms-runtime.ts b/apps/uptime/src/alarms-runtime.ts
new file mode 100644
index 000000000..71853b895
--- /dev/null
+++ b/apps/uptime/src/alarms-runtime.ts
@@ -0,0 +1,58 @@
+import {
+	and,
+	alarmState,
+	alarmTriggerHistory,
+	alarms,
+	db,
+	eq,
+	inArray,
+} from "@databuddy/db";
+import {
+	createNotificationSenders,
+	processUptimeAlarmsWithDeps,
+	type AlarmRecord,
+	type AlarmStateRecord,
+} from "./alarms";
+import type { UptimeData } from "./types";
+
+export async function processUptimeAlarms(
+	uptimeData: UptimeData,
+	websiteId: string | null
+): Promise<void> {
+	return processUptimeAlarmsWithDeps(uptimeData, websiteId, {
+		fetchAlarms: async (targetWebsiteId: string) =>
+			db.query.alarms.findMany({
+				where: and(
+					eq(alarms.websiteId, targetWebsiteId),
+					eq(alarms.enabled, true),
+					eq(alarms.triggerType, "uptime")
+				),
+			}) as Promise<AlarmRecord[]>,
+		fetchStates: async (alarmIds: string[], targetWebsiteId: string) =>
+			db.query.alarmState.findMany({
+				where: and(
+					inArray(alarmState.alarmId, alarmIds),
+					eq(alarmState.websiteId, targetWebsiteId)
+				),
+			}) as Promise<AlarmStateRecord[]>,
+		upsertState: async (state) => {
+			await db
+				.insert(alarmState)
+				.values(state)
+				.onConflictDoUpdate({
+					target: [alarmState.alarmId, alarmState.websiteId],
+					set: {
+						status: state.status,
+						consecutiveFailures: state.consecutiveFailures,
+						downStartedAt: state.downStartedAt,
+						lastCheckedAt: state.lastCheckedAt,
+						updatedAt: state.updatedAt,
+					},
+				});
+		},
+		logHistory: async (entry) => {
+			await db.insert(alarmTriggerHistory).values(entry);
+		},
+		senders: createNotificationSenders(),
+	});
+}
diff --git a/apps/uptime/src/alarms.test.ts b/apps/uptime/src/alarms.test.ts
new file mode 100644
index 000000000..a3af458ab
--- /dev/null
+++ b/apps/uptime/src/alarms.test.ts
@@ -0,0 +1,231 @@
+import { describe, expect, it } from "bun:test";
+import type { NotificationPayload, NotificationResult } from "@databuddy/notifications";
+import type { AlarmRecord, AlarmStateRecord, AlarmTriggerDetails } from "./alarms";
+import { processUptimeAlarmsWithDeps } from "./alarms";
+import type { UptimeData } from "./types";
+
+const baseUptimeData: UptimeData = {
+	site_id: "site-1",
+	url: "https://example.com",
+	timestamp: Date.now(),
+	status: 0,
+	http_code: 503,
+	ttfb_ms: 120,
+	total_ms: 240,
+	attempt: 1,
+	retries: 0,
+	failure_streak: 0,
+	response_bytes: 0,
+	content_hash: "",
+	redirect_count: 0,
+	probe_region: "us-east",
+	probe_ip: "127.0.0.1",
+	ssl_expiry: 0,
+	ssl_valid: 0,
+	env: "test",
+	check_type: "http",
+	user_agent: "test",
+	error: "",
+};
+
+type AlarmStateUpsert = {
+	alarmId: string;
+	websiteId: string;
+	status: "up" | "down";
+	consecutiveFailures: number;
+	downStartedAt: Date | null;
+	lastCheckedAt: Date;
+	updatedAt: Date;
+};
+
+type AlarmHistoryEntry = {
+	id: string;
+	alarmId: string;
+	websiteId: string;
+	status: "down" | "up";
+	details: AlarmTriggerDetails;
+	triggeredAt: Date;
+};
+
+describe("processUptimeAlarmsWithDeps", () => {
+	it("triggers after threshold and avoids duplicates", async () => {
+		const alarm: AlarmRecord = {
+			id: "alarm-1",
+			userId: "user-1",
+			organizationId: "org-1",
+			websiteId: "site-1",
+			name: "Uptime Alarm",
+			description: null,
+			enabled: true,
+			notificationChannels: ["slack", "discord", "email", "webhook"],
+			slackWebhookUrl: "https://hooks.slack.com/services/test",
+			discordWebhookUrl: "https://discord.com/api/webhooks/test",
+			emailAddresses: ["alerts@databuddy.cc"],
+			webhookUrl: "https://example.com/webhook",
+			webhookHeaders: { Authorization: "Bearer token" },
+			triggerType: "uptime",
+			triggerConditions: { failureThreshold: 2 },
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+
+		const states: AlarmStateRecord[] = [];
+		const histories: AlarmHistoryEntry[] = [];
+		const sentChannels: string[] = [];
+
+		const deps = {
+			fetchAlarms: async () => [alarm],
+			fetchStates: async () => states,
+			upsertState: async (state: AlarmStateUpsert) => {
+				const index = states.findIndex((s) => s.alarmId === state.alarmId);
+				if (index >= 0) {
+					states[index] = { ...states[index], ...state };
+				} else {
+					states.push(state);
+				}
+			},
+			logHistory: async (entry: AlarmHistoryEntry) => {
+				histories.push(entry);
+			},
+			senders: {
+				slack: async (_url: string, _payload: NotificationPayload) => {
+					sentChannels.push("slack");
+					const result: NotificationResult = {
+						success: true,
+						channel: "slack",
+					};
+					return result;
+				},
+				discord: async (_url: string, _payload: NotificationPayload) => {
+					sentChannels.push("discord");
+					const result: NotificationResult = {
+						success: true,
+						channel: "discord",
+					};
+					return result;
+				},
+				email: async (_payload: NotificationPayload & { to: string | string[] }) => {
+					sentChannels.push("email");
+					const result: NotificationResult = {
+						success: true,
+						channel: "email",
+					};
+					return result;
+				},
+				webhook: async (
+					_url: string,
+					_payload: NotificationPayload,
+					_headers: Record<string, string>
+				) => {
+					sentChannels.push("webhook");
+					const result: NotificationResult = {
+						success: true,
+						channel: "webhook",
+					};
+					return result;
+				},
+			},
+		};
+
+		await processUptimeAlarmsWithDeps(
+			{ ...baseUptimeData, timestamp: Date.now(), status: 0 },
+			"site-1",
+			deps
+		);
+		expect(histories).toHaveLength(0);
+
+		await processUptimeAlarmsWithDeps(
+			{ ...baseUptimeData, timestamp: Date.now() + 1000, status: 0 },
+			"site-1",
+			deps
+		);
+		expect(histories).toHaveLength(1);
+		expect(sentChannels).toHaveLength(4);
+
+		await processUptimeAlarmsWithDeps(
+			{ ...baseUptimeData, timestamp: Date.now() + 2000, status: 0 },
+			"site-1",
+			deps
+		);
+		expect(histories).toHaveLength(1);
+	});
+
+	it("sends recovery notification and logs history", async () => {
+		const alarm: AlarmRecord = {
+			id: "alarm-2",
+			userId: "user-1",
+			organizationId: "org-1",
+			websiteId: "site-1",
+			name: "Recovery Alarm",
+			description: null,
+			enabled: true,
+			notificationChannels: ["slack", "discord"],
+			slackWebhookUrl: "https://hooks.slack.com/services/test",
+			discordWebhookUrl: "https://discord.com/api/webhooks/test",
+			emailAddresses: [],
+			webhookUrl: null,
+			webhookHeaders: {},
+			triggerType: "uptime",
+			triggerConditions: { failureThreshold: 1 },
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+
+		const states: AlarmStateRecord[] = [];
+		const histories: AlarmHistoryEntry[] = [];
+		const sentChannels: string[] = [];
+
+		const deps = {
+			fetchAlarms: async () => [alarm],
+			fetchStates: async () => states,
+			upsertState: async (state: AlarmStateUpsert) => {
+				const index = states.findIndex((s) => s.alarmId === state.alarmId);
+				if (index >= 0) {
+					states[index] = { ...states[index], ...state };
+				} else {
+					states.push(state);
+				}
+			},
+			logHistory: async (entry: AlarmHistoryEntry) => {
+				histories.push(entry);
+			},
+			senders: {
+				slack: async (_url: string, _payload: NotificationPayload) => {
+					sentChannels.push("slack");
+					return { success: true, channel: "slack" };
+				},
+				discord: async (_url: string, _payload: NotificationPayload) => {
+					sentChannels.push("discord");
+					return { success: true, channel: "discord" };
+				},
+				email: async (_payload: NotificationPayload & { to: string | string[] }) => {
+					sentChannels.push("email");
+					return { success: true, channel: "email" };
+				},
+				webhook: async (
+					_url: string,
+					_payload: NotificationPayload,
+					_headers: Record<string, string>
+				) => {
+					sentChannels.push("webhook");
+					return { success: true, channel: "webhook" };
+				},
+			},
+		};
+
+		await processUptimeAlarmsWithDeps(
+			{ ...baseUptimeData, timestamp: Date.now(), status: 0 },
+			"site-1",
+			deps
+		);
+		await processUptimeAlarmsWithDeps(
+			{ ...baseUptimeData, timestamp: Date.now() + 5000, status: 1 },
+			"site-1",
+			deps
+		);
+
+		expect(histories).toHaveLength(2);
+		expect(sentChannels).toContain("slack");
+		expect(sentChannels).toContain("discord");
+	});
+});
diff --git a/apps/uptime/src/alarms.ts b/apps/uptime/src/alarms.ts
new file mode 100644
index 000000000..f9b403e89
--- /dev/null
+++ b/apps/uptime/src/alarms.ts
@@ -0,0 +1,431 @@
+import dayjs from "dayjs";
+import {
+	sendDiscordWebhook,
+	sendEmail,
+	sendSlackWebhook,
+	sendWebhook,
+	type NotificationPayload,
+	type NotificationResult,
+} from "@databuddy/notifications";
+import { createId } from "@databuddy/shared/utils/ids";
+import { Resend } from "resend";
+import { captureError } from "./lib/tracing";
+import type { UptimeData } from "./types";
+
+const DEFAULT_FAILURE_THRESHOLD = 3;
+const DASHBOARD_BASE_URL =
+	process.env.NEXT_PUBLIC_APP_URL ?? "https://app.databuddy.cc";
+
+const resendClient = process.env.RESEND_API_KEY
+	? new Resend(process.env.RESEND_API_KEY)
+	: null;
+
+const defaultFromEmail =
+	process.env.NOTIFICATIONS_FROM_EMAIL ?? "Databuddy <noreply@databuddy.cc>";
+
+export type AlarmTriggerConditions = {
+	failureThreshold?: number;
+	responseTimeMs?: number;
+};
+
+export type AlarmTriggerDetails = {
+	url?: string;
+	status?: "down" | "up";
+	detectedAt?: string;
+	httpStatus?: number;
+	responseTimeMs?: number;
+	consecutiveFailures?: number;
+	downtimeDurationMs?: number;
+	dashboardUrl?: string;
+};
+
+export type AlarmRecord = {
+	id: string;
+	userId: string;
+	organizationId: string;
+	websiteId: string | null;
+	name: string;
+	description: string | null;
+	enabled: boolean;
+	notificationChannels: Array<"slack" | "discord" | "email" | "webhook">;
+	slackWebhookUrl: string | null;
+	discordWebhookUrl: string | null;
+	emailAddresses: string[];
+	webhookUrl: string | null;
+	webhookHeaders: Record<string, string> | null;
+	triggerType: "uptime" | "traffic_spike" | "error_rate" | "goal" | "custom";
+	triggerConditions: AlarmTriggerConditions;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+export type AlarmStateRecord = {
+	alarmId: string;
+	websiteId: string;
+	status: "up" | "down";
+	consecutiveFailures: number;
+	downStartedAt: Date | null;
+	lastCheckedAt: Date;
+	updatedAt: Date;
+};
+
+type AlarmStateUpsert = AlarmStateRecord;
+
+type AlarmTriggerHistoryEntry = {
+	id: string;
+	alarmId: string;
+	websiteId: string;
+	status: "down" | "up";
+	details: AlarmTriggerDetails;
+	triggeredAt: Date;
+};
+
+export type AlarmNotificationSenders = {
+	slack: (
+		url: string,
+		payload: NotificationPayload
+	) => Promise<NotificationResult>;
+	discord: (
+		url: string,
+		payload: NotificationPayload
+	) => Promise<NotificationResult>;
+	email: (
+		payload: NotificationPayload & { to: string | string[] }
+	) => Promise<NotificationResult>;
+	webhook: (
+		url: string,
+		payload: NotificationPayload,
+		headers: Record<string, string>
+	) => Promise<NotificationResult>;
+};
+
+export function createNotificationSenders(): AlarmNotificationSenders {
+	return {
+		slack: (url, payload) => sendSlackWebhook(url, payload),
+		discord: (url, payload) => sendDiscordWebhook(url, payload),
+		email: (payload) =>
+			sendEmail(
+				async (emailPayload) => {
+					if (!resendClient) {
+						throw new Error("Email provider is not configured");
+					}
+					await resendClient.emails.send({
+						from: defaultFromEmail,
+						...emailPayload,
+					});
+				},
+				payload,
+				{ from: defaultFromEmail }
+			),
+		webhook: (url, payload, headers) => sendWebhook(url, payload, { headers }),
+	};
+}
+
+function buildDashboardUrl(websiteId: string): string {
+	return `${DASHBOARD_BASE_URL}/websites/${websiteId}/uptime`;
+}
+
+function formatTimestamp(value: Date): string {
+	return dayjs(value).format("YYYY-MM-DD HH:mm:ss");
+}
+
+function formatDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const hours = Math.floor(minutes / 60);
+	const days = Math.floor(hours / 24);
+	const remainingHours = hours % 24;
+	const remainingMinutes = minutes % 60;
+	const remainingSeconds = totalSeconds % 60;
+
+	if (days > 0) {
+		return `${days}d ${remainingHours}h ${remainingMinutes}m`;
+	}
+	if (hours > 0) {
+		return `${hours}h ${remainingMinutes}m`;
+	}
+	if (minutes > 0) {
+		return `${minutes}m ${remainingSeconds}s`;
+	}
+	return `${remainingSeconds}s`;
+}
+
+function normalizeHeaders(headers: Record<string, string> | null): Record<string, string> {
+	if (!headers) {
+		return {};
+	}
+	const trimmedEntries = Object.entries(headers)
+		.map(([key, value]) => [key.trim(), value.trim()])
+		.filter(([key, value]) => key.length > 0 && value.length > 0);
+	return Object.fromEntries(trimmedEntries);
+}
+
+function getFailureThreshold(conditions: AlarmTriggerConditions | null): number {
+	const candidate = conditions?.failureThreshold;
+	if (!candidate || candidate < 1) {
+		return DEFAULT_FAILURE_THRESHOLD;
+	}
+	return candidate;
+}
+
+export function evaluateAlarmState(params: {
+	previous: AlarmStateRecord | null;
+	isDown: boolean;
+	failureThreshold: number;
+	checkedAt: Date;
+}): {
+	status: "up" | "down";
+	consecutiveFailures: number;
+	downStartedAt: Date | null;
+	shouldNotifyDown: boolean;
+	shouldNotifyUp: boolean;
+	downtimeDurationMs: number | null;
+} {
+	const { previous, isDown, failureThreshold, checkedAt } = params;
+	const prevStatus = previous?.status ?? "up";
+	const prevFailures = previous?.consecutiveFailures ?? 0;
+	const prevDownStartedAt = previous?.downStartedAt ?? null;
+
+	if (isDown) {
+		const nextFailures = prevFailures + 1;
+		const downStartedAt = prevDownStartedAt ?? checkedAt;
+		const reachedThreshold = nextFailures >= failureThreshold;
+		const shouldNotifyDown = prevStatus === "up" && reachedThreshold;
+		const status = prevStatus === "down" || reachedThreshold ? "down" : "up";
+
+		return {
+			status,
+			consecutiveFailures: nextFailures,
+			downStartedAt,
+			shouldNotifyDown,
+			shouldNotifyUp: false,
+			downtimeDurationMs: null,
+		};
+	}
+
+	const shouldNotifyUp = prevStatus === "down";
+	const downtimeDurationMs = shouldNotifyUp && prevDownStartedAt
+		? dayjs(checkedAt).diff(prevDownStartedAt)
+		: null;
+
+	return {
+		status: "up",
+		consecutiveFailures: 0,
+		downStartedAt: null,
+		shouldNotifyDown: false,
+		shouldNotifyUp,
+		downtimeDurationMs,
+	};
+}
+
+export function buildDownPayload(details: AlarmTriggerDetails): NotificationPayload {
+	const metadata: Record<string, string> = {
+		Website: details.url ?? "",
+		"Detected at": details.detectedAt ?? "",
+		"Consecutive failures": String(details.consecutiveFailures ?? 0),
+		Dashboard: details.dashboardUrl ?? "",
+	};
+	if (details.httpStatus !== undefined) {
+		metadata["HTTP status"] = String(details.httpStatus);
+	}
+	if (details.responseTimeMs !== undefined) {
+		metadata["Response time"] = `${details.responseTimeMs} ms`;
+	}
+
+	return {
+		title: `🔴 Site Down: ${details.url ?? ""}`,
+		message:
+			"We detected consecutive failures for your monitored site. Please investigate the outage.",
+		priority: "urgent",
+		metadata,
+	};
+}
+
+export function buildUpPayload(details: AlarmTriggerDetails): NotificationPayload {
+	const metadata: Record<string, string> = {
+		Website: details.url ?? "",
+		"Recovered at": details.detectedAt ?? "",
+		Downtime: details.downtimeDurationMs
+			? formatDuration(details.downtimeDurationMs)
+			: "Unknown",
+		Dashboard: details.dashboardUrl ?? "",
+	};
+
+	return {
+		title: `🟢 Site Recovered: ${details.url ?? ""}`,
+		message: "Your site is back online and responding normally.",
+		priority: "normal",
+		metadata,
+	};
+}
+
+export async function sendNotifications(
+	alarm: AlarmRecord,
+	payload: NotificationPayload,
+	senders: AlarmNotificationSenders
+): Promise<NotificationResult[]> {
+	const results: NotificationResult[] = [];
+	const headers = normalizeHeaders(alarm.webhookHeaders ?? null);
+
+	for (const channel of alarm.notificationChannels) {
+		try {
+			switch (channel) {
+				case "slack":
+					if (alarm.slackWebhookUrl) {
+						results.push(
+							await senders.slack(alarm.slackWebhookUrl, payload)
+						);
+					}
+					break;
+				case "discord":
+					if (alarm.discordWebhookUrl) {
+						results.push(
+							await senders.discord(alarm.discordWebhookUrl, payload)
+						);
+					}
+					break;
+				case "email":
+					if (alarm.emailAddresses.length > 0) {
+						results.push(
+							await senders.email({
+								...payload,
+								to: alarm.emailAddresses,
+								metadata: {
+									...payload.metadata,
+									to: alarm.emailAddresses,
+								},
+							})
+						);
+					}
+					break;
+				case "webhook":
+					if (alarm.webhookUrl) {
+						results.push(
+							await senders.webhook(alarm.webhookUrl, payload, headers)
+						);
+					}
+					break;
+				default:
+					break;
+			}
+		} catch (error) {
+			captureError(error, {
+				type: "uptime_alarm_notification_failed",
+				alarmId: alarm.id,
+				channel,
+			});
+		}
+	}
+
+	return results;
+}
+
+type AlarmProcessorDeps = {
+	fetchAlarms: (websiteId: string) => Promise<AlarmRecord[]>;
+	fetchStates: (
+		alarmIds: string[],
+		websiteId: string
+	) => Promise<AlarmStateRecord[]>;
+	upsertState: (state: AlarmStateUpsert) => Promise<void>;
+	logHistory: (entry: AlarmTriggerHistoryEntry) => Promise<void>;
+	senders: AlarmNotificationSenders;
+};
+
+export async function processUptimeAlarmsWithDeps(
+	uptimeData: UptimeData,
+	websiteId: string | null,
+	deps: AlarmProcessorDeps
+): Promise<void> {
+	if (!websiteId) {
+		return;
+	}
+
+	const activeAlarms = await deps.fetchAlarms(websiteId);
+
+	if (activeAlarms.length === 0) {
+		return;
+	}
+
+	const alarmIds = activeAlarms.map((alarm) => alarm.id);
+	const existingStates = await deps.fetchStates(alarmIds, websiteId);
+	const stateByAlarmId = new Map(
+		existingStates.map((state) => [state.alarmId, state])
+	);
+
+	const isDown = uptimeData.status === 0;
+	const checkedAt = new Date(uptimeData.timestamp);
+	const dashboardUrl = buildDashboardUrl(websiteId);
+
+	for (const alarm of activeAlarms) {
+		const previousState = stateByAlarmId.get(alarm.id) ?? null;
+		const failureThreshold = getFailureThreshold(alarm.triggerConditions ?? null);
+		const evaluation = evaluateAlarmState({
+			previous: previousState,
+			isDown,
+			failureThreshold,
+			checkedAt,
+		});
+
+		await deps.upsertState({
+			alarmId: alarm.id,
+			websiteId,
+			status: evaluation.status,
+			consecutiveFailures: evaluation.consecutiveFailures,
+			downStartedAt: evaluation.downStartedAt,
+			lastCheckedAt: checkedAt,
+			updatedAt: checkedAt,
+		});
+
+		if (evaluation.shouldNotifyDown || evaluation.shouldNotifyUp) {
+			const details: AlarmTriggerDetails = {
+				url: uptimeData.url,
+				status: evaluation.shouldNotifyDown ? "down" : "up",
+				detectedAt: checkedAt.toISOString(),
+				httpStatus:
+					uptimeData.http_code > 0 ? uptimeData.http_code : undefined,
+				responseTimeMs:
+					uptimeData.total_ms > 0 ? uptimeData.total_ms : undefined,
+				consecutiveFailures: evaluation.consecutiveFailures,
+				downtimeDurationMs: evaluation.downtimeDurationMs ?? undefined,
+				dashboardUrl,
+			};
+
+			const payload = evaluation.shouldNotifyDown
+				? buildDownPayload({
+					...details,
+					detectedAt: formatTimestamp(checkedAt),
+				})
+				: buildUpPayload({
+					...details,
+					detectedAt: formatTimestamp(checkedAt),
+				});
+
+			await sendNotifications(alarm, payload, deps.senders);
+
+			try {
+				await deps.logHistory({
+					id: createId("NANOID"),
+					alarmId: alarm.id,
+					websiteId,
+					status: evaluation.shouldNotifyDown ? "down" : "up",
+					details,
+					triggeredAt: checkedAt,
+				});
+			} catch (error) {
+				captureError(error, {
+					type: "uptime_alarm_history_failed",
+					alarmId: alarm.id,
+				});
+			}
+		}
+	}
+}
+
+export const alarmUtils = {
+	evaluateAlarmState,
+	buildDownPayload,
+	buildUpPayload,
+	formatDuration,
+	buildDashboardUrl,
+	sendNotifications,
+};
diff --git a/apps/uptime/src/index.ts b/apps/uptime/src/index.ts
index f8f136872..d3158bd3e 100644
--- a/apps/uptime/src/index.ts
+++ b/apps/uptime/src/index.ts
@@ -1,6 +1,7 @@
 import { Receiver } from "@upstash/qstash";
 import { Elysia } from "elysia";
 import { z } from "zod";
+import { processUptimeAlarms } from "./alarms-runtime";
 import { type CheckOptions, checkUptime, lookupSchedule } from "./actions";
 import type { JsonParsingConfig } from "./json-parser";
 import { sendUptimeEvent } from "./lib/producer";
@@ -192,6 +193,21 @@ const app = new Elysia()
 				);
 			}
 
+			try {
+				await processUptimeAlarms(result.data, schedule.data.websiteId);
+			} catch (error) {
+				captureError(error, {
+					type: "uptime_alarm_processing_failed",
+					monitorId,
+					websiteId: schedule.data.websiteId ?? undefined,
+				});
+				console.error(
+					"[uptime] Failed to process alarm notifications:",
+					monitorId,
+					error instanceof Error ? error.message : String(error)
+				);
+			}
+
 			return new Response("Uptime check complete", { status: 200 });
 		} catch (error) {
 			captureError(error, { type: "unexpected_error" });
diff --git a/bun.lock b/bun.lock
index e4395bac2..33bab8d2b 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 1,
   "workspaces": {
     "": {
       "name": "databuddy",
@@ -337,7 +336,9 @@
       "version": "1.0.0",
       "dependencies": {
         "@databuddy/db": "workspace:*",
+        "@databuddy/notifications": "workspace:*",
         "@databuddy/services": "workspace:*",
+        "@databuddy/shared": "workspace:*",
         "@opentelemetry/api": "^1.9.0",
         "@opentelemetry/exporter-trace-otlp-proto": "^0.208.0",
         "@opentelemetry/resources": "^2.2.0",
@@ -345,8 +346,10 @@
         "@opentelemetry/sdk-trace-node": "^2.2.0",
         "@opentelemetry/semantic-conventions": "^1.38.0",
         "@upstash/qstash": "^2.8.4",
+        "dayjs": "^1.11.19",
         "elysia": "^1.4.18",
         "kafkajs": "^2.2.4",
+        "resend": "^4.2.0",
         "zod": "^4.2.0",
       },
     },
@@ -501,6 +504,7 @@
         "@ai-sdk-tools/memory": "^1.2.0",
         "@databuddy/auth": "workspace:*",
         "@databuddy/db": "workspace:*",
+        "@databuddy/notifications": "workspace:*",
         "@databuddy/redis": "workspace:*",
         "@databuddy/services": "workspace:*",
         "@databuddy/shared": "workspace:*",
@@ -520,6 +524,7 @@
         "nanoid": "^5.1.6",
         "pg": "^8.16.3",
         "redis": "^5.10.0",
+        "resend": "^4.2.0",
         "superjson": "^2.2.6",
         "zod": "catalog:",
       },
diff --git a/packages/db/src/drizzle/0001_alarms.sql b/packages/db/src/drizzle/0001_alarms.sql
new file mode 100644
index 000000000..be7614f24
--- /dev/null
+++ b/packages/db/src/drizzle/0001_alarms.sql
@@ -0,0 +1,68 @@
+DO $$ BEGIN
+	CREATE TYPE "AlarmTriggerType" AS ENUM ('uptime', 'traffic_spike', 'error_rate', 'goal', 'custom');
+EXCEPTION
+	WHEN duplicate_object THEN null;
+END $$;
+
+DO $$ BEGIN
+	CREATE TYPE "AlarmTriggerStatus" AS ENUM ('down', 'up');
+EXCEPTION
+	WHEN duplicate_object THEN null;
+END $$;
+
+CREATE TABLE IF NOT EXISTS "alarms" (
+	"id" text PRIMARY KEY NOT NULL,
+	"user_id" text NOT NULL,
+	"organization_id" text NOT NULL,
+	"website_id" text,
+	"name" text NOT NULL,
+	"description" text,
+	"enabled" boolean DEFAULT true NOT NULL,
+	"notification_channels" text[] DEFAULT '{}'::text[] NOT NULL,
+	"slack_webhook_url" text,
+	"discord_webhook_url" text,
+	"email_addresses" text[] DEFAULT '{}'::text[] NOT NULL,
+	"webhook_url" text,
+	"webhook_headers" jsonb DEFAULT '{}'::jsonb,
+	"trigger_type" "AlarmTriggerType" NOT NULL,
+	"trigger_conditions" jsonb DEFAULT '{}'::jsonb,
+	"created_at" timestamp(3) DEFAULT now() NOT NULL,
+	"updated_at" timestamp(3) DEFAULT now() NOT NULL,
+	CONSTRAINT "alarms_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "user"("id") ON DELETE cascade,
+	CONSTRAINT "alarms_organization_id_organization_id_fk" FOREIGN KEY ("organization_id") REFERENCES "organization"("id") ON DELETE cascade,
+	CONSTRAINT "alarms_website_id_website_id_fk" FOREIGN KEY ("website_id") REFERENCES "websites"("id") ON DELETE set null
+);
+
+CREATE INDEX IF NOT EXISTS "alarms_user_id_idx" ON "alarms" USING btree ("user_id");
+CREATE INDEX IF NOT EXISTS "alarms_organization_id_idx" ON "alarms" USING btree ("organization_id");
+CREATE INDEX IF NOT EXISTS "alarms_website_id_idx" ON "alarms" USING btree ("website_id");
+CREATE INDEX IF NOT EXISTS "alarms_enabled_idx" ON "alarms" USING btree ("enabled");
+
+CREATE TABLE IF NOT EXISTS "alarm_state" (
+	"alarm_id" text NOT NULL,
+	"website_id" text NOT NULL,
+	"status" "AlarmTriggerStatus" DEFAULT 'up' NOT NULL,
+	"consecutive_failures" integer DEFAULT 0 NOT NULL,
+	"down_started_at" timestamp(3),
+	"last_checked_at" timestamp(3) DEFAULT now() NOT NULL,
+	"updated_at" timestamp(3) DEFAULT now() NOT NULL,
+	CONSTRAINT "alarm_state_alarm_id_alarms_id_fk" FOREIGN KEY ("alarm_id") REFERENCES "alarms"("id") ON DELETE cascade,
+	CONSTRAINT "alarm_state_website_id_websites_id_fk" FOREIGN KEY ("website_id") REFERENCES "websites"("id") ON DELETE cascade,
+	CONSTRAINT "alarm_state_alarm_id_website_id_pk" PRIMARY KEY ("alarm_id", "website_id")
+);
+
+CREATE INDEX IF NOT EXISTS "alarm_state_website_id_idx" ON "alarm_state" USING btree ("website_id");
+
+CREATE TABLE IF NOT EXISTS "alarm_trigger_history" (
+	"id" text PRIMARY KEY NOT NULL,
+	"alarm_id" text NOT NULL,
+	"website_id" text NOT NULL,
+	"status" "AlarmTriggerStatus" NOT NULL,
+	"details" jsonb DEFAULT '{}'::jsonb,
+	"triggered_at" timestamp(3) DEFAULT now() NOT NULL,
+	CONSTRAINT "alarm_trigger_history_alarm_id_alarms_id_fk" FOREIGN KEY ("alarm_id") REFERENCES "alarms"("id") ON DELETE cascade,
+	CONSTRAINT "alarm_trigger_history_website_id_websites_id_fk" FOREIGN KEY ("website_id") REFERENCES "websites"("id") ON DELETE cascade
+);
+
+CREATE INDEX IF NOT EXISTS "alarm_trigger_history_alarm_id_idx" ON "alarm_trigger_history" USING btree ("alarm_id");
+CREATE INDEX IF NOT EXISTS "alarm_trigger_history_website_id_idx" ON "alarm_trigger_history" USING btree ("website_id");
diff --git a/packages/db/src/drizzle/relations.ts b/packages/db/src/drizzle/relations.ts
index c7cd62913..2876429cb 100644
--- a/packages/db/src/drizzle/relations.ts
+++ b/packages/db/src/drizzle/relations.ts
@@ -1,6 +1,9 @@
 import { relations } from "drizzle-orm/relations";
 import {
 	account,
+	alarmState,
+	alarmTriggerHistory,
+	alarms,
 	apikey,
 	flags,
 	flagsToTargetGroups,
@@ -32,6 +35,7 @@ export const userRelations = relations(user, ({ many }) => ({
 	funnelDefinitions: many(funnelDefinitions),
 	apikeys: many(apikey),
 	usageAlertLogs: many(usageAlertLog),
+	alarms: many(alarms),
 }));
 
 export const usageAlertLogRelations = relations(usageAlertLog, ({ one }) => ({
@@ -48,6 +52,7 @@ export const organizationRelations = relations(organization, ({ many }) => ({
 		relationName: "websites_organizationId_organization_id",
 	}),
 	teams: many(team),
+	alarms: many(alarms),
 }));
 
 export const accountRelations = relations(account, ({ one }) => ({
@@ -110,6 +115,7 @@ export const websitesRelations = relations(websites, ({ one, many }) => ({
 		relationName: "websites_organizationId_organization_id",
 	}),
 	funnelDefinitions: many(funnelDefinitions),
+	alarms: many(alarms),
 }));
 
 export const funnelDefinitionsRelations = relations(
@@ -191,6 +197,51 @@ export const uptimeSchedulesRelations = relations(
 	})
 );
 
+export const alarmsRelations = relations(alarms, ({ one, many }) => ({
+	user: one(user, {
+		fields: [alarms.userId],
+		references: [user.id],
+	}),
+	organization: one(organization, {
+		fields: [alarms.organizationId],
+		references: [organization.id],
+	}),
+	website: one(websites, {
+		fields: [alarms.websiteId],
+		references: [websites.id],
+	}),
+	state: one(alarmState, {
+		fields: [alarms.id],
+		references: [alarmState.alarmId],
+	}),
+	triggerHistory: many(alarmTriggerHistory),
+}));
+
+export const alarmStateRelations = relations(alarmState, ({ one }) => ({
+	alarm: one(alarms, {
+		fields: [alarmState.alarmId],
+		references: [alarms.id],
+	}),
+	website: one(websites, {
+		fields: [alarmState.websiteId],
+		references: [websites.id],
+	}),
+}));
+
+export const alarmTriggerHistoryRelations = relations(
+	alarmTriggerHistory,
+	({ one }) => ({
+		alarm: one(alarms, {
+			fields: [alarmTriggerHistory.alarmId],
+			references: [alarms.id],
+		}),
+		website: one(websites, {
+			fields: [alarmTriggerHistory.websiteId],
+			references: [websites.id],
+		}),
+	})
+);
+
 export const linksRelations = relations(links, ({ one }) => ({
 	organization: one(organization, {
 		fields: [links.organizationId],
diff --git a/packages/db/src/drizzle/schema.ts b/packages/db/src/drizzle/schema.ts
index da9e3d3c5..dead2ec11 100644
--- a/packages/db/src/drizzle/schema.ts
+++ b/packages/db/src/drizzle/schema.ts
@@ -58,6 +58,32 @@ export const websiteStatus = pgEnum("WebsiteStatus", [
 	"INACTIVE",
 	"PENDING",
 ]);
+export const alarmTriggerType = pgEnum("AlarmTriggerType", [
+	"uptime",
+	"traffic_spike",
+	"error_rate",
+	"goal",
+	"custom",
+]);
+export const alarmTriggerStatus = pgEnum("AlarmTriggerStatus", ["down", "up"]);
+
+export type AlarmTriggerConditions = {
+	failureThreshold?: number;
+	responseTimeMs?: number;
+};
+
+export type AlarmWebhookHeaders = Record<string, string>;
+
+export type AlarmTriggerDetails = {
+	url?: string;
+	status?: "down" | "up";
+	detectedAt?: string;
+	httpStatus?: number;
+	responseTimeMs?: number;
+	consecutiveFailures?: number;
+	downtimeDurationMs?: number;
+	dashboardUrl?: string;
+};
 
 export const account = pgTable(
 	"account",
@@ -862,6 +888,138 @@ export const uptimeSchedules = pgTable(
 	]
 );
 
+export const alarms = pgTable(
+	"alarms",
+	{
+		id: text().primaryKey().notNull(),
+		userId: text("user_id").notNull(),
+		organizationId: text("organization_id").notNull(),
+		websiteId: text("website_id"),
+		name: text().notNull(),
+		description: text(),
+		enabled: boolean("enabled").default(true).notNull(),
+		notificationChannels: text("notification_channels")
+			.array()
+			.notNull()
+			.default([]),
+		slackWebhookUrl: text("slack_webhook_url"),
+		discordWebhookUrl: text("discord_webhook_url"),
+		emailAddresses: text("email_addresses").array().notNull().default([]),
+		webhookUrl: text("webhook_url"),
+		webhookHeaders: jsonb("webhook_headers")
+			.$type<AlarmWebhookHeaders>()
+			.default({}),
+		triggerType: alarmTriggerType("trigger_type").notNull(),
+		triggerConditions: jsonb("trigger_conditions")
+			.$type<AlarmTriggerConditions>()
+			.default({}),
+		createdAt: timestamp("created_at", { precision: 3 }).defaultNow().notNull(),
+		updatedAt: timestamp("updated_at", { precision: 3 }).defaultNow().notNull(),
+	},
+	(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()),
+		foreignKey({
+			columns: [table.userId],
+			foreignColumns: [user.id],
+			name: "alarms_user_id_user_id_fk",
+		}).onDelete("cascade"),
+		foreignKey({
+			columns: [table.organizationId],
+			foreignColumns: [organization.id],
+			name: "alarms_organization_id_organization_id_fk",
+		}).onDelete("cascade"),
+		foreignKey({
+			columns: [table.websiteId],
+			foreignColumns: [websites.id],
+			name: "alarms_website_id_website_id_fk",
+		})
+			.onUpdate("cascade")
+			.onDelete("set null"),
+	]
+);
+
+export const alarmState = pgTable(
+	"alarm_state",
+	{
+		alarmId: text("alarm_id").notNull(),
+		websiteId: text("website_id").notNull(),
+		status: alarmTriggerStatus("status").default("up").notNull(),
+		consecutiveFailures: integer("consecutive_failures").default(0).notNull(),
+		downStartedAt: timestamp("down_started_at", { precision: 3 }),
+		lastCheckedAt: timestamp("last_checked_at", { precision: 3 })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp("updated_at", { precision: 3 }).defaultNow().notNull(),
+	},
+	(table) => [
+		primaryKey({ columns: [table.alarmId, table.websiteId] }),
+		index("alarm_state_website_id_idx").using(
+			"btree",
+			table.websiteId.asc().nullsLast().op("text_ops")
+		),
+		foreignKey({
+			columns: [table.alarmId],
+			foreignColumns: [alarms.id],
+			name: "alarm_state_alarm_id_alarms_id_fk",
+		}).onDelete("cascade"),
+		foreignKey({
+			columns: [table.websiteId],
+			foreignColumns: [websites.id],
+			name: "alarm_state_website_id_websites_id_fk",
+		})
+			.onUpdate("cascade")
+			.onDelete("cascade"),
+	]
+);
+
+export const alarmTriggerHistory = pgTable(
+	"alarm_trigger_history",
+	{
+		id: text().primaryKey().notNull(),
+		alarmId: text("alarm_id").notNull(),
+		websiteId: text("website_id").notNull(),
+		status: alarmTriggerStatus("status").notNull(),
+		details: jsonb("details").$type<AlarmTriggerDetails>().default({}),
+		triggeredAt: timestamp("triggered_at", { precision: 3 })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => [
+		index("alarm_trigger_history_alarm_id_idx").using(
+			"btree",
+			table.alarmId.asc().nullsLast().op("text_ops")
+		),
+		index("alarm_trigger_history_website_id_idx").using(
+			"btree",
+			table.websiteId.asc().nullsLast().op("text_ops")
+		),
+		foreignKey({
+			columns: [table.alarmId],
+			foreignColumns: [alarms.id],
+			name: "alarm_trigger_history_alarm_id_alarms_id_fk",
+		}).onDelete("cascade"),
+		foreignKey({
+			columns: [table.websiteId],
+			foreignColumns: [websites.id],
+			name: "alarm_trigger_history_website_id_websites_id_fk",
+		})
+			.onUpdate("cascade")
+			.onDelete("cascade"),
+	]
+);
+
 export const links = pgTable(
 	"links",
 	{
diff --git a/packages/rpc/package.json b/packages/rpc/package.json
index 2b6c71403..377bf0348 100644
--- a/packages/rpc/package.json
+++ b/packages/rpc/package.json
@@ -9,6 +9,7 @@
     "@ai-sdk-tools/memory": "^1.2.0",
     "@databuddy/auth": "workspace:*",
     "@databuddy/db": "workspace:*",
+    "@databuddy/notifications": "workspace:*",
     "@databuddy/redis": "workspace:*",
     "@databuddy/services": "workspace:*",
     "@databuddy/shared": "workspace:*",
@@ -28,6 +29,7 @@
     "nanoid": "^5.1.6",
     "pg": "^8.16.3",
     "redis": "^5.10.0",
+    "resend": "^4.2.0",
     "superjson": "^2.2.6",
     "zod": "catalog:"
   },
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-shared.ts b/packages/rpc/src/routers/alarms-shared.ts
new file mode 100644
index 000000000..f4d00a271
--- /dev/null
+++ b/packages/rpc/src/routers/alarms-shared.ts
@@ -0,0 +1,312 @@
+import {
+	sendDiscordWebhook,
+	sendEmail,
+	sendSlackWebhook,
+	sendWebhook,
+	type NotificationPayload,
+	type NotificationResult,
+} from "@databuddy/notifications";
+import { ORPCError } from "@orpc/server";
+import { Resend } from "resend";
+import { z } from "zod";
+
+export const alarmChannelEnum = z.enum(["slack", "discord", "email", "webhook"]);
+export const triggerTypeEnum = z.enum([
+	"uptime",
+	"traffic_spike",
+	"error_rate",
+	"goal",
+	"custom",
+]);
+
+export const triggerConditionsSchema = z
+	.object({
+		failureThreshold: z.number().int().min(1).max(20).optional(),
+		responseTimeMs: z.number().int().min(100).max(120_000).optional(),
+	})
+	.default({});
+
+const webhookHeadersSchema = z.record(z.string(), z.string()).default({});
+
+const baseAlarmSchema = z.object({
+	organizationId: z.string(),
+	websiteId: z.string().optional().nullable(),
+	name: z.string().min(1, "Name is required").max(200),
+	description: z.string().max(500).optional().nullable(),
+	enabled: z.boolean().optional(),
+	notificationChannels: z
+		.array(alarmChannelEnum)
+		.min(1, "Select at least one notification channel"),
+	slackWebhookUrl: z.string().url().optional().nullable(),
+	discordWebhookUrl: z.string().url().optional().nullable(),
+	emailAddresses: z.array(z.string().email()).default([]),
+	webhookUrl: z.string().url().optional().nullable(),
+	webhookHeaders: webhookHeadersSchema,
+	triggerType: triggerTypeEnum,
+	triggerConditions: triggerConditionsSchema,
+});
+
+export const createAlarmInputSchema = baseAlarmSchema.superRefine((data, ctx) => {
+	validateChannelConfiguration(data, ctx);
+});
+
+export const updateAlarmInputSchema = baseAlarmSchema
+	.partial()
+	.extend({ id: z.string() })
+	.superRefine((data, ctx) => {
+		if (data.notificationChannels) {
+			validateChannelConfiguration(
+				{
+					...data,
+					notificationChannels: data.notificationChannels,
+					emailAddresses: data.emailAddresses ?? [],
+					webhookHeaders: data.webhookHeaders ?? {},
+					triggerConditions: data.triggerConditions ?? {},
+					triggerType: data.triggerType ?? "uptime",
+					name: data.name ?? "",
+					organizationId: data.organizationId ?? "",
+				},
+				ctx
+			);
+		}
+	});
+
+export const listAlarmsInputSchema = z
+	.object({
+		organizationId: z.string().optional(),
+		websiteId: z.string().optional(),
+	})
+	.default({});
+
+export const alarmIdSchema = z.object({ id: z.string() });
+
+export type AlarmTriggerConditions = z.infer<typeof triggerConditionsSchema>;
+export type AlarmWebhookHeaders = z.infer<typeof webhookHeadersSchema>;
+
+export type AlarmRecordShape = {
+	id: string;
+	userId: string;
+	organizationId: string;
+	websiteId: string | null;
+	name: string;
+	description: string | null;
+	enabled: boolean;
+	notificationChannels: Array<z.infer<typeof alarmChannelEnum>>;
+	slackWebhookUrl: string | null;
+	discordWebhookUrl: string | null;
+	emailAddresses: string[];
+	webhookUrl: string | null;
+	webhookHeaders: AlarmWebhookHeaders | null;
+	triggerType: z.infer<typeof triggerTypeEnum>;
+	triggerConditions: AlarmTriggerConditions;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+export type CreateAlarmInput = z.infer<typeof createAlarmInputSchema>;
+export type UpdateAlarmInput = z.infer<typeof updateAlarmInputSchema>;
+export type ListAlarmInput = z.infer<typeof listAlarmsInputSchema>;
+
+export type AlarmStore<TAlarm extends AlarmRecordShape = AlarmRecordShape> = {
+	list: (userId: string, filters: ListAlarmInput) => Promise<TAlarm[]>;
+	get: (userId: string, id: string) => Promise<TAlarm | null>;
+	create: (userId: string, input: CreateAlarmInput) => Promise<TAlarm>;
+	update: (userId: string, input: UpdateAlarmInput) => Promise<TAlarm | null>;
+	delete: (userId: string, id: string) => Promise<TAlarm | null>;
+};
+
+type ChannelValidationInput = {
+	notificationChannels: Array<z.infer<typeof alarmChannelEnum>>;
+	slackWebhookUrl?: string | null;
+	discordWebhookUrl?: string | null;
+	emailAddresses: string[];
+	webhookUrl?: string | null;
+};
+
+function validateChannelConfiguration(
+	data: ChannelValidationInput,
+	ctx: z.RefinementCtx
+) {
+	if (data.notificationChannels.includes("slack") && !data.slackWebhookUrl) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Slack webhook URL is required when Slack is selected",
+			path: ["slackWebhookUrl"],
+		});
+	}
+	if (
+		data.notificationChannels.includes("discord") &&
+		!data.discordWebhookUrl
+	) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Discord webhook URL is required when Discord is selected",
+			path: ["discordWebhookUrl"],
+		});
+	}
+	if (
+		data.notificationChannels.includes("email") &&
+		data.emailAddresses.length === 0
+	) {
+		ctx.addIssue({
+			code: "custom",
+			message: "At least one email address is required",
+			path: ["emailAddresses"],
+		});
+	}
+	if (data.notificationChannels.includes("webhook") && !data.webhookUrl) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Webhook URL is required when webhook is selected",
+			path: ["webhookUrl"],
+		});
+	}
+}
+
+function normalizeHeaders(headers: AlarmWebhookHeaders): AlarmWebhookHeaders {
+	const trimmedEntries = Object.entries(headers)
+		.map(([key, value]) => [key.trim(), value.trim()])
+		.filter(([key, value]) => key.length > 0 && value.length > 0);
+	return Object.fromEntries(trimmedEntries);
+}
+
+const defaultFromEmail =
+	process.env.NOTIFICATIONS_FROM_EMAIL ?? "Databuddy <noreply@databuddy.cc>";
+
+const resendClient = process.env.RESEND_API_KEY
+	? new Resend(process.env.RESEND_API_KEY)
+	: null;
+
+type AlarmNotificationSenders = {
+	slack: (
+		url: string,
+		payload: NotificationPayload
+	) => Promise<NotificationResult>;
+	discord: (
+		url: string,
+		payload: NotificationPayload
+	) => Promise<NotificationResult>;
+	email: (
+		payload: NotificationPayload & { to: string | string[] }
+	) => Promise<NotificationResult>;
+	webhook: (
+		url: string,
+		payload: NotificationPayload,
+		headers: AlarmWebhookHeaders
+	) => Promise<NotificationResult>;
+};
+
+function createAlarmNotificationSenders(): AlarmNotificationSenders {
+	return {
+		slack: (url, payload) => sendSlackWebhook(url, payload),
+		discord: (url, payload) => sendDiscordWebhook(url, payload),
+		email: (payload) =>
+			sendEmail(
+				async (emailPayload) => {
+					if (!resendClient) {
+						throw new Error("Email provider is not configured");
+					}
+					await resendClient.emails.send({
+						from: defaultFromEmail,
+						...emailPayload,
+					});
+				},
+				payload,
+				{ from: defaultFromEmail }
+			),
+		webhook: (url, payload, headers) =>
+			sendWebhook(url, payload, { headers }),
+	};
+}
+
+export async function sendAlarmTestNotification(
+	alarm: AlarmRecordShape,
+	senders: AlarmNotificationSenders = createAlarmNotificationSenders()
+): Promise<NotificationResult[]> {
+	const payload: NotificationPayload = {
+		title: `Test alert: ${alarm.name}`,
+		message:
+			"This is a test notification from Databuddy to verify your alarm channels.",
+		priority: "normal",
+		metadata: {
+			Alarm: alarm.name,
+			Trigger: alarm.triggerType,
+			"Sent at": new Date().toISOString(),
+		},
+	};
+
+	const results: NotificationResult[] = [];
+	const channels = alarm.notificationChannels;
+	const headers = normalizeHeaders(alarm.webhookHeaders ?? {});
+
+	if (channels.includes("slack") && alarm.slackWebhookUrl) {
+		results.push(await senders.slack(alarm.slackWebhookUrl, payload));
+	}
+	if (channels.includes("discord") && alarm.discordWebhookUrl) {
+		results.push(await senders.discord(alarm.discordWebhookUrl, payload));
+	}
+	if (channels.includes("email") && alarm.emailAddresses.length > 0) {
+		results.push(
+			await senders.email({
+				...payload,
+				to: alarm.emailAddresses,
+				metadata: { ...payload.metadata, to: alarm.emailAddresses },
+			})
+		);
+	}
+	if (channels.includes("webhook") && alarm.webhookUrl) {
+		results.push(await senders.webhook(alarm.webhookUrl, payload, headers));
+	}
+
+	return results;
+}
+
+export function createAlarmHandlers<TAlarm extends AlarmRecordShape>(
+	store: AlarmStore<TAlarm>
+) {
+	return {
+		list: async (userId: string, input: ListAlarmInput) =>
+			store.list(userId, input),
+		get: async (userId: string, id: string) => {
+			const alarm = await store.get(userId, id);
+			if (!alarm) {
+				throw new ORPCError("NOT_FOUND", { message: "Alarm not found" });
+			}
+			return alarm;
+		},
+		create: async (userId: string, input: CreateAlarmInput) =>
+			store.create(userId, input),
+		update: async (userId: string, input: UpdateAlarmInput) => {
+			const updated = await store.update(userId, input);
+			if (!updated) {
+				throw new ORPCError("NOT_FOUND", { message: "Alarm not found" });
+			}
+			return updated;
+		},
+		delete: async (userId: string, id: string) => {
+			const deleted = await store.delete(userId, id);
+			if (!deleted) {
+				throw new ORPCError("NOT_FOUND", { message: "Alarm not found" });
+			}
+			return deleted;
+		},
+		test: async (userId: string, id: string) => {
+			const alarm = await store.get(userId, id);
+			if (!alarm) {
+				throw new ORPCError("NOT_FOUND", { message: "Alarm not found" });
+			}
+			const results = await sendAlarmTestNotification(alarm);
+			return { results };
+		},
+	};
+}
+
+export const alarmSchemas = {
+	createAlarmInputSchema,
+	updateAlarmInputSchema,
+	listAlarmsInputSchema,
+	alarmIdSchema,
+	alarmChannelEnum,
+	triggerTypeEnum,
+	triggerConditionsSchema,
+};
diff --git a/packages/rpc/src/routers/alarms.test.ts b/packages/rpc/src/routers/alarms.test.ts
new file mode 100644
index 000000000..61cf58b81
--- /dev/null
+++ b/packages/rpc/src/routers/alarms.test.ts
@@ -0,0 +1,277 @@
+import { describe, expect, it } from "bun:test";
+import type { NotificationPayload, NotificationResult } from "@databuddy/notifications";
+import { ORPCError } from "@orpc/server";
+import { z } from "zod";
+import {
+	alarmSchemas,
+	createAlarmHandlers,
+	sendAlarmTestNotification,
+	type AlarmRecordShape,
+} from "./alarms-shared";
+
+const { createAlarmInputSchema } = alarmSchemas;
+
+type AlarmRecord = AlarmRecordShape;
+
+type CreateAlarmInput = z.infer<typeof createAlarmInputSchema>;
+
+type UpdateAlarmInput = z.infer<typeof alarmSchemas.updateAlarmInputSchema>;
+
+type ListAlarmInput = z.infer<typeof alarmSchemas.listAlarmsInputSchema>;
+
+type AlarmStore = {
+	list: (userId: string, filters: ListAlarmInput) => Promise<AlarmRecord[]>;
+	get: (userId: string, id: string) => Promise<AlarmRecord | null>;
+	create: (userId: string, input: CreateAlarmInput) => Promise<AlarmRecord>;
+	update: (userId: string, input: UpdateAlarmInput) => Promise<AlarmRecord | null>;
+	delete: (userId: string, id: string) => Promise<AlarmRecord | null>;
+};
+
+function createInMemoryStore(): AlarmStore {
+	const data: AlarmRecord[] = [];
+	let counter = 1;
+
+	const createRecord = (
+		userId: string,
+		input: CreateAlarmInput
+	): AlarmRecord => {
+		const now = new Date();
+		return {
+			id: `alarm-${counter++}`,
+			userId,
+			organizationId: input.organizationId,
+			websiteId: input.websiteId ?? null,
+			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,
+			createdAt: now,
+			updatedAt: now,
+		};
+	};
+
+	return {
+		list: async (userId, filters) => {
+			return data.filter((alarm) => {
+				if (alarm.userId !== userId) {
+					return false;
+				}
+				if (filters.organizationId && alarm.organizationId !== filters.organizationId) {
+					return false;
+				}
+				if (filters.websiteId && alarm.websiteId !== filters.websiteId) {
+					return false;
+				}
+				return true;
+			});
+		},
+		get: async (userId, id) =>
+			data.find((alarm) => alarm.userId === userId && alarm.id === id) ?? null,
+		create: async (userId, input) => {
+			const record = createRecord(userId, input);
+			data.push(record);
+			return record;
+		},
+		update: async (userId, input) => {
+			const index = data.findIndex(
+				(alarm) => alarm.userId === userId && alarm.id === input.id
+			);
+			if (index < 0) {
+				return null;
+			}
+			const current = data[index];
+			const updated: AlarmRecord = {
+				...current,
+				...input,
+				websiteId:
+					input.websiteId === undefined ? current.websiteId : input.websiteId,
+				updatedAt: new Date(),
+			};
+			data[index] = updated;
+			return updated;
+		},
+		delete: async (userId, id) => {
+			const index = data.findIndex(
+				(alarm) => alarm.userId === userId && alarm.id === id
+			);
+			if (index < 0) {
+				return null;
+			}
+			const [removed] = data.splice(index, 1);
+			return removed ?? null;
+		},
+	};
+}
+
+const validCreateInput: CreateAlarmInput = {
+	organizationId: "org-1",
+	websiteId: "site-1",
+	name: "Uptime Alerts",
+	description: "Notify when site goes down",
+	enabled: true,
+	notificationChannels: ["slack", "email"],
+	slackWebhookUrl: "https://hooks.slack.com/services/test",
+	discordWebhookUrl: null,
+	emailAddresses: ["alerts@databuddy.cc"],
+	webhookUrl: null,
+	webhookHeaders: {},
+	triggerType: "uptime",
+	triggerConditions: { failureThreshold: 3 },
+};
+
+describe("alarms router handlers", () => {
+	it("creates an alarm with valid payload", async () => {
+		const store = createInMemoryStore();
+		const handlers = createAlarmHandlers(store);
+		const alarm = await handlers.create("user-1", validCreateInput);
+		expect(alarm.id).toContain("alarm-");
+		expect(alarm.name).toBe("Uptime Alerts");
+		expect(alarm.notificationChannels).toContain("slack");
+	});
+
+	it("updates an alarm", async () => {
+		const store = createInMemoryStore();
+		const handlers = createAlarmHandlers(store);
+		const created = await handlers.create("user-1", validCreateInput);
+		const updated = await handlers.update("user-1", {
+			id: created.id,
+			name: "Updated Alarm",
+			enabled: false,
+		});
+		expect(updated.name).toBe("Updated Alarm");
+		expect(updated.enabled).toBe(false);
+	});
+
+	it("deletes an alarm", async () => {
+		const store = createInMemoryStore();
+		const handlers = createAlarmHandlers(store);
+		const created = await handlers.create("user-1", validCreateInput);
+		await handlers.delete("user-1", created.id);
+		const list = await handlers.list("user-1", { organizationId: "org-1" });
+		expect(list).toHaveLength(0);
+	});
+
+	it("lists and gets alarms for the correct user", async () => {
+		const store = createInMemoryStore();
+		const handlers = createAlarmHandlers(store);
+		const created = await handlers.create("user-1", validCreateInput);
+		await handlers.create("user-2", {
+			...validCreateInput,
+			organizationId: "org-2",
+			name: "Other",
+		});
+
+		const list = await handlers.list("user-1", { organizationId: "org-1" });
+		expect(list).toHaveLength(1);
+		const fetched = await handlers.get("user-1", created.id);
+		expect(fetched.id).toBe(created.id);
+	});
+
+	it("prevents cross-user access", async () => {
+		const store = createInMemoryStore();
+		const handlers = createAlarmHandlers(store);
+		const created = await handlers.create("user-1", validCreateInput);
+
+		await expect(handlers.get("user-2", created.id)).rejects.toThrow(ORPCError);
+		await expect(
+			handlers.update("user-2", { id: created.id, name: "Nope" })
+		).rejects.toThrow("Alarm not found");
+		await expect(handlers.delete("user-2", created.id)).rejects.toThrow(
+			"Alarm not found"
+		);
+	});
+});
+
+describe("alarm validation", () => {
+	it("rejects missing webhook url when webhook channel selected", () => {
+		const result = createAlarmInputSchema.safeParse({
+			...validCreateInput,
+			notificationChannels: ["webhook"],
+			webhookUrl: null,
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it("rejects invalid webhook url", () => {
+		const result = createAlarmInputSchema.safeParse({
+			...validCreateInput,
+			notificationChannels: ["webhook"],
+			webhookUrl: "not-a-url",
+		});
+		expect(result.success).toBe(false);
+	});
+
+	it("rejects empty name", () => {
+		const result = createAlarmInputSchema.safeParse({
+			...validCreateInput,
+			name: "",
+		});
+		expect(result.success).toBe(false);
+	});
+});
+
+describe("alarms.test notification", () => {
+	it("triggers notifications for configured channels", async () => {
+		const alarm: AlarmRecord = {
+			id: "alarm-test",
+			userId: "user-1",
+			organizationId: "org-1",
+			websiteId: "site-1",
+			name: "Test Alarm",
+			description: null,
+			enabled: true,
+			notificationChannels: ["slack", "discord", "email", "webhook"],
+			slackWebhookUrl: "https://hooks.slack.com/services/test",
+			discordWebhookUrl: "https://discord.com/api/webhooks/test",
+			emailAddresses: ["alerts@databuddy.cc"],
+			webhookUrl: "https://example.com/webhook",
+			webhookHeaders: { Authorization: "Bearer token" },
+			triggerType: "uptime",
+			triggerConditions: { failureThreshold: 2 },
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		};
+
+		const payloads: NotificationPayload[] = [];
+		const senders = {
+			slack: async (_url: string, payload: NotificationPayload) => {
+				payloads.push(payload);
+				const result: NotificationResult = { success: true, channel: "slack" };
+				return result;
+			},
+			discord: async (_url: string, payload: NotificationPayload) => {
+				payloads.push(payload);
+				const result: NotificationResult = {
+					success: true,
+					channel: "discord",
+				};
+				return result;
+			},
+			email: async (payload: NotificationPayload & { to: string | string[] }) => {
+				payloads.push(payload);
+				const result: NotificationResult = { success: true, channel: "email" };
+				return result;
+			},
+			webhook: async (
+				_url: string,
+				payload: NotificationPayload,
+				_headers: Record<string, string>
+			) => {
+				payloads.push(payload);
+				const result: NotificationResult = { success: true, channel: "webhook" };
+				return result;
+			},
+		};
+
+		const results = await sendAlarmTestNotification(alarm, senders);
+		expect(results).toHaveLength(4);
+		expect(payloads[0]?.title).toContain("Test alert");
+	});
+});
diff --git a/packages/rpc/src/routers/alarms.ts b/packages/rpc/src/routers/alarms.ts
new file mode 100644
index 000000000..36ed49502
--- /dev/null
+++ b/packages/rpc/src/routers/alarms.ts
@@ -0,0 +1,178 @@
+import { and, desc, eq, alarms, type InferSelectModel } from "@databuddy/db";
+import { createId } from "@databuddy/shared/utils/ids";
+import { ORPCError } from "@orpc/server";
+import { protectedProcedure } from "../orpc";
+import {
+	alarmSchemas,
+	createAlarmHandlers,
+	type AlarmStore,
+	type CreateAlarmInput,
+	type ListAlarmInput,
+	type UpdateAlarmInput,
+} from "./alarms-shared";
+
+const {
+	createAlarmInputSchema,
+	updateAlarmInputSchema,
+	listAlarmsInputSchema,
+	alarmIdSchema,
+} = alarmSchemas;
+
+type AlarmRecord = InferSelectModel<typeof alarms>;
+
+function createAlarmStore(db: typeof import("@databuddy/db").db): AlarmStore<AlarmRecord> {
+	return {
+		list: async (userId: string, filters: ListAlarmInput) => {
+			const conditions = [eq(alarms.userId, userId)];
+			if (filters.organizationId) {
+				conditions.push(eq(alarms.organizationId, filters.organizationId));
+			}
+			if (filters.websiteId) {
+				conditions.push(eq(alarms.websiteId, filters.websiteId));
+			}
+			const whereClause =
+				conditions.length > 1 ? and(...conditions) : conditions[0];
+			return await db.query.alarms.findMany({
+				where: whereClause,
+				orderBy: (table) => [desc(table.updatedAt)],
+			});
+		},
+		get: async (userId: string, id: string) => {
+			return await db.query.alarms.findFirst({
+				where: and(eq(alarms.id, id), eq(alarms.userId, userId)),
+			});
+		},
+		create: async (userId: string, input: CreateAlarmInput) => {
+			const now = new Date();
+			const [alarm] = await db
+				.insert(alarms)
+				.values({
+					id: createId("NANOID"),
+					userId,
+					organizationId: input.organizationId,
+					websiteId: input.websiteId ?? null,
+					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,
+					createdAt: now,
+					updatedAt: now,
+				})
+				.returning();
+			if (!alarm) {
+				throw new ORPCError("INTERNAL_SERVER_ERROR", {
+					message: "Failed to create alarm",
+				});
+			}
+			return alarm;
+		},
+		update: async (userId: string, input: UpdateAlarmInput) => {
+			const updates: Partial<AlarmRecord> = { updatedAt: new Date() };
+			if (input.organizationId) {
+				updates.organizationId = input.organizationId;
+			}
+			if (input.websiteId !== undefined) {
+				updates.websiteId = input.websiteId ?? null;
+			}
+			if (input.name !== undefined) {
+				updates.name = input.name;
+			}
+			if (input.description !== undefined) {
+				updates.description = input.description ?? null;
+			}
+			if (input.enabled !== undefined) {
+				updates.enabled = input.enabled;
+			}
+			if (input.notificationChannels) {
+				updates.notificationChannels = input.notificationChannels;
+			}
+			if (input.slackWebhookUrl !== undefined) {
+				updates.slackWebhookUrl = input.slackWebhookUrl ?? null;
+			}
+			if (input.discordWebhookUrl !== undefined) {
+				updates.discordWebhookUrl = input.discordWebhookUrl ?? null;
+			}
+			if (input.emailAddresses) {
+				updates.emailAddresses = input.emailAddresses;
+			}
+			if (input.webhookUrl !== undefined) {
+				updates.webhookUrl = input.webhookUrl ?? null;
+			}
+			if (input.webhookHeaders) {
+				updates.webhookHeaders = input.webhookHeaders;
+			}
+			if (input.triggerType) {
+				updates.triggerType = input.triggerType;
+			}
+			if (input.triggerConditions) {
+				updates.triggerConditions = input.triggerConditions;
+			}
+			const [updated] = await db
+				.update(alarms)
+				.set(updates)
+				.where(and(eq(alarms.id, input.id), eq(alarms.userId, userId)))
+				.returning();
+			return updated ?? null;
+		},
+		delete: async (userId: string, id: string) => {
+			const [deleted] = await db
+				.delete(alarms)
+				.where(and(eq(alarms.id, id), eq(alarms.userId, userId)))
+				.returning();
+			return deleted ?? null;
+		},
+	};
+}
+
+export const alarmsRouter = {
+	list: protectedProcedure
+		.input(listAlarmsInputSchema)
+		.handler(async ({ context, input }) => {
+			const handlers = createAlarmHandlers(createAlarmStore(context.db));
+			return await handlers.list(context.user.id, input);
+		}),
+
+	get: protectedProcedure
+		.input(alarmIdSchema)
+		.handler(async ({ context, input }) => {
+			const handlers = createAlarmHandlers(createAlarmStore(context.db));
+			return await handlers.get(context.user.id, input.id);
+		}),
+
+	create: protectedProcedure
+		.input(createAlarmInputSchema)
+		.handler(async ({ context, input }) => {
+			const handlers = createAlarmHandlers(createAlarmStore(context.db));
+			return await handlers.create(context.user.id, input);
+		}),
+
+	update: protectedProcedure
+		.input(updateAlarmInputSchema)
+		.handler(async ({ context, input }) => {
+			const handlers = createAlarmHandlers(createAlarmStore(context.db));
+			return await handlers.update(context.user.id, input);
+		}),
+
+	delete: protectedProcedure
+		.input(alarmIdSchema)
+		.handler(async ({ context, input }) => {
+			const handlers = createAlarmHandlers(createAlarmStore(context.db));
+			return await handlers.delete(context.user.id, input.id);
+		}),
+
+	test: protectedProcedure
+		.input(alarmIdSchema)
+		.handler(async ({ context, input }) => {
+			const handlers = createAlarmHandlers(createAlarmStore(context.db));
+			return await handlers.test(context.user.id, input.id);
+		}),
+};
+
+export { alarmSchemas } from "./alarms-shared";