diff --git a/specs/owners.json b/specs/owners.json
index 52909bc31f..867c552498 100644
--- a/specs/owners.json
+++ b/specs/owners.json
@@ -1,3 +1,3 @@
 {
-  "owners": ["attendees", "payments"]
+  "owners": ["attendees", "payments", "servicing"]
 }
diff --git a/specs/servicing/hold-and-cost.feature b/specs/servicing/hold-and-cost.feature
new file mode 100644
index 0000000000..a34d6390dd
--- /dev/null
+++ b/specs/servicing/hold-and-cost.feature
@@ -0,0 +1,48 @@
+@story:servicing.hold-and-cost
+@owner:servicing @risk:medium
+@actor:organiser
+@edition:managed @edition:self-hosted
+Feature: An organiser holds and costs a service event
+  A service event reserves listing capacity without creating a customer ticket.
+  The organiser can see, duplicate, delete, and cost the hold.
+
+  @rule:servicing.hold-is-visible-and-private
+  Rule: A service hold appears to the organiser but not to the customer
+    The hold reserves capacity and never becomes a public listing or ticket.
+
+    @case:servicing.hold-on-dashboard
+    Scenario: The organiser sees a new hold on the dashboard
+      Given an organiser has created a Boiler Service hold on Room A
+      Then the admin dashboard shows the Boiler Service hold
+      And the public site does not show Boiler Service
+
+  @rule:servicing.hold-can-be-duplicated
+  Rule: A duplicated hold is an independent copy
+    Duplicating a service event creates a second event with the same bookings.
+
+    @case:servicing.duplicate-hold
+    Scenario: The organiser duplicates an annual inspection
+      Given an organiser has created an Annual Inspection hold on Annual Room
+      When the organiser duplicates the service event
+      Then the admin dashboard shows two Annual Inspection holds
+
+  @rule:servicing.hold-can-be-deleted
+  Rule: Deleting a hold frees the reserved capacity
+    The hold and its booking rows are removed.
+
+    @case:servicing.delete-hold
+    Scenario: The organiser deletes a Boiler Service hold
+      Given an organiser has created a Boiler Service hold on Room A
+      When the organiser deletes the service event
+      Then the admin dashboard no longer shows Boiler Service
+      And the held listing has its full capacity restored
+
+  @rule:servicing.hold-can-be-costed
+  Rule: The organiser can record a cost against a hold
+    A cost is money spent on the service, recorded against one of the held listings.
+
+    @case:servicing.record-cost
+    Scenario: The organiser records a cost for a Boiler Service
+      Given an organiser has created a Boiler Service hold on Room A
+      When the organiser records a cost of 90.00 for Boiler Service
+      Then the service event page shows the recorded cost
diff --git a/test/e2e/servicing/e2e-narrative.test.ts b/test/e2e/servicing/e2e-narrative.test.ts
deleted file mode 100644
index e0ed7107df..0000000000
--- a/test/e2e/servicing/e2e-narrative.test.ts
+++ /dev/null
@@ -1,137 +0,0 @@
-/**
- * Servicing §21 — end-to-end narrative scenarios.
- *
- * Story-driven e2e flows (TestBrowser) that string the units together the way
- * a real operator would hit them — each is one coherent narrative, not a
- * grab-bag of assertions. They reuse the same fixtures the [I] tests build.
- *
- * Implementation contract (test-first):
- *   - Servicing routes: `GET/POST /admin/servicing/new` (create),
- *     `GET/POST /admin/servicing/:id` (edit), `POST /admin/servicing/:id/delete`,
- *     `POST /admin/servicing/:id/duplicate`. Form fields mirror the attendee
- *     form minus the contact/payment fields (§0/§6).
- */
-// jscpd:ignore-start
-import { expect } from "@std/expect";
-import { describe, it as test } from "@std/testing/bdd";
-import { useE2eBrowser } from "#test-utils/e2e.ts";
-import {
-  findServicingLink,
-  setupBrowserWithHold,
-} from "#test-utils/servicing.ts";
-import { enablePublicSite } from "#test-utils/settings.ts";
-
-// jscpd:ignore-end
-
-const ROOM_A = { max_attendees: "5", name: "Room A" } as const;
-const DAILY_ROOM_A = {
-  duration_days: "1",
-  listing_type: "daily",
-  max_attendees: "5",
-  max_quantity: "5",
-  maximum_days_after: "365",
-  name: "Room A",
-} as const;
-
-const costListingIdFromForm = (html: string): string => {
-  const match = html.match(
-    /<select name="target_listing_id"[^>]*>[\s\S]*?<option value="(\d+)"/,
-  );
-  if (!match) throw new Error("no cost target listing in servicing form");
-  return match[1]!;
-};
-
-describe("e2e: servicing — narrative scenarios", () => {
-  const ctx = useE2eBrowser();
-
-  test("Boiler service blocks a room, then frees it", async () => {
-    const browser = ctx.browser;
-    await setupBrowserWithHold(
-      browser,
-      { ...DAILY_ROOM_A, max_attendees: "1" },
-      "Boiler Service",
-    );
-    expect(browser.containsText("Boiler Service")).toBe(true);
-
-    await browser.visit(findServicingLink(browser));
-    await browser.submitForm({}, "Delete Service Event");
-    expect(browser.containsText("Boiler Service")).toBe(false);
-  });
-
-  test("Annual servicing schedule, duplicated for next year", async () => {
-    const browser = ctx.browser;
-    await setupBrowserWithHold(
-      browser,
-      {
-        ...DAILY_ROOM_A,
-        max_attendees: "10",
-        maximum_days_after: "1000",
-        name: "Annual Room",
-      },
-      "Annual Inspection",
-    );
-    await browser.visit(findServicingLink(browser));
-    await browser.submitForm({}, "Duplicate");
-
-    expect(browser.containsText("Annual Inspection")).toBe(true);
-    await browser.visit("/admin/");
-    const servicingLinks = browser.links
-      .filter((l) => l.href.includes("/admin/servicing/"))
-      .map((l) => l.href);
-    expect(servicingLinks.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("The morning dashboard glance", async () => {
-    const browser = ctx.browser;
-    await setupBrowserWithHold(browser, { ...ROOM_A }, "Boiler Service");
-
-    await browser.visit("/admin/");
-    expect(browser.containsText("Boiler Service")).toBe(true);
-    expect(browser.currentHtml).toMatch(/\/admin\/servicing\/\d+/);
-    await enablePublicSite();
-    await browser.visit("/");
-    expect(browser.containsText("Boiler Service")).toBe(false);
-  });
-
-  test("The curious operator pokes at URLs", async () => {
-    const browser = ctx.browser;
-    await setupBrowserWithHold(browser, { ...ROOM_A }, "Boiler Service");
-    const id = findServicingLink(browser).match(
-      /\/admin\/servicing\/(\d+)/,
-    )?.[1];
-    if (!id) throw new Error("no servicing id in redirect URL");
-
-    await browser.visit(`/admin/attendees/${id}`);
-    expect(browser.currentHtml).toMatch(/not found|404/i);
-    await browser.visit(`/admin/attendees/${id}/merge`);
-    expect(browser.currentHtml).toMatch(/not found|404/i);
-
-    await browser.visit(`/admin/servicing/${id}`);
-    expect(browser.containsText("Boiler Service")).toBe(true);
-    expect(browser.currentHtml).not.toContain("@example.com");
-  });
-
-  test("A hold with a custom question", async () => {
-    const browser = ctx.browser;
-    await setupBrowserWithHold(browser, { ...ROOM_A }, "Boiler Service");
-    expect(browser.containsText("Boiler Service")).toBe(true);
-    await browser.visit(findServicingLink(browser));
-    expect(browser.containsText("Boiler Service")).toBe(true);
-  });
-
-  test("Costing a boiler service", async () => {
-    const browser = ctx.browser;
-    await setupBrowserWithHold(browser, { ...ROOM_A }, "Boiler Service");
-
-    await browser.visit(findServicingLink(browser));
-    await browser.submitForm(
-      {
-        amount: "90.00",
-        memo: "Boiler part",
-        target_listing_id: costListingIdFromForm(browser.currentHtml),
-      },
-      "Record service event cost",
-    );
-    expect(browser.containsText("90")).toBe(true);
-  });
-});
diff --git a/test/integration/servicing/route-guards.test.ts b/test/integration/servicing/route-guards.test.ts
index 5fe702abb2..0cb63d4cc9 100644
--- a/test/integration/servicing/route-guards.test.ts
+++ b/test/integration/servicing/route-guards.test.ts
@@ -22,10 +22,12 @@ import { createTestListing } from "#test-utils/db-helpers/listings.ts";
 import {
   adminPost,
   assertAdmin404,
+  assertRedirectPathname,
   assertServicingId404sEverywhere,
   createRealAttendee,
   createServicingHold,
   createTestServicingEvent,
+  getServicingEvent,
   listingCostOf,
   recordServiceCost,
 } from "#test-utils/servicing.ts";
@@ -83,12 +85,38 @@ describeWithEnv(
       response.body?.cancel();
     });
 
+    test("POST /admin/servicing/:id/delete redirects to the dashboard on success", async () => {
+      const { id } = await createServicingHold();
+      const response = await adminPost(`/admin/servicing/${id}/delete`, {});
+      assertRedirectPathname(response, "/admin/");
+      expect(await getServicingEvent(id)).toBeNull();
+    });
+
     test("POST /admin/servicing/:id/duplicate 404s for a missing service event id", async () => {
       const response = await adminPost("/admin/servicing/999999/duplicate", {});
       expect(response.status).toBe(404);
       response.body?.cancel();
     });
 
+    test("POST /admin/servicing/:id/duplicate redirects to the copy on success", async () => {
+      const { id, listing } = await createServicingHold({ name: "Original" });
+      const response = await adminPost(`/admin/servicing/${id}/duplicate`, {});
+      expect(response.status).toBe(302);
+      const location = response.headers.get("location");
+      expect(location).not.toBeNull();
+      const match = location!.match(/\/admin\/servicing\/(\d+)/);
+      expect(match).not.toBeNull();
+      const copyId = Number(match![1]);
+      expect(copyId).toBeGreaterThan(id);
+      assertRedirectPathname(response, `/admin/servicing/${copyId}`);
+      const copy = await getServicingEvent(copyId);
+      expect(copy).not.toBeNull();
+      expect(copy!.name).toBe("Original");
+      const firstBooking = copy!.bookings[0];
+      expect(firstBooking).toBeDefined();
+      expect(firstBooking!.listingId).toBe(listing.id);
+    });
+
     test("POST /admin/servicing/:id/cost/:costId 404s for a missing cost id", async () => {
       const { id, listing } = await createServicingHold();
       const response = await adminPost(`/admin/servicing/${id}/cost/999999`, {
diff --git a/test/scripts/specs/catalog.test.ts b/test/scripts/specs/catalog.test.ts
index 8064410a69..f34b6d050c 100644
--- a/test/scripts/specs/catalog.test.ts
+++ b/test/scripts/specs/catalog.test.ts
@@ -13,6 +13,7 @@ describe("Cucumber story catalog", () => {
     expect((await readSpecCatalog()).stories.map(({ id }) => id)).toEqual([
       "attendees.no-quantity-tickets",
       "payments.capacity-after-payment",
+      "servicing.hold-and-cost",
     ]);
   });
 
diff --git a/test/specs/steps/servicing-hold.ts b/test/specs/steps/servicing-hold.ts
new file mode 100644
index 0000000000..a2da8748d8
--- /dev/null
+++ b/test/specs/steps/servicing-hold.ts
@@ -0,0 +1,199 @@
+// jscpd:ignore-start
+
+import { Given, Then, When } from "@cucumber/cucumber";
+import { expect } from "@std/expect";
+import { getListingRemainingForRange } from "#shared/db/attendees/capacity/remaining.ts";
+import {
+  requiredWorldValue,
+  type TicketsWorld,
+} from "#test/specs/support/world.ts";
+import { extractCsrfToken } from "#test-utils/csrf.ts";
+import { createTestListing } from "#test-utils/db-helpers/listings.ts";
+import { awaitTestRequest } from "#test-utils/mocks.ts";
+import {
+  adminPost,
+  assertRedirectPathname,
+  createServicingEvent,
+  renderAdminPage,
+} from "#test-utils/servicing.ts";
+import { enablePublicSite } from "#test-utils/settings.ts";
+import { extractFormEntries } from "#test-utils/test-browser.ts";
+
+// jscpd:ignore-end
+
+const ROOM_A = "Room A";
+const ANNUAL_ROOM = "Annual Room";
+const BOILER_SERVICE = "Boiler Service";
+const ANNUAL_INSPECTION = "Annual Inspection";
+
+/** GET a rendered admin page and return its HTML and CSRF token. */
+const getRenderedForm = async (
+  path: string,
+): Promise<{ csrfToken: string; html: string }> => {
+  const html = await renderAdminPage(path);
+  const csrfToken = extractCsrfToken(html);
+  if (!csrfToken) throw new Error(`No CSRF token on ${path}`);
+  return { csrfToken, html };
+};
+
+const findForms = (html: string): Array<{ action: string; body: string }> => {
+  const re = /<form\s[^>]*action="([^"]*)"[^>]*>([\s\S]*?)<\/form>/gi;
+  const forms: Array<{ action: string; body: string }> = [];
+  for (const match of html.matchAll(re)) {
+    forms.push({ action: match[1]!, body: match[2]! });
+  }
+  return forms;
+};
+
+/** Find the form whose submit button matches `buttonText`, submit it with
+ *  `overrides` merged on top of the rendered fields. Drives through the
+ *  real rendered form per the AGENTS.md guidance. */
+const submitRenderedForm = async (
+  path: string,
+  buttonText: string,
+  overrides: Record<string, string> = {},
+): Promise<Response> => {
+  const { csrfToken, html } = await getRenderedForm(path);
+  const form = findForms(html).find((f) =>
+    new RegExp(`>${buttonText}<`, "i").test(f.body),
+  );
+  if (!form) throw new Error(`No form with button "${buttonText}" on ${path}`);
+  const params = new URLSearchParams();
+  for (const [key, value] of extractFormEntries(form.body)) {
+    params.append(key, value);
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    params.set(key, value);
+  }
+  params.set("csrf_token", csrfToken);
+  return adminPost(form.action, Object.fromEntries(params));
+};
+
+const createHoldViaProduction = async (
+  world: TicketsWorld,
+  listingName: string,
+  holdName: string,
+  listingOverrides: Record<string, string | number> = {},
+): Promise<{ eventId: number; listingId: number }> => {
+  const listing = await createTestListing({
+    durationDays: 1,
+    listingType: "daily",
+    maxAttendees: 5,
+    maximumDaysAfter: 365,
+    maxQuantity: 5,
+    name: listingName,
+    ...listingOverrides,
+  });
+  const event = await createServicingEvent({
+    bookings: [{ date: "2099-07-01", listingId: listing.id, quantity: 1 }],
+    name: holdName,
+  });
+  world.servicingEventId = event.id;
+  world.holdListingId = listing.id;
+  return { eventId: event.id, listingId: listing.id };
+};
+
+Given(
+  "an organiser has created a Boiler Service hold on Room A",
+  async function (this: TicketsWorld): Promise<void> {
+    await createHoldViaProduction(this, ROOM_A, BOILER_SERVICE, {
+      maxAttendees: 1,
+    });
+  },
+);
+
+Given(
+  "an organiser has created an Annual Inspection hold on Annual Room",
+  async function (this: TicketsWorld): Promise<void> {
+    await createHoldViaProduction(this, ANNUAL_ROOM, ANNUAL_INSPECTION, {
+      maxAttendees: 10,
+      maximumDaysAfter: 1000,
+    });
+  },
+);
+
+When(
+  "the organiser duplicates the service event",
+  async function (this: TicketsWorld): Promise<void> {
+    const id = requiredWorldValue(this.servicingEventId, "service event id");
+    await submitRenderedForm(`/admin/servicing/${id}`, "Duplicate");
+  },
+);
+
+When(
+  "the organiser deletes the service event",
+  async function (this: TicketsWorld): Promise<void> {
+    const id = requiredWorldValue(this.servicingEventId, "service event id");
+    await submitRenderedForm(`/admin/servicing/${id}`, "Delete Service Event");
+  },
+);
+
+When(
+  "the organiser records a cost of 90.00 for Boiler Service",
+  async function (this: TicketsWorld): Promise<void> {
+    const id = requiredWorldValue(this.servicingEventId, "service event id");
+    const response = await submitRenderedForm(
+      `/admin/servicing/${id}`,
+      "Record service event cost",
+      {
+        amount: "90.00",
+        memo: "Boiler part",
+      },
+    );
+    assertRedirectPathname(response, `/admin/servicing/${id}`);
+  },
+);
+
+Then(
+  "the admin dashboard shows the Boiler Service hold",
+  async function (this: TicketsWorld): Promise<void> {
+    const body = await renderAdminPage("/admin/");
+    expect(body).toContain(BOILER_SERVICE);
+  },
+);
+
+Then(
+  "the admin dashboard shows two Annual Inspection holds",
+  async function (this: TicketsWorld): Promise<void> {
+    const body = await renderAdminPage("/admin/");
+    const count = (body.match(/Annual Inspection/g) ?? []).length;
+    expect(count).toBeGreaterThanOrEqual(2);
+  },
+);
+
+Then(
+  "the admin dashboard no longer shows Boiler Service",
+  async function (this: TicketsWorld): Promise<void> {
+    const body = await renderAdminPage("/admin/");
+    expect(body).not.toContain(BOILER_SERVICE);
+  },
+);
+
+Then(
+  "the public site does not show Boiler Service",
+  async function (this: TicketsWorld): Promise<void> {
+    await enablePublicSite();
+    const response = await awaitTestRequest("/");
+    expect(response.status).toBe(200);
+    const body = await response.text();
+    expect(body).not.toContain(BOILER_SERVICE);
+  },
+);
+
+Then(
+  "the service event page shows the recorded cost",
+  async function (this: TicketsWorld): Promise<void> {
+    const id = requiredWorldValue(this.servicingEventId, "service event id");
+    const body = await renderAdminPage(`/admin/servicing/${id}`);
+    expect(body).toContain(">£90<");
+    expect(body).toContain("Boiler part");
+  },
+);
+
+Then(
+  "the held listing has its full capacity restored",
+  async function (this: TicketsWorld): Promise<void> {
+    const listingId = requiredWorldValue(this.holdListingId, "hold listing id");
+    expect(await getListingRemainingForRange(listingId, "2099-07-01")).toBe(1);
+  },
+);
diff --git a/test/specs/support/world.ts b/test/specs/support/world.ts
index 5b86e74e0b..60683f1fe0 100644
--- a/test/specs/support/world.ts
+++ b/test/specs/support/world.ts
@@ -9,12 +9,14 @@ export interface TicketsWorld extends World {
   firstBody?: string;
   firstFailureData?: string;
   firstStatus?: number;
+  holdListingId?: number;
   listingId?: number;
   listingIds: Map<string, number>;
   placeholderId?: number;
   refundCalls?: () => number;
   secondBody?: string;
   secondStatus?: number;
+  servicingEventId?: number;
   sessionId?: string;
   ticketToken?: string;
 }
diff --git a/test/test-utils/servicing.ts b/test/test-utils/servicing.ts
index da87908bfb..e5da0d686b 100644
--- a/test/test-utils/servicing.ts
+++ b/test/test-utils/servicing.ts
@@ -35,7 +35,6 @@ import type { Attendee, Listing, ListingWithCount } from "#shared/types.ts";
 import { getTestPrivateKey } from "#test-utils/crypto.ts";
 import { createTestListing } from "#test-utils/db-helpers/listings.ts";
 import { getTestSession, withTestSession } from "#test-utils/session.ts";
-import type { TestBrowser } from "#test-utils/test-browser.ts";
 
 // ─── Production API re-exports (see contract above) ────────────────────────
 
@@ -304,6 +303,18 @@ export const assertRedirectTo = (response: Response, path: string): void => {
   expect(response.headers.get("location")).toContain(path);
 };
 
+/** Assert a 302 response's redirect pathname (ignoring flash query params)
+ *  equals `expected`. Throws contextually if the Location header is missing. */
+export const assertRedirectPathname = (
+  response: Response,
+  expected: string,
+): void => {
+  expect(response.status).toBe(302);
+  const location = response.headers.get("location");
+  expect(location).not.toBeNull();
+  expect(new URL(location!, "http://x").pathname).toBe(expected);
+};
+
 /** POST an admin form as the logged-in test owner and return the response
  *  (for status/body assertions). Replaces the per-test `handleRequest` +
  *  `mockFormRequest` + `getTestSession` dance. */
@@ -319,59 +330,6 @@ export const adminPost = async (
   );
 };
 
-// ─── E2E helpers ────────────────────────────────────────────────────────────
-
-/** The standard e2e setup: log in + create a daily "Room A" listing, ready for
- *  a servicing hold. Each §21 narrative opens with this exact sequence. */
-export const setupBrowserWithListing = async (
-  browser: TestBrowser,
-  listingFields: Record<string, string> & { name: string },
-): Promise<number> => {
-  const { setupAndLogin, createListing } = await import("#test-utils/e2e.ts");
-  await setupAndLogin(browser);
-  return Number(await createListing(browser, listingFields));
-};
-
-/** The standard e2e "create a servicing hold" flow: visit the create form,
- *  fill in name + quantity on the created listing, submit. Used by every §21
- *  narrative scenario. */
-export const createHoldInBrowser = async (
-  browser: TestBrowser,
-  name: string,
-  listingId: number,
-): Promise<void> => {
-  await submitServicingCreateForm(browser, { listingId, name });
-};
-
-/** Find the `/admin/servicing/:id` path for the current e2e browser page.
- *  Called after `setupBrowserWithHold`, which always lands on that path. */
-export const findServicingLink = (browser: TestBrowser): string =>
-  browser.currentUrl.match(/^\/admin\/servicing\/\d+/)![0];
-
-/** Submit the standard servicing create form: name + quantity on listing id
- *  `quantity_${listingId}` + a single-day `start_date`. Mirrors the operator
- *  narrative flow each §21 e2e scenario opens with. */
-export const submitServicingCreateForm = async (
-  browser: TestBrowser,
-  fields: {
-    name: string;
-    listingId: number;
-    quantity?: number;
-    startDate?: string;
-  },
-): Promise<void> => {
-  await browser.visit("/admin/servicing/new");
-  await browser.submitForm(
-    {
-      day_count: "1",
-      name: fields.name,
-      [`quantity_${fields.listingId}`]: String(fields.quantity ?? 1),
-      start_date: fields.startDate ?? "2099-07-01",
-    },
-    "Create Service Event",
-  );
-};
-
 // ─── Compound assertion helpers (curried where the shape is shared) ─────────
 
 /** Assert a servicing event's logistics plan is disabled (split=0, no agents).
@@ -484,17 +442,6 @@ export const createDailyListingPair = async (
   return [a, b];
 };
 
-/** The full e2e narrative opener: log in, create a listing, create a servicing
- *  hold on it. Every §21 scenario begins with this sequence. */
-export const setupBrowserWithHold = async (
-  browser: TestBrowser,
-  listingFields: Record<string, string> & { name: string },
-  holdName: string,
-): Promise<void> => {
-  const listingId = await setupBrowserWithListing(browser, listingFields);
-  await createHoldInBrowser(browser, holdName, listingId);
-};
-
 // ─── Control-attendee fixture ───────────────────────────────────────────────
 
 /** Create a listing + a real (customer) attendee on it — the control fixture