diff --git a/src/components/BackupsTab.test.ts b/src/components/BackupsTab.test.ts
index a6c5249..a04f23e 100644
--- a/src/components/BackupsTab.test.ts
+++ b/src/components/BackupsTab.test.ts
@@ -15,6 +15,23 @@ vi.mock("@/services/api", () => ({
       data: { job: { id: "job-123", status: "completed", type: "backup" } },
     }),
     retryPublication: vi.fn().mockResolvedValue({ data: { backup: { status: "completed" } } }),
+    getDeploymentBackupDestinations: vi.fn().mockResolvedValue({ data: { destinations: [] } }),
+    getDeploymentBackupConfig: vi.fn().mockResolvedValue({ data: { backup_config: {} } }),
+    updateDeploymentBackupConfig: vi.fn().mockResolvedValue({ data: { backup_config: {} } }),
+    getDeploymentBackupPolicy: vi.fn().mockResolvedValue({
+      data: {
+        policy: {
+          config: {},
+          schedules: [],
+          backup_count: 0,
+          local_bytes: 0,
+          failed_count: 0,
+          size_alert: false,
+          cleanup_preview: { keep_count: 7, delete_ids: [], reclaimed_bytes: 0 },
+        },
+      },
+    }),
+    cleanupDeploymentBackups: vi.fn().mockResolvedValue({ data: { deleted: 0 } }),
   },
   schedulerApi: {
     listTasks: vi.fn().mockResolvedValue({ data: { tasks: [] } }),
@@ -30,6 +47,11 @@ const mockCreateDeploymentBackup = backupsApi.createDeploymentBackup as ReturnTy
 const mockDeleteBackup = backupsApi.delete as ReturnType<typeof vi.fn>;
 const mockRestoreBackup = backupsApi.restore as ReturnType<typeof vi.fn>;
 const mockRetryPublication = backupsApi.retryPublication as ReturnType<typeof vi.fn>;
+const mockGetBackupDestinations = backupsApi.getDeploymentBackupDestinations as ReturnType<typeof vi.fn>;
+const mockGetBackupConfig = backupsApi.getDeploymentBackupConfig as ReturnType<typeof vi.fn>;
+const mockUpdateBackupConfig = backupsApi.updateDeploymentBackupConfig as ReturnType<typeof vi.fn>;
+const mockGetBackupPolicy = backupsApi.getDeploymentBackupPolicy as ReturnType<typeof vi.fn>;
+const mockCleanupBackups = backupsApi.cleanupDeploymentBackups as ReturnType<typeof vi.fn>;
 const mockListTasks = schedulerApi.listTasks as ReturnType<typeof vi.fn>;
 const mockCreateTask = schedulerApi.createTask as ReturnType<typeof vi.fn>;
 
@@ -71,6 +93,21 @@ describe("BackupsTab", () => {
     vi.clearAllMocks();
     mockGetDeploymentBackups.mockResolvedValue({ data: { backups: [] } });
     mockListTasks.mockResolvedValue({ data: { tasks: [] } });
+    mockGetBackupDestinations.mockResolvedValue({ data: { destinations: [] } });
+    mockGetBackupConfig.mockResolvedValue({ data: { backup_config: {} } });
+    mockGetBackupPolicy.mockResolvedValue({
+      data: {
+        policy: {
+          config: {},
+          schedules: [],
+          backup_count: 0,
+          local_bytes: 0,
+          failed_count: 0,
+          size_alert: false,
+          cleanup_preview: { keep_count: 7, delete_ids: [], reclaimed_bytes: 0 },
+        },
+      },
+    });
     vi.stubGlobal("URL", {
       ...URL,
       createObjectURL: vi.fn().mockReturnValue("blob:backup"),
@@ -105,6 +142,60 @@ describe("BackupsTab", () => {
   };
 
   describe("Component structure", () => {
+    it("saves selected destinations for this deployment", async () => {
+      mockGetBackupDestinations.mockResolvedValue({
+        data: {
+          destinations: [
+            { name: "primary", kind: "external" },
+            { name: "archive", kind: "managed" },
+          ],
+        },
+      });
+      mockGetBackupConfig.mockResolvedValue({ data: { backup_config: { destinations: ["primary"] } } });
+      mockUpdateBackupConfig.mockResolvedValue({ data: { backup_config: { destinations: ["primary", "archive"] } } });
+      const wrapper = mountBackupsTab();
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      const archive = wrapper.findAll(".destination-option").find((option) => option.text().includes("archive"));
+      await archive!.find("input").setValue(true);
+      await wrapper
+        .findAll("button")
+        .find((button) => button.text().includes("Save policy"))!
+        .trigger("click");
+
+      expect(mockUpdateBackupConfig).toHaveBeenCalledWith("my-app", {
+        destinations: ["primary", "archive"],
+        retention_count: 7,
+        size_alert_bytes: 0,
+        exclude_patterns: [],
+      });
+    });
+
+    it("applies the retention value shown in the cleanup preview", async () => {
+      mockGetBackupPolicy.mockResolvedValue({
+        data: {
+          policy: {
+            config: { retention_count: 7 },
+            schedules: [],
+            backup_count: 9,
+            local_bytes: 0,
+            failed_count: 0,
+            size_alert: false,
+            cleanup_preview: { keep_count: 7, delete_ids: ["old"], reclaimed_bytes: 1 },
+          },
+        },
+      });
+      const wrapper = mountBackupsTab();
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await wrapper.find('input[type="number"]').setValue(1);
+      await wrapper
+        .findAll("button")
+        .find((button) => button.text().includes("Apply cleanup"))!
+        .trigger("click");
+
+      expect(mockCleanupBackups).toHaveBeenCalledWith("my-app", 7);
+    });
+
     it("renders the backups tab container", () => {
       const wrapper = mountBackupsTab();
       expect(wrapper.find(".backups-tab").exists()).toBe(true);
@@ -197,6 +288,18 @@ describe("BackupsTab", () => {
       expect(mockRetryPublication).toHaveBeenCalledWith("my-app", mockBackups[0].id);
     });
 
+    it("shows when a remote copy was verified", async () => {
+      const verified = [
+        {
+          ...mockBackups[0],
+          destination_results: [{ name: "archive", status: "completed", verified: true }],
+        },
+      ];
+      const wrapper = mountBackupsTab({ backups: verified as typeof mockBackups });
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      expect(wrapper.text()).toContain("archive: completed verified");
+    });
+
     it("does not offer publication retry for cleanup-only failures", async () => {
       const cleanupFailure = [
         {
@@ -259,7 +362,7 @@ describe("BackupsTab", () => {
 
       const restoreButtons = wrapper
         .findAll(".backup-actions .btn-secondary")
-        .filter((btn) => btn.text().includes("Restore"));
+        .filter((btn) => btn.text().trim() === "Restore");
       expect(restoreButtons.length).toBe(2);
     });
 
@@ -378,6 +481,29 @@ describe("BackupsTab", () => {
         "my-app",
       );
     });
+
+    it("restores into a separate deployment with isolation enabled", async () => {
+      const wrapper = mountBackupsTab({ backups: mockBackups });
+      await wrapper.vm.$nextTick();
+      await new Promise((r) => setTimeout(r, 10));
+      const vm = wrapper.vm as any;
+      vm.backupToRestore = mockBackups[0];
+      vm.isolatedDeploymentName = "my-app-recovery";
+
+      await vm.restoreBackupIsolated();
+
+      expect(mockRestoreBackup).toHaveBeenCalledWith(
+        "my-app_20250101_120000",
+        {
+          deployment_name: "my-app-recovery",
+          isolated: true,
+          restore_data: true,
+          restore_db: true,
+          stop_first: true,
+        },
+        "my-app",
+      );
+    });
   });
 
   describe("Schedule modal", () => {
diff --git a/src/components/BackupsTab.vue b/src/components/BackupsTab.vue
index bcb70e3..9898f68 100644
--- a/src/components/BackupsTab.vue
+++ b/src/components/BackupsTab.vue
@@ -16,6 +16,58 @@
       </div>
     </div>
 
+    <BaseCard v-if="canWrite" title="Backup destinations" class="backup-policy">
+      <p class="policy-copy">Choose every remote store that should receive this application's backups.</p>
+      <p v-if="destinationOptions.length === 0" class="policy-copy">No enabled remote destinations are available.</p>
+      <div v-else class="destination-options">
+        <label v-for="destination in destinationOptions" :key="destination.name" class="destination-option">
+          <input
+            type="checkbox"
+            :checked="selectedDestinations.includes(destination.name)"
+            @change="toggleDestination(destination.name)"
+          />
+          <span>{{ destination.name }}</span>
+          <span class="destination-kind">{{ destination.kind }}</span>
+        </label>
+      </div>
+      <div class="policy-fields">
+        <label>
+          Keep local backups
+          <BaseInput v-model="retentionCount" type="number" />
+        </label>
+        <label>
+          Alert above MiB
+          <BaseInput v-model="sizeAlertMiB" type="number" />
+        </label>
+        <label class="policy-exclusions">
+          Exclusions, one pattern per line
+          <textarea v-model="excludePatterns" class="form-control" rows="3" placeholder="cache/**" />
+        </label>
+      </div>
+      <div v-if="policy" class="policy-summary" :class="{ warning: policy.size_alert }">
+        {{ policy.backup_count }} backups, {{ formatBytes(policy.local_bytes) }} local,
+        {{ policy.failed_count }} needing attention.
+        <span v-if="policy.cleanup_preview.delete_ids.length">
+          Cleanup would remove {{ policy.cleanup_preview.delete_ids.length }} and reclaim
+          {{ formatBytes(policy.cleanup_preview.reclaimed_bytes) }}.
+        </span>
+      </div>
+      <template #footer>
+        <BaseButton
+          variant="primary"
+          size="sm"
+          :loading="savingDestinations"
+          :disabled="destinationOptions.length === 0 || selectedDestinations.length === 0"
+          @click="savePolicy"
+        >
+          Save policy
+        </BaseButton>
+        <BaseButton v-if="policy?.cleanup_preview.delete_ids.length" variant="secondary" size="sm" @click="applyCleanup"
+          >Apply cleanup</BaseButton
+        >
+      </template>
+    </BaseCard>
+
     <div v-if="loadingBackups" class="loading-state">
       <i class="pi pi-spin pi-spinner" />
       Loading backups...
@@ -68,7 +120,7 @@
               :class="destination.status"
               :title="destination.error"
             >
-              {{ destination.name }}: {{ destination.status }}
+              {{ destination.name }}: {{ destination.status }}{{ destination.verified ? " verified" : "" }}
             </span>
           </div>
         </div>
@@ -91,6 +143,15 @@
             <i :class="restoringBackup === backup.id ? 'pi pi-spin pi-spinner' : 'pi pi-replay'" />
             Restore
           </button>
+          <button
+            v-if="canWrite && backup.status !== 'failed'"
+            class="btn btn-sm btn-secondary"
+            :disabled="restoringBackup === backup.id"
+            @click="confirmIsolatedRestore(backup)"
+          >
+            <i class="pi pi-shield" />
+            Restore isolated
+          </button>
           <button
             v-if="backup.status !== 'failed'"
             class="btn btn-sm btn-secondary"
@@ -201,6 +262,28 @@
       @cancel="showDeleteBackupModal = false"
     />
 
+    <div v-if="showIsolatedRestoreModal" class="modal-overlay" @click.self="showIsolatedRestoreModal = false">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h2>Restore into isolation</h2>
+          <button class="btn-icon" @click="showIsolatedRestoreModal = false"><i class="pi pi-times" /></button>
+        </div>
+        <div class="modal-body">
+          <p>The restored services can communicate with each other, but cannot reach external networks.</p>
+          <div class="form-group">
+            <label for="isolated-deployment-name">New deployment name</label>
+            <BaseInput id="isolated-deployment-name" v-model="isolatedDeploymentName" placeholder="my-app-recovery" />
+          </div>
+        </div>
+        <div class="modal-footer">
+          <BaseButton variant="secondary" @click="showIsolatedRestoreModal = false">Cancel</BaseButton>
+          <BaseButton :disabled="!isolatedDeploymentName.trim()" @click="restoreBackupIsolated"
+            >Restore isolated</BaseButton
+          >
+        </div>
+      </div>
+    </div>
+
     <!-- Delete Task Confirm Modal -->
     <ConfirmModal
       :visible="showDeleteTaskModal"
@@ -228,9 +311,19 @@
 <script setup lang="ts">
 import { ref, onMounted, onUnmounted } from "vue";
 import { backupsApi, schedulerApi } from "@/services/api";
-import type { Backup, ScheduledTask, BackupJob } from "@/services/api";
+import type {
+  Backup,
+  ScheduledTask,
+  BackupJob,
+  BackupSpec,
+  BackupDestinationOption,
+  DeploymentBackupPolicy,
+} from "@/services/api";
 import { useNotificationsStore } from "@/stores/notifications";
 import ConfirmModal from "@/components/ConfirmModal.vue";
+import BaseCard from "@/components/base/BaseCard.vue";
+import BaseButton from "@/components/base/BaseButton.vue";
+import BaseInput from "@/components/base/BaseInput.vue";
 
 const props = withDefaults(
   defineProps<{
@@ -251,6 +344,79 @@ const creatingBackup = ref(false);
 const restoringBackup = ref<string | null>(null);
 const downloadingBackup = ref<string | null>(null);
 const retryingPublication = ref<string | null>(null);
+const destinationOptions = ref<BackupDestinationOption[]>([]);
+const selectedDestinations = ref<string[]>([]);
+const backupSpec = ref<BackupSpec>({});
+const savingDestinations = ref(false);
+const retentionCount = ref(7);
+const sizeAlertMiB = ref(0);
+const excludePatterns = ref("");
+const policy = ref<DeploymentBackupPolicy | null>(null);
+
+const fetchBackupDestinations = async () => {
+  try {
+    const [optionsResponse, configResponse, policyResponse] = await Promise.all([
+      backupsApi.getDeploymentBackupDestinations(props.deploymentName),
+      backupsApi.getDeploymentBackupConfig(props.deploymentName),
+      backupsApi.getDeploymentBackupPolicy(props.deploymentName),
+    ]);
+    destinationOptions.value = optionsResponse.data.destinations || [];
+    backupSpec.value = configResponse.data.backup_config || {};
+    policy.value = policyResponse.data.policy;
+    retentionCount.value = backupSpec.value.retention_count || 7;
+    sizeAlertMiB.value = Math.round((backupSpec.value.size_alert_bytes || 0) / 1024 / 1024);
+    excludePatterns.value = (backupSpec.value.exclude_patterns || []).join("\n");
+    selectedDestinations.value = backupSpec.value.destinations?.length
+      ? [...backupSpec.value.destinations]
+      : destinationOptions.value.map((destination) => destination.name);
+  } catch (err: any) {
+    notifications.error("Backup Policy Failed", err.response?.data?.error || "Failed to load backup destinations");
+  }
+};
+
+const toggleDestination = (name: string) => {
+  selectedDestinations.value = selectedDestinations.value.includes(name)
+    ? selectedDestinations.value.filter((destination) => destination !== name)
+    : [...selectedDestinations.value, name];
+};
+
+const savePolicy = async () => {
+  savingDestinations.value = true;
+  try {
+    const updated = {
+      ...backupSpec.value,
+      destinations: selectedDestinations.value,
+      retention_count: Number(retentionCount.value),
+      size_alert_bytes: Number(sizeAlertMiB.value) * 1024 * 1024,
+      exclude_patterns: excludePatterns.value
+        .split("\n")
+        .map((pattern) => pattern.trim())
+        .filter(Boolean),
+    };
+    const response = await backupsApi.updateDeploymentBackupConfig(props.deploymentName, updated);
+    backupSpec.value = response.data.backup_config;
+    notifications.success("Backup Policy Saved", "Backup storage policy has been updated");
+    await fetchBackupDestinations();
+  } catch (err: any) {
+    notifications.error("Save Failed", err.response?.data?.error || "Failed to save backup destinations");
+  } finally {
+    savingDestinations.value = false;
+  }
+};
+
+const applyCleanup = async () => {
+  try {
+    if (!policy.value) return;
+    const response = await backupsApi.cleanupDeploymentBackups(
+      props.deploymentName,
+      policy.value.cleanup_preview.keep_count,
+    );
+    notifications.success("Cleanup Complete", `${response.data.deleted} local backups removed`);
+    await Promise.all([fetchBackups(), fetchBackupDestinations()]);
+  } catch (err: any) {
+    notifications.error("Cleanup Failed", err.response?.data?.error || "Failed to clean up backups");
+  }
+};
 
 const failedResults = (backup: Backup) =>
   [...(backup.component_results || []), ...(backup.cleanup_results || [])].filter(
@@ -305,6 +471,8 @@ const taskToDelete = ref<number | null>(null);
 const showRestoreModal = ref(false);
 const backupToRestore = ref<Backup | null>(null);
 const restoreMessage = ref("");
+const showIsolatedRestoreModal = ref(false);
+const isolatedDeploymentName = ref("");
 
 const fetchBackups = async () => {
   loadingBackups.value = true;
@@ -350,7 +518,7 @@ const pollActiveJobs = async () => {
   const updatedJobs: TrackedJob[] = [];
   for (const job of activeJobs.value) {
     try {
-      const response = await backupsApi.getJob(job.id, props.deploymentName);
+      const response = await backupsApi.getJob(job.id, job.deployment_name || props.deploymentName);
       const updatedJob = response.data.job;
 
       if (["completed", "partial", "local_only"].includes(updatedJob.status)) {
@@ -444,6 +612,48 @@ const confirmRestore = (backup: Backup) => {
   showRestoreModal.value = true;
 };
 
+const confirmIsolatedRestore = (backup: Backup) => {
+  backupToRestore.value = backup;
+  isolatedDeploymentName.value = `${props.deploymentName}-recovery`;
+  showIsolatedRestoreModal.value = true;
+};
+
+const restoreBackupIsolated = async () => {
+  if (!backupToRestore.value || !isolatedDeploymentName.value.trim()) return;
+  const backupId = backupToRestore.value.id;
+  const deploymentName = isolatedDeploymentName.value.trim();
+  restoringBackup.value = backupId;
+  showIsolatedRestoreModal.value = false;
+  try {
+    const response = await backupsApi.restore(
+      backupId,
+      {
+        deployment_name: deploymentName,
+        isolated: true,
+        restore_data: true,
+        restore_db: true,
+        stop_first: true,
+      },
+      props.deploymentName,
+    );
+    activeJobs.value.push({
+      id: response.data.job_id,
+      type: "restore",
+      status: "running",
+      deployment_name: deploymentName,
+      backup_id: backupId,
+      started_at: new Date().toISOString(),
+    });
+    notifications.success("Isolated Restore Started", `Restoring into ${deploymentName}`);
+    startJobPolling();
+  } catch (err: any) {
+    notifications.error("Restore Failed", err.response?.data?.error || "Failed to start isolated restore");
+    restoringBackup.value = null;
+  } finally {
+    backupToRestore.value = null;
+  }
+};
+
 const restoreBackup = async () => {
   if (!backupToRestore.value) return;
   const backupId = backupToRestore.value.id;
@@ -574,6 +784,7 @@ const formatDate = (dateStr: string): string => {
 onMounted(() => {
   fetchBackups();
   fetchScheduledTasks();
+  if (props.canWrite) fetchBackupDestinations();
 });
 
 onUnmounted(() => {
@@ -599,6 +810,33 @@ onUnmounted(() => {
   font-weight: var(--font-semibold);
 }
 
+.backup-policy {
+  margin-bottom: var(--space-4);
+}
+
+.policy-copy {
+  margin: 0;
+  color: var(--text-muted);
+}
+
+.destination-options {
+  display: grid;
+  gap: var(--space-2);
+  margin-top: var(--space-3);
+}
+
+.destination-option {
+  display: flex;
+  align-items: center;
+  gap: var(--space-2);
+  color: var(--text);
+}
+
+.destination-kind {
+  color: var(--text-muted);
+  font-size: var(--text-sm);
+}
+
 .backups-actions {
   display: flex;
   gap: var(--space-2);
diff --git a/src/components/MigrationTab.test.ts b/src/components/MigrationTab.test.ts
new file mode 100644
index 0000000..2e7c7f5
--- /dev/null
+++ b/src/components/MigrationTab.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from "vitest";
+import { mount } from "@vue/test-utils";
+import { createTestingPinia } from "@pinia/testing";
+import MigrationTab from "./MigrationTab.vue";
+import { migrationsApi } from "@/services/api";
+
+vi.mock("@/services/api", () => ({
+  migrationsApi: {
+    get: vi.fn().mockResolvedValue({ data: { migration: { plan: null, retirement_ready: false, blockers: [] } } }),
+    update: vi.fn().mockResolvedValue({ data: { migration: { plan: null, retirement_ready: false, blockers: [] } } }),
+    checkDns: vi.fn(),
+  },
+}));
+
+describe("MigrationTab", () => {
+  it("saves the source inventory and transfer state", async () => {
+    const wrapper = mount(MigrationTab, {
+      props: { deploymentName: "shop" },
+      global: { plugins: [createTestingPinia({ createSpy: vi.fn })] },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const vm = wrapper.vm as any;
+    vm.plan.source = "legacy";
+    vm.plan.inventory_complete = true;
+    vm.addSite();
+    vm.plan.sites[0].hostname = "shop.example.com";
+    vm.markTransfer();
+    await vm.save();
+    expect(migrationsApi.update).toHaveBeenCalledWith(
+      "shop",
+      expect.objectContaining({
+        source: "legacy",
+        inventory_complete: true,
+        sites: [expect.objectContaining({ hostname: "shop.example.com", transferred: true })],
+      }),
+    );
+  });
+});
diff --git a/src/components/MigrationTab.vue b/src/components/MigrationTab.vue
new file mode 100644
index 0000000..82aa7b2
--- /dev/null
+++ b/src/components/MigrationTab.vue
@@ -0,0 +1,117 @@
+<template>
+  <div class="migration-tab">
+    <BaseCard title="Migration and cutover">
+      <div class="migration-grid">
+        <BaseField label="Source"><BaseInput v-model="plan.source" placeholder="legacy-server" /></BaseField>
+        <BaseField label="Target address"
+          ><BaseInput v-model="plan.expected_address" placeholder="203.0.113.10"
+        /></BaseField>
+      </div>
+      <label class="inventory-check"
+        ><input v-model="plan.inventory_complete" type="checkbox" /> Source inventory complete</label
+      >
+      <div v-for="(site, index) in plan.sites" :key="index" class="site-row">
+        <BaseInput v-model="site.hostname" placeholder="site.example.com" />
+        <BaseInput v-model="site.source_path" placeholder="/srv/site" />
+        <BaseInput v-model="site.bytes" type="number" placeholder="Bytes" />
+        <label><input v-model="site.transferred" type="checkbox" /> Transferred</label>
+        <BaseButton variant="secondary" size="sm" @click="plan.sites.splice(index, 1)">Remove</BaseButton>
+      </div>
+      <BaseButton variant="secondary" size="sm" @click="addSite">Add site</BaseButton>
+      <div class="milestones">
+        <BaseButton variant="secondary" @click="markTransfer">Record initial transfer</BaseButton>
+        <BaseButton variant="secondary" @click="markSync">Record synchronization</BaseButton>
+        <BaseButton variant="secondary" @click="markCutover">Record cutover</BaseButton>
+        <BaseButton variant="secondary" @click="checkDns">Check DNS</BaseButton>
+      </div>
+      <div v-if="status" class="readiness" :class="{ ready: status.retirement_ready }">
+        <strong>{{ status.retirement_ready ? "Source can be retired" : "Source must remain online" }}</strong>
+        <ul v-if="status.blockers.length">
+          <li v-for="blocker in status.blockers" :key="blocker">{{ blocker }}</li>
+        </ul>
+      </div>
+      <template #footer><BaseButton :loading="saving" @click="save">Save migration</BaseButton></template>
+    </BaseCard>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { onMounted, reactive, ref } from "vue";
+import { migrationsApi } from "@/services/api";
+import type { MigrationPlan, MigrationStatus } from "@/services/api";
+import { useNotificationsStore } from "@/stores/notifications";
+import BaseButton from "@/components/base/BaseButton.vue";
+import BaseCard from "@/components/base/BaseCard.vue";
+import BaseField from "@/components/base/BaseField.vue";
+import BaseInput from "@/components/base/BaseInput.vue";
+
+const props = defineProps<{ deploymentName: string }>();
+const notifications = useNotificationsStore();
+const saving = ref(false);
+const status = ref<MigrationStatus | null>(null);
+const plan = reactive<MigrationPlan>({ source: "", sites: [], inventory_complete: false });
+
+const load = async () => {
+  const response = await migrationsApi.get(props.deploymentName);
+  status.value = response.data.migration;
+  if (status.value.plan) Object.assign(plan, status.value.plan);
+};
+const save = async () => {
+  saving.value = true;
+  try {
+    const response = await migrationsApi.update(props.deploymentName, plan);
+    status.value = response.data.migration;
+    notifications.success("Migration Saved", "Migration progress has been updated");
+  } catch (err: any) {
+    notifications.error("Migration Failed", err.response?.data?.error || "Failed to save migration");
+  } finally {
+    saving.value = false;
+  }
+};
+const addSite = () =>
+  plan.sites.push({ hostname: "", source_path: "", bytes: 0, transferred: false, dns_propagated: false });
+const now = () => new Date().toISOString();
+const markTransfer = () => {
+  plan.initial_transfer_at = now();
+  plan.sites.forEach((site) => (site.transferred = true));
+};
+const markSync = () => {
+  plan.last_sync_at = now();
+  plan.sites.forEach((site) => (site.last_synced_at = plan.last_sync_at));
+};
+const markCutover = () => (plan.cutover_at = now());
+const checkDns = async () => {
+  const response = await migrationsApi.checkDns(props.deploymentName);
+  status.value = response.data.migration;
+  if (status.value.plan) Object.assign(plan, status.value.plan);
+};
+onMounted(load);
+</script>
+
+<style scoped>
+.migration-grid,
+.site-row,
+.milestones {
+  display: flex;
+  gap: var(--space-3);
+  flex-wrap: wrap;
+  margin-bottom: var(--space-3);
+}
+.site-row > * {
+  flex: 1;
+  min-width: 150px;
+}
+.inventory-check {
+  display: block;
+  margin-bottom: var(--space-3);
+}
+.readiness {
+  margin-top: var(--space-4);
+  padding: var(--space-3);
+  border-radius: var(--radius-sm);
+  background: var(--warning-bg);
+}
+.readiness.ready {
+  background: var(--success-bg);
+}
+</style>
diff --git a/src/services/api.ts b/src/services/api.ts
index defe145..66906e0 100755
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -1709,6 +1709,7 @@ export interface Backup {
   readonly deployment_name: string;
   readonly status: "pending" | "in_progress" | "completed" | "partial" | "local_only" | "failed";
   readonly size: number;
+  readonly checksum?: string;
   readonly path: string;
   readonly components: readonly string[];
   readonly error?: string;
@@ -1733,6 +1734,8 @@ export interface BackupDestinationResult {
   readonly name: string;
   readonly status: "completed" | "skipped" | "failed";
   readonly error?: string;
+  readonly checksum?: string;
+  readonly verified: boolean;
 }
 
 export interface BackupSpec {
@@ -1741,6 +1744,65 @@ export interface BackupSpec {
   readonly pre_hooks?: readonly BackupHookSpec[];
   readonly post_hooks?: readonly BackupHookSpec[];
   readonly exclude_patterns?: readonly string[];
+  readonly destinations?: readonly string[];
+  readonly retention_count?: number;
+  readonly size_alert_bytes?: number;
+}
+
+export interface BackupCleanupPreview {
+  readonly keep_count: number;
+  readonly delete_ids: readonly string[];
+  readonly reclaimed_bytes: number;
+}
+
+export interface DeploymentBackupPolicy {
+  readonly config: BackupSpec;
+  readonly schedules: readonly ScheduledTask[];
+  readonly backup_count: number;
+  readonly local_bytes: number;
+  readonly failed_count: number;
+  readonly size_alert: boolean;
+  readonly cleanup_preview: BackupCleanupPreview;
+}
+
+export interface MigrationSite {
+  hostname: string;
+  source_path?: string;
+  bytes?: number;
+  transferred: boolean;
+  last_synced_at?: string;
+  resolved?: readonly string[];
+  dns_propagated: boolean;
+}
+
+export interface MigrationPlan {
+  source: string;
+  sites: MigrationSite[];
+  inventory_complete: boolean;
+  initial_transfer_at?: string;
+  last_sync_at?: string;
+  cutover_at?: string;
+  expected_address?: string;
+  notes?: string;
+}
+
+export interface MigrationStatus {
+  plan: MigrationPlan | null;
+  retirement_ready: boolean;
+  blockers: readonly string[];
+}
+
+export const migrationsApi = {
+  get: (name: string) => apiClient.get<{ migration: MigrationStatus }>(`/deployments/${name}/migration`),
+  update: (name: string, plan: MigrationPlan) =>
+    apiClient.put<{ migration: MigrationStatus }>(`/deployments/${name}/migration`, plan),
+  checkDns: (name: string) =>
+    apiClient.post<{ migration: MigrationStatus }>(`/deployments/${name}/migration/check-dns`),
+};
+
+export interface BackupDestinationOption {
+  readonly name: string;
+  readonly kind: string;
 }
 
 export interface ContainerBackupPath {
@@ -1806,7 +1868,13 @@ export const backupsApi = {
 
   restore: (
     id: string,
-    options?: { restore_data?: boolean; restore_db?: boolean; stop_first?: boolean },
+    options?: {
+      deployment_name?: string;
+      isolated?: boolean;
+      restore_data?: boolean;
+      restore_db?: boolean;
+      stop_first?: boolean;
+    },
     deploymentName?: string,
   ) =>
     apiClient.post<{ job_id: string; message: string }>(
@@ -1839,6 +1907,15 @@ export const backupsApi = {
   updateDeploymentBackupConfig: (name: string, config: BackupSpec) =>
     apiClient.put<{ backup_config: BackupSpec }>(`/deployments/${name}/backup-config`, config),
 
+  getDeploymentBackupPolicy: (name: string) =>
+    apiClient.get<{ policy: DeploymentBackupPolicy }>(`/deployments/${name}/backup-policy`),
+
+  cleanupDeploymentBackups: (name: string, keep: number) =>
+    apiClient.post<{ deleted: number }>(`/deployments/${name}/backup-cleanup`, { keep }),
+
+  getDeploymentBackupDestinations: (name: string) =>
+    apiClient.get<{ destinations: BackupDestinationOption[] }>(`/deployments/${name}/backup-destinations`),
+
   getJob: (jobId: string, deploymentName?: string) =>
     apiClient.get<{ job: BackupJob }>(
       deploymentName ? `/deployments/${deploymentName}/backups/jobs/${jobId}` : `/backups/jobs/${jobId}`,
diff --git a/src/views/DeploymentDetailView.test.ts b/src/views/DeploymentDetailView.test.ts
index 9b892b1..3ac4f82 100644
--- a/src/views/DeploymentDetailView.test.ts
+++ b/src/views/DeploymentDetailView.test.ts
@@ -213,11 +213,11 @@ describe("DeploymentDetailView", () => {
   });
 
   describe("Tab navigation", () => {
-    it("displays all ten tabs", async () => {
+    it("displays all eleven tabs", async () => {
       const wrapper = mountView();
       await flushPromises();
       const tabs = wrapper.findAll(".tab-btn");
-      expect(tabs.length).toBe(10);
+      expect(tabs.length).toBe(11);
     });
 
     it("has Overview tab", async () => {
@@ -341,6 +341,7 @@ describe("DeploymentDetailView", () => {
         { id: "databases", label: "Databases", icon: "pi pi-database" },
         { id: "actions", label: "Quick Actions", icon: "pi pi-bolt" },
         { id: "backups", label: "Backups", icon: "pi pi-history" },
+        { id: "migration", label: "Migration", icon: "pi pi-directions" },
         { id: "security", label: "Security", icon: "pi pi-shield" },
         { id: "config", label: "Configuration", icon: "pi pi-cog" },
       ]);
diff --git a/src/views/DeploymentDetailView.vue b/src/views/DeploymentDetailView.vue
index 735ecfd..b306882 100755
--- a/src/views/DeploymentDetailView.vue
+++ b/src/views/DeploymentDetailView.vue
@@ -784,6 +784,7 @@
           :can-schedule="canManageSchedules"
           :can-delete-schedule="canDeleteSchedules"
         />
+        <MigrationTab v-if="activeTab === 'migration'" :deployment-name="route.params.name as string" />
 
         <div v-for="pt in pluginTabs" :key="pt.id" v-show="activeTab === pt.id" class="plugin-tab">
           <PluginSlot
@@ -2043,6 +2044,7 @@ import LogViewer from "@/components/LogViewer.vue";
 import ConfirmModal from "@/components/ConfirmModal.vue";
 import ContainerTerminal from "@/components/ContainerTerminal.vue";
 import BackupsTab from "@/components/BackupsTab.vue";
+import MigrationTab from "@/components/MigrationTab.vue";
 import PluginSlot from "@/components/plugins/PluginSlot.vue";
 import { usePluginsStore } from "@/stores/plugins";
 import DomainsManager from "@/components/DomainsManager.vue";
@@ -2197,6 +2199,7 @@ const tabs = [
   { id: "databases", label: "Databases", icon: "pi pi-database" },
   { id: "actions", label: "Quick Actions", icon: "pi pi-bolt" },
   { id: "backups", label: "Backups", icon: "pi pi-history" },
+  { id: "migration", label: "Migration", icon: "pi pi-directions" },
   { id: "security", label: "Security", icon: "pi pi-shield" },
   { id: "config", label: "Configuration", icon: "pi pi-cog" },
 ];