diff --git a/nuxt/assets/js/cookieconsent-config.js b/nuxt/assets/js/cookieconsent-config.js
index 9c58da555d..242e3e2a73 100644
--- a/nuxt/assets/js/cookieconsent-config.js
+++ b/nuxt/assets/js/cookieconsent-config.js
@@ -79,9 +79,6 @@ function applyAnalyticsConsent (options) {
     syncHubSpotConsent(accepted);
 
     if (accepted) {
-        if (typeof window._ffLoadMeetings === 'function') {
-            window._ffLoadMeetings();
-        }
         window._ffLoadChat = true;
         if (window.HubSpotConversations) {
             window.HubSpotConversations.widget.load();
diff --git a/nuxt/components/HubSpotMeetings.vue b/nuxt/components/HubSpotMeetings.vue
index f1d377f2b9..98199d5fec 100644
--- a/nuxt/components/HubSpotMeetings.vue
+++ b/nuxt/components/HubSpotMeetings.vue
@@ -1,58 +1,129 @@
 <script setup lang="ts">
-// src/_includes/hubspot/hs-book-meeting.njk plus the non-form branch of
-// hubspot/consent-fallback.njk: the HubSpot meetings scheduler, with the "choose a time"
-// panel that stands in for it.
+// The HubSpot meetings scheduler, with a "choose a time" panel that stands in for it when
+// analytics consent hasn't been given yet. Defaults to the shared sales calendar
+// (site.meetings.salesRoundRobin); dataSrc overrides it for a campaign-specific one.
 //
-// The embed is gated on analytics consent and MUST STAY THAT WAY. The .njk defined
-// `window._ffLoadMeetings`, and nuxt/assets/js/cookieconsent-config.js calls it only once the
-// visitor accepts; until then the embed is never injected. This registers the same global
-// rather than loading on mount, so declining analytics still means no third-party
-// scheduler script.
-//
-// The panel below is therefore not an error state: it is what a visitor who has not
-// accepted analytics sees, and it gives them a way to book anyway. It is rendered
-// unhidden and replaced once the embed is up, which is what the .njk did.
-const props = defineProps<{ dataSrc: string }>()
+// Consent-gated and MUST STAY THAT WAY: listens for vanilla-cookieconsent's own
+// cc:onConsent/cc:onChange DOM events, plus a direct check on mount for consent already
+// stored from an earlier visit, since that event can otherwise fire before this mounts.
+import site from '../data/site.json'
+import { parseMeetingMessage } from '../lib/hubspot-meeting-message.mjs'
+import { createMeetingTracker } from '../lib/hubspot-meeting-tracker.mjs'
+
+const props = defineProps<{ position: string, dataSrc?: string }>()
 
+const capture = useCapture()
+const identify = useIdentify()
 const embedded = ref(false)
+const tracker = createMeetingTracker()
 
-type ConsentWindow = Window & {
-    _ffLoadMeetings?: (() => void) | null
-    CookieConsent?: { showPreferences: () => void }
+// HubSpot's own meetings-booked report can break bookings down by utm_source/utm_medium/
+// campaign, but has no idea which page or placement an embed sits on unless told - hence
+// these, derived rather than a prop, so they can't drift from where the embed actually is.
+const meetingsSrc = (() => {
+    const url = new URL(props.dataSrc ?? site.meetings.salesRoundRobin)
+    url.searchParams.set('embed', 'true')
+    url.searchParams.set('utm_source', 'website')
+    url.searchParams.set('utm_medium', 'embedded_calendar')
+    const pageSlug = useRoute().path.replace(/^\/|\/$/g, '').replace(/\//g, '-') || 'home'
+    url.searchParams.set('utm_campaign', `${pageSlug}-${props.position}`)
+    return url.toString()
+})()
+const meetingsOrigin = new URL(meetingsSrc).origin
+
+type EmbedWindow = Window & {
+    CookieConsent?: { showPreferences: () => void, acceptedCategory?: (category: string) => boolean }
+    hbspt?: { meetings?: { create: (selector: string) => unknown } }
 }
 
 function showCookiePreferences() {
-    ;(window as ConsentWindow).CookieConsent?.showPreferences()
+    ;(window as EmbedWindow).CookieConsent?.showPreferences()
 }
 
 function loadEmbed() {
     if (embedded.value) return
+    const win = window as EmbedWindow
     const existing = document.querySelector('script[src*="MeetingsEmbedCode.js"]')
     if (!existing) {
         const script = document.createElement('script')
         script.src = 'https://static.hsappstatic.net/MeetingsEmbed/ex/MeetingsEmbedCode.js'
         script.onload = () => { embedded.value = true }
         document.head.appendChild(script)
-    } else {
+        return
+    }
+    // A later mount (e.g. browser back/forward) gets a fresh, empty container the
+    // already-loaded script never scans for on its own - this re-runs that scan. If hbspt
+    // isn't ready yet (script tag present but still loading, on a fast nav right after an
+    // earlier mount added it), wait for its load event and retry once.
+    if (win.hbspt?.meetings?.create) {
+        win.hbspt.meetings.create('.meetings-iframe-container')
         embedded.value = true
+        return
+    }
+    existing.addEventListener('load', loadEmbed, { once: true })
+}
+
+function handleMeetingMessage(event: MessageEvent) {
+    if (event.origin !== meetingsOrigin) return
+    const parsed = parseMeetingMessage(event.data)
+
+    if (parsed.type === 'booked') {
+        if (!tracker.recordBooked()) return
+        if (parsed.email) identify(parsed.email, { name: parsed.name ?? undefined })
+        capture('hubspot-meeting-booked', { position: props.position, step_count: tracker.stepCount })
+        return
     }
+
+    if (parsed.type === 'resize') tracker.recordResize(parsed.height)
+}
+
+// Bypasses useCapture()'s normal call here only for the options argument, not the function
+// itself: any capture() call carrying an options object (this one, or none at all) already
+// skips PostHog's batch queue - only a call with an explicit _batchKey gets batched. What
+// send_instantly actually adds is preferSyncCompression: without it, compression can be
+// async and the page may close before that promise settles, dropping the request.
+function reportAbandonment() {
+    if (!tracker.recordAbandonment()) return
+    capture(
+        'hubspot-meeting-abandoned',
+        { position: props.position, step_count: tracker.stepCount },
+        { transport: 'sendBeacon', send_instantly: true }
+    )
+}
+
+function onPageshow(event: Event) {
+    if ((event as PageTransitionEvent).persisted) tracker.resumeFromBfcache()
+}
+
+function loadEmbedIfConsented() {
+    if ((window as EmbedWindow).CookieConsent?.acceptedCategory?.('analytics')) loadEmbed()
 }
 
-// Registered for cookieconsent-config.js to call on accept, exactly as the .njk did.
-// It also calls it on load when consent is already stored, so an existing acceptance is
-// covered without this component reading cookies itself.
 onMounted(() => {
-    ;(window as ConsentWindow)._ffLoadMeetings = loadEmbed
+    loadEmbedIfConsented()
+    window.addEventListener('cc:onConsent', loadEmbedIfConsented)
+    window.addEventListener('cc:onChange', loadEmbedIfConsented)
+    window.addEventListener('message', handleMeetingMessage)
+    window.addEventListener('pagehide', reportAbandonment)
+    window.addEventListener('pageshow', onPageshow)
 })
 
 onUnmounted(() => {
-    ;(window as ConsentWindow)._ffLoadMeetings = null
+    window.removeEventListener('cc:onConsent', loadEmbedIfConsented)
+    window.removeEventListener('cc:onChange', loadEmbedIfConsented)
+    window.removeEventListener('message', handleMeetingMessage)
+    window.removeEventListener('pagehide', reportAbandonment)
+    window.removeEventListener('pageshow', onPageshow)
+    reportAbandonment()
 })
 </script>
 
 <template>
   <div>
-    <div class="meetings-iframe-container -mb-20 md:-mb-6" :data-src="props.dataSrc" />
+    <!-- The negative margin only makes sense once the real iframe is loaded, to tuck away
+         HubSpot's own excess bottom whitespace - applied while empty, it pulls the fallback
+         panel up into this container's parent's overflow-hidden and clips its top edge. -->
+    <div class="meetings-iframe-container" :class="{ '-mb-20 md:-mb-6': embedded }" :data-src="meetingsSrc" />
     <div v-if="!embedded" class="ff-hubspot-consent-fallback text-center border bg-indigo-900 rounded-lg px-6 pt-8 pb-4">
       <h4 class="text-white font-medium">Choose a time to talk</h4>
       <p class="text-indigo-200">30-minute session with our team.</p>
diff --git a/nuxt/composables/useCapture.ts b/nuxt/composables/useCapture.ts
index 70f4d4139e..155dab5ac3 100644
--- a/nuxt/composables/useCapture.ts
+++ b/nuxt/composables/useCapture.ts
@@ -3,9 +3,11 @@
 // PostHog isn't loaded (no analytics consent). Guarded here too so components
 // can call this during SSR/tests without a `window`.
 export function useCapture () {
-    return function capture (event: string, props?: Record<string, unknown>) {
+    return function capture (event: string, props?: Record<string, unknown>, options?: Record<string, unknown>) {
         if (typeof window === 'undefined') return
-        const win = window as unknown as { capture?: (event: string, props?: Record<string, unknown>) => void }
-        if (typeof win.capture === 'function') win.capture(event, props)
+        const win = window as unknown as {
+            capture?: (event: string, props?: Record<string, unknown>, options?: Record<string, unknown>) => void
+        }
+        if (typeof win.capture === 'function') win.capture(event, props, options)
     }
 }
diff --git a/nuxt/composables/useIdentify.ts b/nuxt/composables/useIdentify.ts
new file mode 100644
index 0000000000..3012390006
--- /dev/null
+++ b/nuxt/composables/useIdentify.ts
@@ -0,0 +1,19 @@
+type PosthogWindow = Window & {
+    posthog?: {
+        identify: (distinctId: string, properties?: Record<string, unknown>) => void
+        get_property: (key: string) => unknown
+    }
+}
+
+// Skips re-identifying an already-identified session, so a second booking in the same
+// browser doesn't silently re-point its whole history at a different identity.
+export function useIdentify () {
+    return function identify (email: string, properties?: Record<string, unknown>) {
+        if (typeof window === 'undefined') return
+        const posthog = (window as PosthogWindow).posthog
+        if (!posthog || posthog.get_property('$user_state') === 'identified') return
+
+        const normalizedEmail = email.trim().toLowerCase()
+        posthog.identify(normalizedEmail, { email: normalizedEmail, ...properties })
+    }
+}
diff --git a/nuxt/lib/custom-cta-destinations.ts b/nuxt/lib/custom-cta-destinations.ts
index 5c01bfabcc..dbaf872f40 100644
--- a/nuxt/lib/custom-cta-destinations.ts
+++ b/nuxt/lib/custom-cta-destinations.ts
@@ -1,4 +1,5 @@
 import { CTA_DESTINATIONS, normalizeHref } from './cta-destinations'
+import site from '../data/site.json'
 
 // Registry for one-off CTA destinations that aren't one of the five reserved
 // ones (see cta-destinations.ts) but still deserve one fixed PostHog event -
@@ -33,7 +34,7 @@ import { CTA_DESTINATIONS, normalizeHref } from './cta-destinations'
 // `position`), not an attempt at an identical payload shape.
 export const CUSTOM_CTA_DESTINATIONS = {
     hubspotMeeting: {
-        href: 'https://meetings-eu1.hubspot.com/michael-davis/round-robin-sales-team',
+        href: site.meetings.salesRoundRobin,
         event: 'calendar_fallback_cta_clicked',
     },
     communityForum: {
diff --git a/nuxt/lib/hubspot-meeting-message.mjs b/nuxt/lib/hubspot-meeting-message.mjs
new file mode 100644
index 0000000000..021468c4a0
--- /dev/null
+++ b/nuxt/lib/hubspot-meeting-message.mjs
@@ -0,0 +1,21 @@
+// Parses HubSpot's undocumented meetings-embed postMessage shapes, kept pure and testable
+// so a format change breaks a test here instead of going silently quiet in the component.
+
+/**
+ * @param {unknown} data
+ * @returns {{ type: 'booked', email: string | null, name: string | null } | { type: 'resize', height: number } | { type: 'unknown' }}
+ */
+export function parseMeetingMessage (data) {
+    if (!data || typeof data !== 'object') return { type: 'unknown' }
+
+    if ('meetingBookSucceeded' in data && data.meetingBookSucceeded) {
+        const contact = data.meetingsPayload?.bookingResponse?.postResponse?.contact
+        return { type: 'booked', email: contact?.email ?? null, name: contact?.name ?? null }
+    }
+
+    if ('height' in data && typeof data.height === 'number') {
+        return { type: 'resize', height: data.height }
+    }
+
+    return { type: 'unknown' }
+}
diff --git a/nuxt/lib/hubspot-meeting-message.test.mjs b/nuxt/lib/hubspot-meeting-message.test.mjs
new file mode 100644
index 0000000000..a5ff2eddee
--- /dev/null
+++ b/nuxt/lib/hubspot-meeting-message.test.mjs
@@ -0,0 +1,52 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { parseMeetingMessage } from './hubspot-meeting-message.mjs'
+
+test('a booking-succeeded message returns the contact email and name', () => {
+    // Shape captured from a real test booking on meetings-eu1.hubspot.com - not documented
+    // by HubSpot anywhere, so this fixture is the actual contract, not a guess. Values
+    // replaced with fake ones; only the shape matters for the test.
+    const data = {
+        meetingBookSucceeded: true,
+        meetingsPayload: {
+            bookingResponse: {
+                postResponse: {
+                    bookedOffline: false,
+                    contact: { firstName: 'Jane', lastName: 'Doe', email: 'jane@example.com', fullName: '', name: 'Jane Doe' },
+                    organizer: { firstName: 'Sam', lastName: 'Rep', email: '', fullName: '', name: 'Sam Rep' },
+                },
+            },
+            formGuid: '00000000-0000-0000-0000-000000000000',
+            linkType: 'ROUND_ROBIN_CALENDAR',
+            userSlug: 'sam-rep/round-robin-sales-team',
+        },
+    }
+
+    assert.deepEqual(parseMeetingMessage(data), { type: 'booked', email: 'jane@example.com', name: 'Jane Doe' })
+})
+
+test('a booking-succeeded message with no contact still reports booked, with nulls', () => {
+    assert.deepEqual(
+        parseMeetingMessage({ meetingBookSucceeded: true }),
+        { type: 'booked', email: null, name: null }
+    )
+})
+
+test('meetingBookSucceeded: false is not a booking', () => {
+    assert.deepEqual(parseMeetingMessage({ meetingBookSucceeded: false }), { type: 'unknown' })
+})
+
+test('a resize message returns its height', () => {
+    assert.deepEqual(parseMeetingMessage({ height: 640 }), { type: 'resize', height: 640 })
+})
+
+test('a non-numeric height is not a resize message', () => {
+    assert.deepEqual(parseMeetingMessage({ height: '640' }), { type: 'unknown' })
+})
+
+test('an unrelated or empty message is unknown', () => {
+    assert.deepEqual(parseMeetingMessage({ someOtherKey: true }), { type: 'unknown' })
+    assert.deepEqual(parseMeetingMessage(null), { type: 'unknown' })
+    assert.deepEqual(parseMeetingMessage('a string'), { type: 'unknown' })
+})
diff --git a/nuxt/lib/hubspot-meeting-tracker.mjs b/nuxt/lib/hubspot-meeting-tracker.mjs
new file mode 100644
index 0000000000..b86937b7f0
--- /dev/null
+++ b/nuxt/lib/hubspot-meeting-tracker.mjs
@@ -0,0 +1,47 @@
+// Pure state machine for one HubSpotMeetings embed's lifecycle - no DOM/window access, so
+// it's testable without a browser. HubSpotMeetings.vue wires DOM/postMessage events to
+// these methods and only calls capture() when a method returns true.
+
+export function createMeetingTracker () {
+    let booked = false
+    let reported = false
+    let stepCount = 0
+    let lastHeight = null
+
+    return {
+        /** A resize message's height. Returns true for a new value, false for a repeat. */
+        recordResize (height) {
+            if (height === lastHeight) return false
+            lastHeight = height
+            stepCount += 1
+            return true
+        },
+        /** Returns true the first time a booking succeeds, false for a resent message. */
+        recordBooked () {
+            if (booked) return false
+            booked = true
+            return true
+        },
+        /**
+         * Returns true if an abandonment should be reported: not already reported, not
+         * booked, and past the embed's own first render (step 1 is automatic on load, not
+         * something the visitor did).
+         */
+        recordAbandonment () {
+            if (reported || booked || stepCount <= 1) return false
+            reported = true
+            return true
+        },
+        /**
+         * A bfcache restore resumes this exact state rather than remounting, so a
+         * departure that already reported stays reportable if the visitor leaves again
+         * without booking. This does not un-send the first abandoned event - a session can
+         * still end up with both abandoned and booked; treat that as "abandoned without a
+         * later booked", not as a bug to suppress here.
+         */
+        resumeFromBfcache () {
+            reported = false
+        },
+        get stepCount () { return stepCount },
+    }
+}
diff --git a/nuxt/lib/hubspot-meeting-tracker.test.mjs b/nuxt/lib/hubspot-meeting-tracker.test.mjs
new file mode 100644
index 0000000000..6303dbc5a1
--- /dev/null
+++ b/nuxt/lib/hubspot-meeting-tracker.test.mjs
@@ -0,0 +1,66 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { createMeetingTracker } from './hubspot-meeting-tracker.mjs'
+
+test('a repeat height does not count as progress', () => {
+    const tracker = createMeetingTracker()
+    assert.equal(tracker.recordResize(640), true)
+    assert.equal(tracker.recordResize(640), false)
+    assert.equal(tracker.stepCount, 1)
+})
+
+test('recordBooked is true once, false for a resent message', () => {
+    const tracker = createMeetingTracker()
+    assert.equal(tracker.recordBooked(), true)
+    assert.equal(tracker.recordBooked(), false)
+})
+
+test('abandonment is not reported at step 1 (the embed\'s own first render)', () => {
+    const tracker = createMeetingTracker()
+    tracker.recordResize(528)
+    assert.equal(tracker.recordAbandonment(), false)
+})
+
+test('abandonment is reported past step 1', () => {
+    const tracker = createMeetingTracker()
+    tracker.recordResize(528)
+    tracker.recordResize(640)
+    assert.equal(tracker.recordAbandonment(), true)
+})
+
+test('abandonment is not reported twice', () => {
+    const tracker = createMeetingTracker()
+    tracker.recordResize(528)
+    tracker.recordResize(640)
+    assert.equal(tracker.recordAbandonment(), true)
+    assert.equal(tracker.recordAbandonment(), false)
+})
+
+test('abandonment is not reported once booked', () => {
+    const tracker = createMeetingTracker()
+    tracker.recordResize(528)
+    tracker.recordResize(640)
+    tracker.recordBooked()
+    assert.equal(tracker.recordAbandonment(), false)
+})
+
+test('resumeFromBfcache allows a second abandonment after a second departure', () => {
+    const tracker = createMeetingTracker()
+    tracker.recordResize(528)
+    tracker.recordResize(640)
+    assert.equal(tracker.recordAbandonment(), true)
+    tracker.resumeFromBfcache()
+    tracker.recordResize(690)
+    assert.equal(tracker.recordAbandonment(), true)
+})
+
+test('resumeFromBfcache does not re-arm abandonment once booked', () => {
+    const tracker = createMeetingTracker()
+    tracker.recordResize(528)
+    tracker.recordResize(640)
+    tracker.recordAbandonment()
+    tracker.recordBooked()
+    tracker.resumeFromBfcache()
+    assert.equal(tracker.recordAbandonment(), false)
+})
diff --git a/nuxt/pages/book-demo/index.vue b/nuxt/pages/book-demo/index.vue
index 6420417f33..2ffe003b63 100644
--- a/nuxt/pages/book-demo/index.vue
+++ b/nuxt/pages/book-demo/index.vue
@@ -21,7 +21,7 @@ useSeoMeta({
     description="See how you'd build, deploy, and govern operational applications across your own plants and production lines."
     :highlights="highlights"
   >
-    <HubSpotMeetings data-src="https://meetings-eu1.hubspot.com/michael-davis/round-robin-sales-team?embed=true" />
+    <HubSpotMeetings position="hero" />
   </MqlContactPage>
 
   <div class="container m-auto max-w-5xl px-6 pb-20">
diff --git a/nuxt/pages/contact-us/index.vue b/nuxt/pages/contact-us/index.vue
index a38b139d64..69f6a783ae 100644
--- a/nuxt/pages/contact-us/index.vue
+++ b/nuxt/pages/contact-us/index.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
+const resolveHref = useResolveHref()
+
 const otherChannels = [
     {
         title: 'Want to talk it through live?',
         description: 'Book a session and we\'ll go through your setup together.',
         buttonText: 'Book a session',
-        buttonLink: 'https://meetings-eu1.hubspot.com/michael-davis/round-robin-sales-team',
+        buttonLink: resolveHref('site:meetings.salesRoundRobin'),
         icon: 'calendar',
     },
     {
diff --git a/nuxt/pages/landing/tulip.vue b/nuxt/pages/landing/tulip.vue
index 3a6dc380f3..362a18253f 100644
--- a/nuxt/pages/landing/tulip.vue
+++ b/nuxt/pages/landing/tulip.vue
@@ -73,8 +73,6 @@ const STORIES_HEADING = {
     urlText: 'See more customer stories',
 }
 
-const MEETINGS_SRC = 'https://meetings-eu1.hubspot.com/michael-davis/round-robin-michael-omar-kasheef?embed=true'
-
 const { data: stories } = await useAsyncData('tulip-stories', () =>
     queryCollection('stories').select('path', 'title', 'image', 'logo', 'story', 'date')
         .order('date', 'DESC').limit(3).all()
@@ -224,7 +222,7 @@ useHead({ meta: [{ name: 'robots', content: 'noindex' }] })
             <h2 class="mb-8 max-md:text-center">Ready to Make the Wiser Decision?</h2>
             <p>See how FlowFuse can connect ALL your data sources to Tulip. Book your demo now.</p>
             <div class="my-10">
-              <HubSpotMeetings :data-src="MEETINGS_SRC" />
+              <HubSpotMeetings position="form" />
             </div>
           </div>
         </div>
diff --git a/nuxt/server/assets/analytics/body.html b/nuxt/server/assets/analytics/body.html
index 938a94eecb..ecfa6ec580 100644
--- a/nuxt/server/assets/analytics/body.html
+++ b/nuxt/server/assets/analytics/body.html
@@ -32,9 +32,9 @@
     window.addEventListener &&
             window.addEventListener('onpagehide' in self ? 'pagehide' : 'unload', emitPageLeave)
 
-    function capture (eventName, props) {
+    function capture (eventName, props, options) {
         if (window.posthog) {
-            posthog.capture(eventName, props);
+            posthog.capture(eventName, props, options);
         }
     }
 </script>