From 11e9fbcc441f135cf7e55454194e0c1af301464b Mon Sep 17 00:00:00 2001
From: Nico <47644445+nicotsx@users.noreply.github.com>
Date: Wed, 29 Apr 2026 23:48:58 +0200
Subject: [PATCH] feat: pre/post backup webhooks (#835)

* feat: pre/post backup webhooks

* fix(hooks): run post when cancelled

* refactor(webhooks): headers as array

* refactor: pr feedback

* refactor: simplify hooks ceremonies

* chore: pr feedbacks

* chore: re-gen migration
---
 app/client/api-client/types.gen.ts            |   84 +
 .../components/webhook-request-preview.tsx    |   25 +
 .../create-schedule-form/advanced-section.tsx |   82 +-
 .../components/create-schedule-form/index.tsx |   16 +-
 .../components/create-schedule-form/types.ts  |   33 +-
 .../components/create-schedule-form/utils.ts  |   36 +-
 .../routes/__tests__/backup-details.test.tsx  |    1 +
 .../routes/__tests__/edit-backup.test.tsx     |   26 +
 .../modules/backups/routes/backup-details.tsx |    1 +
 .../modules/backups/routes/create-backup.tsx  |    1 +
 .../notification-forms/generic-form.tsx       |   19 +-
 .../migration.sql                             |    1 +
 .../snapshot.json                             | 2341 +++++++++++++++++
 app/server/db/schema.ts                       |    2 +
 .../modules/agents/__tests__/session.test.ts  |    1 +
 .../backups.service.execution.test.ts         |   35 +
 .../backups/__tests__/backups.service.test.ts |   56 +
 app/server/modules/backups/backup-executor.ts |   52 +-
 .../modules/backups/backups.controller.ts     |    9 +-
 app/server/modules/backups/backups.dto.ts     |   10 +-
 app/server/modules/backups/backups.service.ts |    9 +-
 .../backups/helpers/backup-lifecycle.ts       |    2 +-
 .../src/__tests__/controller-session.test.ts  |    1 +
 apps/agent/src/commands/backup-run.test.ts    |  258 +-
 apps/agent/src/commands/backup-run.ts         |  113 +-
 packages/contracts/src/agent-protocol.ts      |    2 +
 packages/core/package.json                    |    5 +
 .../src/backup-hooks/__tests__/hooks.test.ts  |  383 +++
 packages/core/src/backup-hooks/index.ts       |  280 ++
 29 files changed, 3762 insertions(+), 122 deletions(-)
 create mode 100644 app/client/components/webhook-request-preview.tsx
 create mode 100644 app/drizzle/20260429214453_classy_namora/migration.sql
 create mode 100644 app/drizzle/20260429214453_classy_namora/snapshot.json
 create mode 100644 packages/core/src/backup-hooks/__tests__/hooks.test.ts
 create mode 100644 packages/core/src/backup-hooks/index.ts

diff --git a/app/client/api-client/types.gen.ts b/app/client/api-client/types.gen.ts
index ddf355f3..e6e5f670 100644
--- a/app/client/api-client/types.gen.ts
+++ b/app/client/api-client/types.gen.ts
@@ -2434,6 +2434,18 @@ export type ListBackupSchedulesResponses = {
         includePatterns: Array<string> | null;
         oneFileSystem: boolean;
         customResticParams: Array<string> | null;
+        backupWebhooks: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries: number;
         retryDelay: number;
         lastBackupAt: number | null;
@@ -2712,6 +2724,18 @@ export type CreateBackupScheduleData = {
         oneFileSystem?: boolean;
         tags?: Array<string>;
         customResticParams?: Array<string>;
+        backupWebhooks?: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries?: number;
         retryDelay?: number;
     };
@@ -2747,6 +2771,18 @@ export type CreateBackupScheduleResponses = {
         includePatterns: Array<string> | null;
         oneFileSystem: boolean;
         customResticParams: Array<string> | null;
+        backupWebhooks: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries: number;
         retryDelay: number;
         lastBackupAt: number | null;
@@ -2816,6 +2852,18 @@ export type GetBackupScheduleResponses = {
         includePatterns: Array<string> | null;
         oneFileSystem: boolean;
         customResticParams: Array<string> | null;
+        backupWebhooks: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries: number;
         retryDelay: number;
         lastBackupAt: number | null;
@@ -3093,6 +3141,18 @@ export type UpdateBackupScheduleData = {
         oneFileSystem?: boolean;
         tags?: Array<string>;
         customResticParams?: Array<string>;
+        backupWebhooks?: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries?: number;
         retryDelay?: number;
     };
@@ -3130,6 +3190,18 @@ export type UpdateBackupScheduleResponses = {
         includePatterns: Array<string> | null;
         oneFileSystem: boolean;
         customResticParams: Array<string> | null;
+        backupWebhooks: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries: number;
         retryDelay: number;
         lastBackupAt: number | null;
@@ -3179,6 +3251,18 @@ export type GetBackupScheduleForVolumeResponses = {
         includePatterns: Array<string> | null;
         oneFileSystem: boolean;
         customResticParams: Array<string> | null;
+        backupWebhooks: {
+            pre: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+            post: {
+                url: string;
+                headers?: Array<string>;
+                body?: string;
+            } | null;
+        } | null;
         maxRetries: number;
         retryDelay: number;
         lastBackupAt: number | null;
diff --git a/app/client/components/webhook-request-preview.tsx b/app/client/components/webhook-request-preview.tsx
new file mode 100644
index 00000000..1b1c132f
--- /dev/null
+++ b/app/client/components/webhook-request-preview.tsx
@@ -0,0 +1,25 @@
+import { CodeBlock } from "~/client/components/ui/code-block";
+import { Label } from "~/client/components/ui/label";
+
+type WebhookRequestPreviewProps = {
+	method: string;
+	url?: string;
+	contentType?: string;
+	headers?: string[];
+	body: string;
+};
+
+export const WebhookRequestPreview = ({ method, url, contentType, headers, body }: WebhookRequestPreviewProps) => {
+	const headerLines = [contentType ? `Content-Type: ${contentType}` : undefined, ...(headers ?? [])].filter(Boolean);
+	const previewCode = `${method} ${url || "https://api.example.com/webhook"}${headerLines.length > 0 ? `\n${headerLines.join("\n")}` : ""}
+
+${body}`;
+
+	return (
+		<div className="space-y-2 pt-4 border-t">
+			<Label>Request Preview</Label>
+			<CodeBlock code={previewCode} filename="HTTP Request" />
+			<p className="text-[0.8rem] text-muted-foreground">This is a preview of the HTTP request that will be sent.</p>
+		</div>
+	);
+};
diff --git a/app/client/modules/backups/components/create-schedule-form/advanced-section.tsx b/app/client/modules/backups/components/create-schedule-form/advanced-section.tsx
index a6d865a3..0b6c3d33 100644
--- a/app/client/modules/backups/components/create-schedule-form/advanced-section.tsx
+++ b/app/client/modules/backups/components/create-schedule-form/advanced-section.tsx
@@ -1,6 +1,6 @@
 import { FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage } from "~/client/components/ui/form";
 import { Textarea } from "~/client/components/ui/textarea";
-import type { UseFormReturn } from "react-hook-form";
+import { type UseFormReturn } from "react-hook-form";
 import type { InternalFormValues } from "./types";
 import { Input } from "~/client/components/ui/input";
 
@@ -8,6 +8,72 @@ type AdvancedSectionProps = {
 	form: UseFormReturn<InternalFormValues>;
 };
 
+type WebhookFieldsProps = {
+	form: UseFormReturn<InternalFormValues>;
+	phase: "pre" | "post";
+	urlPlaceholder: string;
+	bodyPlaceholder: string;
+	description: string;
+};
+
+const WebhookFields = ({ form, phase, urlPlaceholder, bodyPlaceholder, description }: WebhookFieldsProps) => {
+	const labelPrefix = phase === "pre" ? "Pre-backup" : "Post-backup";
+	const fieldPrefix = phase === "pre" ? "preBackupWebhook" : "postBackupWebhook";
+
+	return (
+		<>
+			<FormField
+				control={form.control}
+				name={`${fieldPrefix}Url`}
+				render={({ field }) => (
+					<FormItem>
+						<FormLabel>{labelPrefix} webhook</FormLabel>
+						<FormControl>
+							<Input {...field} type="url" placeholder={urlPlaceholder} />
+						</FormControl>
+						<FormDescription>{description}</FormDescription>
+						<FormMessage />
+					</FormItem>
+				)}
+			/>
+			<FormField
+				control={form.control}
+				name={`${fieldPrefix}HeadersText`}
+				render={({ field }) => (
+					<FormItem>
+						<FormLabel>{labelPrefix} webhook headers</FormLabel>
+						<FormControl>
+							<Textarea
+								{...field}
+								placeholder="Authorization: Bearer token&#10;X-Custom-Header: value"
+								className="font-mono text-sm min-h-24"
+							/>
+						</FormControl>
+						<FormDescription>
+							One header per line in Key: Value format. Values are stored as plain text.
+						</FormDescription>
+						<FormMessage />
+					</FormItem>
+				)}
+			/>
+			<FormField
+				control={form.control}
+				name={`${fieldPrefix}Body`}
+				render={({ field }) => (
+					<FormItem>
+						<FormLabel>{labelPrefix} webhook body</FormLabel>
+						<FormControl>
+							<Textarea {...field} placeholder={bodyPlaceholder} className="font-mono text-sm min-h-24" />
+						</FormControl>
+						<FormDescription>Optional raw POST body. Leave empty to send the backup context JSON.</FormDescription>
+						<FormMessage />
+					</FormItem>
+				)}
+			/>
+		</>
+	);
+};
+
 export const AdvancedSection = ({ form }: AdvancedSectionProps) => {
 	return (
 		<>
@@ -56,6 +122,20 @@ export const AdvancedSection = ({ form }: AdvancedSectionProps) => {
 					</FormItem>
 				)}
 			/>
+			<WebhookFields
+				form={form}
+				phase="pre"
+				urlPlaceholder="http://host.docker.internal:8080/stop"
+				bodyPlaceholder='{"action":"stop"}'
+				description="Called with POST before restic starts. A non-2xx response stops the backup."
+			/>
+			<WebhookFields
+				form={form}
+				phase="post"
+				urlPlaceholder="http://host.docker.internal:8080/start"
+				bodyPlaceholder='{"action":"start"}'
+				description="Called with POST after restic finishes, including failed or cancelled runs."
+			/>
 			<FormField
 				control={form.control}
 				name="customResticParamsText"
diff --git a/app/client/modules/backups/components/create-schedule-form/index.tsx b/app/client/modules/backups/components/create-schedule-form/index.tsx
index d1779027..446801d9 100644
--- a/app/client/modules/backups/components/create-schedule-form/index.tsx
+++ b/app/client/modules/backups/components/create-schedule-form/index.tsx
@@ -14,7 +14,7 @@ import { PathsSection } from "./paths-section";
 import { RetentionSection } from "./retention-section";
 import { SummarySection } from "./summary-section";
 import { internalFormSchema, type BackupScheduleFormValues, type InternalFormValues } from "./types";
-import { backupScheduleToFormValues, parseMultilineEntries } from "./utils";
+import { backupScheduleToFormValues, parseMultilineEntries, toWebhookConfig } from "./utils";
 
 export type { BackupScheduleFormValues };
 
@@ -46,12 +46,24 @@ export const CreateScheduleForm = ({ initialValues, formId, onSubmit, volume }:
 				cronExpression,
 				maxRetries,
 				retryDelay,
+				preBackupWebhookUrl,
+				preBackupWebhookHeadersText,
+				preBackupWebhookBody,
+				postBackupWebhookUrl,
+				postBackupWebhookHeadersText,
+				postBackupWebhookBody,
 				...rest
 			} = data;
 			const excludePatterns = parseMultilineEntries(excludePatternsText);
 			const excludeIfPresent = parseMultilineEntries(excludeIfPresentText);
 			const parsedIncludePatterns = parseMultilineEntries(includePatterns);
 			const customResticParams = parseMultilineEntries(customResticParamsText);
+			const preBackupWebhook = toWebhookConfig(preBackupWebhookUrl, preBackupWebhookHeadersText, preBackupWebhookBody);
+			const postBackupWebhook = toWebhookConfig(
+				postBackupWebhookUrl,
+				postBackupWebhookHeadersText,
+				postBackupWebhookBody,
+			);
 
 			onSubmit({
 				...rest,
@@ -61,6 +73,8 @@ export const CreateScheduleForm = ({ initialValues, formId, onSubmit, volume }:
 				excludePatterns,
 				excludeIfPresent,
 				customResticParams,
+				backupWebhooks:
+					preBackupWebhook || postBackupWebhook ? { pre: preBackupWebhook, post: postBackupWebhook } : null,
 				maxRetries,
 				retryDelay,
 			});
diff --git a/app/client/modules/backups/components/create-schedule-form/types.ts b/app/client/modules/backups/components/create-schedule-form/types.ts
index c5f80dff..c4d1d9e8 100644
--- a/app/client/modules/backups/components/create-schedule-form/types.ts
+++ b/app/client/modules/backups/components/create-schedule-form/types.ts
@@ -1,4 +1,19 @@
 import { z } from "zod";
+import type { BackupWebhooks } from "@zerobyte/core/backup-hooks";
+
+const webhookHeadersSchema = z.string().refine(
+	(value) =>
+		value
+			.split("\n")
+			.map((header) => header.trim())
+			.filter(Boolean)
+			.every((header) => {
+				const [key, value] = header.split(":", 2);
+
+				return /^[A-Za-z0-9-]+$/.test(key.trim()) && (value?.trim().length ?? 0) > 0;
+			}),
+	{ message: "Headers must use non-empty Key: Value format with valid header names" },
+);
 
 export const internalFormSchema = z.object({
 	name: z.string().min(1).max(128),
@@ -20,6 +35,12 @@ export const internalFormSchema = z.object({
 	keepYearly: z.number().optional(),
 	oneFileSystem: z.boolean().optional(),
 	customResticParamsText: z.string().optional(),
+	preBackupWebhookUrl: z.union([z.url(), z.literal("")]).optional(),
+	preBackupWebhookHeadersText: webhookHeadersSchema.optional(),
+	preBackupWebhookBody: z.string().optional(),
+	postBackupWebhookUrl: z.union([z.url(), z.literal("")]).optional(),
+	postBackupWebhookHeadersText: webhookHeadersSchema.optional(),
+	postBackupWebhookBody: z.string().optional(),
 	maxRetries: z.number().min(0).max(32).optional(),
 	retryDelay: z.number().min(1).max(1440).optional(),
 });
@@ -38,10 +59,20 @@ export type InternalFormValues = z.infer<typeof internalFormSchema>;
 
 export type BackupScheduleFormValues = Omit<
 	InternalFormValues,
-	"excludePatternsText" | "excludeIfPresentText" | "includePatterns" | "customResticParamsText"
+	| "excludePatternsText"
+	| "excludeIfPresentText"
+	| "includePatterns"
+	| "customResticParamsText"
+	| "preBackupWebhookUrl"
+	| "preBackupWebhookHeadersText"
+	| "preBackupWebhookBody"
+	| "postBackupWebhookUrl"
+	| "postBackupWebhookHeadersText"
+	| "postBackupWebhookBody"
 > & {
 	excludePatterns?: string[];
 	excludeIfPresent?: string[];
 	includePatterns?: string[];
 	customResticParams?: string[];
+	backupWebhooks?: BackupWebhooks | null;
 };
diff --git a/app/client/modules/backups/components/create-schedule-form/utils.ts b/app/client/modules/backups/components/create-schedule-form/utils.ts
index bae1367d..314a8118 100644
--- a/app/client/modules/backups/components/create-schedule-form/utils.ts
+++ b/app/client/modules/backups/components/create-schedule-form/utils.ts
@@ -2,13 +2,29 @@ import type { BackupSchedule } from "~/client/lib/types";
 import { cronToFormValues } from "../../lib/cron-utils";
 import type { InternalFormValues } from "./types";
 
-export const parseMultilineEntries = (value?: string) =>
-	value
-		? value
-				.split("\n")
-				.map((entry) => entry.trim())
-				.filter(Boolean)
-		: [];
+export const parseMultilineEntries = (value?: string) => {
+	if (!value) {
+		return [];
+	}
+
+	return value
+		.split("\n")
+		.map((entry) => entry.trim())
+		.filter(Boolean);
+};
+
+export const toWebhookConfig = (url?: string, headers?: string, body?: string) => {
+	const trimmedUrl = url?.trim();
+	const parsedHeaders = parseMultilineEntries(headers);
+
+	return trimmedUrl
+		? {
+				url: trimmedUrl,
+				headers: parsedHeaders.length > 0 ? parsedHeaders : undefined,
+				body: body === "" ? undefined : body,
+			}
+		: null;
+};
 
 export const backupScheduleToFormValues = (schedule?: BackupSchedule): InternalFormValues | undefined => {
 	if (!schedule) {
@@ -26,6 +42,12 @@ export const backupScheduleToFormValues = (schedule?: BackupSchedule): InternalF
 		excludeIfPresentText: schedule.excludeIfPresent?.join("\n") || undefined,
 		oneFileSystem: schedule.oneFileSystem ?? false,
 		customResticParamsText: schedule.customResticParams?.join("\n") ?? "",
+		preBackupWebhookUrl: schedule.backupWebhooks?.pre?.url ?? "",
+		preBackupWebhookHeadersText: schedule.backupWebhooks?.pre?.headers?.join("\n") ?? "",
+		preBackupWebhookBody: schedule.backupWebhooks?.pre?.body ?? "",
+		postBackupWebhookUrl: schedule.backupWebhooks?.post?.url ?? "",
+		postBackupWebhookHeadersText: schedule.backupWebhooks?.post?.headers?.join("\n") ?? "",
+		postBackupWebhookBody: schedule.backupWebhooks?.post?.body ?? "",
 		maxRetries: schedule.maxRetries,
 		retryDelay: schedule.retryDelay,
 		...cronValues,
diff --git a/app/client/modules/backups/routes/__tests__/backup-details.test.tsx b/app/client/modules/backups/routes/__tests__/backup-details.test.tsx
index 26863d30..d4447fde 100644
--- a/app/client/modules/backups/routes/__tests__/backup-details.test.tsx
+++ b/app/client/modules/backups/routes/__tests__/backup-details.test.tsx
@@ -79,6 +79,7 @@ const schedule = {
 	excludeIfPresent: [],
 	oneFileSystem: false,
 	customResticParams: [],
+	backupWebhooks: null,
 };
 
 const snapshot = {
diff --git a/app/client/modules/backups/routes/__tests__/edit-backup.test.tsx b/app/client/modules/backups/routes/__tests__/edit-backup.test.tsx
index 3d61bdb2..6ca557d4 100644
--- a/app/client/modules/backups/routes/__tests__/edit-backup.test.tsx
+++ b/app/client/modules/backups/routes/__tests__/edit-backup.test.tsx
@@ -49,6 +49,7 @@ const renderEditBackupPage = ({ enabled, cronExpression }: { enabled: boolean; c
 					excludeIfPresent: [],
 					oneFileSystem: false,
 					customResticParams: [],
+					backupWebhooks: null,
 				});
 			}),
 			http.get("/api/v1/repositories", () => {
@@ -124,3 +125,28 @@ test("preserves a disabled schedule when saving a non-manual frequency", async (
 		cronExpression: "00 02 * * *",
 	});
 });
+
+test("submits webhook headers and body as plain config values", async () => {
+	const { submittedBody } = renderEditBackupPage({ enabled: true, cronExpression: "0 2 * * *" });
+
+	await userEvent.click(await screen.findByText("Advanced"));
+	await userEvent.type(screen.getByLabelText("Pre-backup webhook"), "http://localhost:8080/stop");
+	fireEvent.change(screen.getByLabelText("Pre-backup webhook headers"), {
+		target: { value: "Authorization: Bearer stop-token" },
+	});
+	fireEvent.change(screen.getByLabelText("Pre-backup webhook body"), {
+		target: { value: '{"action":"stop"}' },
+	});
+	await userEvent.click(screen.getByRole("button", { name: "Update schedule" }));
+
+	await expect(submittedBody).resolves.toMatchObject({
+		backupWebhooks: {
+			pre: {
+				url: "http://localhost:8080/stop",
+				headers: ["Authorization: Bearer stop-token"],
+				body: '{"action":"stop"}',
+			},
+			post: null,
+		},
+	});
+});
diff --git a/app/client/modules/backups/routes/backup-details.tsx b/app/client/modules/backups/routes/backup-details.tsx
index 0e7358a1..243f520e 100644
--- a/app/client/modules/backups/routes/backup-details.tsx
+++ b/app/client/modules/backups/routes/backup-details.tsx
@@ -167,6 +167,7 @@ export function ScheduleDetailsPage(props: Props) {
 				excludeIfPresent: schedule.excludeIfPresent || [],
 				oneFileSystem: schedule.oneFileSystem,
 				customResticParams: schedule.customResticParams || [],
+				backupWebhooks: schedule.backupWebhooks,
 			},
 		});
 	};
diff --git a/app/client/modules/backups/routes/create-backup.tsx b/app/client/modules/backups/routes/create-backup.tsx
index 571ac99b..a2bf9591 100644
--- a/app/client/modules/backups/routes/create-backup.tsx
+++ b/app/client/modules/backups/routes/create-backup.tsx
@@ -75,6 +75,7 @@ export function CreateBackupPage() {
 				excludeIfPresent: formValues.excludeIfPresent,
 				oneFileSystem: formValues.oneFileSystem,
 				customResticParams: formValues.customResticParams,
+				backupWebhooks: formValues.backupWebhooks,
 				maxRetries: formValues.maxRetries,
 				retryDelay: formValues.retryDelay,
 			},
diff --git a/app/client/modules/notifications/components/notification-forms/generic-form.tsx b/app/client/modules/notifications/components/notification-forms/generic-form.tsx
index a62ce1e7..8f46fe21 100644
--- a/app/client/modules/notifications/components/notification-forms/generic-form.tsx
+++ b/app/client/modules/notifications/components/notification-forms/generic-form.tsx
@@ -4,8 +4,7 @@ import { Input } from "~/client/components/ui/input";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "~/client/components/ui/select";
 import { Checkbox } from "~/client/components/ui/checkbox";
 import { Textarea } from "~/client/components/ui/textarea";
-import { CodeBlock } from "~/client/components/ui/code-block";
-import { Label } from "~/client/components/ui/label";
+import { WebhookRequestPreview } from "~/client/components/webhook-request-preview";
 import type { NotificationFormValues } from "../create-notification-form";
 
 type Props = {
@@ -35,16 +34,14 @@ const WebhookPreview = ({ values }: { values: Partial<NotificationFormValues> })
 		body = "Notification message";
 	}
 
-	const previewCode = `${values.method} ${values.url}\nContent-Type: ${contentType}${headers.length > 0 ? `\n${headers.join("\n")}` : ""}
-
-${body}`;
-
 	return (
-		<div className="space-y-2 pt-4 border-t">
-			<Label>Request Preview</Label>
-			<CodeBlock code={previewCode} filename="HTTP Request" />
-			<p className="text-[0.8rem] text-muted-foreground">This is a preview of the HTTP request that will be sent.</p>
-		</div>
+		<WebhookRequestPreview
+			method={values.method || "POST"}
+			url={values.url}
+			contentType={contentType}
+			headers={headers}
+			body={body}
+		/>
 	);
 };
 
diff --git a/app/drizzle/20260429214453_classy_namora/migration.sql b/app/drizzle/20260429214453_classy_namora/migration.sql
new file mode 100644
index 00000000..95edb8b8
--- /dev/null
+++ b/app/drizzle/20260429214453_classy_namora/migration.sql
@@ -0,0 +1 @@
+ALTER TABLE `backup_schedules_table` ADD `backup_webhooks` text;
\ No newline at end of file
diff --git a/app/drizzle/20260429214453_classy_namora/snapshot.json b/app/drizzle/20260429214453_classy_namora/snapshot.json
new file mode 100644
index 00000000..e3d9599c
--- /dev/null
+++ b/app/drizzle/20260429214453_classy_namora/snapshot.json
@@ -0,0 +1,2341 @@
+{
+	"version": "7",
+	"dialect": "sqlite",
+	"id": "1a572f3e-6b7d-4761-8df3-7b28115506e3",
+	"prevIds": ["11dfb429-048c-4f65-abf1-f25ac2ae9d93"],
+	"ddl": [
+		{
+			"name": "account",
+			"entityType": "tables"
+		},
+		{
+			"name": "app_metadata",
+			"entityType": "tables"
+		},
+		{
+			"name": "backup_schedule_mirrors_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "backup_schedule_notifications_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "backup_schedules_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "invitation",
+			"entityType": "tables"
+		},
+		{
+			"name": "member",
+			"entityType": "tables"
+		},
+		{
+			"name": "notification_destinations_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "organization",
+			"entityType": "tables"
+		},
+		{
+			"name": "repositories_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "sessions_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "sso_provider",
+			"entityType": "tables"
+		},
+		{
+			"name": "two_factor",
+			"entityType": "tables"
+		},
+		{
+			"name": "users_table",
+			"entityType": "tables"
+		},
+		{
+			"name": "verification",
+			"entityType": "tables"
+		},
+		{
+			"name": "volumes_table",
+			"entityType": "tables"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "account_id",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "provider_id",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "user_id",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "access_token",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "refresh_token",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id_token",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "access_token_expires_at",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "refresh_token_expires_at",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "scope",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "password",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "account"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "key",
+			"entityType": "columns",
+			"table": "app_metadata"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "value",
+			"entityType": "columns",
+			"table": "app_metadata"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "app_metadata"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "app_metadata"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": true,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "schedule_id",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "repository_id",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "true",
+			"generated": null,
+			"name": "enabled",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_copy_at",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_copy_status",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_copy_error",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "schedule_id",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "destination_id",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "notify_on_start",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "notify_on_success",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "true",
+			"generated": null,
+			"name": "notify_on_warning",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "true",
+			"generated": null,
+			"name": "notify_on_failure",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": true,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "short_id",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "name",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "volume_id",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "repository_id",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "true",
+			"generated": null,
+			"name": "enabled",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "cron_expression",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "retention_policy",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'[]'",
+			"generated": null,
+			"name": "exclude_patterns",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'[]'",
+			"generated": null,
+			"name": "exclude_if_present",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'[]'",
+			"generated": null,
+			"name": "include_paths",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'[]'",
+			"generated": null,
+			"name": "include_patterns",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_backup_at",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_backup_status",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_backup_error",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "next_backup_at",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "one_file_system",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'[]'",
+			"generated": null,
+			"name": "custom_restic_params",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "backup_webhooks",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "0",
+			"generated": null,
+			"name": "sort_order",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "0",
+			"generated": null,
+			"name": "failure_retry_count",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "2",
+			"generated": null,
+			"name": "max_retries",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "900000",
+			"generated": null,
+			"name": "retry_delay",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "backup_schedules_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "email",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "role",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'pending'",
+			"generated": null,
+			"name": "status",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "expires_at",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "inviter_id",
+			"entityType": "columns",
+			"table": "invitation"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "member"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "member"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "user_id",
+			"entityType": "columns",
+			"table": "member"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'member'",
+			"generated": null,
+			"name": "role",
+			"entityType": "columns",
+			"table": "member"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "member"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": true,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "name",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "true",
+			"generated": null,
+			"name": "enabled",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "type",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "config",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "notification_destinations_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "organization"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "name",
+			"entityType": "columns",
+			"table": "organization"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "slug",
+			"entityType": "columns",
+			"table": "organization"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "logo",
+			"entityType": "columns",
+			"table": "organization"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "organization"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "metadata",
+			"entityType": "columns",
+			"table": "organization"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "short_id",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "provisioning_id",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "name",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "type",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "config",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'auto'",
+			"generated": null,
+			"name": "compression_mode",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": "'unknown'",
+			"generated": null,
+			"name": "status",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_checked",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_error",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "doctor_result",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "stats",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "stats_updated_at",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "upload_limit_enabled",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "real",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "1",
+			"generated": null,
+			"name": "upload_limit_value",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'Mbps'",
+			"generated": null,
+			"name": "upload_limit_unit",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "download_limit_enabled",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "real",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "1",
+			"generated": null,
+			"name": "download_limit_value",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'Mbps'",
+			"generated": null,
+			"name": "download_limit_unit",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "repositories_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "user_id",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "token",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "expires_at",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "ip_address",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "user_agent",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "impersonated_by",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "active_organization_id",
+			"entityType": "columns",
+			"table": "sessions_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "provider_id",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "user_id",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "issuer",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "domain",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "auto_link_matching_emails",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "oidc_config",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "saml_config",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "sso_provider"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "two_factor"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "secret",
+			"entityType": "columns",
+			"table": "two_factor"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "backup_codes",
+			"entityType": "columns",
+			"table": "two_factor"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "user_id",
+			"entityType": "columns",
+			"table": "two_factor"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "username",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "password_hash",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "has_downloaded_restic_password",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'MM/DD/YYYY'",
+			"generated": null,
+			"name": "date_format",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'12h'",
+			"generated": null,
+			"name": "time_format",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "name",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "email",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "email_verified",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "image",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "display_username",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "two_factor_enabled",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'user'",
+			"generated": null,
+			"name": "role",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "false",
+			"generated": null,
+			"name": "banned",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "ban_reason",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "ban_expires",
+			"entityType": "columns",
+			"table": "users_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "verification"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "identifier",
+			"entityType": "columns",
+			"table": "verification"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "value",
+			"entityType": "columns",
+			"table": "verification"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "expires_at",
+			"entityType": "columns",
+			"table": "verification"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "verification"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "verification"
+		},
+		{
+			"type": "integer",
+			"notNull": false,
+			"autoincrement": true,
+			"default": null,
+			"generated": null,
+			"name": "id",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "short_id",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "provisioning_id",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "name",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "type",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "'unmounted'",
+			"generated": null,
+			"name": "status",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": false,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "last_error",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "last_health_check",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "created_at",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "(unixepoch() * 1000)",
+			"generated": null,
+			"name": "updated_at",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "config",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "integer",
+			"notNull": true,
+			"autoincrement": false,
+			"default": "true",
+			"generated": null,
+			"name": "auto_remount",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"type": "text",
+			"notNull": true,
+			"autoincrement": false,
+			"default": null,
+			"generated": null,
+			"name": "organization_id",
+			"entityType": "columns",
+			"table": "volumes_table"
+		},
+		{
+			"columns": ["user_id"],
+			"tableTo": "users_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "account_user_id_users_table_id_fk",
+			"entityType": "fks",
+			"table": "account"
+		},
+		{
+			"columns": ["schedule_id"],
+			"tableTo": "backup_schedules_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedule_mirrors_table_schedule_id_backup_schedules_table_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"columns": ["repository_id"],
+			"tableTo": "repositories_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedule_mirrors_table_repository_id_repositories_table_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"columns": ["schedule_id"],
+			"tableTo": "backup_schedules_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedule_notifications_table_schedule_id_backup_schedules_table_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"columns": ["destination_id"],
+			"tableTo": "notification_destinations_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedule_notifications_table_destination_id_notification_destinations_table_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"columns": ["volume_id"],
+			"tableTo": "volumes_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedules_table_volume_id_volumes_table_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedules_table"
+		},
+		{
+			"columns": ["repository_id"],
+			"tableTo": "repositories_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedules_table_repository_id_repositories_table_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedules_table"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "backup_schedules_table_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "backup_schedules_table"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "invitation_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "invitation"
+		},
+		{
+			"columns": ["inviter_id"],
+			"tableTo": "users_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "invitation_inviter_id_users_table_id_fk",
+			"entityType": "fks",
+			"table": "invitation"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "member_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "member"
+		},
+		{
+			"columns": ["user_id"],
+			"tableTo": "users_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "member_user_id_users_table_id_fk",
+			"entityType": "fks",
+			"table": "member"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "notification_destinations_table_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "notification_destinations_table"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "repositories_table_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "repositories_table"
+		},
+		{
+			"columns": ["user_id"],
+			"tableTo": "users_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "sessions_table_user_id_users_table_id_fk",
+			"entityType": "fks",
+			"table": "sessions_table"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "fk_sso_provider_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "sso_provider"
+		},
+		{
+			"columns": ["user_id"],
+			"tableTo": "users_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "SET NULL",
+			"nameExplicit": false,
+			"name": "fk_sso_provider_user_id_users_table_id_fk",
+			"entityType": "fks",
+			"table": "sso_provider"
+		},
+		{
+			"columns": ["user_id"],
+			"tableTo": "users_table",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "two_factor_user_id_users_table_id_fk",
+			"entityType": "fks",
+			"table": "two_factor"
+		},
+		{
+			"columns": ["organization_id"],
+			"tableTo": "organization",
+			"columnsTo": ["id"],
+			"onUpdate": "NO ACTION",
+			"onDelete": "CASCADE",
+			"nameExplicit": false,
+			"name": "volumes_table_organization_id_organization_id_fk",
+			"entityType": "fks",
+			"table": "volumes_table"
+		},
+		{
+			"columns": ["schedule_id", "destination_id"],
+			"nameExplicit": false,
+			"name": "backup_schedule_notifications_table_schedule_id_destination_id_pk",
+			"entityType": "pks",
+			"table": "backup_schedule_notifications_table"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "account_pk",
+			"table": "account",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["key"],
+			"nameExplicit": false,
+			"name": "app_metadata_pk",
+			"table": "app_metadata",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "backup_schedule_mirrors_table_pk",
+			"table": "backup_schedule_mirrors_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "backup_schedules_table_pk",
+			"table": "backup_schedules_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "invitation_pk",
+			"table": "invitation",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "member_pk",
+			"table": "member",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "notification_destinations_table_pk",
+			"table": "notification_destinations_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "organization_pk",
+			"table": "organization",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "repositories_table_pk",
+			"table": "repositories_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "sessions_table_pk",
+			"table": "sessions_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "sso_provider_pk",
+			"table": "sso_provider",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "two_factor_pk",
+			"table": "two_factor",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "users_table_pk",
+			"table": "users_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "verification_pk",
+			"table": "verification",
+			"entityType": "pks"
+		},
+		{
+			"columns": ["id"],
+			"nameExplicit": false,
+			"name": "volumes_table_pk",
+			"table": "volumes_table",
+			"entityType": "pks"
+		},
+		{
+			"columns": [
+				{
+					"value": "user_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "account_userId_idx",
+			"entityType": "indexes",
+			"table": "account"
+		},
+		{
+			"columns": [
+				{
+					"value": "organization_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "invitation_organizationId_idx",
+			"entityType": "indexes",
+			"table": "invitation"
+		},
+		{
+			"columns": [
+				{
+					"value": "email",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "invitation_email_idx",
+			"entityType": "indexes",
+			"table": "invitation"
+		},
+		{
+			"columns": [
+				{
+					"value": "organization_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "member_organizationId_idx",
+			"entityType": "indexes",
+			"table": "member"
+		},
+		{
+			"columns": [
+				{
+					"value": "user_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "member_userId_idx",
+			"entityType": "indexes",
+			"table": "member"
+		},
+		{
+			"columns": [
+				{
+					"value": "organization_id",
+					"isExpression": false
+				},
+				{
+					"value": "user_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": true,
+			"where": null,
+			"origin": "manual",
+			"name": "member_org_user_uidx",
+			"entityType": "indexes",
+			"table": "member"
+		},
+		{
+			"columns": [
+				{
+					"value": "slug",
+					"isExpression": false
+				}
+			],
+			"isUnique": true,
+			"where": null,
+			"origin": "manual",
+			"name": "organization_slug_uidx",
+			"entityType": "indexes",
+			"table": "organization"
+		},
+		{
+			"columns": [
+				{
+					"value": "organization_id",
+					"isExpression": false
+				},
+				{
+					"value": "provisioning_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": true,
+			"where": null,
+			"origin": "manual",
+			"name": "repositories_table_org_provisioning_id_uidx",
+			"entityType": "indexes",
+			"table": "repositories_table"
+		},
+		{
+			"columns": [
+				{
+					"value": "user_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "sessionsTable_userId_idx",
+			"entityType": "indexes",
+			"table": "sessions_table"
+		},
+		{
+			"columns": [
+				{
+					"value": "secret",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "twoFactor_secret_idx",
+			"entityType": "indexes",
+			"table": "two_factor"
+		},
+		{
+			"columns": [
+				{
+					"value": "user_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "twoFactor_userId_idx",
+			"entityType": "indexes",
+			"table": "two_factor"
+		},
+		{
+			"columns": [
+				{
+					"value": "identifier",
+					"isExpression": false
+				}
+			],
+			"isUnique": false,
+			"where": null,
+			"origin": "manual",
+			"name": "verification_identifier_idx",
+			"entityType": "indexes",
+			"table": "verification"
+		},
+		{
+			"columns": [
+				{
+					"value": "organization_id",
+					"isExpression": false
+				},
+				{
+					"value": "provisioning_id",
+					"isExpression": false
+				}
+			],
+			"isUnique": true,
+			"where": null,
+			"origin": "manual",
+			"name": "volumes_table_org_provisioning_id_uidx",
+			"entityType": "indexes",
+			"table": "volumes_table"
+		},
+		{
+			"columns": ["schedule_id", "repository_id"],
+			"nameExplicit": false,
+			"name": "backup_schedule_mirrors_table_schedule_id_repository_id_unique",
+			"entityType": "uniques",
+			"table": "backup_schedule_mirrors_table"
+		},
+		{
+			"columns": ["name", "organization_id"],
+			"nameExplicit": false,
+			"name": "volumes_table_name_organization_id_unique",
+			"entityType": "uniques",
+			"table": "volumes_table"
+		},
+		{
+			"columns": ["short_id"],
+			"nameExplicit": false,
+			"name": "backup_schedules_table_short_id_unique",
+			"entityType": "uniques",
+			"table": "backup_schedules_table"
+		},
+		{
+			"columns": ["short_id"],
+			"nameExplicit": false,
+			"name": "repositories_table_short_id_unique",
+			"entityType": "uniques",
+			"table": "repositories_table"
+		},
+		{
+			"columns": ["token"],
+			"nameExplicit": false,
+			"name": "sessions_table_token_unique",
+			"entityType": "uniques",
+			"table": "sessions_table"
+		},
+		{
+			"columns": ["provider_id"],
+			"nameExplicit": false,
+			"name": "sso_provider_provider_id_unique",
+			"entityType": "uniques",
+			"table": "sso_provider"
+		},
+		{
+			"columns": ["username"],
+			"nameExplicit": false,
+			"name": "users_table_username_unique",
+			"entityType": "uniques",
+			"table": "users_table"
+		},
+		{
+			"columns": ["email"],
+			"nameExplicit": false,
+			"name": "users_table_email_unique",
+			"entityType": "uniques",
+			"table": "users_table"
+		},
+		{
+			"columns": ["short_id"],
+			"nameExplicit": false,
+			"name": "volumes_table_short_id_unique",
+			"entityType": "uniques",
+			"table": "volumes_table"
+		}
+	],
+	"renames": []
+}
diff --git a/app/server/db/schema.ts b/app/server/db/schema.ts
index 8ba21f41..5fd8439a 100644
--- a/app/server/db/schema.ts
+++ b/app/server/db/schema.ts
@@ -9,6 +9,7 @@ import type {
 	DoctorResult,
 	ResticStatsDto,
 } from "@zerobyte/core/restic";
+import type { BackupWebhooks } from "@zerobyte/core/backup-hooks";
 import type { BackendConfig, BackendStatus, BackendType } from "~/schemas/volumes";
 import type { NotificationConfig, NotificationType } from "~/schemas/notifications";
 import type { ShortId } from "~/server/utils/branded";
@@ -310,6 +311,7 @@ export const backupSchedulesTable = sqliteTable("backup_schedules_table", {
 	nextBackupAt: int("next_backup_at", { mode: "number" }),
 	oneFileSystem: int("one_file_system", { mode: "boolean" }).notNull().default(false),
 	customResticParams: text("custom_restic_params", { mode: "json" }).$type<string[]>().default([]),
+	backupWebhooks: text("backup_webhooks", { mode: "json" }).$type<BackupWebhooks | null>(),
 	sortOrder: int("sort_order", { mode: "number" }).notNull().default(0),
 	failureRetryCount: int("failure_retry_count").notNull().default(0),
 	maxRetries: int("max_retries").notNull().default(2),
diff --git a/app/server/modules/agents/__tests__/session.test.ts b/app/server/modules/agents/__tests__/session.test.ts
index de184c01..34c66339 100644
--- a/app/server/modules/agents/__tests__/session.test.ts
+++ b/app/server/modules/agents/__tests__/session.test.ts
@@ -144,6 +144,7 @@ test("close emits a synthetic backup.cancelled for a queued backup", () => {
 				defaultExcludes: [],
 				rcloneConfigFile: "/tmp/rclone.conf",
 			},
+			webhooks: { pre: null, post: null },
 		}),
 	);
 
diff --git a/app/server/modules/backups/__tests__/backups.service.execution.test.ts b/app/server/modules/backups/__tests__/backups.service.execution.test.ts
index 9dedf873..a4d363aa 100644
--- a/app/server/modules/backups/__tests__/backups.service.execution.test.ts
+++ b/app/server/modules/backups/__tests__/backups.service.execution.test.ts
@@ -276,6 +276,41 @@ describe("backup execution - validation failures", () => {
 		).toBe(false);
 	});
 
+	test("passes configured backup webhooks to the backup agent", async () => {
+		const { runBackupMock } = setup();
+		const volume = await createTestVolume();
+		const repository = await createTestRepository();
+		const backupWebhooks = {
+			pre: {
+				url: "http://localhost:8080/stop",
+				headers: ["authorization: Bearer stop-token"],
+				body: '{"action":"stop"}',
+			},
+			post: {
+				url: "http://localhost:8080/start",
+				headers: ["authorization: Bearer start-token"],
+				body: '{"action":"start"}',
+			},
+		};
+
+		const schedule = await createTestBackupSchedule({
+			volumeId: volume.id,
+			repositoryId: repository.id,
+			backupWebhooks,
+		});
+
+		await backupsService.executeBackup(schedule.id);
+
+		expect(runBackupMock).toHaveBeenCalledWith(
+			"local",
+			expect.objectContaining({
+				payload: expect.objectContaining({
+					webhooks: backupWebhooks,
+				}),
+			}),
+		);
+	});
+
 	test("should fail backup when the local agent is unavailable", async () => {
 		const { runBackupMock } = setup();
 		const volume = await createTestVolume();
diff --git a/app/server/modules/backups/__tests__/backups.service.test.ts b/app/server/modules/backups/__tests__/backups.service.test.ts
index 8b927e44..f7a5f9ba 100644
--- a/app/server/modules/backups/__tests__/backups.service.test.ts
+++ b/app/server/modules/backups/__tests__/backups.service.test.ts
@@ -402,6 +402,62 @@ describe("manual only schedules", () => {
 	});
 });
 
+describe("schedule webhooks", () => {
+	test("stores pre and post backup webhooks when creating a schedule", async () => {
+		setup();
+		const volume = await createTestVolume();
+		const repository = await createTestRepository();
+
+		const backupWebhooks = {
+			pre: {
+				url: "http://localhost:8080/stop",
+				headers: ["authorization: Bearer stop-token"],
+				body: '{"action":"stop"}',
+			},
+			post: {
+				url: "http://localhost:8080/start",
+				headers: ["authorization: Bearer start-token"],
+				body: '{"action":"start"}',
+			},
+		};
+
+		const schedule = await backupsService.createSchedule({
+			name: "with-webhooks",
+			volumeId: volume.shortId,
+			repositoryId: repository.shortId,
+			enabled: true,
+			cronExpression: "0 0 * * *",
+			backupWebhooks,
+			retryDelay: 15 * 60 * 1000,
+			maxRetries: 2,
+		});
+
+		expect(schedule.backupWebhooks).toEqual(backupWebhooks);
+	});
+
+	test("clears backup webhooks when updating a schedule with null values", async () => {
+		setup();
+		const repository = await createTestRepository();
+		const schedule = await createTestBackupSchedule({
+			repositoryId: repository.id,
+			backupWebhooks: {
+				pre: { url: "http://localhost:8080/stop" },
+				post: { url: "http://localhost:8080/start" },
+			},
+		});
+
+		const updated = await backupsService.updateSchedule(schedule.id, {
+			repositoryId: repository.shortId,
+			cronExpression: schedule.cronExpression,
+			backupWebhooks: null,
+			retryDelay: 15 * 60 * 1000,
+			maxRetries: 2,
+		});
+
+		expect(updated.backupWebhooks).toBeNull();
+	});
+});
+
 describe("listSchedules", () => {
 	test("should ignore schedules with missing relations", async () => {
 		setup();
diff --git a/app/server/modules/backups/backup-executor.ts b/app/server/modules/backups/backup-executor.ts
index 93cb420b..c604f286 100644
--- a/app/server/modules/backups/backup-executor.ts
+++ b/app/server/modules/backups/backup-executor.ts
@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { runBackupLifecycle } from "@zerobyte/core/backup-hooks";
 import type { BackupSchedule, Volume, Repository } from "../../db/schema";
 import { config } from "../../core/config";
 import { restic, resticDeps } from "../../core/restic";
@@ -54,6 +55,7 @@ const createBackupRunPayload = async ({
 			rcloneConfigFile: resticDeps.rcloneConfigFile,
 			hostname: resticDeps.hostname,
 		},
+		webhooks: schedule.backupWebhooks ?? { pre: null, post: null },
 	};
 };
 
@@ -61,41 +63,21 @@ const executeBackupWithoutAgent = async (
 	payload: BackupRunPayload,
 	{ signal, onProgress }: Pick<BackupExecutionRequest, "signal" | "onProgress">,
 ) => {
-	try {
-		const execution = await Effect.runPromise(
-			restic
-				.backup(payload.repositoryConfig, payload.sourcePath, {
-					...payload.options,
-					organizationId: payload.organizationId,
-					signal,
-					onProgress,
-				})
-				.pipe(
-					Effect.map((result) => ({ success: true as const, result })),
-					Effect.catchAll((error) => Effect.succeed({ success: false as const, error })),
-				),
-		);
-
-		if (!execution.success) {
-			return {
-				status: "failed" as const,
-				error: toErrorDetails(execution.error),
-			};
-		}
-
-		const { exitCode, result, warningDetails } = execution.result;
-		return {
-			status: "completed" as const,
-			exitCode,
-			result,
-			warningDetails,
-		};
-	} catch (error) {
-		return {
-			status: "failed" as const,
-			error: toErrorDetails(error),
-		};
-	}
+	return Effect.runPromise(
+		runBackupLifecycle({
+			restic,
+			repositoryConfig: payload.repositoryConfig,
+			sourcePath: payload.sourcePath,
+			jobId: payload.jobId,
+			scheduleId: payload.scheduleId,
+			organizationId: payload.organizationId,
+			options: payload.options,
+			webhooks: payload.webhooks,
+			signal,
+			onProgress,
+			formatError: toErrorDetails,
+		}),
+	);
 };
 
 export const backupExecutor = {
diff --git a/app/server/modules/backups/backups.controller.ts b/app/server/modules/backups/backups.controller.ts
index f7a31a71..950bf219 100644
--- a/app/server/modules/backups/backups.controller.ts
+++ b/app/server/modules/backups/backups.controller.ts
@@ -2,11 +2,13 @@ import { Hono } from "hono";
 import { validator } from "hono-openapi";
 import {
 	createBackupScheduleBody,
+	createBackupScheduleResponse,
 	createBackupScheduleDto,
 	deleteBackupScheduleDto,
 	getBackupScheduleDto,
 	getBackupScheduleResponse,
 	getBackupScheduleForVolumeDto,
+	getBackupScheduleForVolumeResponse,
 	listBackupSchedulesDto,
 	listBackupSchedulesResponse,
 	runBackupNowDto,
@@ -14,6 +16,7 @@ import {
 	stopBackupDto,
 	updateBackupScheduleDto,
 	updateBackupScheduleBody,
+	updateBackupScheduleResponse,
 	getScheduleMirrorsDto,
 	updateScheduleMirrorsDto,
 	updateScheduleMirrorsBody,
@@ -73,20 +76,20 @@ export const backupScheduleController = new Hono()
 		const volumeShortId = asShortId(c.req.param("volumeShortId"));
 		const schedule = await backupsService.getScheduleForVolume(volumeShortId);
 
-		return c.json<GetBackupScheduleForVolumeResponseDto>(schedule, 200);
+		return c.json<GetBackupScheduleForVolumeResponseDto>(getBackupScheduleForVolumeResponse.parse(schedule), 200);
 	})
 	.post("/", createBackupScheduleDto, validator("json", createBackupScheduleBody), async (c) => {
 		const body = c.req.valid("json");
 		const schedule = await backupsService.createSchedule(body);
 
-		return c.json<CreateBackupScheduleDto>(schedule, 201);
+		return c.json<CreateBackupScheduleDto>(createBackupScheduleResponse.parse(schedule), 201);
 	})
 	.patch("/:shortId", updateBackupScheduleDto, validator("json", updateBackupScheduleBody), async (c) => {
 		const shortId = asShortId(c.req.param("shortId"));
 		const body = c.req.valid("json");
 		const schedule = await backupsService.updateSchedule(shortId, body);
 
-		return c.json<UpdateBackupScheduleDto>(schedule, 200);
+		return c.json<UpdateBackupScheduleDto>(updateBackupScheduleResponse.parse(schedule), 200);
 	})
 	.delete("/:shortId", deleteBackupScheduleDto, async (c) => {
 		const shortId = asShortId(c.req.param("shortId"));
diff --git a/app/server/modules/backups/backups.dto.ts b/app/server/modules/backups/backups.dto.ts
index 9244cdce..c785b130 100644
--- a/app/server/modules/backups/backups.dto.ts
+++ b/app/server/modules/backups/backups.dto.ts
@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { describeRoute, resolver } from "hono-openapi";
+import { backupWebhooksSchema } from "@zerobyte/core/backup-hooks";
 import { volumeSchema } from "../volumes/volume.dto";
 import { repositorySchema } from "../repositories/repositories.dto";
 import { backupProgressEventSchema } from "~/schemas/events-dto";
@@ -29,6 +30,7 @@ const backupScheduleSchema = z.object({
 	includePatterns: z.array(z.string()).nullable(),
 	oneFileSystem: z.boolean(),
 	customResticParams: z.array(z.string()).nullable(),
+	backupWebhooks: backupWebhooksSchema.nullable(),
 	maxRetries: z.number(),
 	retryDelay: z.number().transform((ms) => Math.round(ms / 60000)),
 	lastBackupAt: z.number().nullable(),
@@ -92,7 +94,7 @@ export const getBackupScheduleDto = describeRoute({
 	},
 });
 
-const getBackupScheduleForVolumeResponse = backupScheduleSchema.nullable();
+export const getBackupScheduleForVolumeResponse = backupScheduleSchema.nullable();
 
 export type GetBackupScheduleForVolumeResponseDto = z.infer<typeof getBackupScheduleForVolumeResponse>;
 
@@ -126,6 +128,7 @@ export const createBackupScheduleBody = z.object({
 	oneFileSystem: z.boolean().optional(),
 	tags: z.array(z.string()).optional(),
 	customResticParams: z.array(z.string()).optional(),
+	backupWebhooks: backupWebhooksSchema.nullable().optional(),
 	maxRetries: z.number().min(0).max(32).optional().default(2),
 	retryDelay: z
 		.number()
@@ -138,7 +141,7 @@ export const createBackupScheduleBody = z.object({
 
 export type CreateBackupScheduleBody = z.infer<typeof createBackupScheduleBody>;
 
-const createBackupScheduleResponse = backupScheduleSchema.omit({ volume: true, repository: true });
+export const createBackupScheduleResponse = backupScheduleSchema.omit({ volume: true, repository: true });
 
 export type CreateBackupScheduleDto = z.infer<typeof createBackupScheduleResponse>;
 
@@ -171,6 +174,7 @@ export const updateBackupScheduleBody = z.object({
 	oneFileSystem: z.boolean().optional(),
 	tags: z.array(z.string()).optional(),
 	customResticParams: z.array(z.string()).optional(),
+	backupWebhooks: backupWebhooksSchema.nullable().optional(),
 	maxRetries: z.number().min(0).max(32).optional().default(2),
 	retryDelay: z
 		.number()
@@ -183,7 +187,7 @@ export const updateBackupScheduleBody = z.object({
 
 export type UpdateBackupScheduleBody = z.infer<typeof updateBackupScheduleBody>;
 
-const updateBackupScheduleResponse = backupScheduleSchema.omit({ volume: true, repository: true });
+export const updateBackupScheduleResponse = backupScheduleSchema.omit({ volume: true, repository: true });
 
 export type UpdateBackupScheduleDto = z.infer<typeof updateBackupScheduleResponse>;
 
diff --git a/app/server/modules/backups/backups.service.ts b/app/server/modules/backups/backups.service.ts
index 04b15896..7b8246c9 100644
--- a/app/server/modules/backups/backups.service.ts
+++ b/app/server/modules/backups/backups.service.ts
@@ -104,6 +104,7 @@ const createSchedule = async (data: CreateBackupScheduleBody) => {
 			includePatterns: data.includePatterns ?? [],
 			oneFileSystem: data.oneFileSystem,
 			customResticParams: data.customResticParams ?? [],
+			backupWebhooks: data.backupWebhooks ?? null,
 			nextBackupAt: nextBackupAt,
 			shortId: generateShortId(),
 			maxRetries: data.maxRetries,
@@ -163,7 +164,13 @@ const updateSchedule = async (scheduleIdOrShortId: number | string, data: Update
 
 	const [updated] = await db
 		.update(backupSchedulesTable)
-		.set({ ...data, repositoryId: repository.id, nextBackupAt, updatedAt: Date.now() })
+		.set({
+			...data,
+			repositoryId: repository.id,
+			backupWebhooks: data.backupWebhooks === undefined ? schedule.backupWebhooks : data.backupWebhooks,
+			nextBackupAt,
+			updatedAt: Date.now(),
+		})
 		.where(and(eq(backupSchedulesTable.id, schedule.id), eq(backupSchedulesTable.organizationId, organizationId)))
 		.returning();
 
diff --git a/app/server/modules/backups/helpers/backup-lifecycle.ts b/app/server/modules/backups/helpers/backup-lifecycle.ts
index 522a0166..ba89e80a 100644
--- a/app/server/modules/backups/helpers/backup-lifecycle.ts
+++ b/app/server/modules/backups/helpers/backup-lifecycle.ts
@@ -149,7 +149,7 @@ export async function finalizeSuccessfulBackup(
 	warningDetails: string | null,
 ) {
 	const scheduleId = ctx.schedule.id;
-	const finalStatus = exitCode === 0 ? "success" : "warning";
+	const finalStatus = exitCode === 0 && !warningDetails ? "success" : "warning";
 
 	if (ctx.schedule.retentionPolicy) {
 		void runForget(scheduleId, undefined, ctx.organizationId).catch((error) => {
diff --git a/apps/agent/src/__tests__/controller-session.test.ts b/apps/agent/src/__tests__/controller-session.test.ts
index 4f238b8f..d8d630f4 100644
--- a/apps/agent/src/__tests__/controller-session.test.ts
+++ b/apps/agent/src/__tests__/controller-session.test.ts
@@ -46,6 +46,7 @@ test("emits backup.failed when a backup command hits a restic error", async () =
 					defaultExcludes: [],
 					rcloneConfigFile: "/root/.config/rclone/rclone.conf",
 				},
+				webhooks: { pre: null, post: null },
 			}),
 		);
 
diff --git a/apps/agent/src/commands/backup-run.test.ts b/apps/agent/src/commands/backup-run.test.ts
index fb65677b..aee05a58 100644
--- a/apps/agent/src/commands/backup-run.test.ts
+++ b/apps/agent/src/commands/backup-run.test.ts
@@ -1,5 +1,7 @@
-import { afterEach, expect, test, vi } from "vitest";
 import { Effect } from "effect";
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, expect, test, vi } from "vitest";
 import waitForExpect from "wait-for-expect";
 import { fromPartial } from "@total-typescript/shoehorn";
 import { parseAgentMessage, type BackupCancelPayload, type BackupRunPayload } from "@zerobyte/contracts/agent-protocol";
@@ -8,6 +10,12 @@ import { handleBackupCancelCommand } from "./backup-cancel";
 import { handleBackupRunCommand } from "./backup-run";
 import type { ControllerCommandContext, RunningJob } from "../context";
 
+const server = setupServer();
+
+beforeAll(() => {
+	server.listen({ onUnhandledRequest: "error" });
+});
+
 const createDeferred = <T>() => {
 	let resolve!: (value: T) => void;
 	const promise = new Promise<T>((resolvePromise) => {
@@ -19,6 +27,253 @@ const createDeferred = <T>() => {
 
 afterEach(() => {
 	vi.restoreAllMocks();
+	server.resetHandlers();
+});
+
+afterAll(() => {
+	server.close();
+});
+
+const createRunPayload = (overrides: Partial<BackupRunPayload> = {}) =>
+	fromPartial<BackupRunPayload>({
+		jobId: "job-1",
+		scheduleId: "schedule-1",
+		organizationId: "org-1",
+		sourcePath: "/tmp/source",
+		repositoryConfig: {
+			backend: "local",
+			path: "/tmp/repository",
+		},
+		options: {},
+		runtime: {
+			password: "password",
+			cacheDir: "/tmp/restic-cache",
+			passFile: "/tmp/restic-pass",
+			defaultExcludes: [],
+			rcloneConfigFile: "/tmp/rclone.conf",
+		},
+		webhooks: { pre: null, post: null },
+		...overrides,
+	});
+
+const runBackupCommand = async (payload: BackupRunPayload) => {
+	const outboundMessages: string[] = [];
+	const runningJobs = new Map<string, RunningJob>();
+
+	const context: ControllerCommandContext = {
+		getRunningJob: (jobId) => Effect.succeed(runningJobs.get(jobId)),
+		setRunningJob: (jobId, job) =>
+			Effect.sync(() => {
+				runningJobs.set(jobId, job);
+			}),
+		deleteRunningJob: (jobId) =>
+			Effect.sync(() => {
+				runningJobs.delete(jobId);
+			}),
+		offerOutbound: (message) =>
+			Effect.sync(() => {
+				outboundMessages.push(message);
+				return true;
+			}),
+	};
+
+	await Effect.runPromise(
+		Effect.gen(function* () {
+			yield* handleBackupRunCommand(context, payload);
+			yield* Effect.promise(() =>
+				waitForExpect(() => {
+					expect(runningJobs.has(payload.jobId)).toBe(false);
+				}),
+			);
+		}),
+	);
+
+	return outboundMessages.map((message) => parseAgentMessage(message));
+};
+
+test("runs pre and post backup webhooks around restic", async () => {
+	const events: string[] = [];
+
+	server.use(
+		http.post("http://localhost:8080/pre", async ({ request }) => {
+			const body = (await request.json()) as { event: string };
+			events.push(body.event);
+			return new HttpResponse(null, { status: 204 });
+		}),
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			const body = (await request.json()) as { event: string };
+			events.push(body.event);
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	vi.spyOn(resticServer, "createRestic").mockReturnValue(
+		fromPartial({
+			backup: () =>
+				Effect.sync(() => {
+					events.push("restic");
+					return { exitCode: 0, result: null, warningDetails: null };
+				}),
+		}),
+	);
+
+	const messages = await runBackupCommand(
+		createRunPayload({
+			webhooks: {
+				pre: { url: "http://localhost:8080/pre" },
+				post: { url: "http://localhost:8080/post" },
+			},
+		}),
+	);
+
+	expect(events).toEqual(["backup.pre", "restic", "backup.post"]);
+	expect(messages.some((message) => message?.success && message.data.type === "backup.completed")).toBe(true);
+});
+
+test("sends configured webhook headers and body without changing them", async () => {
+	const requests: Array<{ url: string; headers: Headers; body: string }> = [];
+
+	server.use(
+		http.post("http://localhost:8080/pre", async ({ request }) => {
+			requests.push({
+				url: request.url,
+				headers: request.headers,
+				body: await request.text(),
+			});
+			return new HttpResponse(null, { status: 204 });
+		}),
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			requests.push({
+				url: request.url,
+				headers: request.headers,
+				body: await request.text(),
+			});
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	vi.spyOn(resticServer, "createRestic").mockReturnValue(
+		fromPartial({
+			backup: () => Effect.succeed({ exitCode: 0, result: null, warningDetails: null }),
+		}),
+	);
+
+	await runBackupCommand(
+		createRunPayload({
+			webhooks: {
+				pre: {
+					url: "http://localhost:8080/pre",
+					headers: ["authorization: Bearer pre-token", "content-type: application/json"],
+					body: '{"action":"stop"}',
+				},
+				post: {
+					url: "http://localhost:8080/post",
+					headers: ["authorization: Bearer post-token"],
+					body: "start-container",
+				},
+			},
+		}),
+	);
+
+	expect(requests).toHaveLength(2);
+	expect(requests[0]?.url).toBe("http://localhost:8080/pre");
+	expect(requests[0]?.headers.get("authorization")).toBe("Bearer pre-token");
+	expect(requests[0]?.headers.get("content-type")).toBe("application/json");
+	expect(requests[0]?.body).toBe('{"action":"stop"}');
+	expect(requests[1]?.url).toBe("http://localhost:8080/post");
+	expect(requests[1]?.headers.get("authorization")).toBe("Bearer post-token");
+	expect(requests[1]?.body).toBe("start-container");
+});
+
+test("fails without running restic when the pre-backup webhook fails", async () => {
+	const backupMock = vi.fn();
+	server.use(
+		http.post("http://localhost:8080/pre", () => {
+			return new HttpResponse("stop failed", { status: 500 });
+		}),
+	);
+	vi.spyOn(resticServer, "createRestic").mockReturnValue(
+		fromPartial({
+			backup: backupMock,
+		}),
+	);
+
+	const messages = await runBackupCommand(
+		createRunPayload({
+			webhooks: {
+				pre: { url: "http://localhost:8080/pre" },
+				post: null,
+			},
+		}),
+	);
+
+	const failed = messages.find((message) => message?.success && message.data.type === "backup.failed");
+	expect(backupMock).not.toHaveBeenCalled();
+	expect(failed?.success).toBe(true);
+	if (failed?.success && failed.data.type === "backup.failed") {
+		expect(failed.data.payload.errorDetails).toContain("pre webhook returned HTTP 500");
+	}
+});
+
+test("reports a post-backup webhook failure as completed warning details", async () => {
+	server.use(
+		http.post("http://localhost:8080/post", () => {
+			return new HttpResponse("start failed", { status: 500 });
+		}),
+	);
+	vi.spyOn(resticServer, "createRestic").mockReturnValue(
+		fromPartial({
+			backup: () => Effect.succeed({ exitCode: 0, result: null, warningDetails: null }),
+		}),
+	);
+
+	const messages = await runBackupCommand(
+		createRunPayload({
+			webhooks: {
+				pre: null,
+				post: { url: "http://localhost:8080/post" },
+			},
+		}),
+	);
+
+	const completed = messages.find((message) => message?.success && message.data.type === "backup.completed");
+	expect(completed?.success).toBe(true);
+	if (completed?.success && completed.data.type === "backup.completed") {
+		expect(completed.data.payload.warningDetails).toContain("post webhook returned HTTP 500");
+	}
+});
+
+test("includes post-backup webhook failure details when a backup is cancelled", async () => {
+	server.use(
+		http.post("http://localhost:8080/post", () => {
+			return new HttpResponse("start failed", { status: 500 });
+		}),
+	);
+	vi.spyOn(resticServer, "createRestic").mockReturnValue(
+		fromPartial({
+			backup: (_config: unknown, _source: string, options: { signal: AbortSignal }) =>
+				Effect.sync(() => {
+					vi.spyOn(options.signal, "aborted", "get").mockReturnValue(true);
+					vi.spyOn(options.signal, "reason", "get").mockReturnValue(new Error("Backup was cancelled"));
+					return { exitCode: 0, result: null, warningDetails: null };
+				}),
+		}),
+	);
+
+	const messages = await runBackupCommand(
+		createRunPayload({
+			webhooks: {
+				pre: null,
+				post: { url: "http://localhost:8080/post" },
+			},
+		}),
+	);
+
+	const cancelled = messages.find((message) => message?.success && message.data.type === "backup.cancelled");
+	expect(cancelled?.success).toBe(true);
+	if (cancelled?.success && cancelled.data.type === "backup.cancelled") {
+		expect(cancelled.data.payload.message).toContain("post webhook returned HTTP 500: start failed");
+	}
 });
 
 test("waits for running-job registration before returning to the processor loop", async () => {
@@ -78,6 +333,7 @@ test("waits for running-job registration before returning to the processor loop"
 			passFile: "/tmp/restic-pass",
 			defaultExcludes: [],
 		},
+		webhooks: { pre: null, post: null },
 	});
 	const cancelPayload = fromPartial<BackupCancelPayload>({
 		jobId: "job-1",
diff --git a/apps/agent/src/commands/backup-run.ts b/apps/agent/src/commands/backup-run.ts
index 56511d4e..8943be92 100644
--- a/apps/agent/src/commands/backup-run.ts
+++ b/apps/agent/src/commands/backup-run.ts
@@ -1,9 +1,10 @@
 import { Effect, Runtime } from "effect";
 import { createAgentMessage, type BackupRunPayload } from "@zerobyte/contracts/agent-protocol";
+import { runBackupLifecycle } from "@zerobyte/core/backup-hooks";
 import { logger } from "@zerobyte/core/node";
 import { type ResticDeps } from "@zerobyte/core/restic";
 import { createRestic } from "@zerobyte/core/restic/server";
-import { toErrorDetails, toMessage } from "@zerobyte/core/utils";
+import { toMessage } from "@zerobyte/core/utils";
 import type { ControllerCommandContext } from "../context";
 
 export const handleBackupRunCommand = (context: ControllerCommandContext, payload: BackupRunPayload) => {
@@ -26,12 +27,12 @@ export const handleBackupRunCommand = (context: ControllerCommandContext, payloa
 
 		yield* Effect.fork(
 			Effect.gen(function* () {
-				const sendCancelled = () => {
+				const sendCancelled = (message?: string) => {
 					return context.offerOutbound(
 						createAgentMessage("backup.cancelled", {
 							jobId: payload.jobId,
 							scheduleId: payload.scheduleId,
-							message: "Backup was cancelled",
+							message: message ?? "Backup was cancelled",
 						}),
 					);
 				};
@@ -56,61 +57,59 @@ export const handleBackupRunCommand = (context: ControllerCommandContext, payloa
 				const restic = createRestic(deps);
 				const runtime = yield* Effect.runtime<never>();
 
-				yield* restic
-					.backup(payload.repositoryConfig, payload.sourcePath, {
-						organizationId: payload.organizationId,
-						...payload.options,
-						signal: abortController.signal,
-						onProgress: (progress) => {
-							void Runtime.runPromise(
-								runtime,
-								context.offerOutbound(
-									createAgentMessage("backup.progress", {
-										jobId: payload.jobId,
-										scheduleId: payload.scheduleId,
-										progress,
-									}),
-								),
-							).catch((error) => {
-								logger.error(`Failed to send backup progress update: ${toMessage(error)}`);
-							});
-						},
-					})
-					.pipe(
-						Effect.matchEffect({
-							onSuccess: (result) => {
-								if (abortController.signal.aborted) {
-									return sendCancelled();
-								}
+				const backupResult = yield* runBackupLifecycle({
+					restic,
+					repositoryConfig: payload.repositoryConfig,
+					sourcePath: payload.sourcePath,
+					jobId: payload.jobId,
+					scheduleId: payload.scheduleId,
+					organizationId: payload.organizationId,
+					options: payload.options,
+					webhooks: payload.webhooks,
+					signal: abortController.signal,
+					onProgress: (progress) => {
+						void Runtime.runPromise(
+							runtime,
+							context.offerOutbound(
+								createAgentMessage("backup.progress", {
+									jobId: payload.jobId,
+									scheduleId: payload.scheduleId,
+									progress,
+								}),
+							),
+						).catch((error) => {
+							logger.error(`Failed to send backup progress update: ${toMessage(error)}`);
+						});
+					},
+				});
 
-								return context.offerOutbound(
-									createAgentMessage("backup.completed", {
-										jobId: payload.jobId,
-										scheduleId: payload.scheduleId,
-										exitCode: result.exitCode,
-										result: result.result,
-										warningDetails: result.warningDetails ?? undefined,
-									}),
-								);
-							},
-							onFailure: (error) => {
-								if (abortController.signal.aborted) {
-									return sendCancelled();
-								}
-
-								return context.offerOutbound(
-									createAgentMessage("backup.failed", {
-										jobId: payload.jobId,
-										scheduleId: payload.scheduleId,
-										error: toMessage(error),
-										errorDetails: toErrorDetails(error),
-									}),
-								);
-							},
-						}),
-						Effect.ensuring(context.deleteRunningJob(payload.jobId)),
-					);
-			}),
+				switch (backupResult.status) {
+					case "completed":
+						yield* context.offerOutbound(
+							createAgentMessage("backup.completed", {
+								jobId: payload.jobId,
+								scheduleId: payload.scheduleId,
+								exitCode: backupResult.exitCode,
+								result: backupResult.result,
+								warningDetails: backupResult.warningDetails ?? undefined,
+							}),
+						);
+						return;
+					case "failed":
+						yield* context.offerOutbound(
+							createAgentMessage("backup.failed", {
+								jobId: payload.jobId,
+								scheduleId: payload.scheduleId,
+								error: toMessage(backupResult.error),
+								errorDetails: backupResult.error,
+							}),
+						);
+						return;
+					case "cancelled":
+						yield* sendCancelled(backupResult.message);
+						return;
+				}
+			}).pipe(Effect.ensuring(context.deleteRunningJob(payload.jobId))),
 		);
 	}).pipe(Effect.asVoid);
 };
diff --git a/packages/contracts/src/agent-protocol.ts b/packages/contracts/src/agent-protocol.ts
index 3144514b..28e575db 100644
--- a/packages/contracts/src/agent-protocol.ts
+++ b/packages/contracts/src/agent-protocol.ts
@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { backupWebhooksSchema } from "@zerobyte/core/backup-hooks";
 import { safeJsonParse } from "@zerobyte/core/utils";
 import {
 	repositoryConfigSchema,
@@ -39,6 +40,7 @@ const backupRunSchema = z.object({
 		repositoryConfig: repositoryConfigSchema,
 		options: backupExecutionOptionsSchema,
 		runtime: backupRuntimeSchema,
+		webhooks: backupWebhooksSchema,
 	}),
 });
 
diff --git a/packages/core/package.json b/packages/core/package.json
index 90face3e..f60e7406 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -18,6 +18,11 @@
 			"import": "./src/utils/index.ts",
 			"default": "./src/utils/index.ts"
 		},
+		"./backup-hooks": {
+			"types": "./src/backup-hooks/index.ts",
+			"import": "./src/backup-hooks/index.ts",
+			"default": "./src/backup-hooks/index.ts"
+		},
 		"./node": {
 			"types": "./src/node/index.ts",
 			"import": "./src/node/index.ts",
diff --git a/packages/core/src/backup-hooks/__tests__/hooks.test.ts b/packages/core/src/backup-hooks/__tests__/hooks.test.ts
new file mode 100644
index 00000000..6f0bea6b
--- /dev/null
+++ b/packages/core/src/backup-hooks/__tests__/hooks.test.ts
@@ -0,0 +1,383 @@
+import { Effect } from "effect";
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, expect, test } from "vitest";
+import { runBackupLifecycle } from "../index.js";
+
+const server = setupServer();
+
+beforeAll(() => {
+	server.listen({ onUnhandledRequest: "error" });
+});
+
+afterEach(() => {
+	server.resetHandlers();
+});
+
+afterAll(() => {
+	server.close();
+});
+
+const metadata = {
+	jobId: "job-1",
+	scheduleId: "schedule-1",
+	organizationId: "org-1",
+	sourcePath: "/tmp/source",
+};
+
+const defaultSignal = () => new AbortController().signal;
+
+const completedBackup = <TResult>(result: TResult, exitCode = 0, warningDetails: string | null = null) =>
+	Effect.succeed({ exitCode, result, warningDetails });
+
+const runWithHooks = <TResult>(
+	overrides: Omit<Partial<Parameters<typeof runBackupLifecycle<TResult>>[0]>, "restic"> & {
+		runBackup: () => Effect.Effect<{ exitCode: number; result: TResult; warningDetails: string | null }, unknown>;
+	},
+) => {
+	const { runBackup, ...options } = overrides;
+
+	return Effect.runPromise(
+		runBackupLifecycle({
+			...metadata,
+			restic: { backup: runBackup },
+			repositoryConfig: { backend: "local", path: "/tmp/repository" },
+			options: {},
+			webhooks: { pre: null, post: null },
+			signal: defaultSignal(),
+			...options,
+		}),
+	);
+};
+
+type WebhookBody = {
+	phase?: string;
+	event?: string;
+	jobId?: string;
+	scheduleId?: string;
+	organizationId?: string;
+	sourcePath?: string;
+	status?: string;
+	error?: string;
+};
+
+test("runs pre and post webhooks around a successful backup", async () => {
+	const events: string[] = [];
+	let preBody: WebhookBody | undefined;
+	let postBody: WebhookBody | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/pre", async ({ request }) => {
+			events.push("pre");
+			preBody = (await request.json()) as WebhookBody;
+			return new HttpResponse(null, { status: 204 });
+		}),
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			events.push("post");
+			postBody = (await request.json()) as WebhookBody;
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: { url: "http://localhost:8080/pre" },
+			post: { url: "http://localhost:8080/post" },
+		},
+		runBackup: () =>
+			Effect.sync(() => {
+				events.push("backup");
+				return { exitCode: 0, result: "snapshot-1", warningDetails: null };
+			}),
+	});
+
+	expect(events).toEqual(["pre", "backup", "post"]);
+	expect(preBody).toMatchObject({ ...metadata, phase: "pre", event: "backup.pre" });
+	expect(postBody).toMatchObject({ ...metadata, phase: "post", event: "backup.post", status: "success" });
+	expect(result).toEqual({ status: "completed", exitCode: 0, result: "snapshot-1", warningDetails: null });
+});
+
+test("sends warning details to the post-backup webhook for a non-zero completed backup", async () => {
+	let postBody: WebhookBody | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			postBody = (await request.json()) as WebhookBody;
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: { url: "http://localhost:8080/post" },
+		},
+		runBackup: () => completedBackup("snapshot-1", 3, "some files could not be read"),
+	});
+
+	expect(postBody).toMatchObject({ status: "warning", error: "some files could not be read" });
+	expect(result).toEqual({
+		status: "completed",
+		exitCode: 3,
+		result: "snapshot-1",
+		warningDetails: "some files could not be read",
+	});
+});
+
+test("sends error details to the post-backup webhook when the backup fails", async () => {
+	let postBody: WebhookBody | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			postBody = (await request.json()) as WebhookBody;
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: { url: "http://localhost:8080/post" },
+		},
+		runBackup: () => Effect.fail(new Error("restic failed")),
+	});
+
+	expect(postBody).toMatchObject({ status: "error", error: "restic failed" });
+	expect(result).toEqual({ status: "failed", error: "restic failed" });
+});
+
+test("fails without running the backup or post webhook when the pre-backup webhook fails", async () => {
+	let backupRan = false;
+	let postRan = false;
+
+	server.use(
+		http.post("http://localhost:8080/pre", () => {
+			return new HttpResponse("stop failed", { status: 500 });
+		}),
+		http.post("http://localhost:8080/post", () => {
+			postRan = true;
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: { url: "http://localhost:8080/pre" },
+			post: { url: "http://localhost:8080/post" },
+		},
+		runBackup: () =>
+			Effect.sync(() => {
+				backupRan = true;
+				return { exitCode: 0, result: null, warningDetails: null };
+			}),
+	});
+
+	expect(backupRan).toBe(false);
+	expect(postRan).toBe(false);
+	expect(result.status).toBe("failed");
+	if (result.status === "failed") {
+		expect(result.error).toContain("pre webhook returned HTTP 500: stop failed");
+	}
+});
+
+test("sends configured webhook headers and body without replacing them", async () => {
+	let body: string | undefined;
+	let authorization: string | null | undefined;
+	let contentType: string | null | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			body = await request.text();
+			authorization = request.headers.get("authorization");
+			contentType = request.headers.get("content-type");
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: {
+				url: "http://localhost:8080/post",
+				headers: ["authorization: Bearer post-token"],
+				body: "start-container",
+			},
+		},
+		runBackup: () => completedBackup(null),
+	});
+
+	expect(body).toBe("start-container");
+	expect(authorization).toBe("Bearer post-token");
+	expect(contentType).toBeNull();
+});
+
+test("runs the post-backup webhook after cancellation without using the cancelled signal", async () => {
+	const abortController = new AbortController();
+	let postBody: { status?: string; error?: string } | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			postBody = (await request.json()) as { status?: string; error?: string };
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: { url: "http://localhost:8080/post" },
+		},
+		signal: abortController.signal,
+		runBackup: () =>
+			Effect.gen(function* () {
+				abortController.abort(new Error("Backup was cancelled"));
+				return yield* Effect.fail(new Error("restic cancelled"));
+			}),
+	});
+
+	expect(postBody).toMatchObject({ status: "cancelled", error: "restic cancelled" });
+	expect(result).toEqual({ status: "cancelled", message: "Backup was cancelled" });
+});
+
+test("runs the post-backup webhook when cancellation returns a completed backup result", async () => {
+	const abortController = new AbortController();
+	let postBody: { status?: string; error?: string } | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			postBody = (await request.json()) as { status?: string; error?: string };
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: { url: "http://localhost:8080/post" },
+		},
+		signal: abortController.signal,
+		runBackup: () =>
+			Effect.sync(() => {
+				abortController.abort(new Error("Backup was cancelled"));
+				return { exitCode: 0, result: null, warningDetails: null };
+			}),
+	});
+
+	expect(postBody).toMatchObject({ status: "cancelled" });
+	expect(result).toEqual({ status: "cancelled", message: "Backup was cancelled" });
+});
+
+test("includes post-backup webhook failure details after cancellation", async () => {
+	const abortController = new AbortController();
+	let postBody: { status?: string; error?: string } | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			postBody = (await request.json()) as { status?: string; error?: string };
+			return new HttpResponse("start failed", { status: 500 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: { url: "http://localhost:8080/post" },
+		},
+		signal: abortController.signal,
+		runBackup: () =>
+			Effect.gen(function* () {
+				abortController.abort(new Error("Backup was cancelled"));
+				return yield* Effect.fail(new Error("restic cancelled"));
+			}),
+	});
+
+	expect(postBody).toMatchObject({ status: "cancelled", error: "restic cancelled" });
+	expect(result.status).toBe("cancelled");
+	if (result.status === "cancelled") {
+		expect(result.message).toContain("Backup was cancelled");
+		expect(result.message).toContain("post webhook returned HTTP 500: start failed");
+	}
+});
+
+test("includes post-backup webhook failure details after completed cancellation", async () => {
+	const abortController = new AbortController();
+	let postBody: { status?: string; error?: string } | undefined;
+
+	server.use(
+		http.post("http://localhost:8080/post", async ({ request }) => {
+			postBody = (await request.json()) as { status?: string; error?: string };
+			return new HttpResponse("cleanup failed", { status: 500 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: null,
+			post: { url: "http://localhost:8080/post" },
+		},
+		signal: abortController.signal,
+		runBackup: () =>
+			Effect.sync(() => {
+				abortController.abort(new Error("Backup was cancelled"));
+				return { exitCode: 0, result: null, warningDetails: null };
+			}),
+	});
+
+	expect(postBody).toMatchObject({ status: "cancelled", error: "Backup was cancelled" });
+	expect(result.status).toBe("cancelled");
+	if (result.status === "cancelled") {
+		expect(result.message).toContain("Backup was cancelled");
+		expect(result.message).toContain("post webhook returned HTTP 500: cleanup failed");
+	}
+});
+
+test("cancels before the pre-backup webhook without running the backup", async () => {
+	const abortController = new AbortController();
+	let backupRan = false;
+
+	abortController.abort(new Error("Backup was cancelled"));
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: { url: "http://localhost:8080/pre" },
+			post: { url: "http://localhost:8080/post" },
+		},
+		signal: abortController.signal,
+		runBackup: () =>
+			Effect.sync(() => {
+				backupRan = true;
+				return { exitCode: 0, result: null, warningDetails: null };
+			}),
+	});
+
+	expect(backupRan).toBe(false);
+	expect(result).toEqual({ status: "cancelled", message: "Backup was cancelled" });
+});
+
+test("cancels after the pre-backup webhook without running the backup", async () => {
+	const abortController = new AbortController();
+	let backupRan = false;
+
+	server.use(
+		http.post("http://localhost:8080/pre", () => {
+			abortController.abort(new Error("Backup was cancelled"));
+			return new HttpResponse(null, { status: 204 });
+		}),
+	);
+
+	const result = await runWithHooks({
+		webhooks: {
+			pre: { url: "http://localhost:8080/pre" },
+			post: null,
+		},
+		signal: abortController.signal,
+		runBackup: () =>
+			Effect.sync(() => {
+				backupRan = true;
+				return { exitCode: 0, result: null, warningDetails: null };
+			}),
+	});
+
+	expect(backupRan).toBe(false);
+	expect(result).toEqual({ status: "cancelled", message: "Backup was cancelled" });
+});
diff --git a/packages/core/src/backup-hooks/index.ts b/packages/core/src/backup-hooks/index.ts
new file mode 100644
index 00000000..3ef95a69
--- /dev/null
+++ b/packages/core/src/backup-hooks/index.ts
@@ -0,0 +1,280 @@
+import { Data, Effect } from "effect";
+import { z } from "zod";
+import type { CompressionMode, RepositoryConfig, ResticBackupProgressDto } from "../restic/index.js";
+import { toErrorDetails, toMessage } from "../utils/index.js";
+
+const DEFAULT_BACKUP_WEBHOOK_TIMEOUT_MS = 60_000;
+
+export const backupWebhookConfigSchema = z.object({
+	url: z.url(),
+	headers: z.array(z.string()).optional(),
+	body: z.string().optional(),
+});
+
+export const backupWebhooksSchema = z.object({
+	pre: backupWebhookConfigSchema.nullable(),
+	post: backupWebhookConfigSchema.nullable(),
+});
+
+export type BackupWebhookConfig = z.infer<typeof backupWebhookConfigSchema>;
+export type BackupWebhooks = z.infer<typeof backupWebhooksSchema>;
+
+type BackupWebhookPhase = "pre" | "post";
+type BackupWebhookStatus = "success" | "warning" | "error" | "cancelled";
+
+type BackupWebhookContext = {
+	phase: BackupWebhookPhase;
+	event: "backup.pre" | "backup.post";
+	jobId: string;
+	scheduleId: string;
+	organizationId: string;
+	sourcePath: string;
+	status?: BackupWebhookStatus;
+	error?: string;
+};
+
+type BackupResult<TResult> = { exitCode: number; result: TResult; warningDetails: string | null };
+
+type BackupLifecycleResult<TResult> =
+	| { status: "completed"; exitCode: number; result: TResult; warningDetails: string | null }
+	| { status: "failed"; error: string }
+	| { status: "cancelled"; message?: string };
+
+type BackupOptions = {
+	tags?: string[];
+	oneFileSystem?: boolean;
+	exclude?: string[];
+	excludeIfPresent?: string[];
+	includePaths?: string[];
+	includePatterns?: string[];
+	customResticParams?: string[];
+	compressionMode?: CompressionMode;
+};
+
+type BackupLifecycleOptions<TResult> = {
+	jobId: string;
+	scheduleId: string;
+	organizationId: string;
+	sourcePath: string;
+	restic: {
+		backup: (
+			config: RepositoryConfig,
+			sourcePath: string,
+			options: BackupOptions & {
+				organizationId: string;
+				signal: AbortSignal;
+				onProgress?: (progress: ResticBackupProgressDto) => void;
+			},
+		) => Effect.Effect<BackupResult<TResult>, unknown>;
+	};
+	repositoryConfig: RepositoryConfig;
+	options: BackupOptions;
+	webhooks: BackupWebhooks;
+	signal: AbortSignal;
+	onProgress?: (progress: ResticBackupProgressDto) => void;
+	formatError?: (error: unknown) => string;
+};
+
+class BackupWebhookError extends Data.TaggedError("BackupWebhookError")<{
+	cause: unknown;
+	message: string;
+}> {}
+
+const appendDetails = (primary: string | null | undefined, next: string | null | undefined) => {
+	return [primary, next].filter(Boolean).join("\n\n");
+};
+
+const getCompletedStatus = (exitCode: number, signal: AbortSignal): BackupWebhookStatus => {
+	if (signal.aborted) {
+		return "cancelled";
+	}
+
+	return exitCode === 0 ? "success" : "warning";
+};
+
+const createAbortController = (timeoutMs: number, signal?: AbortSignal) => {
+	const abortController = new AbortController();
+	const timeout = setTimeout(() => {
+		abortController.abort(new Error(`Webhook timed out after ${Math.round(timeoutMs / 1000)} seconds`));
+	}, timeoutMs);
+
+	const abortFromSignal = () => {
+		abortController.abort(signal?.reason || new Error("Operation aborted"));
+	};
+
+	if (signal?.aborted) {
+		abortFromSignal();
+	} else {
+		signal?.addEventListener("abort", abortFromSignal, { once: true });
+	}
+
+	return {
+		signal: abortController.signal,
+		cleanup: () => {
+			clearTimeout(timeout);
+			signal?.removeEventListener("abort", abortFromSignal);
+		},
+	};
+};
+
+const createRequestInit = (config: BackupWebhookConfig, context: BackupWebhookContext): RequestInit => {
+	const headers = new Headers();
+	const body = config.body ?? JSON.stringify(context);
+
+	if (config.body === undefined) {
+		headers.set("content-type", "application/json");
+	}
+
+	for (const header of config.headers ?? []) {
+		const [name, ...valueParts] = header.split(":");
+
+		if (name && valueParts.length > 0) {
+			headers.set(name.trim(), valueParts.join(":").trim());
+		}
+	}
+
+	return { method: "POST", headers, body };
+};
+
+const runBackupWebhook = (
+	config: BackupWebhookConfig | null,
+	context: BackupWebhookContext,
+	options: {
+		formatError: (error: unknown) => string;
+		signal?: AbortSignal;
+		timeoutMs?: number;
+	},
+) =>
+	Effect.suspend(() => {
+		if (!config) {
+			return Effect.succeed(null);
+		}
+
+		const timeoutMs = options.timeoutMs ?? DEFAULT_BACKUP_WEBHOOK_TIMEOUT_MS;
+		const controller = createAbortController(timeoutMs, options.signal);
+
+		return Effect.tryPromise({
+			try: async () => {
+				const response = await fetch(config.url, { ...createRequestInit(config, context), signal: controller.signal });
+
+				if (!response.ok) {
+					const responseText = await response.text().catch(() => "");
+					const details = responseText.trim().slice(0, 500);
+					throw new BackupWebhookError({
+						cause: new Error(`${context.phase} webhook returned HTTP ${response.status}`),
+						message: `${context.phase} webhook returned HTTP ${response.status}${details ? `: ${details}` : ""}`,
+					});
+				}
+			},
+			catch: (error) => {
+				if (error instanceof BackupWebhookError) {
+					return error;
+				}
+
+				if (controller.signal.aborted && controller.signal.reason instanceof Error) {
+					return new BackupWebhookError({
+						cause: controller.signal.reason,
+						message: `${context.phase} webhook failed: ${controller.signal.reason.message}`,
+					});
+				}
+
+				return new BackupWebhookError({
+					cause: error,
+					message: `${context.phase} webhook failed: ${toMessage(error)}`,
+				});
+			},
+		}).pipe(
+			Effect.as(null),
+			Effect.catchAll((error) => Effect.succeed(options.formatError(error))),
+			Effect.ensuring(Effect.sync(controller.cleanup)),
+		);
+	});
+
+export const runBackupLifecycle = <TResult>({
+	jobId,
+	scheduleId,
+	organizationId,
+	sourcePath,
+	restic,
+	repositoryConfig,
+	options,
+	webhooks,
+	signal,
+	onProgress,
+	formatError = toErrorDetails,
+}: BackupLifecycleOptions<TResult>): Effect.Effect<BackupLifecycleResult<TResult>, never> =>
+	Effect.gen(function* () {
+		const context = { jobId, scheduleId, organizationId, sourcePath };
+		const preHookError = yield* runBackupWebhook(
+			webhooks.pre,
+			{ ...context, phase: "pre", event: "backup.pre" },
+			{
+				formatError,
+				signal,
+			},
+		);
+		if (preHookError) {
+			if (signal.aborted) {
+				return { status: "cancelled", message: formatError(signal.reason) };
+			}
+
+			return { status: "failed", error: preHookError };
+		}
+		if (signal.aborted) {
+			return { status: "cancelled", message: formatError(signal.reason) };
+		}
+
+		const backupResult = yield* Effect.suspend(() =>
+			restic.backup(repositoryConfig, sourcePath, { ...options, organizationId, signal, onProgress }),
+		).pipe(
+			Effect.map((result) => ({
+				status: "completed" as const,
+				...result,
+				hookStatus: getCompletedStatus(result.exitCode, signal),
+				hookError: signal.aborted ? formatError(signal.reason) : (result.warningDetails ?? undefined),
+			})),
+			Effect.catchAll((error) => {
+				const errorDetails = formatError(error);
+
+				return Effect.succeed({
+					status: "failed" as const,
+					errorDetails,
+					hookStatus: signal.aborted ? ("cancelled" as const) : ("error" as const),
+					hookError: errorDetails,
+				});
+			}),
+		);
+
+		const postHookError = yield* runBackupWebhook(
+			webhooks.post,
+			{
+				...context,
+				phase: "post",
+				event: "backup.post",
+				status: backupResult.hookStatus,
+				error: backupResult.hookError,
+			},
+			{ formatError },
+		);
+
+		if (signal.aborted) {
+			return {
+				status: "cancelled",
+				message: appendDetails(formatError(signal.reason || backupResult.hookError), postHookError) || undefined,
+			};
+		}
+
+		if (backupResult.status === "completed") {
+			return {
+				status: "completed",
+				exitCode: backupResult.exitCode,
+				result: backupResult.result,
+				warningDetails: appendDetails(backupResult.warningDetails, postHookError) || null,
+			};
+		}
+
+		return {
+			status: "failed",
+			error: appendDetails(backupResult.errorDetails, postHookError) || backupResult.errorDetails,
+		};
+	});