diff --git a/frontend/src/components/heartbeats/OutboundHeartbeatsPanel.vue b/frontend/src/components/heartbeats/OutboundHeartbeatsPanel.vue
new file mode 100644
index 00000000..534a7426
--- /dev/null
+++ b/frontend/src/components/heartbeats/OutboundHeartbeatsPanel.vue
@@ -0,0 +1,382 @@
+<!--
+  Copyright 2026 Benjamin Touchard (kOlapsis)
+
+  Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+  or a commercial license. You may not use this file except in compliance
+  with one of these licenses.
+
+  AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+  Commercial: See COMMERCIAL-LICENSE.md
+
+  Source: https://github.com/kolapsis/maintenant
+-->
+
+<script setup lang="ts">
+import { onMounted, ref, watch } from 'vue'
+import { Send, Pencil, Trash2, ArrowUpRight } from 'lucide-vue-next'
+import { useOutboundHeartbeatsStore } from '@/stores/outboundHeartbeats'
+import { useConfirm } from '@/composables/useConfirm'
+import { formatInterval } from '@/utils/heartbeatFormat'
+import { timeAgo } from '@/utils/time'
+import type { OutboundHeartbeat } from '@/services/outboundHeartbeatApi'
+import LoadingSkeleton from '@/components/ui/LoadingSkeleton.vue'
+import EmptyState from '@/components/ui/EmptyState.vue'
+import ErrorState from '@/components/ui/ErrorState.vue'
+import QuotaRefusal from '@/components/QuotaRefusal.vue'
+import DataTable, { type Column } from '@/components/ui/DataTable.vue'
+import type { ChipTone } from '@/components/ui/listFilters'
+
+const showCreateForm = defineModel<boolean>('showCreateForm', { default: false })
+
+const store = useOutboundHeartbeatsStore()
+const confirm = useConfirm()
+
+const editingId = ref<string | null>(null)
+const formError = ref<unknown>(null)
+const sendingId = ref<string | null>(null)
+const togglingId = ref<string | null>(null)
+
+const intervalPresets = [
+  { label: '30s', value: 30 },
+  { label: '1m', value: 60 },
+  { label: '5m', value: 300 },
+  { label: '15m', value: 900 },
+  { label: '1h', value: 3600 },
+  { label: '6h', value: 21600 },
+  { label: '12h', value: 43200 },
+  { label: '24h', value: 86400 },
+]
+
+function blankForm() {
+  return { name: '', url: '', interval_seconds: 300, enabled: true }
+}
+
+const form = ref(blankForm())
+
+watch(showCreateForm, (open) => {
+  if (open && !editingId.value) {
+    form.value = blankForm()
+    formError.value = null
+  }
+})
+
+function startEdit(hb: OutboundHeartbeat) {
+  editingId.value = hb.id
+  form.value = {
+    name: hb.name,
+    url: hb.url,
+    interval_seconds: hb.interval_seconds,
+    enabled: hb.enabled,
+  }
+  formError.value = null
+  showCreateForm.value = true
+}
+
+function closeForm() {
+  showCreateForm.value = false
+  editingId.value = null
+}
+
+async function handleSubmit() {
+  formError.value = null
+  try {
+    if (editingId.value) {
+      await store.update(editingId.value, form.value)
+    } else {
+      await store.create(form.value)
+    }
+    closeForm()
+  } catch (e) {
+    formError.value = e
+  }
+}
+
+async function handleDelete(hb: OutboundHeartbeat) {
+  const ok = await confirm({
+    title: 'Delete target',
+    message: `Remove "${hb.name}"? Maintenant will stop pinging it.`,
+    confirmLabel: 'Delete',
+    destructive: true,
+  })
+  if (!ok) return
+  await store.remove(hb.id)
+}
+
+async function handleSendNow(hb: OutboundHeartbeat) {
+  sendingId.value = hb.id
+  try {
+    await store.sendNow(hb.id)
+  } finally {
+    sendingId.value = null
+  }
+}
+
+async function toggleEnabled(hb: OutboundHeartbeat) {
+  togglingId.value = hb.id
+  try {
+    await store.update(hb.id, {
+      name: hb.name,
+      url: hb.url,
+      interval_seconds: hb.interval_seconds,
+      enabled: !hb.enabled,
+    })
+  } finally {
+    togglingId.value = null
+  }
+}
+
+function tone(hb: OutboundHeartbeat): ChipTone {
+  if (!hb.enabled) return 'neutral'
+  if (hb.last_error) return 'down'
+  if (hb.last_status_code != null) return hb.last_status_code >= 200 && hb.last_status_code < 300 ? 'ok' : 'down'
+  return 'unknown'
+}
+
+function lastSendLabel(hb: OutboundHeartbeat): string {
+  if (!hb.last_sent_at) return 'Never'
+  const status = hb.last_error || (hb.last_status_code != null ? `HTTP ${hb.last_status_code}` : '')
+  return status ? `${timeAgo(hb.last_sent_at)} · ${status}` : timeAgo(hb.last_sent_at)
+}
+
+function lastSendColor(hb: OutboundHeartbeat): string {
+  if (hb.last_error) return 'var(--mnt-status-down-text)'
+  if (hb.last_status_code != null) {
+    return hb.last_status_code >= 200 && hb.last_status_code < 300
+      ? 'var(--mnt-status-ok-text)'
+      : 'var(--mnt-status-down-text)'
+  }
+  return 'var(--mnt-text-muted)'
+}
+
+const columns: Column[] = [
+  { key: 'name', label: 'Name', sortable: true, width: 'minmax(0, 1.4fr)' },
+  { key: 'url', label: 'URL', width: 'minmax(0, 2fr)', priority: 'sm' },
+  { key: 'interval', label: 'Interval', sortable: true, align: 'right', width: '90px', priority: 'md' },
+  { key: 'enabled', label: 'Enabled', align: 'right', width: '96px' },
+  { key: 'last_send', label: 'Last send', sortable: true, align: 'right', width: '190px', priority: 'lg' },
+  { key: 'actions', label: 'Actions', align: 'right', width: '116px' },
+]
+
+function sortValue(hb: OutboundHeartbeat, key: string): string | number | undefined {
+  switch (key) {
+    case 'name':
+      return hb.name
+    case 'interval':
+      return hb.interval_seconds
+    case 'last_send':
+      return hb.last_sent_at ? new Date(hb.last_sent_at).getTime() : undefined
+    default:
+      return undefined
+  }
+}
+
+onMounted(() => {
+  store.fetchOutboundHeartbeats()
+})
+</script>
+
+<template>
+  <div>
+    <div
+      v-if="showCreateForm"
+      class="mb-6 p-4"
+      :style="{
+        backgroundColor: 'var(--mnt-bg-surface)',
+        border: '1px solid var(--mnt-border-default)',
+        borderRadius: 'var(--mnt-radius-lg)',
+      }"
+    >
+      <h3 class="mb-3 text-sm font-semibold" :style="{ color: 'var(--mnt-text-primary)' }">
+        {{ editingId ? 'Edit outgoing target' : 'Add outgoing target' }}
+      </h3>
+      <QuotaRefusal v-if="formError" :error="formError" />
+      <form class="flex flex-col gap-3" @submit.prevent="handleSubmit">
+        <div>
+          <label class="mb-1 block text-xs font-medium" :style="{ color: 'var(--mnt-text-secondary)' }">Name</label>
+          <input
+            v-model="form.name"
+            type="text"
+            placeholder="e.g., Watched by DR site"
+            :style="{
+              width: '100%',
+              borderRadius: 'var(--mnt-radius-md)',
+              border: '1px solid var(--mnt-border-default)',
+              backgroundColor: 'var(--mnt-bg-elevated)',
+              color: 'var(--mnt-text-primary)',
+              padding: '0.375rem 0.75rem',
+              fontSize: '0.875rem',
+              minHeight: '44px',
+            }"
+            required
+          />
+        </div>
+        <div>
+          <label class="mb-1 block text-xs font-medium" :style="{ color: 'var(--mnt-text-secondary)' }">Ping URL</label>
+          <input
+            v-model="form.url"
+            type="url"
+            placeholder="https://other-instance.example.com/ping/…"
+            class="font-mono"
+            :style="{
+              width: '100%',
+              borderRadius: 'var(--mnt-radius-md)',
+              border: '1px solid var(--mnt-border-default)',
+              backgroundColor: 'var(--mnt-bg-elevated)',
+              color: 'var(--mnt-text-primary)',
+              padding: '0.375rem 0.75rem',
+              fontSize: '0.8125rem',
+              minHeight: '44px',
+            }"
+            pattern="https://.+"
+            required
+          />
+          <p class="mt-1 text-xs" :style="{ color: 'var(--mnt-text-muted)' }">HTTPS only, on a public address.</p>
+        </div>
+        <div>
+          <label class="mb-1 block text-xs font-medium" :style="{ color: 'var(--mnt-text-secondary)' }">Ping every</label>
+          <div class="flex flex-wrap gap-2">
+            <button
+              v-for="preset in intervalPresets"
+              :key="preset.value"
+              type="button"
+              class="rounded-full px-3 py-1 text-xs font-medium transition"
+              :style="{
+                border: form.interval_seconds === preset.value
+                  ? '1px solid var(--mnt-accent)'
+                  : '1px solid var(--mnt-border-default)',
+                backgroundColor: form.interval_seconds === preset.value
+                  ? 'var(--mnt-accent)'
+                  : 'transparent',
+                color: form.interval_seconds === preset.value
+                  ? 'var(--mnt-text-inverted)'
+                  : 'var(--mnt-text-secondary)',
+              }"
+              @click="form.interval_seconds = preset.value"
+            >
+              {{ preset.label }}
+            </button>
+          </div>
+        </div>
+        <label class="flex min-h-[44px] items-center gap-2">
+          <input v-model="form.enabled" type="checkbox" class="focus-ring h-4 w-4" />
+          <span class="text-xs font-semibold text-mnt-secondary">Enabled</span>
+        </label>
+        <div class="flex items-center gap-2">
+          <button
+            type="submit"
+            class="min-h-[44px]"
+            :style="{
+              borderRadius: 'var(--mnt-radius-lg)',
+              backgroundColor: 'var(--mnt-accent)',
+              color: 'var(--mnt-text-inverted)',
+              padding: '0.5rem 1rem',
+              fontSize: '0.875rem',
+              fontWeight: '500',
+            }"
+          >
+            {{ editingId ? 'Save' : 'Create' }}
+          </button>
+          <button
+            type="button"
+            class="focus-ring min-h-[44px] rounded-lg border border-mnt-default px-4 text-sm font-medium text-mnt-secondary hover:text-mnt-primary"
+            @click="closeForm"
+          >
+            Cancel
+          </button>
+        </div>
+      </form>
+    </div>
+
+    <LoadingSkeleton v-if="store.loading" variant="cards" :count="4" />
+
+    <ErrorState v-else-if="store.error" :message="store.error" />
+
+    <EmptyState
+      v-else-if="store.outboundHeartbeats.length === 0"
+      :icon="ArrowUpRight"
+      title="No outgoing targets"
+      description="Add the ping URL of a heartbeat monitor created on another Maintenant instance. This instance will ping it on schedule, so the other one alerts if this one goes quiet."
+    >
+      <template #action>
+        <button
+          class="min-h-[44px] rounded-lg px-4 text-sm font-medium"
+          style="background-color: var(--mnt-accent); color: var(--mnt-text-inverted); border-radius: var(--mnt-radius-lg)"
+          @click="showCreateForm = true"
+        >
+          Add your first target
+        </button>
+      </template>
+    </EmptyState>
+
+    <DataTable
+      v-else
+      :columns="columns"
+      :rows="store.outboundHeartbeats"
+      :row-key="(hb: OutboundHeartbeat) => hb.id"
+      :sort-value="sortValue"
+      :tone="tone"
+      default-sort="name"
+      caption="Outgoing heartbeat targets"
+    >
+      <template #cell-name="{ row }">
+        <span class="font-medium text-mnt-primary">{{ row.name }}</span>
+      </template>
+      <template #cell-url="{ row }">
+        <span class="font-mono text-xs" :title="row.url">{{ row.url }}</span>
+      </template>
+      <template #cell-interval="{ row }">
+        <span class="font-mono tabular-nums">{{ formatInterval(row.interval_seconds) }}</span>
+      </template>
+      <template #cell-enabled="{ row }">
+        <button
+          type="button"
+          role="switch"
+          :aria-checked="row.enabled"
+          :disabled="togglingId === row.id"
+          :title="row.enabled ? 'Click to disable' : 'Click to enable'"
+          class="focus-ring inline-flex min-h-[32px] items-center rounded-full border px-2.5 py-1 text-xs font-semibold transition-colors disabled:opacity-50"
+          :style="row.enabled
+            ? { borderColor: 'var(--mnt-status-ok)', backgroundColor: 'var(--mnt-status-ok-bg)', color: 'var(--mnt-status-ok-text)' }
+            : { borderColor: 'var(--mnt-border-default)', backgroundColor: 'var(--mnt-bg-elevated)', color: 'var(--mnt-text-muted)' }"
+          @click.stop="toggleEnabled(row)"
+        >
+          {{ row.enabled ? 'On' : 'Off' }}
+        </button>
+      </template>
+      <template #cell-last_send="{ row }">
+        <span class="truncate" :style="{ color: lastSendColor(row) }" :title="row.last_error ?? undefined">
+          {{ lastSendLabel(row) }}
+        </span>
+      </template>
+      <template #cell-actions="{ row }">
+        <div class="flex items-center justify-end gap-1">
+          <button
+            type="button"
+            class="focus-ring rounded p-1 text-mnt-muted transition-all hover:bg-mnt-elevated hover:text-mnt-secondary disabled:opacity-50"
+            title="Send now"
+            :disabled="sendingId === row.id"
+            @click.stop="handleSendNow(row)"
+          >
+            <Send :size="14" />
+          </button>
+          <button
+            type="button"
+            class="focus-ring rounded p-1 text-mnt-muted transition-all hover:bg-mnt-elevated hover:text-mnt-secondary"
+            title="Edit"
+            @click.stop="startEdit(row)"
+          >
+            <Pencil :size="14" />
+          </button>
+          <button
+            type="button"
+            class="focus-ring rounded p-1 text-mnt-muted transition-all hover:bg-mnt-status-down/10 hover:text-mnt-status-down"
+            title="Delete"
+            @click.stop="handleDelete(row)"
+          >
+            <Trash2 :size="14" />
+          </button>
+        </div>
+      </template>
+    </DataTable>
+  </div>
+</template>
diff --git a/frontend/src/pages/HeartbeatsPage.vue b/frontend/src/pages/HeartbeatsPage.vue
index 39349401..574ef177 100644
--- a/frontend/src/pages/HeartbeatsPage.vue
+++ b/frontend/src/pages/HeartbeatsPage.vue
@@ -12,7 +12,8 @@
 -->
 
 <script setup lang="ts">
-import { inject, ref, computed, onMounted, onUnmounted } from 'vue'
+import { inject, ref, computed, watch, onMounted, onUnmounted } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
 import { useHeartbeatsStore } from '@/stores/heartbeats'
 import { usePreferencesStore } from '@/stores/preferences'
 import { useEdition } from '@/composables/useEdition'
@@ -21,6 +22,7 @@ import { createHeartbeat, type Heartbeat } from '@/services/heartbeatApi'
 import HeartbeatCard from '@/components/HeartbeatCard.vue'
 import HeartbeatRow from '@/components/HeartbeatRow.vue'
 import HeartbeatStatusBadge from '@/components/HeartbeatStatusBadge.vue'
+import OutboundHeartbeatsPanel from '@/components/heartbeats/OutboundHeartbeatsPanel.vue'
 import { detailSlideOverKey } from '@/composables/useDetailSlideOver'
 import FeatureHint from '@/components/ui/FeatureHint.vue'
 import LoadingSkeleton from '@/components/ui/LoadingSkeleton.vue'
@@ -28,6 +30,7 @@ import EmptyState from '@/components/ui/EmptyState.vue'
 import ErrorState from '@/components/ui/ErrorState.vue'
 import ListToolbar from '@/components/ui/ListToolbar.vue'
 import DataTable, { type Column } from '@/components/ui/DataTable.vue'
+import SegmentedToggle from '@/components/ui/SegmentedToggle.vue'
 import type { StatusChip } from '@/components/ui/listFilters'
 import { formatDeadline, formatInterval, heartbeatTone } from '@/utils/heartbeatFormat'
 import { timeAgo } from '@/utils/time'
@@ -35,6 +38,19 @@ import { Heart } from 'lucide-vue-next'
 import { docUrl } from '@/utils/docs'
 import QuotaRefusal from '@/components/QuotaRefusal.vue'
 
+const route = useRoute()
+const router = useRouter()
+
+const activeTab = computed<string>({
+  get: () => (route.query.tab === 'outgoing' ? 'outgoing' : 'incoming'),
+  set: (tab) => router.replace({ query: { ...route.query, tab: tab === 'outgoing' ? 'outgoing' : undefined } }),
+})
+
+const tabOptions = [
+  { value: 'incoming', label: 'Incoming' },
+  { value: 'outgoing', label: 'Outgoing' },
+]
+
 const store = useHeartbeatsStore()
 const prefs = usePreferencesStore()
 const { openDetail } = inject(detailSlideOverKey)!
@@ -43,7 +59,13 @@ const quota = getQuota('heartbeats')
 
 const showCreateForm = ref(false)
 const createError = ref<unknown>(null)
+const showOutgoingCreateForm = ref(false)
 
+watch(activeTab, () => {
+  showCreateForm.value = false
+  createError.value = null
+  showOutgoingCreateForm.value = false
+})
 
 const form = ref({
   name: '',
@@ -181,10 +203,10 @@ async function handleCreate() {
       <div>
         <h1 class="text-2xl font-black text-mnt-primary">Heartbeats</h1>
         <p class="mt-1 text-sm" :style="{ color: 'var(--mnt-text-muted)' }">
-          Passive cron &amp; scheduled task monitoring
+          {{ activeTab === 'incoming' ? "Passive cron & scheduled task monitoring" : "Ping other Maintenant instances so they alert if this one goes down" }}
         </p>
       </div>
-      <div class="flex items-center gap-2">
+      <div v-if="activeTab === 'incoming'" class="flex items-center gap-2">
         <span
           v-if="!quota.isUnlimited"
           class="rounded-full px-2.5 py-1 text-xs font-medium"
@@ -222,9 +244,30 @@ async function handleCreate() {
           {{ showCreateForm ? 'Cancel' : 'New Heartbeat' }}
         </button>
       </div>
+      <div v-else class="flex items-center gap-2">
+        <button
+          class="min-h-[44px]"
+          :style="{
+            borderRadius: 'var(--mnt-radius-lg)',
+            backgroundColor: 'var(--mnt-accent)',
+            color: 'var(--mnt-text-inverted)',
+            padding: '0.5rem 1rem',
+            fontSize: '0.875rem',
+            fontWeight: '500',
+          }"
+          @click="showOutgoingCreateForm = !showOutgoingCreateForm"
+        >
+          {{ showOutgoingCreateForm ? 'Cancel' : 'New target' }}
+        </button>
+      </div>
+    </div>
+
+    <div class="mb-6">
+      <SegmentedToggle v-model="activeTab" :options="tabOptions" ariaLabel="Heartbeat direction" />
     </div>
 
     <FeatureHint
+      v-if="activeTab === 'incoming'"
       storage-key="heartbeats"
       title="Monitor cron jobs with a single curl"
       :doc-href="docUrl('features/heartbeats/#ping-url-format')"
@@ -238,6 +281,20 @@ async function handleCreate() {
       + exit code to track duration. If no ping arrives before the deadline (interval + grace), a <em>deadline missed</em> alert fires.
     </FeatureHint>
 
+    <FeatureHint
+      v-else
+      storage-key="outbound-heartbeats"
+      title="Let another instance watch this one"
+      :doc-href="docUrl('features/heartbeats/#outbound-heartbeats')"
+    >
+      Create a heartbeat monitor on another Maintenant instance, then paste its ping URL
+      (<code class="rounded-md px-1.5 py-0.5 text-xs font-mono" style="background: var(--mnt-bg-elevated); color: var(--mnt-text-secondary)">/ping/{uuid}</code>)
+      as a target here. This instance pings it on the interval you choose &mdash; if this instance goes down, the other one raises the alert.
+    </FeatureHint>
+
+    <OutboundHeartbeatsPanel v-if="activeTab === 'outgoing'" v-model:show-create-form="showOutgoingCreateForm" />
+
+    <template v-else>
     <!-- Create form -->
     <div
       v-if="showCreateForm"
@@ -457,6 +514,7 @@ async function handleCreate() {
         {{ row.status === 'paused' ? '-' : formatDeadline(row.next_deadline_at) }}
       </template>
     </DataTable>
+    </template>
   </div>
   </div>
 </template>
diff --git a/frontend/src/services/outboundHeartbeatApi.ts b/frontend/src/services/outboundHeartbeatApi.ts
new file mode 100644
index 00000000..d7cfb140
--- /dev/null
+++ b/frontend/src/services/outboundHeartbeatApi.ts
@@ -0,0 +1,65 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. See COMMERCIAL-LICENSE.md.
+
+import { apiFetch, apiFetchVoid } from './apiFetch'
+
+const API_BASE = import.meta.env.VITE_API_BASE || '/api/v1'
+
+export interface OutboundHeartbeat {
+  id: string
+  name: string
+  url: string
+  interval_seconds: number
+  enabled: boolean
+  last_sent_at: string | null
+  last_status_code: number | null
+  last_error: string | null
+  created_at: string
+  updated_at: string
+}
+
+export interface OutboundHeartbeatsResponse {
+  outbound_heartbeats: OutboundHeartbeat[]
+}
+
+export interface OutboundHeartbeatInput {
+  name: string
+  url: string
+  interval_seconds: number
+  enabled: boolean
+}
+
+export function listOutboundHeartbeats(): Promise<OutboundHeartbeatsResponse> {
+  return apiFetch<OutboundHeartbeatsResponse>(`${API_BASE}/outbound-heartbeats`)
+}
+
+export function createOutboundHeartbeat(data: OutboundHeartbeatInput): Promise<OutboundHeartbeat> {
+  return apiFetch<OutboundHeartbeat>(`${API_BASE}/outbound-heartbeats`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  })
+}
+
+export function updateOutboundHeartbeat(
+  id: string,
+  data: OutboundHeartbeatInput,
+): Promise<OutboundHeartbeat> {
+  return apiFetch<OutboundHeartbeat>(`${API_BASE}/outbound-heartbeats/${id}`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  })
+}
+
+export function deleteOutboundHeartbeat(id: string): Promise<void> {
+  return apiFetchVoid(`${API_BASE}/outbound-heartbeats/${id}`, { method: 'DELETE' })
+}
+
+export function sendOutboundHeartbeat(id: string): Promise<OutboundHeartbeat> {
+  return apiFetch<OutboundHeartbeat>(`${API_BASE}/outbound-heartbeats/${id}/send`, {
+    method: 'POST',
+  })
+}
diff --git a/frontend/src/stores/__tests__/outboundHeartbeats.spec.ts b/frontend/src/stores/__tests__/outboundHeartbeats.spec.ts
new file mode 100644
index 00000000..501b1559
--- /dev/null
+++ b/frontend/src/stores/__tests__/outboundHeartbeats.spec.ts
@@ -0,0 +1,119 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. See COMMERCIAL-LICENSE.md.
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { setActivePinia, createPinia } from 'pinia'
+
+const listOutboundHeartbeats = vi.hoisted(() => vi.fn())
+const createOutboundHeartbeat = vi.hoisted(() => vi.fn())
+const updateOutboundHeartbeat = vi.hoisted(() => vi.fn())
+const deleteOutboundHeartbeat = vi.hoisted(() => vi.fn())
+const sendOutboundHeartbeat = vi.hoisted(() => vi.fn())
+
+vi.mock('@/services/outboundHeartbeatApi', () => ({
+  listOutboundHeartbeats,
+  createOutboundHeartbeat,
+  updateOutboundHeartbeat,
+  deleteOutboundHeartbeat,
+  sendOutboundHeartbeat,
+}))
+
+import { useOutboundHeartbeatsStore } from '../outboundHeartbeats'
+import type { OutboundHeartbeat } from '@/services/outboundHeartbeatApi'
+
+function target(overrides: Partial<OutboundHeartbeat> = {}): OutboundHeartbeat {
+  return {
+    id: 't1',
+    name: 'DR site',
+    url: 'https://dr.example.com/ping/abc',
+    interval_seconds: 300,
+    enabled: true,
+    last_sent_at: null,
+    last_status_code: null,
+    last_error: null,
+    created_at: '2026-01-01T00:00:00Z',
+    updated_at: '2026-01-01T00:00:00Z',
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+  listOutboundHeartbeats.mockReset()
+  createOutboundHeartbeat.mockReset()
+  updateOutboundHeartbeat.mockReset()
+  deleteOutboundHeartbeat.mockReset()
+  sendOutboundHeartbeat.mockReset()
+})
+
+describe('outbound heartbeats store', () => {
+  it('loads the list', async () => {
+    listOutboundHeartbeats.mockResolvedValue({ outbound_heartbeats: [target()] })
+    const store = useOutboundHeartbeatsStore()
+
+    await store.fetchOutboundHeartbeats()
+
+    expect(store.outboundHeartbeats).toHaveLength(1)
+    expect(store.loading).toBe(false)
+    expect(store.error).toBeNull()
+  })
+
+  it('surfaces a fetch failure without throwing', async () => {
+    listOutboundHeartbeats.mockRejectedValue(new Error('boom'))
+    const store = useOutboundHeartbeatsStore()
+
+    await store.fetchOutboundHeartbeats()
+
+    expect(store.error).toBe('boom')
+    expect(store.outboundHeartbeats).toEqual([])
+  })
+
+  it('appends a created target', async () => {
+    createOutboundHeartbeat.mockResolvedValue(target())
+    const store = useOutboundHeartbeatsStore()
+
+    await store.create({ name: 'DR site', url: 'https://dr.example.com/ping/abc', interval_seconds: 300, enabled: true })
+
+    expect(store.outboundHeartbeats).toHaveLength(1)
+    expect(store.outboundHeartbeats[0]?.id).toBe('t1')
+  })
+
+  it('replaces the row in place on update, including a toggle', async () => {
+    listOutboundHeartbeats.mockResolvedValue({ outbound_heartbeats: [target()] })
+    const store = useOutboundHeartbeatsStore()
+    await store.fetchOutboundHeartbeats()
+
+    updateOutboundHeartbeat.mockResolvedValue(target({ enabled: false }))
+    await store.update('t1', { name: 'DR site', url: 'https://dr.example.com/ping/abc', interval_seconds: 300, enabled: false })
+
+    expect(store.outboundHeartbeats).toHaveLength(1)
+    expect(store.outboundHeartbeats[0]?.enabled).toBe(false)
+  })
+
+  it('removes a target on delete', async () => {
+    listOutboundHeartbeats.mockResolvedValue({ outbound_heartbeats: [target()] })
+    const store = useOutboundHeartbeatsStore()
+    await store.fetchOutboundHeartbeats()
+
+    deleteOutboundHeartbeat.mockResolvedValue(undefined)
+    await store.remove('t1')
+
+    expect(store.outboundHeartbeats).toEqual([])
+  })
+
+  it('reflects a manual send result on the row', async () => {
+    listOutboundHeartbeats.mockResolvedValue({ outbound_heartbeats: [target()] })
+    const store = useOutboundHeartbeatsStore()
+    await store.fetchOutboundHeartbeats()
+
+    sendOutboundHeartbeat.mockResolvedValue(
+      target({ last_sent_at: '2026-01-02T00:00:00Z', last_status_code: 200 }),
+    )
+    await store.sendNow('t1')
+
+    expect(store.outboundHeartbeats[0]?.last_status_code).toBe(200)
+    expect(store.outboundHeartbeats[0]?.last_sent_at).toBe('2026-01-02T00:00:00Z')
+  })
+})
diff --git a/frontend/src/stores/outboundHeartbeats.ts b/frontend/src/stores/outboundHeartbeats.ts
new file mode 100644
index 00000000..dd659147
--- /dev/null
+++ b/frontend/src/stores/outboundHeartbeats.ts
@@ -0,0 +1,78 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. See COMMERCIAL-LICENSE.md.
+
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import {
+  listOutboundHeartbeats,
+  createOutboundHeartbeat,
+  updateOutboundHeartbeat,
+  deleteOutboundHeartbeat,
+  sendOutboundHeartbeat,
+  type OutboundHeartbeat,
+  type OutboundHeartbeatInput,
+} from '@/services/outboundHeartbeatApi'
+
+export const useOutboundHeartbeatsStore = defineStore('outboundHeartbeats', () => {
+  const outboundHeartbeats = ref<OutboundHeartbeat[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  function replace(hb: OutboundHeartbeat) {
+    const idx = outboundHeartbeats.value.findIndex((h) => h.id === hb.id)
+    if (idx >= 0) {
+      outboundHeartbeats.value[idx] = hb
+    } else {
+      outboundHeartbeats.value.push(hb)
+    }
+  }
+
+  async function fetchOutboundHeartbeats() {
+    loading.value = true
+    error.value = null
+    try {
+      const res = await listOutboundHeartbeats()
+      outboundHeartbeats.value = res.outbound_heartbeats || []
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : 'Failed to fetch outgoing targets'
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function create(data: OutboundHeartbeatInput): Promise<OutboundHeartbeat> {
+    const created = await createOutboundHeartbeat(data)
+    outboundHeartbeats.value.push(created)
+    return created
+  }
+
+  async function update(id: string, data: OutboundHeartbeatInput): Promise<OutboundHeartbeat> {
+    const updated = await updateOutboundHeartbeat(id, data)
+    replace(updated)
+    return updated
+  }
+
+  async function remove(id: string): Promise<void> {
+    await deleteOutboundHeartbeat(id)
+    outboundHeartbeats.value = outboundHeartbeats.value.filter((hb) => hb.id !== id)
+  }
+
+  async function sendNow(id: string): Promise<OutboundHeartbeat> {
+    const updated = await sendOutboundHeartbeat(id)
+    replace(updated)
+    return updated
+  }
+
+  return {
+    outboundHeartbeats,
+    loading,
+    error,
+    fetchOutboundHeartbeats,
+    create,
+    update,
+    remove,
+    sendNow,
+  }
+})
diff --git a/internal/api/v1/outbound_heartbeats.go b/internal/api/v1/outbound_heartbeats.go
new file mode 100644
index 00000000..72e2bdeb
--- /dev/null
+++ b/internal/api/v1/outbound_heartbeats.go
@@ -0,0 +1,102 @@
+// Copyright 2026 Benjamin Touchard (kOlapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+package v1
+
+import (
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+
+	"github.com/kolapsis/maintenant/internal/outbound"
+)
+
+// OutboundHeartbeatHandler serves the outbound heartbeat endpoints.
+type OutboundHeartbeatHandler struct {
+	svc *outbound.Service
+}
+
+// NewOutboundHeartbeatHandler creates an outbound heartbeat handler.
+func NewOutboundHeartbeatHandler(svc *outbound.Service) *OutboundHeartbeatHandler {
+	return &OutboundHeartbeatHandler{svc: svc}
+}
+
+// HandleList handles GET /api/v1/outbound-heartbeats.
+func (h *OutboundHeartbeatHandler) HandleList(w http.ResponseWriter, r *http.Request) {
+	list, err := h.svc.List(r.Context())
+	if err != nil {
+		WriteStoreError(w, err, "Failed to list outbound heartbeats")
+		return
+	}
+	WriteJSON(w, http.StatusOK, map[string]interface{}{"outbound_heartbeats": list})
+}
+
+// HandleCreate handles POST /api/v1/outbound-heartbeats.
+func (h *OutboundHeartbeatHandler) HandleCreate(w http.ResponseWriter, r *http.Request) {
+	var in outbound.Input
+	if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
+		WriteError(w, http.StatusBadRequest, "INVALID_JSON", "Invalid request body")
+		return
+	}
+	o, err := h.svc.Create(r.Context(), in)
+	if err != nil {
+		writeOutboundError(w, err, "Failed to create outbound heartbeat")
+		return
+	}
+	WriteJSON(w, http.StatusCreated, o)
+}
+
+// HandleUpdate handles PUT /api/v1/outbound-heartbeats/{id}.
+func (h *OutboundHeartbeatHandler) HandleUpdate(w http.ResponseWriter, r *http.Request) {
+	var in outbound.Input
+	if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
+		WriteError(w, http.StatusBadRequest, "INVALID_JSON", "Invalid request body")
+		return
+	}
+	o, err := h.svc.Update(r.Context(), r.PathValue("id"), in)
+	if err != nil {
+		writeOutboundError(w, err, "Failed to update outbound heartbeat")
+		return
+	}
+	WriteJSON(w, http.StatusOK, o)
+}
+
+// HandleDelete handles DELETE /api/v1/outbound-heartbeats/{id}.
+func (h *OutboundHeartbeatHandler) HandleDelete(w http.ResponseWriter, r *http.Request) {
+	if err := h.svc.Delete(r.Context(), r.PathValue("id")); err != nil {
+		writeOutboundError(w, err, "Failed to delete outbound heartbeat")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// HandleSend handles POST /api/v1/outbound-heartbeats/{id}/send.
+func (h *OutboundHeartbeatHandler) HandleSend(w http.ResponseWriter, r *http.Request) {
+	o, err := h.svc.SendNow(r.Context(), r.PathValue("id"))
+	if err != nil {
+		writeOutboundError(w, err, "Failed to send outbound heartbeat")
+		return
+	}
+	WriteJSON(w, http.StatusOK, o)
+}
+
+func writeOutboundError(w http.ResponseWriter, err error, message string) {
+	switch {
+	case errors.Is(err, outbound.ErrNotFound):
+		WriteError(w, http.StatusNotFound, "NOT_FOUND", "Outbound heartbeat not found")
+	case errors.Is(err, outbound.ErrInvalidInput):
+		WriteError(w, http.StatusBadRequest, "INVALID_INPUT", err.Error())
+	default:
+		slog.Error(message, "error", err)
+		WriteStoreError(w, err, message)
+	}
+}
diff --git a/internal/api/v1/outbound_heartbeats_test.go b/internal/api/v1/outbound_heartbeats_test.go
new file mode 100644
index 00000000..e08837a0
--- /dev/null
+++ b/internal/api/v1/outbound_heartbeats_test.go
@@ -0,0 +1,179 @@
+// Copyright 2026 Benjamin Touchard (kOlapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+package v1
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/kolapsis/maintenant/internal/outbound"
+)
+
+type memOutboundStore struct {
+	mu    sync.Mutex
+	items map[string]outbound.OutboundHeartbeat
+}
+
+func (m *memOutboundStore) List(context.Context) ([]*outbound.OutboundHeartbeat, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	var out []*outbound.OutboundHeartbeat
+	for _, o := range m.items {
+		cp := o
+		out = append(out, &cp)
+	}
+	return out, nil
+}
+
+func (m *memOutboundStore) Get(_ context.Context, id string) (*outbound.OutboundHeartbeat, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	o, ok := m.items[id]
+	if !ok {
+		return nil, nil
+	}
+	return &o, nil
+}
+
+func (m *memOutboundStore) Create(_ context.Context, o *outbound.OutboundHeartbeat) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.items[o.ID] = *o
+	return nil
+}
+
+func (m *memOutboundStore) Update(_ context.Context, o *outbound.OutboundHeartbeat) (bool, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, ok := m.items[o.ID]; !ok {
+		return false, nil
+	}
+	m.items[o.ID] = *o
+	return true, nil
+}
+
+func (m *memOutboundStore) Delete(_ context.Context, id string) (bool, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	_, ok := m.items[id]
+	delete(m.items, id)
+	return ok, nil
+}
+
+func (m *memOutboundStore) RecordSend(_ context.Context, id string, r outbound.SendResult) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	o := m.items[id]
+	at := r.SentAt
+	o.LastSentAt, o.LastStatusCode, o.LastError = &at, r.StatusCode, r.Error
+	m.items[id] = o
+	return nil
+}
+
+func newOutboundTestMux() *http.ServeMux {
+	oh := NewOutboundHeartbeatHandler(outbound.NewService(outbound.Deps{
+		Store:       &memOutboundStore{items: map[string]outbound.OutboundHeartbeat{}},
+		ValidateURL: func(context.Context, string) error { return nil },
+	}))
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/outbound-heartbeats", oh.HandleList)
+	mux.HandleFunc("POST /api/v1/outbound-heartbeats", oh.HandleCreate)
+	mux.HandleFunc("PUT /api/v1/outbound-heartbeats/{id}", oh.HandleUpdate)
+	mux.HandleFunc("DELETE /api/v1/outbound-heartbeats/{id}", oh.HandleDelete)
+	mux.HandleFunc("POST /api/v1/outbound-heartbeats/{id}/send", oh.HandleSend)
+	return mux
+}
+
+func doOutbound(t *testing.T, mux http.Handler, method, path, body string) *httptest.ResponseRecorder {
+	t.Helper()
+	rec := httptest.NewRecorder()
+	mux.ServeHTTP(rec, httptest.NewRequest(method, path, strings.NewReader(body)))
+	return rec
+}
+
+func TestOutboundHeartbeatHandler_Validation(t *testing.T) {
+	tests := []struct {
+		name string
+		body string
+		code string
+	}{
+		{"malformed json", `{`, "INVALID_JSON"},
+		{"missing name", `{"url":"https://h/ping/x","interval_seconds":60}`, "INVALID_INPUT"},
+		{"bad scheme", `{"name":"a","url":"ftp://h/x","interval_seconds":60}`, "INVALID_INPUT"},
+		{"plain http", `{"name":"a","url":"http://h/ping/x","interval_seconds":60}`, "INVALID_INPUT"},
+		{"relative url", `{"name":"a","url":"/ping/x","interval_seconds":60}`, "INVALID_INPUT"},
+		{"interval below 30", `{"name":"a","url":"https://h","interval_seconds":10}`, "INVALID_INPUT"},
+		{"interval above 86400", `{"name":"a","url":"https://h","interval_seconds":90000}`, "INVALID_INPUT"},
+	}
+	mux := newOutboundTestMux()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			rec := doOutbound(t, mux, http.MethodPost, "/api/v1/outbound-heartbeats", tt.body)
+			assert.Equal(t, http.StatusBadRequest, rec.Code)
+			var resp ErrorResponse
+			require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+			assert.Equal(t, tt.code, resp.Error.Code)
+		})
+	}
+}
+
+func TestOutboundHeartbeatHandler_UnknownID(t *testing.T) {
+	mux := newOutboundTestMux()
+	valid := `{"name":"a","url":"https://h","interval_seconds":60}`
+	for _, tc := range []struct{ method, path, body string }{
+		{http.MethodPut, "/api/v1/outbound-heartbeats/nope", valid},
+		{http.MethodDelete, "/api/v1/outbound-heartbeats/nope", ""},
+		{http.MethodPost, "/api/v1/outbound-heartbeats/nope/send", ""},
+	} {
+		rec := doOutbound(t, mux, tc.method, tc.path, tc.body)
+		assert.Equal(t, http.StatusNotFound, rec.Code, "%s %s", tc.method, tc.path)
+	}
+}
+
+func TestOutboundHeartbeatHandler_CreateListDelete(t *testing.T) {
+	mux := newOutboundTestMux()
+	rec := doOutbound(t, mux, http.MethodPost, "/api/v1/outbound-heartbeats",
+		`{"name":"upstream","url":"https://mnt.example/ping/abc","interval_seconds":60,"enabled":false}`)
+	require.Equal(t, http.StatusCreated, rec.Code)
+
+	var created map[string]any
+	require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &created))
+	for _, key := range []string{"id", "name", "url", "interval_seconds", "enabled",
+		"last_sent_at", "last_status_code", "last_error", "created_at", "updated_at"} {
+		assert.Contains(t, created, key)
+	}
+	assert.Equal(t, false, created["enabled"])
+	assert.Nil(t, created["last_sent_at"])
+	id := created["id"].(string)
+
+	rec = doOutbound(t, mux, http.MethodGet, "/api/v1/outbound-heartbeats", "")
+	require.Equal(t, http.StatusOK, rec.Code)
+	var list struct {
+		OutboundHeartbeats []map[string]any `json:"outbound_heartbeats"`
+	}
+	require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &list))
+	require.Len(t, list.OutboundHeartbeats, 1)
+
+	rec = doOutbound(t, mux, http.MethodDelete, "/api/v1/outbound-heartbeats/"+id, "")
+	assert.Equal(t, http.StatusNoContent, rec.Code)
+
+	rec = doOutbound(t, mux, http.MethodGet, "/api/v1/outbound-heartbeats", "")
+	assert.JSONEq(t, `{"outbound_heartbeats":[]}`, rec.Body.String())
+}
diff --git a/internal/api/v1/router.go b/internal/api/v1/router.go
index 95c42fb6..bb088219 100644
--- a/internal/api/v1/router.go
+++ b/internal/api/v1/router.go
@@ -28,6 +28,7 @@ import (
 	"github.com/kolapsis/maintenant/internal/extension"
 	"github.com/kolapsis/maintenant/internal/heartbeat"
 	"github.com/kolapsis/maintenant/internal/license"
+	"github.com/kolapsis/maintenant/internal/outbound"
 	"github.com/kolapsis/maintenant/internal/resource"
 	"github.com/kolapsis/maintenant/internal/runtime"
 	"github.com/kolapsis/maintenant/internal/security"
@@ -78,6 +79,7 @@ type HandlerDeps struct {
 	Endpoints    *endpoint.Service
 	Heartbeats   *heartbeat.Service
 	Certificates *certificate.Service
+	Outbound     *outbound.Service
 	Resources    *resource.Service
 	Logger       *slog.Logger
 
@@ -283,6 +285,15 @@ func NewRouter(d HandlerDeps) *Router {
 		r.mux.HandleFunc("POST /ping/{uuid}", ph.HandlePing)
 	}
 
+	if d.Outbound != nil {
+		oh := NewOutboundHeartbeatHandler(d.Outbound)
+		r.mux.HandleFunc("GET /api/v1/outbound-heartbeats", oh.HandleList)
+		r.mux.HandleFunc("POST /api/v1/outbound-heartbeats", oh.HandleCreate)
+		r.mux.HandleFunc("PUT /api/v1/outbound-heartbeats/{id}", oh.HandleUpdate)
+		r.mux.HandleFunc("DELETE /api/v1/outbound-heartbeats/{id}", oh.HandleDelete)
+		r.mux.HandleFunc("POST /api/v1/outbound-heartbeats/{id}/send", oh.HandleSend)
+	}
+
 	// Resource monitoring endpoints
 	if d.Resources != nil {
 		rh := NewResourceHandler(d.Resources)
diff --git a/internal/app/app.go b/internal/app/app.go
index 270c7f93..6500aa89 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -42,6 +42,7 @@ import (
 	"github.com/kolapsis/maintenant/internal/kubernetes"
 	"github.com/kolapsis/maintenant/internal/license"
 	"github.com/kolapsis/maintenant/internal/mcp"
+	"github.com/kolapsis/maintenant/internal/outbound"
 	"github.com/kolapsis/maintenant/internal/ratelimit"
 	"github.com/kolapsis/maintenant/internal/resource"
 	"github.com/kolapsis/maintenant/internal/runtime"
@@ -75,6 +76,7 @@ type App struct {
 	containerSvc       *container.Service
 	endpointSvc        *endpoint.Service
 	heartbeatSvc       *heartbeat.Service
+	outboundSvc        *outbound.Service
 	certSvc            *certificate.Service
 	resourceSvc        *resource.Service
 	securitySvc        *security.Service
@@ -391,6 +393,11 @@ func New(cfg Config, logger *slog.Logger) (*App, error) {
 		LicenseChecker: heartbeatLicenseChecker,
 		BaseURL:        cfg.BaseURL,
 	})
+	a.outboundSvc = outbound.NewService(outbound.Deps{
+		Store:   store.NewOutboundHeartbeatStore(db),
+		Logger:  logger,
+		Version: cfg.Version,
+	})
 
 	// --- SMTP ---
 	var smtpSender *alert.SMTPSender
@@ -611,6 +618,7 @@ func New(cfg Config, logger *slog.Logger) (*App, error) {
 		Endpoints:    a.endpointSvc,
 		Heartbeats:   a.heartbeatSvc,
 		Certificates: a.certSvc,
+		Outbound:     a.outboundSvc,
 		Resources:    a.resourceSvc,
 		Logger:       logger,
 		// Alert pipeline
@@ -830,6 +838,7 @@ func (a *App) Start(ctx context.Context) error {
 	a.notifier.Start(ctx)
 	a.endpointSvc.Start(ctx)
 	a.heartbeatSvc.StartDeadlineChecker(ctx)
+	a.outboundSvc.Start(ctx)
 
 	// Telemetry: best-effort. Self-exits on ctx cancellation; panics are
 	// contained inside the package (FR-009/FR-011/FR-012).
diff --git a/internal/outbound/model.go b/internal/outbound/model.go
new file mode 100644
index 00000000..c74c08d0
--- /dev/null
+++ b/internal/outbound/model.go
@@ -0,0 +1,108 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+// Package outbound periodically pings admin-configured URLs so that another
+// monitoring system notices when this instance stops.
+package outbound
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const (
+	MinIntervalSeconds = 30
+	MaxIntervalSeconds = 86400
+	MaxNameLength      = 255
+)
+
+var (
+	ErrNotFound     = errors.New("outbound heartbeat not found")
+	ErrInvalidInput = errors.New("invalid input")
+)
+
+// OutboundHeartbeat is a URL this instance sends a GET to at a fixed interval.
+type OutboundHeartbeat struct {
+	ID              string     `json:"id"`
+	Name            string     `json:"name"`
+	URL             string     `json:"url"`
+	IntervalSeconds int        `json:"interval_seconds"`
+	Enabled         bool       `json:"enabled"`
+	LastSentAt      *time.Time `json:"last_sent_at"`
+	LastStatusCode  *int       `json:"last_status_code"`
+	LastError       *string    `json:"last_error"`
+	CreatedAt       time.Time  `json:"created_at"`
+	UpdatedAt       time.Time  `json:"updated_at"`
+}
+
+// Input is the admin-editable part of an outbound heartbeat.
+type Input struct {
+	Name            string `json:"name"`
+	URL             string `json:"url"`
+	IntervalSeconds int    `json:"interval_seconds"`
+	Enabled         *bool  `json:"enabled"`
+}
+
+// SendResult is the outcome of one send.
+type SendResult struct {
+	SentAt     time.Time
+	StatusCode *int
+	Error      *string
+}
+
+// Store persists outbound heartbeats; Get returns nil, nil when the id is unknown.
+type Store interface {
+	List(ctx context.Context) ([]*OutboundHeartbeat, error)
+	Get(ctx context.Context, id string) (*OutboundHeartbeat, error)
+	Create(ctx context.Context, o *OutboundHeartbeat) error
+	Update(ctx context.Context, o *OutboundHeartbeat) (bool, error)
+	Delete(ctx context.Context, id string) (bool, error)
+	RecordSend(ctx context.Context, id string, r SendResult) error
+}
+
+// Validate normalises the input and reports the first invalid field.
+func (in *Input) Validate() error {
+	in.Name = strings.TrimSpace(in.Name)
+	in.URL = strings.TrimSpace(in.URL)
+	if in.Name == "" {
+		return fmt.Errorf("%w: name is required", ErrInvalidInput)
+	}
+	if len(in.Name) > MaxNameLength {
+		return fmt.Errorf("%w: name must be at most %d characters", ErrInvalidInput, MaxNameLength)
+	}
+	u, err := url.Parse(in.URL)
+	if err != nil || u.Scheme != "https" || u.Host == "" {
+		return fmt.Errorf("%w: url must be an absolute https URL", ErrInvalidInput)
+	}
+	if in.IntervalSeconds < MinIntervalSeconds || in.IntervalSeconds > MaxIntervalSeconds {
+		return fmt.Errorf("%w: interval_seconds must be between %d and %d",
+			ErrInvalidInput, MinIntervalSeconds, MaxIntervalSeconds)
+	}
+	return nil
+}
+
+func (in Input) enabled() bool {
+	return in.Enabled == nil || *in.Enabled
+}
+
+func (o *OutboundHeartbeat) due(now time.Time) bool {
+	if !o.Enabled {
+		return false
+	}
+	if o.LastSentAt == nil {
+		return true
+	}
+	return !o.LastSentAt.Add(time.Duration(o.IntervalSeconds) * time.Second).After(now)
+}
diff --git a/internal/outbound/service.go b/internal/outbound/service.go
new file mode 100644
index 00000000..a12b0cb1
--- /dev/null
+++ b/internal/outbound/service.go
@@ -0,0 +1,284 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+package outbound
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/kolapsis/maintenant/internal/ssrf"
+	"github.com/kolapsis/maintenant/internal/uid"
+)
+
+const (
+	tickInterval = 5 * time.Second
+	sendTimeout  = 10 * time.Second
+)
+
+// Deps holds the service dependencies.
+type Deps struct {
+	Store       Store
+	Logger      *slog.Logger
+	Version     string
+	Client      *http.Client
+	ValidateURL func(ctx context.Context, rawURL string) error
+}
+
+// Service manages outbound heartbeats and sends them when due.
+type Service struct {
+	store     Store
+	logger    *slog.Logger
+	userAgent string
+	client    *http.Client
+	validate  func(ctx context.Context, rawURL string) error
+	now       func() time.Time
+
+	mu       sync.Mutex
+	inFlight map[string]struct{}
+	wg       sync.WaitGroup
+}
+
+// NewService creates an outbound heartbeat service.
+func NewService(d Deps) *Service {
+	logger := d.Logger
+	if logger == nil {
+		logger = slog.Default()
+	}
+	client := d.Client
+	if client == nil {
+		client = ssrf.NewHTTPClient(sendTimeout, false)
+	}
+	validate := d.ValidateURL
+	if validate == nil {
+		validate = ssrf.ValidateURL
+	}
+	return &Service{
+		store:     d.Store,
+		logger:    logger,
+		userAgent: "maintenant/" + d.Version + " outbound-heartbeat",
+		client:    client,
+		validate:  validate,
+		now:       time.Now,
+		inFlight:  make(map[string]struct{}),
+	}
+}
+
+// List returns every outbound heartbeat.
+func (s *Service) List(ctx context.Context) ([]*OutboundHeartbeat, error) {
+	list, err := s.store.List(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		list = []*OutboundHeartbeat{}
+	}
+	return list, nil
+}
+
+// Get returns one outbound heartbeat or ErrNotFound.
+func (s *Service) Get(ctx context.Context, id string) (*OutboundHeartbeat, error) {
+	o, err := s.store.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if o == nil {
+		return nil, ErrNotFound
+	}
+	return o, nil
+}
+
+func (s *Service) validateInput(ctx context.Context, in *Input) error {
+	if err := in.Validate(); err != nil {
+		return err
+	}
+	if err := s.validate(ctx, in.URL); err != nil {
+		return fmt.Errorf("%w: url: %v", ErrInvalidInput, err)
+	}
+	return nil
+}
+
+// Create validates and stores a new outbound heartbeat.
+func (s *Service) Create(ctx context.Context, in Input) (*OutboundHeartbeat, error) {
+	if err := s.validateInput(ctx, &in); err != nil {
+		return nil, err
+	}
+	now := s.now().Truncate(time.Second)
+	o := &OutboundHeartbeat{
+		ID:              uid.New(),
+		Name:            in.Name,
+		URL:             in.URL,
+		IntervalSeconds: in.IntervalSeconds,
+		Enabled:         in.enabled(),
+		CreatedAt:       now,
+		UpdatedAt:       now,
+	}
+	if err := s.store.Create(ctx, o); err != nil {
+		return nil, fmt.Errorf("create outbound heartbeat: %w", err)
+	}
+	return o, nil
+}
+
+// Update replaces the editable fields of an outbound heartbeat.
+func (s *Service) Update(ctx context.Context, id string, in Input) (*OutboundHeartbeat, error) {
+	if err := s.validateInput(ctx, &in); err != nil {
+		return nil, err
+	}
+	o, err := s.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	o.Name = in.Name
+	o.URL = in.URL
+	o.IntervalSeconds = in.IntervalSeconds
+	o.Enabled = in.enabled()
+	o.UpdatedAt = s.now().Truncate(time.Second)
+	found, err := s.store.Update(ctx, o)
+	if err != nil {
+		return nil, fmt.Errorf("update outbound heartbeat: %w", err)
+	}
+	if !found {
+		return nil, ErrNotFound
+	}
+	return o, nil
+}
+
+// Delete removes an outbound heartbeat.
+func (s *Service) Delete(ctx context.Context, id string) error {
+	found, err := s.store.Delete(ctx, id)
+	if err != nil {
+		return fmt.Errorf("delete outbound heartbeat: %w", err)
+	}
+	if !found {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// SendNow sends one outbound heartbeat immediately and returns it updated.
+func (s *Service) SendNow(ctx context.Context, id string) (*OutboundHeartbeat, error) {
+	o, err := s.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if s.claim(o.ID) {
+		defer s.release(o.ID)
+	}
+	if err := s.send(ctx, o); err != nil {
+		return nil, err
+	}
+	return s.Get(ctx, id)
+}
+
+// Start runs the send loop until ctx is cancelled.
+func (s *Service) Start(ctx context.Context) {
+	go func() {
+		s.logger.Info("outbound heartbeat: sender started")
+		ticker := time.NewTicker(tickInterval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				s.wg.Wait()
+				return
+			case <-ticker.C:
+				s.sendDue(ctx)
+			}
+		}
+	}()
+}
+
+func (s *Service) sendDue(ctx context.Context) {
+	list, err := s.store.List(ctx)
+	if err != nil {
+		s.logger.Error("outbound heartbeat: list targets", "error", err)
+		return
+	}
+	now := s.now()
+	for _, o := range list {
+		if !o.due(now) || !s.claim(o.ID) {
+			continue
+		}
+		s.wg.Add(1)
+		go func(o *OutboundHeartbeat) {
+			defer s.wg.Done()
+			defer s.release(o.ID)
+			if err := s.send(ctx, o); err != nil && ctx.Err() == nil {
+				s.logger.Error("outbound heartbeat: record result", "id", o.ID, "error", err)
+			}
+		}(o)
+	}
+}
+
+func (s *Service) claim(id string) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if _, busy := s.inFlight[id]; busy {
+		return false
+	}
+	s.inFlight[id] = struct{}{}
+	return true
+}
+
+func (s *Service) release(id string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	delete(s.inFlight, id)
+}
+
+func (s *Service) send(ctx context.Context, o *OutboundHeartbeat) error {
+	res := SendResult{SentAt: s.now()}
+	code, err := s.get(ctx, o.URL)
+	switch {
+	case err != nil:
+		var uerr *url.Error
+		if errors.As(err, &uerr) {
+			err = uerr.Err
+		}
+		msg := err.Error()
+		res.Error = &msg
+	case code < 200 || code > 299:
+		msg := fmt.Sprintf("unexpected status %d %s", code, http.StatusText(code))
+		res.StatusCode = &code
+		res.Error = &msg
+	default:
+		res.StatusCode = &code
+	}
+	if res.Error != nil && ctx.Err() == nil {
+		s.logger.Warn("outbound heartbeat: send failed",
+			"id", o.ID, "name", o.Name, "error", *res.Error)
+	}
+	return s.store.RecordSend(ctx, o.ID, res)
+}
+
+func (s *Service) get(ctx context.Context, target string) (int, error) {
+	reqCtx, cancel := context.WithTimeout(ctx, sendTimeout)
+	defer cancel()
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, target, nil)
+	if err != nil {
+		return 0, err
+	}
+	req.Header.Set("User-Agent", s.userAgent)
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return 0, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+	_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 64<<10))
+	return resp.StatusCode, nil
+}
diff --git a/internal/outbound/service_test.go b/internal/outbound/service_test.go
new file mode 100644
index 00000000..1c4cc52d
--- /dev/null
+++ b/internal/outbound/service_test.go
@@ -0,0 +1,300 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+package outbound
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type fakeStore struct {
+	mu    sync.Mutex
+	items map[string]*OutboundHeartbeat
+	order []string
+}
+
+func newFakeStore(items ...*OutboundHeartbeat) *fakeStore {
+	f := &fakeStore{items: map[string]*OutboundHeartbeat{}}
+	for _, o := range items {
+		f.items[o.ID] = o
+		f.order = append(f.order, o.ID)
+	}
+	return f
+}
+
+func (f *fakeStore) List(context.Context) ([]*OutboundHeartbeat, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []*OutboundHeartbeat
+	for _, id := range f.order {
+		if o, ok := f.items[id]; ok {
+			cp := *o
+			out = append(out, &cp)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) Get(_ context.Context, id string) (*OutboundHeartbeat, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	o, ok := f.items[id]
+	if !ok {
+		return nil, nil
+	}
+	cp := *o
+	return &cp, nil
+}
+
+func (f *fakeStore) Create(_ context.Context, o *OutboundHeartbeat) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	cp := *o
+	f.items[o.ID] = &cp
+	f.order = append(f.order, o.ID)
+	return nil
+}
+
+func (f *fakeStore) Update(_ context.Context, o *OutboundHeartbeat) (bool, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if _, ok := f.items[o.ID]; !ok {
+		return false, nil
+	}
+	cp := *o
+	f.items[o.ID] = &cp
+	return true, nil
+}
+
+func (f *fakeStore) Delete(_ context.Context, id string) (bool, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	_, ok := f.items[id]
+	delete(f.items, id)
+	return ok, nil
+}
+
+func (f *fakeStore) RecordSend(_ context.Context, id string, r SendResult) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	o, ok := f.items[id]
+	if !ok {
+		return errors.New("not found")
+	}
+	at := r.SentAt
+	o.LastSentAt = &at
+	o.LastStatusCode = r.StatusCode
+	o.LastError = r.Error
+	return nil
+}
+
+func ptrTime(t time.Time) *time.Time { return &t }
+
+func TestDue(t *testing.T) {
+	now := time.Unix(1_700_000_000, 0)
+	tests := []struct {
+		name string
+		o    OutboundHeartbeat
+		want bool
+	}{
+		{"never sent", OutboundHeartbeat{Enabled: true, IntervalSeconds: 60}, true},
+		{"disabled", OutboundHeartbeat{Enabled: false, IntervalSeconds: 60}, false},
+		{"sent recently", OutboundHeartbeat{Enabled: true, IntervalSeconds: 60, LastSentAt: ptrTime(now.Add(-30 * time.Second))}, false},
+		{"interval just elapsed", OutboundHeartbeat{Enabled: true, IntervalSeconds: 60, LastSentAt: ptrTime(now.Add(-60 * time.Second))}, true},
+		{"overdue", OutboundHeartbeat{Enabled: true, IntervalSeconds: 60, LastSentAt: ptrTime(now.Add(-time.Hour))}, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.o.due(now))
+		})
+	}
+}
+
+func TestValidate(t *testing.T) {
+	tests := []struct {
+		name string
+		in   Input
+		ok   bool
+	}{
+		{"valid https", Input{Name: "a", URL: "https://mnt.example/ping/x", IntervalSeconds: 60}, true},
+		{"http rejected", Input{Name: "a", URL: "http://mnt.example/ping/x", IntervalSeconds: 30}, false},
+		{"max interval", Input{Name: "a", URL: "https://h", IntervalSeconds: 86400}, true},
+		{"blank name", Input{Name: "  ", URL: "https://h", IntervalSeconds: 60}, false},
+		{"no scheme", Input{Name: "a", URL: "mnt.example/ping", IntervalSeconds: 60}, false},
+		{"ftp scheme", Input{Name: "a", URL: "ftp://h/x", IntervalSeconds: 60}, false},
+		{"no host", Input{Name: "a", URL: "https:///x", IntervalSeconds: 60}, false},
+		{"interval too short", Input{Name: "a", URL: "https://h", IntervalSeconds: 29}, false},
+		{"interval too long", Input{Name: "a", URL: "https://h", IntervalSeconds: 86401}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.in.Validate()
+			if tt.ok {
+				assert.NoError(t, err)
+			} else {
+				assert.ErrorIs(t, err, ErrInvalidInput)
+			}
+		})
+	}
+}
+
+func TestSendDue_RecordsResults(t *testing.T) {
+	var userAgent atomic.Value
+	okSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		userAgent.Store(r.Header.Get("User-Agent"))
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer okSrv.Close()
+	failSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer failSrv.Close()
+	deadSrv := httptest.NewServer(http.NotFoundHandler())
+	deadURL := deadSrv.URL
+	deadSrv.Close()
+
+	now := time.Unix(1_700_000_000, 0)
+	recent := now.Add(-10 * time.Second)
+	st := newFakeStore(
+		&OutboundHeartbeat{ID: "ok", URL: okSrv.URL, IntervalSeconds: 60, Enabled: true},
+		&OutboundHeartbeat{ID: "fail", URL: failSrv.URL, IntervalSeconds: 60, Enabled: true},
+		&OutboundHeartbeat{ID: "dead", URL: deadURL, IntervalSeconds: 60, Enabled: true},
+		&OutboundHeartbeat{ID: "notdue", URL: okSrv.URL, IntervalSeconds: 60, Enabled: true, LastSentAt: &recent},
+		&OutboundHeartbeat{ID: "off", URL: okSrv.URL, IntervalSeconds: 60, Enabled: false},
+	)
+	s := NewService(Deps{Store: st, Version: "1.2.3", Client: &http.Client{Timeout: time.Second}})
+	s.now = func() time.Time { return now }
+
+	s.sendDue(context.Background())
+	s.wg.Wait()
+
+	ok, _ := st.Get(context.Background(), "ok")
+	require.NotNil(t, ok.LastSentAt)
+	assert.Equal(t, now, *ok.LastSentAt)
+	require.NotNil(t, ok.LastStatusCode)
+	assert.Equal(t, 200, *ok.LastStatusCode)
+	assert.Nil(t, ok.LastError)
+	assert.Equal(t, "maintenant/1.2.3 outbound-heartbeat", userAgent.Load())
+
+	fail, _ := st.Get(context.Background(), "fail")
+	require.NotNil(t, fail.LastStatusCode)
+	assert.Equal(t, 500, *fail.LastStatusCode)
+	require.NotNil(t, fail.LastError)
+	assert.Contains(t, *fail.LastError, "500")
+
+	dead, _ := st.Get(context.Background(), "dead")
+	require.NotNil(t, dead.LastSentAt)
+	assert.Nil(t, dead.LastStatusCode)
+	require.NotNil(t, dead.LastError)
+	assert.NotContains(t, *dead.LastError, deadURL)
+
+	notDue, _ := st.Get(context.Background(), "notdue")
+	assert.Equal(t, recent, *notDue.LastSentAt)
+	assert.Nil(t, notDue.LastStatusCode)
+
+	off, _ := st.Get(context.Background(), "off")
+	assert.Nil(t, off.LastSentAt)
+}
+
+func TestSendDue_SkipsTargetInFlight(t *testing.T) {
+	var hits atomic.Int32
+	release := make(chan struct{})
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		hits.Add(1)
+		<-release
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer srv.Close()
+
+	st := newFakeStore(&OutboundHeartbeat{ID: "slow", URL: srv.URL, IntervalSeconds: 30, Enabled: true})
+	s := NewService(Deps{Store: st, Client: &http.Client{Timeout: 5 * time.Second}})
+
+	s.sendDue(context.Background())
+	require.Eventually(t, func() bool { return hits.Load() == 1 }, 2*time.Second, 10*time.Millisecond)
+	s.sendDue(context.Background())
+	close(release)
+	s.wg.Wait()
+
+	assert.Equal(t, int32(1), hits.Load())
+	got, _ := st.Get(context.Background(), "slow")
+	require.NotNil(t, got.LastStatusCode)
+	assert.Equal(t, 204, *got.LastStatusCode)
+}
+
+func TestSendNow(t *testing.T) {
+	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	s := NewService(Deps{Store: newFakeStore(), Client: srv.Client(), ValidateURL: acceptURL})
+	ctx := context.Background()
+	o, err := s.Create(ctx, Input{Name: "up", URL: srv.URL, IntervalSeconds: 60})
+	require.NoError(t, err)
+	assert.True(t, o.Enabled, "enabled defaults to true")
+
+	got, err := s.SendNow(ctx, o.ID)
+	require.NoError(t, err)
+	require.NotNil(t, got.LastSentAt)
+	assert.Equal(t, 200, *got.LastStatusCode)
+
+	_, err = s.SendNow(ctx, "missing")
+	assert.ErrorIs(t, err, ErrNotFound)
+}
+
+func TestUpdateDelete_NotFound(t *testing.T) {
+	s := NewService(Deps{Store: newFakeStore(), ValidateURL: acceptURL})
+	ctx := context.Background()
+	_, err := s.Update(ctx, "missing", Input{Name: "a", URL: "https://h", IntervalSeconds: 60})
+	assert.ErrorIs(t, err, ErrNotFound)
+	assert.ErrorIs(t, s.Delete(ctx, "missing"), ErrNotFound)
+}
+
+func acceptURL(context.Context, string) error { return nil }
+
+func TestCreate_RejectsInternalTargets(t *testing.T) {
+	s := NewService(Deps{Store: newFakeStore()})
+	ctx := context.Background()
+	for _, u := range []string{"https://127.0.0.1/ping/x", "https://10.0.0.5/ping/x", "https://169.254.169.254/latest", "https://localhost/ping/x"} {
+		_, err := s.Create(ctx, Input{Name: "a", URL: u, IntervalSeconds: 60})
+		assert.ErrorIs(t, err, ErrInvalidInput, u)
+	}
+}
+
+func TestSendDue_DefaultClientRefusesLoopback(t *testing.T) {
+	var hits atomic.Int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		hits.Add(1)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	st := newFakeStore(&OutboundHeartbeat{ID: "loop", URL: srv.URL, IntervalSeconds: 60, Enabled: true})
+	s := NewService(Deps{Store: st})
+
+	s.sendDue(context.Background())
+	s.wg.Wait()
+
+	assert.Equal(t, int32(0), hits.Load())
+	got, _ := st.Get(context.Background(), "loop")
+	assert.Nil(t, got.LastStatusCode)
+	require.NotNil(t, got.LastError)
+}
diff --git a/internal/store/copy.go b/internal/store/copy.go
index 2a82a243..08ebee55 100644
--- a/internal/store/copy.go
+++ b/internal/store/copy.go
@@ -69,6 +69,7 @@ var carriedTables = []carriedTable{
 	{"endpoints", "declared endpoint monitors"},
 	{"heartbeats", "declared heartbeat monitors"},
 	{"cert_monitors", "declared certificate monitors"},
+	{"outbound_heartbeats", "outbound heartbeat targets"},
 
 	// Alerting configuration, channel secrets included.
 	{"notification_channels", "notification channels and their secrets"},
diff --git a/internal/store/migrations/postgres/34_outbound_heartbeats.down.sql b/internal/store/migrations/postgres/34_outbound_heartbeats.down.sql
new file mode 100644
index 00000000..c9be73c4
--- /dev/null
+++ b/internal/store/migrations/postgres/34_outbound_heartbeats.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS outbound_heartbeats;
diff --git a/internal/store/migrations/postgres/34_outbound_heartbeats.up.sql b/internal/store/migrations/postgres/34_outbound_heartbeats.up.sql
new file mode 100644
index 00000000..7ab099eb
--- /dev/null
+++ b/internal/store/migrations/postgres/34_outbound_heartbeats.up.sql
@@ -0,0 +1,12 @@
+CREATE TABLE outbound_heartbeats (
+    id               TEXT PRIMARY KEY NOT NULL,
+    name             TEXT NOT NULL,
+    url              TEXT NOT NULL,
+    interval_seconds INTEGER NOT NULL,
+    enabled          INTEGER NOT NULL DEFAULT 1,
+    last_sent_at     BIGINT,
+    last_status_code INTEGER,
+    last_error       TEXT,
+    created_at       BIGINT NOT NULL,
+    updated_at       BIGINT NOT NULL
+);
diff --git a/internal/store/migrations/sqlite/34_outbound_heartbeats.down.sql b/internal/store/migrations/sqlite/34_outbound_heartbeats.down.sql
new file mode 100644
index 00000000..c9be73c4
--- /dev/null
+++ b/internal/store/migrations/sqlite/34_outbound_heartbeats.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS outbound_heartbeats;
diff --git a/internal/store/migrations/sqlite/34_outbound_heartbeats.up.sql b/internal/store/migrations/sqlite/34_outbound_heartbeats.up.sql
new file mode 100644
index 00000000..7ab099eb
--- /dev/null
+++ b/internal/store/migrations/sqlite/34_outbound_heartbeats.up.sql
@@ -0,0 +1,12 @@
+CREATE TABLE outbound_heartbeats (
+    id               TEXT PRIMARY KEY NOT NULL,
+    name             TEXT NOT NULL,
+    url              TEXT NOT NULL,
+    interval_seconds INTEGER NOT NULL,
+    enabled          INTEGER NOT NULL DEFAULT 1,
+    last_sent_at     BIGINT,
+    last_status_code INTEGER,
+    last_error       TEXT,
+    created_at       BIGINT NOT NULL,
+    updated_at       BIGINT NOT NULL
+);
diff --git a/internal/store/migrations_postgres_test.go b/internal/store/migrations_postgres_test.go
index a02b27ab..2e20bbad 100644
--- a/internal/store/migrations_postgres_test.go
+++ b/internal/store/migrations_postgres_test.go
@@ -119,6 +119,7 @@ func TestMigratePostgres_ConcurrentCatchUp(t *testing.T) {
 		"DROP TABLE cve_evaluations", // 31
 		"ALTER TABLE containers DROP COLUMN image_version, DROP COLUMN image_source, DROP COLUMN image_url, DROP COLUMN image_description",                                                  // 32
 		"ALTER TABLE agents DROP COLUMN os_id, DROP COLUMN os_version_id, DROP COLUMN os_pretty_name, DROP COLUMN os_source, DROP COLUMN os_unavailable_reason, DROP COLUMN os_reported_at", // 33
+		"DROP TABLE outbound_heartbeats", // 34
 	} {
 		_, err = db.ReadDB().Exec(undo)
 		require.NoError(t, err, undo)
diff --git a/internal/store/outbound_heartbeats.go b/internal/store/outbound_heartbeats.go
new file mode 100644
index 00000000..ed6fe594
--- /dev/null
+++ b/internal/store/outbound_heartbeats.go
@@ -0,0 +1,136 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/kolapsis/maintenant/internal/outbound"
+)
+
+// OutboundHeartbeatStore implements outbound.Store.
+type OutboundHeartbeatStore struct {
+	db     *Reader
+	writer *Writer
+}
+
+// NewOutboundHeartbeatStore creates an outbound heartbeat store.
+func NewOutboundHeartbeatStore(d *DB) *OutboundHeartbeatStore {
+	return &OutboundHeartbeatStore{db: d.Reader(), writer: d.Writer()}
+}
+
+const outboundHeartbeatColumns = `id, name, url, interval_seconds, enabled,
+	last_sent_at, last_status_code, last_error, created_at, updated_at`
+
+func (s *OutboundHeartbeatStore) List(ctx context.Context) ([]*outbound.OutboundHeartbeat, error) {
+	rows, err := s.db.QueryContext(ctx,
+		`SELECT `+outboundHeartbeatColumns+` FROM outbound_heartbeats ORDER BY created_at, id`)
+	if err != nil {
+		return nil, fmt.Errorf("list outbound heartbeats: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	var out []*outbound.OutboundHeartbeat
+	for rows.Next() {
+		o, err := scanOutboundHeartbeat(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, o)
+	}
+	return out, rows.Err()
+}
+
+func (s *OutboundHeartbeatStore) Get(ctx context.Context, id string) (*outbound.OutboundHeartbeat, error) {
+	o, err := scanOutboundHeartbeat(s.db.QueryRowContext(ctx,
+		`SELECT `+outboundHeartbeatColumns+` FROM outbound_heartbeats WHERE id=?`, id))
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	return o, err
+}
+
+func (s *OutboundHeartbeatStore) Create(ctx context.Context, o *outbound.OutboundHeartbeat) error {
+	_, err := s.writer.Exec(ctx,
+		`INSERT INTO outbound_heartbeats (id, name, url, interval_seconds, enabled, created_at, updated_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?)`,
+		o.ID, o.Name, o.URL, o.IntervalSeconds, boolToInt(o.Enabled),
+		o.CreatedAt.Unix(), o.UpdatedAt.Unix())
+	if err != nil {
+		return fmt.Errorf("insert outbound heartbeat: %w", err)
+	}
+	return nil
+}
+
+func (s *OutboundHeartbeatStore) Update(ctx context.Context, o *outbound.OutboundHeartbeat) (bool, error) {
+	res, err := s.writer.Exec(ctx,
+		`UPDATE outbound_heartbeats SET name=?, url=?, interval_seconds=?, enabled=?, updated_at=?
+		WHERE id=?`,
+		o.Name, o.URL, o.IntervalSeconds, boolToInt(o.Enabled), o.UpdatedAt.Unix(), o.ID)
+	if err != nil {
+		return false, fmt.Errorf("update outbound heartbeat %s: %w", o.ID, err)
+	}
+	return res.RowsAffected > 0, nil
+}
+
+func (s *OutboundHeartbeatStore) Delete(ctx context.Context, id string) (bool, error) {
+	res, err := s.writer.Exec(ctx, `DELETE FROM outbound_heartbeats WHERE id=?`, id)
+	if err != nil {
+		return false, fmt.Errorf("delete outbound heartbeat %s: %w", id, err)
+	}
+	return res.RowsAffected > 0, nil
+}
+
+func (s *OutboundHeartbeatStore) RecordSend(ctx context.Context, id string, r outbound.SendResult) error {
+	_, err := s.writer.Exec(ctx,
+		`UPDATE outbound_heartbeats SET last_sent_at=?, last_status_code=?, last_error=? WHERE id=?`,
+		r.SentAt.Unix(), r.StatusCode, r.Error, id)
+	if err != nil {
+		return fmt.Errorf("record outbound heartbeat send %s: %w", id, err)
+	}
+	return nil
+}
+
+func scanOutboundHeartbeat(row rowScanner) (*outbound.OutboundHeartbeat, error) {
+	var o outbound.OutboundHeartbeat
+	var enabled int
+	var lastSentAt, lastStatusCode sql.NullInt64
+	var lastError sql.NullString
+	var createdAt, updatedAt int64
+	if err := row.Scan(&o.ID, &o.Name, &o.URL, &o.IntervalSeconds, &enabled,
+		&lastSentAt, &lastStatusCode, &lastError, &createdAt, &updatedAt); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, err
+		}
+		return nil, fmt.Errorf("scan outbound heartbeat: %w", err)
+	}
+	o.Enabled = enabled != 0
+	o.CreatedAt = time.Unix(createdAt, 0)
+	o.UpdatedAt = time.Unix(updatedAt, 0)
+	if lastSentAt.Valid {
+		t := time.Unix(lastSentAt.Int64, 0)
+		o.LastSentAt = &t
+	}
+	if lastStatusCode.Valid {
+		v := int(lastStatusCode.Int64)
+		o.LastStatusCode = &v
+	}
+	if lastError.Valid {
+		v := lastError.String
+		o.LastError = &v
+	}
+	return &o, nil
+}
diff --git a/internal/store/outbound_heartbeats_test.go b/internal/store/outbound_heartbeats_test.go
new file mode 100644
index 00000000..6cc32abe
--- /dev/null
+++ b/internal/store/outbound_heartbeats_test.go
@@ -0,0 +1,130 @@
+// Copyright 2026 Benjamin Touchard (Kolapsis)
+//
+// Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0)
+// or a commercial license. You may not use this file except in compliance
+// with one of these licenses.
+//
+// AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.html
+// Commercial: See COMMERCIAL-LICENSE.md
+//
+// Source: https://github.com/kolapsis/maintenant
+
+package store
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/kolapsis/maintenant/internal/outbound"
+	"github.com/kolapsis/maintenant/internal/uid"
+)
+
+func TestOutboundHeartbeatStore_CRUD(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+	s := NewOutboundHeartbeatStore(db)
+
+	created := time.Unix(1_700_000_000, 0)
+	o := &outbound.OutboundHeartbeat{
+		ID:              uid.New(),
+		Name:            "upstream",
+		URL:             "https://mnt.example/ping/abc",
+		IntervalSeconds: 60,
+		Enabled:         true,
+		CreatedAt:       created,
+		UpdatedAt:       created,
+	}
+	require.NoError(t, s.Create(ctx, o))
+
+	got, err := s.Get(ctx, o.ID)
+	require.NoError(t, err)
+	require.NotNil(t, got)
+	assert.Equal(t, o.Name, got.Name)
+	assert.Equal(t, o.URL, got.URL)
+	assert.Equal(t, 60, got.IntervalSeconds)
+	assert.True(t, got.Enabled)
+	assert.Nil(t, got.LastSentAt)
+	assert.Nil(t, got.LastStatusCode)
+	assert.Nil(t, got.LastError)
+	assert.Equal(t, created.Unix(), got.CreatedAt.Unix())
+
+	o.Name = "renamed"
+	o.Enabled = false
+	o.UpdatedAt = created.Add(time.Minute)
+	found, err := s.Update(ctx, o)
+	require.NoError(t, err)
+	assert.True(t, found)
+
+	got, err = s.Get(ctx, o.ID)
+	require.NoError(t, err)
+	assert.Equal(t, "renamed", got.Name)
+	assert.False(t, got.Enabled)
+	assert.Equal(t, created.Add(time.Minute).Unix(), got.UpdatedAt.Unix())
+
+	list, err := s.List(ctx)
+	require.NoError(t, err)
+	require.Len(t, list, 1)
+
+	found, err = s.Delete(ctx, o.ID)
+	require.NoError(t, err)
+	assert.True(t, found)
+
+	got, err = s.Get(ctx, o.ID)
+	require.NoError(t, err)
+	assert.Nil(t, got)
+
+	var n int
+	require.NoError(t, db.Reader().QueryRowContext(ctx,
+		"SELECT COUNT(*) FROM outbound_heartbeats WHERE id = ?", o.ID).Scan(&n))
+	assert.Zero(t, n)
+}
+
+func TestOutboundHeartbeatStore_UnknownID(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+	s := NewOutboundHeartbeatStore(db)
+
+	found, err := s.Update(ctx, &outbound.OutboundHeartbeat{ID: uid.New(), Name: "x", URL: "http://x", IntervalSeconds: 60})
+	require.NoError(t, err)
+	assert.False(t, found)
+
+	found, err = s.Delete(ctx, uid.New())
+	require.NoError(t, err)
+	assert.False(t, found)
+}
+
+func TestOutboundHeartbeatStore_RecordSend(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+	s := NewOutboundHeartbeatStore(db)
+
+	now := time.Unix(1_700_000_000, 0)
+	o := &outbound.OutboundHeartbeat{ID: uid.New(), Name: "a", URL: "http://a", IntervalSeconds: 30,
+		Enabled: true, CreatedAt: now, UpdatedAt: now}
+	require.NoError(t, s.Create(ctx, o))
+
+	code := 503
+	msg := "unexpected status 503 Service Unavailable"
+	require.NoError(t, s.RecordSend(ctx, o.ID, outbound.SendResult{SentAt: now.Add(time.Minute), StatusCode: &code, Error: &msg}))
+
+	got, err := s.Get(ctx, o.ID)
+	require.NoError(t, err)
+	require.NotNil(t, got.LastSentAt)
+	assert.Equal(t, now.Add(time.Minute).Unix(), got.LastSentAt.Unix())
+	require.NotNil(t, got.LastStatusCode)
+	assert.Equal(t, 503, *got.LastStatusCode)
+	require.NotNil(t, got.LastError)
+	assert.Equal(t, msg, *got.LastError)
+
+	ok := 200
+	require.NoError(t, s.RecordSend(ctx, o.ID, outbound.SendResult{SentAt: now.Add(2 * time.Minute), StatusCode: &ok}))
+	got, err = s.Get(ctx, o.ID)
+	require.NoError(t, err)
+	assert.Equal(t, 200, *got.LastStatusCode)
+	assert.Nil(t, got.LastError, "a success clears the previous error")
+	assert.Equal(t, now.Unix(), got.UpdatedAt.Unix(), "a send does not touch updated_at")
+}
diff --git a/internal/store/transform.go b/internal/store/transform.go
index e33b817e..3d69b795 100644
--- a/internal/store/transform.go
+++ b/internal/store/transform.go
@@ -148,10 +148,10 @@ func runConversion(ctx context.Context, conn *sql.Conn) error {
 	// Drop any pre-existing agents/enrollment_tokens from the never-deployed
 	// agent migrations (22-23) so the new schema can recreate them cleanly. No-op
 	// on production databases (migrations 1-21 never created these tables).
-	// instances and cve_evaluations were created empty by later migrations
-	// moments ago (neither is a legacy table), and uuid_schema recreates
-	// them below.
-	for _, t := range []string{"agents", "enrollment_tokens", "instances", "cve_evaluations"} {
+	// instances, cve_evaluations and outbound_heartbeats were created empty by
+	// later migrations moments ago (none is a legacy table), and uuid_schema
+	// recreates them below.
+	for _, t := range []string{"agents", "enrollment_tokens", "instances", "cve_evaluations", "outbound_heartbeats"} {
 		if err := exec("drop unreleased "+t, fmt.Sprintf("DROP TABLE IF EXISTS %q", t)); err != nil {
 			return err
 		}
diff --git a/internal/store/uuid_schema.sql b/internal/store/uuid_schema.sql
index df857c9e..86f69fc5 100644
--- a/internal/store/uuid_schema.sql
+++ b/internal/store/uuid_schema.sql
@@ -309,6 +309,19 @@ CREATE INDEX idx_heartbeat_status_deadline ON heartbeats(status, next_deadline_a
 CREATE INDEX idx_heartbeat_active ON heartbeats(active);
 CREATE INDEX idx_heartbeats_agent_id ON heartbeats(agent_id);
 
+CREATE TABLE outbound_heartbeats (
+    id               TEXT PRIMARY KEY NOT NULL,
+    name             TEXT NOT NULL,
+    url              TEXT NOT NULL,
+    interval_seconds INTEGER NOT NULL,
+    enabled          INTEGER NOT NULL DEFAULT 1,
+    last_sent_at     BIGINT,
+    last_status_code INTEGER,
+    last_error       TEXT,
+    created_at       BIGINT NOT NULL,
+    updated_at       BIGINT NOT NULL
+);
+
 CREATE TABLE heartbeat_pings (
     id            TEXT PRIMARY KEY NOT NULL,
     heartbeat_id  TEXT NOT NULL REFERENCES heartbeats(id) ON DELETE CASCADE,