diff --git a/buzz/api/events/__init__.py b/buzz/api/events/__init__.py
index 35e0dc1c..6888b211 100644
--- a/buzz/api/events/__init__.py
+++ b/buzz/api/events/__init__.py
@@ -1,7 +1,13 @@
 import frappe
 
 from buzz.api.events import services
-from buzz.api.events.schemas import CreatedEvent, MyEventsResponse, NewEvent
+from buzz.api.events.schemas import (
+	CreatedEvent,
+	EventDetail,
+	MyEventsResponse,
+	NewEvent,
+	RouteAvailability,
+)
 
 
 @frappe.whitelist()
@@ -10,6 +16,18 @@ def get_my_events() -> MyEventsResponse:
 	return services.my_events()
 
 
+@frappe.whitelist()
+def get_event(event: str) -> EventDetail:
+	"""One event for the manage page, for someone who can edit it."""
+	return services.event_detail(event)
+
+
+@frappe.whitelist()
+def check_event_route(route: str, event: str | None = None) -> RouteAvailability:
+	"""Whether an event can take this route. `event` is the one being edited, if any."""
+	return services.route_availability(route, event)
+
+
 @frappe.whitelist(methods=["POST"])
 def create_event(event: NewEvent) -> CreatedEvent:
 	return services.create_event(event)
diff --git a/buzz/api/events/exceptions.py b/buzz/api/events/exceptions.py
index acb362ad..2b950f75 100644
--- a/buzz/api/events/exceptions.py
+++ b/buzz/api/events/exceptions.py
@@ -1,6 +1,16 @@
 from frappe import _lt
 
-from buzz.api.exceptions import BuzzAPIError, NotPermitted
+from buzz.api.exceptions import BuzzAPIError, NotPermitted, ResourceNotFound
+
+
+class EventNotFound(ResourceNotFound):
+	title = _lt("Event Not Found")
+	message = _lt("This event does not exist.")
+
+
+class CannotManageEvent(NotPermitted):
+	title = _lt("Not Permitted")
+	message = _lt("You cannot manage this event.")
 
 
 class CannotCreateEvents(NotPermitted):
diff --git a/buzz/api/events/schemas.py b/buzz/api/events/schemas.py
index 539a94b7..e15bb666 100644
--- a/buzz/api/events/schemas.py
+++ b/buzz/api/events/schemas.py
@@ -23,6 +23,38 @@ class MyEventsResponse(APIResponse):
 	past: list[MyEvent]
 
 
+class EventVenue(APIResponse):
+	name: str
+	address: str | None = None
+
+
+class EventDetail(APIResponse):
+	"""One event, with everything the manage page edits or shows."""
+
+	name: str
+	title: str
+	route: str | None = None
+	team: str | None = None
+	start_date: date
+	end_date: date | None = None
+	start_time: timedelta | None = None
+	end_time: timedelta | None = None
+	time_zone: str | None = None
+	short_description: str | None = None
+	about: str | None = None
+	banner_image: str | None = None
+	medium: str | None = None
+	venue: EventVenue | None = None
+	# The organiser's own link, or the one Zoom issued when the meeting was booked.
+	meeting_link: str | None = None
+	is_published: bool
+
+
+class RouteAvailability(APIResponse):
+	available: bool
+	message: str
+
+
 class NewEvent(APIRequest):
 	team: str
 	title: str
diff --git a/buzz/api/events/services.py b/buzz/api/events/services.py
index 52bdcda0..e268d8ec 100644
--- a/buzz/api/events/services.py
+++ b/buzz/api/events/services.py
@@ -4,8 +4,22 @@
 from frappe.query_builder import Case
 from frappe.utils import getdate
 
-from buzz.api.events.exceptions import CannotCreateEvents, ZoomNotAvailable
-from buzz.api.events.schemas import CreatedEvent, MyEvent, MyEventsResponse, NewEvent
+from buzz.api.events.exceptions import (
+	CannotCreateEvents,
+	CannotManageEvent,
+	EventNotFound,
+	ZoomNotAvailable,
+)
+from buzz.api.events.schemas import (
+	CreatedEvent,
+	EventDetail,
+	EventVenue,
+	MyEvent,
+	MyEventsResponse,
+	NewEvent,
+	RouteAvailability,
+)
+from buzz.events.doctype.buzz_event.buzz_event import RESERVED_EVENT_ROUTES
 from buzz.permissions import has_team_access, my_teams
 from buzz.utils import is_app_installed
 
@@ -69,6 +83,89 @@ def split_by_date(events: list[MyEvent]) -> tuple[list[MyEvent], list[MyEvent]]:
 	return upcoming, list(reversed(past))
 
 
+DETAIL_FIELDS = (
+	"name",
+	"title",
+	"route",
+	"team",
+	"start_date",
+	"end_date",
+	"start_time",
+	"end_time",
+	"time_zone",
+	"short_description",
+	"about",
+	"banner_image",
+	"medium",
+	"venue",
+	"meeting_link",
+	"is_published",
+)
+
+
+def event_detail(event: str) -> EventDetail:
+	"""One event for its manage page, with the venue and meeting link resolved."""
+	row = frappe.db.get_value("Buzz Event", event, DETAIL_FIELDS, as_dict=True)
+	if not row:
+		EventNotFound.throw()
+
+	# Read is not enough: this payload backs the page that edits the event.
+	if not has_team_access(row.team, "write", frappe.session.user):
+		CannotManageEvent.throw()
+
+	return EventDetail(
+		**row | {"name": str(row.name), "venue": venue_of(row.venue), "meeting_link": meeting_link_of(row)}
+	)
+
+
+def venue_of(venue: str | None) -> EventVenue | None:
+	if not venue:
+		return None
+	address = frappe.db.get_value("Event Venue", venue, "address")
+	return EventVenue(name=venue, address=address)
+
+
+def meeting_link_of(row) -> str | None:
+	"""The organiser's own link, falling back to the one Zoom issued.
+
+	`zoom_meeting` is a custom field the zoom_integration app adds, so it is absent on a
+	site without it — and a booked meeting is the link even when nobody typed one in.
+	"""
+	if row.meeting_link:
+		return row.meeting_link
+	if not is_app_installed("zoom_integration"):
+		return None
+
+	meeting = frappe.db.get_value("Buzz Event", row.name, "zoom_meeting")
+	return frappe.db.get_value("Zoom Meeting", meeting, "zoom_link") if meeting else None
+
+
+def route_availability(route: str, event: str | None = None) -> RouteAvailability:
+	"""Whether an event can take this route.
+
+	Routes are the public URL namespace, so this checks every event rather than only the
+	published ones: an unpublished event still holds its route, and publishing it later
+	would collide.
+	"""
+	route = (route or "").strip().lower()
+	if not route:
+		return RouteAvailability(available=False, message=_("Enter a route."))
+
+	if route in RESERVED_EVENT_ROUTES:
+		return RouteAvailability(
+			available=False, message=_("'{0}' is reserved and cannot be used.").format(route)
+		)
+
+	filters = {"route": route}
+	if event:
+		filters["name"] = ("!=", event)
+
+	if frappe.db.exists("Buzz Event", filters):
+		return RouteAvailability(available=False, message=_("This route is already taken."))
+
+	return RouteAvailability(available=True, message=_("This route is available."))
+
+
 # Buzz Event demands a category and a host, neither of which the create form asks for.
 # These are the defaults it fills in; the organiser changes them on the event afterwards.
 DEFAULT_CATEGORY = "Meetups"
diff --git a/buzz/api/events/test_events.py b/buzz/api/events/test_events.py
index 4ad6fc4e..6378dd14 100644
--- a/buzz/api/events/test_events.py
+++ b/buzz/api/events/test_events.py
@@ -2,9 +2,14 @@
 from frappe.tests import IntegrationTestCase
 from frappe.utils import add_days, today
 
+from buzz.api.events import check_event_route, get_event, get_my_events
 from buzz.api.events import create_event as create_event_endpoint
-from buzz.api.events import get_my_events
-from buzz.api.events.exceptions import CannotCreateEvents, ZoomNotAvailable
+from buzz.api.events.exceptions import (
+	CannotCreateEvents,
+	CannotManageEvent,
+	EventNotFound,
+	ZoomNotAvailable,
+)
 from buzz.api.events.schemas import NewEvent
 from buzz.events.doctype.buzz_team.test_buzz_team import create_owned_team, create_user, payload_for
 from buzz.test_permissions import add_member, create_ticket
@@ -282,3 +287,124 @@ def test_zoom_is_refused_when_the_app_is_missing(self):
 
 		with self.assertRaises(ZoomNotAvailable):
 			create_event_endpoint(self.payload(zoom_meeting=True))
+
+
+class TestGetEvent(IntegrationTestCase):
+	@classmethod
+	def setUpClass(cls):
+		super().setUpClass()
+		frappe.set_user("Administrator")
+
+		cls.owner = create_user("get-event-owner@example.com", "Owner")
+		cls.viewer = create_user("get-event-viewer@example.com", "Viewer")
+		cls.stranger = create_user("get-event-stranger@example.com", "Stranger")
+		cls.team = create_owned_team("Get Event Team", cls.owner)
+		add_member(cls.team, cls.viewer, "Viewer")
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		self.addCleanup(frappe.set_user, "Administrator")
+
+	def test_returns_the_fields_the_manage_page_edits(self):
+		event = create_event(
+			"Detailed Event",
+			self.team,
+			short_description="A short one",
+			about="<p>A long one</p>",
+			medium="Online",
+			meeting_link="https://example.com/join",
+		)
+		frappe.set_user(self.owner)
+
+		detail = get_event(event).__json__()
+
+		self.assertEqual(detail["name"], event)
+		self.assertEqual(detail["short_description"], "A short one")
+		self.assertEqual(detail["about"], "<p>A long one</p>")
+		self.assertEqual(detail["medium"], "Online")
+		self.assertEqual(detail["meeting_link"], "https://example.com/join")
+		self.assertIsNone(detail["venue"])
+
+	def test_resolves_the_venue_with_its_address(self):
+		venue = frappe.get_doc(
+			{
+				"doctype": "Event Venue",
+				"name": "Get Event Venue",
+				"address": "12 Example Street",
+				"team": self.team,
+			}
+		).insert(ignore_permissions=True)
+		event = create_event("Venued Event", self.team, venue=venue.name)
+		frappe.set_user(self.owner)
+
+		detail = get_event(event).__json__()
+
+		self.assertEqual(detail["venue"]["name"], venue.name)
+		self.assertEqual(detail["venue"]["address"], "12 Example Street")
+
+	def test_a_viewer_cannot_open_the_manage_payload(self):
+		event = create_event("Viewer Event", self.team)
+		frappe.set_user(self.viewer)
+
+		with self.assertRaises(CannotManageEvent):
+			get_event(event)
+
+	def test_a_non_member_cannot_open_the_manage_payload(self):
+		event = create_event("Stranger Event", self.team)
+		frappe.set_user(self.stranger)
+
+		with self.assertRaises(CannotManageEvent):
+			get_event(event)
+
+	def test_an_unknown_event_is_not_found(self):
+		frappe.set_user(self.owner)
+
+		with self.assertRaises(EventNotFound):
+			get_event("999999999")
+
+
+class TestCheckEventRoute(IntegrationTestCase):
+	@classmethod
+	def setUpClass(cls):
+		super().setUpClass()
+		frappe.set_user("Administrator")
+
+		cls.owner = create_user("check-route-owner@example.com", "Owner")
+		cls.team = create_owned_team("Check Route Team", cls.owner)
+
+	def setUp(self):
+		frappe.set_user("Administrator")
+		self.addCleanup(frappe.set_user, "Administrator")
+
+	def test_an_unused_route_is_available(self):
+		frappe.set_user(self.owner)
+
+		self.assertTrue(check_event_route("a-route-nobody-has").available)
+
+	def test_a_route_another_event_holds_is_taken(self):
+		create_event("Route Holder", self.team, route="taken-route")
+		frappe.set_user(self.owner)
+
+		self.assertFalse(check_event_route("taken-route").available)
+
+	def test_an_unpublished_event_still_holds_its_route(self):
+		create_event("Draft Route Holder", self.team, route="draft-route", is_published=0)
+		frappe.set_user(self.owner)
+
+		self.assertFalse(check_event_route("draft-route").available)
+
+	def test_an_event_does_not_block_its_own_route(self):
+		event = create_event("Self Route", self.team, route="own-route")
+		frappe.set_user(self.owner)
+
+		self.assertTrue(check_event_route("own-route", event=event).available)
+
+	def test_a_reserved_route_is_refused(self):
+		frappe.set_user(self.owner)
+
+		self.assertFalse(check_event_route("account").available)
+
+	def test_a_blank_route_is_not_available(self):
+		frappe.set_user(self.owner)
+
+		self.assertFalse(check_event_route("   ").available)
diff --git a/buzz/events/doctype/buzz_event/buzz_event.json b/buzz/events/doctype/buzz_event/buzz_event.json
index f461c142..47661cc0 100644
--- a/buzz/events/doctype/buzz_event/buzz_event.json
+++ b/buzz/events/doctype/buzz_event/buzz_event.json
@@ -15,6 +15,7 @@
   "banner_image",
   "host",
   "venue",
+  "meeting_link",
   "section_break_naqe",
   "start_date",
   "start_time",
@@ -118,6 +119,14 @@
    "mandatory_depends_on": "eval:doc.medium!=\"Online\"",
    "options": "Event Venue"
   },
+  {
+   "depends_on": "eval:doc.medium==\"Online\"",
+   "description": "Where attendees join an online event.",
+   "fieldname": "meeting_link",
+   "fieldtype": "Data",
+   "label": "Meeting Link",
+   "options": "URL"
+  },
   {
    "default": "In Person",
    "fieldname": "medium",
@@ -612,7 +621,7 @@
    "link_fieldname": "event"
   }
  ],
- "modified": "2026-07-31 12:00:00.000000",
+ "modified": "2026-08-14 13:08:24.523151",
  "modified_by": "Administrator",
  "module": "Events",
  "name": "Buzz Event",
diff --git a/buzz/events/doctype/buzz_event/buzz_event.py b/buzz/events/doctype/buzz_event/buzz_event.py
index c59cbe45..7da572d0 100644
--- a/buzz/events/doctype/buzz_event/buzz_event.py
+++ b/buzz/events/doctype/buzz_event/buzz_event.py
@@ -99,9 +99,22 @@ def validate(self):
 		self.validate_tax_settings()
 		self.validate_guest_verification_config()
 		self.validate_custom_forms()
+		self.clear_unused_location()
 		self.validate_venue_team()
 		self.set_time_zone_label()
 
+	def clear_unused_location(self):
+		"""Only the medium in force keeps its location.
+
+		`generate_ics_file` and the booking page both read `venue` without consulting
+		`medium`, so a venue left behind by a switch to Online publishes an address the
+		event no longer has.
+		"""
+		if self.medium == "Online":
+			self.venue = None
+		else:
+			self.meeting_link = None
+
 	def validate_venue_team(self):
 		"""A venue may only be linked by the team that owns it.
 
diff --git a/buzz/events/doctype/buzz_event/test_buzz_event.py b/buzz/events/doctype/buzz_event/test_buzz_event.py
index c8bbb617..b3112910 100644
--- a/buzz/events/doctype/buzz_event/test_buzz_event.py
+++ b/buzz/events/doctype/buzz_event/test_buzz_event.py
@@ -226,6 +226,44 @@ def test_a_venue_without_a_team_is_accepted(self):
 
 		event.validate_venue_team()
 
+	def test_turning_an_event_online_drops_its_venue(self):
+		"""The venue outlives the medium otherwise.
+
+		`generate_ics_file` and the booking page both read `venue` without consulting
+		`medium`, so a leftover venue puts a physical address on an online event.
+		"""
+		team = self._make_team("Venue Test Team")
+		event = self._make_event_with_venue(self._make_venue("Venue Test Hall", team), team)
+		event.medium = "Online"
+		event.meeting_link = "https://example.com/room"
+
+		event.clear_unused_location()
+
+		self.assertIsNone(event.venue)
+		self.assertEqual(event.meeting_link, "https://example.com/room")
+
+	def test_turning_an_event_in_person_drops_its_meeting_link(self):
+		team = self._make_team("Venue Test Team")
+		venue = self._make_venue("Venue Test Hall", team)
+		event = self._make_event_with_venue(venue, team)
+		event.medium = "In Person"
+		event.meeting_link = "https://example.com/room"
+
+		event.clear_unused_location()
+
+		self.assertEqual(event.venue, venue)
+		self.assertIsNone(event.meeting_link)
+
+	def test_an_online_event_keeps_a_venue_it_never_had(self):
+		"""Clearing must not invent a change on an event that was always online."""
+		team = self._make_team("Venue Test Team")
+		event = self._make_event_with_venue(None, team)
+		event.medium = "Online"
+
+		event.clear_unused_location()
+
+		self.assertIsNone(event.venue)
+
 	# ==================== Create from Template Tests ====================
 
 	def test_create_from_template_copies_direct_fields(self):
diff --git a/dashboard/components.d.ts b/dashboard/components.d.ts
index 14fb93cf..2fe320a1 100644
--- a/dashboard/components.d.ts
+++ b/dashboard/components.d.ts
@@ -28,9 +28,12 @@ declare module 'vue' {
     CancellationRequestNotice: typeof import('./src/components/CancellationRequestNotice.vue')['default']
     CustomFieldInput: typeof import('./src/components/CustomFieldInput.vue')['default']
     CustomFieldsSection: typeof import('./src/components/CustomFieldsSection.vue')['default']
+    EventBanner: typeof import('./src/components/dashboard/events/EventBanner.vue')['default']
     EventCard: typeof import('./src/components/dashboard/events/EventCard.vue')['default']
     EventDetailsHeader: typeof import('./src/components/EventDetailsHeader.vue')['default']
     EventLocation: typeof import('./src/components/dashboard/events/EventLocation.vue')['default']
+    EventMedium: typeof import('./src/components/dashboard/events/EventMedium.vue')['default']
+    EventRoute: typeof import('./src/components/dashboard/events/EventRoute.vue')['default']
     EventSchedule: typeof import('./src/components/dashboard/events/EventSchedule.vue')['default']
     EventSelector: typeof import('./src/components/EventSelector.vue')['default']
     FormFieldSections: typeof import('./src/components/FormFieldSections.vue')['default']
diff --git a/dashboard/src/components/dashboard/events/EventBanner.vue b/dashboard/src/components/dashboard/events/EventBanner.vue
new file mode 100644
index 00000000..c689e825
--- /dev/null
+++ b/dashboard/src/components/dashboard/events/EventBanner.vue
@@ -0,0 +1,105 @@
+<script setup lang="ts">
+import { bannerPattern } from "@/utils/eventBanner";
+import { refDebounced } from "@vueuse/core";
+import { Button, ErrorMessage, FileUploader } from "frappe-ui";
+import { computed, ref, watch } from "vue";
+
+// The picker is filtered to these, and the file that comes back is checked against the
+// same list: `accept` is a hint the OS may ignore, and a drag-drop never consults it.
+// Raster only — an SVG banner would be same-origin markup, which a banner has no need
+// to be. Neither check is enforcement; the upload endpoint takes what it is given.
+const IMAGE_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+
+function validateImage(file: File): string | void {
+	if (!IMAGE_TYPES.includes(file.type)) {
+		return "Choose a PNG, JPEG, WebP or GIF image";
+	}
+}
+
+// The event title. The generated pattern is seeded by it, so a draft banner settles into
+// the one the event keeps.
+const props = defineProps<{ seed: string; disabled?: boolean }>();
+
+const image = defineModel<string>({ default: "" });
+
+// Seeded off a debounced copy: a gradient cannot be transitioned, so re-seeding per
+// keystroke would redraw the banner once per character while the organiser types. An
+// untitled draft seeds on "Untitled" rather than the empty string, which would draw
+// every new event the same.
+const settledSeed = refDebounced(
+	computed(() => props.seed.trim()),
+	250
+);
+
+const pattern = computed(() => ({
+	backgroundImage: bannerPattern(settledSeed.value || "Untitled"),
+}));
+
+// True from the first keystroke until the debounce fires — and the pattern swaps on the
+// same tick it turns false. So the blur is already up when the swap lands, and only
+// falls away afterwards, which is what hides the change.
+const isSettling = computed(() => props.seed.trim() !== settledSeed.value);
+
+// Reset per image, so a second upload fades in rather than snapping.
+const loaded = ref(false);
+watch(image, () => {
+	loaded.value = false;
+});
+</script>
+
+<template>
+	<FileUploader
+		:file-types="IMAGE_TYPES"
+		:validate-file="validateImage"
+		@success="(file: { file_url: string }) => (image = file.file_url)"
+	>
+		<template #default="{ openFileSelector, error: uploadError }">
+			<!-- The whole banner is the hit area; the button inside stays the -->
+			<!-- keyboard-reachable control, so its press must not fire twice. -->
+			<div
+				class="relative aspect-[3/1] overflow-hidden rounded-xl border border-outline-gray-2"
+				:class="disabled ? 'cursor-default' : 'cursor-pointer'"
+				@click="!disabled && openFileSelector()"
+			>
+				<!-- The pattern gets a layer of its own so the blur below never
+					 reaches the image or the button. Overscaled because blur samples
+					 past the edges, which would otherwise go milky against the border.
+					 A gradient cannot be interpolated, so blurring over the swap is
+					 what hides it. -->
+				<div
+					class="absolute inset-0 scale-105 transition-[filter] duration-200 ease-out"
+					:class="
+						isSettling && !image ? 'blur-[10px] motion-reduce:blur-none' : 'blur-0'
+					"
+					:style="pattern"
+					aria-hidden="true"
+				/>
+
+				<!-- Fades onto the pattern rather than replacing it outright. -->
+				<!-- Absolute, like the pattern behind it: a static sibling would paint
+					 under the positioned layer instead of over it. -->
+				<img
+					v-if="image"
+					class="absolute inset-0 h-full w-full object-cover object-center transition-opacity duration-200 ease-out"
+					:class="loaded ? 'opacity-100' : 'opacity-0'"
+					:src="image"
+					alt=""
+					@load="loaded = true"
+				/>
+
+				<div class="absolute inset-0 grid place-items-center">
+					<Button
+						variant="subtle"
+						icon-left="lucide-image-up"
+						:label="image ? 'Change banner' : 'Add a banner'"
+						:disabled="disabled"
+						@click.stop="openFileSelector"
+					/>
+				</div>
+			</div>
+
+			<!-- The slot types its error as {}, so the message needs narrowing. -->
+			<ErrorMessage v-if="uploadError" class="mt-2" :message="String(uploadError)" />
+		</template>
+	</FileUploader>
+</template>
diff --git a/dashboard/src/components/dashboard/events/EventCard.vue b/dashboard/src/components/dashboard/events/EventCard.vue
index 2dd4e254..f357a7ce 100644
--- a/dashboard/src/components/dashboard/events/EventCard.vue
+++ b/dashboard/src/components/dashboard/events/EventCard.vue
@@ -4,16 +4,27 @@ import { dayLabel } from "@/utils/dateLabels";
 import { bannerPattern } from "@/utils/eventBanner";
 import { Avatar, Button } from "frappe-ui";
 import { computed } from "vue";
+import { RouterLink } from "vue-router";
 
 // The Events page files cards under a date heading; a standalone list has to
 // carry the date on the card itself.
 const props = withDefaults(
-	defineProps<{ event: MyEvent; showDate?: boolean; showManage?: boolean }>(),
+	defineProps<{
+		event: MyEvent;
+		showDate?: boolean;
+		showManage?: boolean;
+		// A list where every card is manageable — a team's own events — can drop the
+		// per-card button and make the whole card the way in.
+		routeToManage?: boolean;
+	}>(),
 	{ showManage: true }
 );
 
-// Two gates: the caller has to want the button, and only a host has anything to manage.
-const canManage = computed(() => props.showManage && props.event.is_host);
+// Only a host has anything to manage, whichever way in the caller asked for.
+const linksToManage = computed(() => props.routeToManage && props.event.is_host);
+
+// The button would be a second link inside the first, so the card link wins.
+const canManage = computed(() => props.showManage && !linksToManage.value && props.event.is_host);
 
 // Times arrive as a serialized timedelta ("9:00:00"), so the hour needs padding.
 const startTime = computed((): string => {
@@ -38,8 +49,9 @@ const venue = computed(() => {
 </script>
 
 <template>
-	<!-- TODO: some sort of action on click of this card -->
-	<article
+	<component
+		:is="linksToManage ? RouterLink : 'article'"
+		:to="linksToManage ? `/manage/events/${event.name}` : undefined"
 		class="flex gap-4 border border-outline-gray-2 hover:border-outline-gray-3 rounded-2xl p-3"
 	>
 		<!-- The pattern also backs the image, so the slot is never blank while it loads. -->
@@ -84,9 +96,14 @@ const venue = computed(() => {
 					/>
 					{{ venue.label }}
 				</p>
-				<!-- TODO: wire this button up with the manage event page -->
-				<Button v-if="canManage" label="Manage" icon-right="arrow-right" size="sm" />
+				<Button
+					v-if="canManage"
+					label="Manage"
+					icon-right="arrow-right"
+					size="sm"
+					:route="`/manage/events/${event.name}`"
+				/>
 			</div>
 		</div>
-	</article>
+	</component>
 </template>
diff --git a/dashboard/src/components/dashboard/events/EventLocation.vue b/dashboard/src/components/dashboard/events/EventLocation.vue
index 42e2e68a..fc966397 100644
--- a/dashboard/src/components/dashboard/events/EventLocation.vue
+++ b/dashboard/src/components/dashboard/events/EventLocation.vue
@@ -8,7 +8,12 @@ import { computed, ref, watch } from "vue";
 // venue really could be called "Zoom" — the sentinel keeps the two apart.
 const ZOOM = "__zoom__";
 
-const props = defineProps<{ team: string; disabled?: boolean }>();
+// A page that asks for the medium separately picks a venue and nothing else, so the
+// Zoom option would be a second way to answer a question already answered.
+const props = withDefaults(
+	defineProps<{ team: string; disabled?: boolean; showVirtual?: boolean }>(),
+	{ showVirtual: true }
+);
 
 const venue = defineModel<string>("venue", { default: "" });
 // Zoom cannot be booked until the event exists, so this is the intent to act on at save.
@@ -32,37 +37,41 @@ const selected = computed({
 	},
 });
 
+const addVenue = {
+	type: "custom" as const,
+	key: "add-venue",
+	label: "Add venue",
+	icon: "lucide-plus",
+	// Only worth offering once they have typed a name nothing answers to.
+	condition: ({ query }: { query: string }) =>
+		Boolean(query.trim()) &&
+		!(venues.data ?? []).some((row) => row.name.toLowerCase() === query.trim().toLowerCase()),
+	onClick: ({ query }: { query: string }) => {
+		suggestedName.value = query.trim();
+		isAdding.value = true;
+	},
+};
+
 const options = computed(() => [
 	{
 		group: "Venues",
-		options: (venues.data ?? []).map((row) => ({
-			label: row.name,
-			description: row.address,
-			value: row.name,
-		})),
-	},
-	{
-		group: "Virtual",
 		options: [
-			{ label: "Create Zoom meeting", value: ZOOM, icon: "lucide-video" },
-			{
-				type: "custom" as const,
-				key: "add-venue",
-				label: "Add venue",
-				icon: "lucide-plus",
-				// Only worth offering once they have typed a name nothing answers to.
-				condition: ({ query }: { query: string }) =>
-					Boolean(query.trim()) &&
-					!(venues.data ?? []).some(
-						(row) => row.name.toLowerCase() === query.trim().toLowerCase()
-					),
-				onClick: ({ query }: { query: string }) => {
-					suggestedName.value = query.trim();
-					isAdding.value = true;
-				},
-			},
+			...(venues.data ?? []).map((row) => ({
+				label: row.name,
+				description: row.address,
+				value: row.name,
+			})),
+			addVenue,
 		],
 	},
+	...(props.showVirtual
+		? [
+				{
+					group: "Virtual",
+					options: [{ label: "Create Zoom meeting", value: ZOOM, icon: "lucide-video" }],
+				},
+		  ]
+		: []),
 ]);
 
 async function onVenueCreated(name: string) {
diff --git a/dashboard/src/components/dashboard/events/EventMedium.vue b/dashboard/src/components/dashboard/events/EventMedium.vue
new file mode 100644
index 00000000..a7653388
--- /dev/null
+++ b/dashboard/src/components/dashboard/events/EventMedium.vue
@@ -0,0 +1,84 @@
+<script setup lang="ts">
+import EventLocation from "@/components/dashboard/events/EventLocation.vue";
+import { venues } from "@/data/venues";
+import { Button, FormControl, toast } from "frappe-ui";
+import { computed } from "vue";
+
+// The two values Buzz Event's `medium` select takes.
+const IN_PERSON = "In Person";
+const ONLINE = "Online";
+
+const props = defineProps<{ team: string; venueAddress?: string | null }>();
+
+const medium = defineModel<string>("medium", { default: IN_PERSON });
+const venue = defineModel<string>("venue", { default: "" });
+const meetingLink = defineModel<string>("meetingLink", { default: "" });
+
+const isOnline = computed(() => medium.value === ONLINE);
+
+const options = [
+	{ label: "In person", icon: "lucide-map-pin", value: IN_PERSON },
+	{ label: "Virtual", icon: "lucide-video", value: ONLINE },
+];
+
+// The picker knows the address of a venue chosen in this session; the one loaded with
+// the event is only known to the payload until that list arrives.
+const address = computed(() => {
+	const picked = (venues.data ?? []).find((row) => row.name === venue.value);
+	return picked?.address || props.venueAddress || "";
+});
+
+// The hidden field is dropped here as well as on the server: the calendar invite and the
+// booking page both read `venue` without consulting `medium`, so a leftover one shows an
+// address the event no longer has.
+function pick(value: string) {
+	medium.value = value;
+	if (value === ONLINE) venue.value = "";
+	else meetingLink.value = "";
+}
+
+async function copyLink() {
+	await navigator.clipboard.writeText(meetingLink.value);
+	toast.success("Link copied");
+}
+</script>
+
+<template>
+	<div class="flex flex-col gap-3">
+		<div class="grid grid-cols-2 gap-2">
+			<Button
+				v-for="option in options"
+				:key="option.value"
+				:variant="medium === option.value ? 'subtle' : 'ghost'"
+				:icon-left="option.icon"
+				:label="option.label"
+				:aria-pressed="medium === option.value"
+				class="w-full"
+				@click="pick(option.value)"
+			/>
+		</div>
+
+		<template v-if="isOnline">
+			<div class="flex items-end gap-2">
+				<FormControl
+					v-model="meetingLink"
+					class="flex-1"
+					type="url"
+					label="Meeting link"
+					placeholder="https://…"
+				/>
+				<Button
+					icon="lucide-copy"
+					label="Copy meeting link"
+					:disabled="!meetingLink"
+					@click="copyLink"
+				/>
+			</div>
+		</template>
+
+		<template v-else>
+			<EventLocation v-model:venue="venue" :team="team" :show-virtual="false" />
+			<p v-if="address" class="text-base text-ink-gray-5">{{ address }}</p>
+		</template>
+	</div>
+</template>
diff --git a/dashboard/src/components/dashboard/events/EventRoute.vue b/dashboard/src/components/dashboard/events/EventRoute.vue
new file mode 100644
index 00000000..b7a19a18
--- /dev/null
+++ b/dashboard/src/components/dashboard/events/EventRoute.vue
@@ -0,0 +1,102 @@
+<script setup lang="ts">
+import { checkEventRoute } from "@/data/events";
+import { watchDebounced } from "@vueuse/core";
+import { computed, ref } from "vue";
+
+// The route the event already answers to, which is the one that opens and copies —
+// an edit in the field is not a live address until it is saved.
+const props = defineProps<{ event: string; saved: string | null }>();
+
+const route = defineModel<string>({ default: "" });
+
+// The host the dashboard is being used on, so the chip reads as the address it will be.
+const hostname = window.location.hostname;
+// Events are served under the dashboard's own base, not off the bare host.
+const publicPath = computed(() => `/b/register/${props.saved}`);
+
+type Availability = { available: boolean; message: string };
+const availability = ref<Availability | null>(null);
+
+// Only worth saying anything about a route that is not already this event's.
+watchDebounced(
+	route,
+	async (value) => {
+		availability.value = null;
+		if (!value.trim() || value === props.saved) return;
+		const answer = (await checkEventRoute.submit({
+			route: value,
+			event: props.event,
+		})) as Availability;
+		// A later keystroke may have overtaken this request while it was in flight.
+		if (route.value !== value) return;
+		availability.value = answer;
+	},
+	{ debounce: 400 }
+);
+
+// The icon carries the confirmation, so this needs no toast on top of it.
+const justCopied = ref(false);
+let clearCopied: ReturnType<typeof setTimeout>;
+
+async function copy() {
+	// The path the link opens, not the shorthand the chip reads.
+	await navigator.clipboard.writeText(`${window.location.origin}${publicPath.value}`);
+	justCopied.value = true;
+	clearTimeout(clearCopied);
+	clearCopied = setTimeout(() => (justCopied.value = false), 1500);
+}
+</script>
+
+<template>
+	<div class="w-80">
+		<div class="flex items-center gap-1 rounded bg-surface-gray-1 py-1 pl-2.5 pr-1 text-base">
+			<span class="shrink-0 text-ink-gray-5">{{ hostname }}/</span>
+
+			<input
+				v-model="route"
+				aria-label="Event route"
+				placeholder="your-event"
+				class="min-w-0 flex-1 bg-transparent text-ink-gray-8 placeholder:text-ink-gray-4 focus:outline-none"
+			/>
+
+			<template v-if="saved">
+				<a
+					:href="publicPath"
+					target="_blank"
+					rel="noopener"
+					aria-label="Open event page"
+					class="shrink-0 rounded p-1 text-ink-gray-5 transition-[color,transform] duration-150 ease-out hover:text-ink-gray-8 active:scale-95 motion-reduce:transition-none"
+				>
+					<span class="lucide-arrow-up-right block size-4" aria-hidden="true" />
+				</a>
+
+				<button
+					type="button"
+					aria-label="Copy"
+					class="shrink-0 rounded p-1 text-ink-gray-5 transition-[color,transform] duration-150 ease-out hover:text-ink-gray-8 active:scale-95 motion-reduce:transition-none"
+					@click="copy"
+				>
+					<!-- Swapped, not crossfaded: at this size a fade reads as a flicker. -->
+					<span
+						class="block size-4"
+						:class="justCopied ? 'lucide-check text-ink-gray-6' : 'lucide-copy'"
+						aria-hidden="true"
+					/>
+				</button>
+			</template>
+		</div>
+
+		<p
+			v-if="availability"
+			class="mt-1.5 flex items-center gap-1 text-sm"
+			:class="availability.available ? 'text-ink-green-6' : 'text-ink-red-6'"
+		>
+			<span
+				class="size-3.5 shrink-0"
+				:class="availability.available ? 'lucide-check' : 'lucide-triangle-alert'"
+				aria-hidden="true"
+			/>
+			{{ availability.message }}
+		</p>
+	</div>
+</template>
diff --git a/dashboard/src/data/events.ts b/dashboard/src/data/events.ts
index 9af852c0..973e238b 100644
--- a/dashboard/src/data/events.ts
+++ b/dashboard/src/data/events.ts
@@ -1,4 +1,4 @@
-import type { MyEvents } from "@/types"
+import type { EventDetail, MyEvents } from "@/types"
 import { createResource, useCall } from "frappe-ui"
 
 // v2 path: useCall reads the payload from `data`, which /api/method names `message`.
@@ -12,3 +12,24 @@ export function useMyEvents() {
 export const createEvent = createResource<{ name: string; title: string }>({
 	url: "buzz.api.events.create_event",
 })
+
+/** One event with everything its manage page edits. Per page, so it is not a singleton. */
+export function eventDetail(event: string) {
+	return createResource<EventDetail>({
+		url: "buzz.api.events.get_event",
+		params: { event },
+		auto: true,
+	})
+}
+
+/**
+ * Save edits back onto an event.
+ *
+ * `set_value` takes a fieldname-to-value map, so the whole form travels as one write —
+ * and the team permission hooks guard Buzz Event, which is why this needs no endpoint of
+ * its own.
+ */
+export const updateEvent = createResource({ url: "frappe.client.set_value" })
+
+/** Whether an event can take a route. Routes are the public URL namespace, so they are unique. */
+export const checkEventRoute = createResource({ url: "buzz.api.events.check_event_route" })
diff --git a/dashboard/src/layouts/ManagerLayout.vue b/dashboard/src/layouts/ManagerLayout.vue
index 8a2a3236..346927c4 100644
--- a/dashboard/src/layouts/ManagerLayout.vue
+++ b/dashboard/src/layouts/ManagerLayout.vue
@@ -4,7 +4,7 @@ import UserMenu from "@/components/UserMenu.vue";
 import { useTeamAccess } from "@/composables/useTeamAccess";
 import NotFound from "@/pages/NotFound.vue";
 import { DesktopShell, PageHeaderTarget, Sidebar, SidebarItem, SidebarLabel } from "frappe-ui";
-import { ref } from "vue";
+import { computed, ref } from "vue";
 import { useRoute } from "vue-router";
 
 const collapsed = ref(false);
@@ -30,6 +30,29 @@ const teamItems = [
 	{ label: "Events", icon: "lucide-calendar-days", to: "/manage/team/events" },
 	{ label: "Members", icon: "lucide-users-round", to: "/manage/team/members" },
 ];
+
+// An event opens into the same shell with its own destinations in place of the
+// personal and team ones.
+const eventId = computed(() => route.params.eventId as string | undefined);
+
+const eventItems = computed(() => [
+	{ label: "Back", icon: "lucide-arrow-left", to: "/" },
+	{
+		label: "Details",
+		icon: "lucide-receipt-text",
+		to: `/manage/events/${eventId.value}/details`,
+	},
+	{
+		label: "Attendees",
+		icon: "lucide-users-round",
+		to: `/manage/events/${eventId.value}/attendees`,
+	},
+	{
+		label: "Talks",
+		icon: "lucide-presentation",
+		to: `/manage/events/${eventId.value}/talks`,
+	},
+]);
 </script>
 
 <template>
@@ -43,7 +66,18 @@ const teamItems = [
 					<TeamSwitcher />
 				</div>
 
-				<div class="flex flex-col mx-2 py-2">
+				<div v-if="eventId" class="flex flex-col mx-2 py-2">
+					<SidebarItem
+						v-for="item in eventItems"
+						:key="item.label"
+						:label="item.label"
+						:icon="item.icon"
+						:to="item.to"
+						:active="isActive(item.to)"
+					/>
+				</div>
+
+				<div v-else class="flex flex-col mx-2 py-2">
 					<SidebarItem
 						v-for="item in personalItems"
 						:key="item.label"
diff --git a/dashboard/src/pages/manage/events/CreateEvent.vue b/dashboard/src/pages/manage/events/CreateEvent.vue
index 7b16c0a1..aa539b16 100644
--- a/dashboard/src/pages/manage/events/CreateEvent.vue
+++ b/dashboard/src/pages/manage/events/CreateEvent.vue
@@ -1,19 +1,18 @@
 <script setup lang="ts">
+import EventBanner from "@/components/dashboard/events/EventBanner.vue";
 import EventLocation from "@/components/dashboard/events/EventLocation.vue";
 import EventSchedule from "@/components/dashboard/events/EventSchedule.vue";
 import { useTeamAccess } from "@/composables/useTeamAccess";
 import { createEvent } from "@/data/events";
 import { currentTeam } from "@/data/teams";
 import NotFound from "@/pages/NotFound.vue";
-import { bannerPattern } from "@/utils/eventBanner";
 import { isEndBeforeStart } from "@/utils/eventDates";
 import { canCreateEvents } from "@/utils/teamRoles";
 import { currentTimeZone } from "@/utils/timeZones";
-import { refDebounced } from "@vueuse/core";
 import type { FrappeError } from "@/types";
-import { Alert, Button, ErrorMessage, FileUploader, toast, useTheme } from "frappe-ui";
+import { Alert, Button, ErrorMessage, toast, useTheme } from "frappe-ui";
 import { Editor, EditorContent, RichTextKit } from "frappe-ui/editor";
-import { computed, ref, watch } from "vue";
+import { computed, ref } from "vue";
 import { useRouter } from "vue-router";
 
 const router = useRouter();
@@ -24,18 +23,6 @@ const access = useTeamAccess();
 // letting someone fill it in and lose the work to a 403 on save.
 const canCreate = computed(() => canCreateEvents(currentTeam.value?.team_role));
 
-// The picker is filtered to these, and the file that comes back is checked against the
-// same list: `accept` is a hint the OS may ignore, and a drag-drop never consults it.
-// Raster only — an SVG banner would be same-origin markup, which a banner has no need
-// to be. Neither check is enforcement; the upload endpoint takes what it is given.
-const BANNER_IMAGE_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
-
-function validateBannerImage(file: File): string | void {
-	if (!BANNER_IMAGE_TYPES.includes(file.type)) {
-		return "Choose a PNG, JPEG, WebP or GIF image";
-	}
-}
-
 const { currentTheme, setTheme, getSystemTheme } = useTheme();
 // `system` resolves against the OS, so the icon shows what is on screen rather than
 // what was picked — and the toggle sets the opposite outright instead of stepping
@@ -59,22 +46,6 @@ const venue = ref("");
 // The Zoom meeting can only be booked once the event exists, so save has to act on this.
 const zoomMeeting = ref(false);
 
-// The pattern is seeded by the title, so the draft banner settles into the one the
-// event keeps. Seeded off a debounced copy: a gradient cannot be transitioned, so
-// re-seeding per keystroke would redraw the banner once per character while the
-// organiser types. An untitled draft seeds on "Untitled" rather than the empty string,
-// which would draw every new event the same.
-const settledTitle = refDebounced(title, 250);
-
-const banner = computed(() => ({
-	backgroundImage: bannerPattern(settledTitle.value.trim() || "Untitled"),
-}));
-
-// True from the first keystroke until the debounce fires — and the pattern swaps on the
-// same tick it turns false. So the blur is already up when the swap lands, and only
-// falls away afterwards, which is what hides the change.
-const isSettling = computed(() => title.value.trim() !== settledTitle.value.trim());
-
 // About is optional: an event needs a name, when it runs, and where.
 const canSave = computed(() =>
 	Boolean(
@@ -116,12 +87,6 @@ async function save() {
 	toast.success(`${createEvent.data?.title} created`);
 	router.push({ name: "team-events" });
 }
-
-// Reset per image, so a second upload fades in rather than snapping.
-const bannerLoaded = ref(false);
-watch(bannerImage, () => {
-	bannerLoaded.value = false;
-});
 </script>
 
 <template>
@@ -174,62 +139,7 @@ watch(bannerImage, () => {
 				:dismissible="false"
 			/>
 
-			<FileUploader
-				:file-types="BANNER_IMAGE_TYPES"
-				:validate-file="validateBannerImage"
-				@success="(file: { file_url: string }) => (bannerImage = file.file_url)"
-			>
-				<template #default="{ openFileSelector, error: uploadError }">
-					<!-- The whole banner is the hit area; the button inside stays the -->
-					<!-- keyboard-reachable control, so its press must not fire twice. -->
-					<div
-						class="relative aspect-[3/1] overflow-hidden rounded-xl border border-outline-gray-2"
-						:class="canCreate ? 'cursor-pointer' : 'cursor-default'"
-						@click="canCreate && openFileSelector()"
-					>
-						<!-- The pattern gets a layer of its own so the blur below never
-							 reaches the image or the button. Overscaled because blur samples
-							 past the edges, which would otherwise go milky against the border.
-							 A gradient cannot be interpolated, so blurring over the swap is
-							 what hides it. -->
-						<div
-							class="absolute inset-0 scale-105 transition-[filter] duration-200 ease-out"
-							:class="
-								isSettling && !bannerImage
-									? 'blur-[10px] motion-reduce:blur-none'
-									: 'blur-0'
-							"
-							:style="banner"
-							aria-hidden="true"
-						/>
-
-						<!-- Fades onto the pattern rather than replacing it outright. -->
-						<!-- Absolute, like the pattern behind it: a static sibling would paint
-							 under the positioned layer instead of over it. -->
-						<img
-							v-if="bannerImage"
-							class="absolute inset-0 h-full w-full object-cover object-center transition-opacity duration-200 ease-out"
-							:class="bannerLoaded ? 'opacity-100' : 'opacity-0'"
-							:src="bannerImage"
-							alt=""
-							@load="bannerLoaded = true"
-						/>
-
-						<div class="absolute inset-0 grid place-items-center">
-							<Button
-								variant="subtle"
-								icon-left="lucide-image-up"
-								:label="bannerImage ? 'Change banner' : 'Add a banner'"
-								:disabled="!canCreate"
-								@click.stop="openFileSelector"
-							/>
-						</div>
-					</div>
-
-					<!-- The slot types its error as {}, so the message needs narrowing. -->
-					<ErrorMessage v-if="uploadError" class="mt-2" :message="String(uploadError)" />
-				</template>
-			</FileUploader>
+			<EventBanner v-model="bannerImage" :seed="title" :disabled="!canCreate" />
 
 			<!-- Plain input on purpose: this is the page's headline, not a labelled field. -->
 			<input
diff --git a/dashboard/src/pages/manage/events/EventDetails.vue b/dashboard/src/pages/manage/events/EventDetails.vue
new file mode 100644
index 00000000..aa27e1b3
--- /dev/null
+++ b/dashboard/src/pages/manage/events/EventDetails.vue
@@ -0,0 +1,181 @@
+<script setup lang="ts">
+import EventBanner from "@/components/dashboard/events/EventBanner.vue";
+import EventMedium from "@/components/dashboard/events/EventMedium.vue";
+import EventRoute from "@/components/dashboard/events/EventRoute.vue";
+import EventSchedule from "@/components/dashboard/events/EventSchedule.vue";
+import { eventDetail, updateEvent } from "@/data/events";
+import type { EventDetail, FrappeError } from "@/types";
+import { Breadcrumbs, Button, ErrorMessage, PageHeader, Textarea, toast } from "frappe-ui";
+import { Editor, EditorContent, RichTextKit } from "frappe-ui/editor";
+import { computed, reactive, ref, watch } from "vue";
+import { useRoute } from "vue-router";
+
+const route = useRoute();
+const eventId = route.params.eventId as string;
+
+const event = eventDetail(eventId);
+
+// The form the page edits, and the copy it is compared against to know it is dirty.
+const form = reactive(blank());
+const saved = ref(JSON.stringify(blank()));
+
+function blank() {
+	return {
+		title: "",
+		route: "",
+		short_description: "",
+		about: "",
+		banner_image: "",
+		start_date: "",
+		start_time: "",
+		end_date: "",
+		end_time: "",
+		time_zone: "",
+		medium: "In Person",
+		venue: "",
+		meeting_link: "",
+	};
+}
+
+// Nulls all the way through the payload; the form works in empty strings so an untouched
+// field compares equal to itself.
+function fill(detail: EventDetail) {
+	Object.assign(form, {
+		title: detail.title ?? "",
+		route: detail.route ?? "",
+		short_description: detail.short_description ?? "",
+		about: detail.about ?? "",
+		banner_image: detail.banner_image ?? "",
+		start_date: detail.start_date ?? "",
+		start_time: detail.start_time ?? "",
+		end_date: detail.end_date ?? "",
+		end_time: detail.end_time ?? "",
+		time_zone: detail.time_zone ?? "",
+		medium: detail.medium || "In Person",
+		venue: detail.venue?.name ?? "",
+		meeting_link: detail.meeting_link ?? "",
+	});
+	saved.value = JSON.stringify(form);
+}
+
+watch(
+	() => event.data,
+	(detail) => detail && fill(detail)
+);
+
+const isDirty = computed(() => JSON.stringify(form) !== saved.value);
+
+const items = computed(() => [{ label: event.data?.title || "Event" }, { label: "Details" }]);
+
+// createResource types its error as {}, so the message needs narrowing.
+const errorMessage = computed(() =>
+	(updateEvent.error as FrappeError | null)?.messages?.join("\n")
+);
+
+async function save() {
+	// A blank date or venue has to reach the server as null, not "".
+	const fieldname = Object.fromEntries(
+		Object.entries(form).map(([field, value]) => [field, value === "" ? null : value])
+	);
+
+	await updateEvent.submit({ doctype: "Buzz Event", name: eventId, fieldname });
+	if (updateEvent.error) return;
+
+	saved.value = JSON.stringify(form);
+	toast.success("Event saved");
+}
+</script>
+
+<template>
+	<PageHeader class="border-none pt-2 bg-surface-elevation-1">
+		<Breadcrumbs :items="items" />
+		<Button
+			v-if="isDirty"
+			variant="solid"
+			label="Save"
+			:loading="updateEvent.loading"
+			@click="save"
+		/>
+	</PageHeader>
+
+	<div v-if="event.data" class="m-auto max-w-[800px] w-full py-8 px-4 space-y-8">
+		<ErrorMessage v-if="errorMessage" :message="errorMessage" />
+
+		<EventBanner v-model="form.banner_image" :seed="form.title" />
+
+		<div class="space-y-2">
+			<div class="flex items-start justify-between gap-4">
+				<!-- Plain input on purpose: this is the page's headline, not a labelled field. -->
+				<input
+					v-model="form.title"
+					aria-label="Event title"
+					placeholder="Name your event"
+					class="min-w-0 flex-1 bg-transparent text-4xl font-semibold text-ink-gray-9 placeholder:text-ink-gray-4 focus:outline-none"
+				/>
+				<EventRoute
+					v-model="form.route"
+					:event="eventId"
+					:saved="event.data.route"
+					class="shrink-0"
+				/>
+			</div>
+			<!-- Ghost variant: no border, so it reads as a subtitle under the name. -->
+			<Textarea
+				v-model="form.short_description"
+				variant="ghost"
+				:rows="2"
+				aria-label="Short description"
+				placeholder="Add a small description"
+				class="!border-0 resize-none px-0 text-ink-gray-6 bg-transparent"
+			/>
+		</div>
+
+		<div class="grid gap-8 md:grid-cols-5">
+			<section class="space-y-3 md:col-span-3">
+				<h2 class="text-sm font-medium uppercase tracking-wide text-ink-gray-5">About</h2>
+				<!-- Editor is renderless, so EditorContent's root is the ProseMirror element
+					 itself: the height and scrolling land on the editable area rather than on a
+					 wrapper, and the whole box takes a click. -->
+				<div class="rounded-lg border border-outline-gray-2 p-3">
+					<Editor
+						v-model="form.about"
+						:extensions="[RichTextKit]"
+						placeholder="What is this event about?"
+					>
+						<EditorContent
+							class="prose-sm h-48 max-w-none overflow-y-auto text-ink-gray-8 focus:outline-none"
+						/>
+					</Editor>
+				</div>
+			</section>
+
+			<div class="space-y-8 md:col-span-2">
+				<section class="space-y-3">
+					<h2 class="text-sm font-medium uppercase tracking-wide text-ink-gray-5">
+						When
+					</h2>
+					<EventSchedule
+						v-model:start-date="form.start_date"
+						v-model:start-time="form.start_time"
+						v-model:end-date="form.end_date"
+						v-model:end-time="form.end_time"
+						v-model:time-zone="form.time_zone"
+					/>
+				</section>
+
+				<section class="space-y-3">
+					<h2 class="text-sm font-medium uppercase tracking-wide text-ink-gray-5">
+						Where
+					</h2>
+					<EventMedium
+						v-model:medium="form.medium"
+						v-model:venue="form.venue"
+						v-model:meeting-link="form.meeting_link"
+						:team="event.data.team || ''"
+						:venue-address="event.data.venue?.address"
+					/>
+				</section>
+			</div>
+		</div>
+	</div>
+</template>
diff --git a/dashboard/src/pages/manage/teams/TeamEvents.vue b/dashboard/src/pages/manage/teams/TeamEvents.vue
index 6451a52c..9c6f1094 100644
--- a/dashboard/src/pages/manage/teams/TeamEvents.vue
+++ b/dashboard/src/pages/manage/teams/TeamEvents.vue
@@ -34,9 +34,10 @@ const months = computed(() =>
 		:loading="myEvents.loading"
 		:error="myEvents.error"
 	>
-		<!-- Every event here belongs to the team, so a per-card Manage button says nothing. -->
+		<!-- Every event here belongs to the team, so a per-card Manage button says nothing —
+		     the card itself opens the event instead. -->
 		<template #default="{ item }">
-			<EventCard :event="item" :show-manage="false" />
+			<EventCard :event="item" route-to-manage />
 		</template>
 	</TimelineList>
 </template>
diff --git a/dashboard/src/router.ts b/dashboard/src/router.ts
index 7265e670..25340e89 100644
--- a/dashboard/src/router.ts
+++ b/dashboard/src/router.ts
@@ -35,6 +35,19 @@ const routes: RouteRecordRaw[] = [
 				name: "events",
 				component: () => import("@/pages/manage/MyEvents.vue"),
 			},
+			{
+				path: "events/:eventId",
+				redirect: (to) => `/manage/events/${to.params.eventId}/details`,
+			},
+			{
+				path: "events/:eventId/details",
+				name: "event-details",
+				component: () => import("@/pages/manage/events/EventDetails.vue"),
+			},
+			{
+				path: "events/:eventId/:section",
+				component: () => import("@/pages/manage/WorkInProgress.vue"),
+			},
 			{
 				path: "tickets",
 				name: "tickets",
diff --git a/dashboard/src/types.ts b/dashboard/src/types.ts
index 50c99fe7..2c3023a1 100644
--- a/dashboard/src/types.ts
+++ b/dashboard/src/types.ts
@@ -125,6 +125,31 @@ export interface MyEvents {
 	past: MyEvent[]
 }
 
+export interface EventVenueDetail {
+	name: string
+	address: string | null
+}
+
+// buzz.api.events.get_event: one event with everything its manage page edits.
+export interface EventDetail {
+	name: string
+	title: string
+	route: string | null
+	team: string | null
+	start_date: string
+	end_date: string | null
+	start_time: string | null
+	end_time: string | null
+	time_zone: string | null
+	short_description: string | null
+	about: string | null
+	banner_image: string | null
+	medium: string | null
+	venue: EventVenueDetail | null
+	meeting_link: string | null
+	is_published: boolean
+}
+
 // A ticket the user holds, flattened with the context its event carries.
 export interface TicketStub {
 	name: string
diff --git a/e2e/tests/create-event.spec.ts b/e2e/tests/create-event.spec.ts
new file mode 100644
index 00000000..086c2d5e
--- /dev/null
+++ b/e2e/tests/create-event.spec.ts
@@ -0,0 +1,17 @@
+import { expect, test } from "@playwright/test";
+
+// The create page and the event details page share EventBanner, so this is the guard
+// that the extraction did not cost the create form its banner.
+test.describe("Create event", () => {
+	test("offers a banner, a title and a way to save", async ({ page }) => {
+		await page.goto("/b/manage/events");
+		await page.getByRole("link", { name: "Events", exact: true }).click();
+		await page.getByRole("link", { name: "Create Event" }).click();
+
+		await expect(page).toHaveURL(/\/b\/manage\/team\/events\/new$/, { timeout: 15000 });
+		await expect(page.getByRole("button", { name: "Add a banner" })).toBeVisible();
+		await expect(page.getByRole("textbox", { name: "Event title" })).toBeVisible();
+		// Nothing is filled in yet, so the page must not offer to create anything.
+		await expect(page.getByRole("button", { name: "Create event" })).toBeDisabled();
+	});
+});
diff --git a/e2e/tests/manage-event.spec.ts b/e2e/tests/manage-event.spec.ts
new file mode 100644
index 00000000..bc23c91e
--- /dev/null
+++ b/e2e/tests/manage-event.spec.ts
@@ -0,0 +1,194 @@
+import { expect, test } from "@playwright/test";
+import { callMethod, createDoc, ensureTestTeam, getDoc } from "../helpers/frappe";
+
+// Runs under the shared Administrator state, whose team hosts the event seeded by
+// event.setup.ts — the one card guaranteed to carry a Manage button.
+test.describe("Event workspace", () => {
+	test.beforeEach(async ({ page }) => {
+		await page.goto("/b/manage/events");
+		await page.getByRole("link", { name: "Manage" }).first().click();
+	});
+
+	test("opens the event on its details section", async ({ page }) => {
+		await expect(page).toHaveURL(/\/b\/manage\/events\/\d+\/details$/, { timeout: 15000 });
+		// The details page opens on the event's own values, with the section after it
+		// in the trail.
+		await expect(page.getByRole("textbox", { name: "Event title" })).not.toHaveValue("", {
+			timeout: 15000,
+		});
+		await expect(page.getByRole("banner").first()).toContainText("Details");
+	});
+
+	test("saves an edit, offering Save only once something changed", async ({ page }) => {
+		const description = page.getByRole("textbox", { name: "Short description" });
+		await expect(description).toBeVisible({ timeout: 15000 });
+
+		const save = page.getByRole("button", { name: "Save" });
+		await expect(save).toHaveCount(0);
+
+		const text = `Edited at ${Date.now()}`;
+		await description.fill(text);
+		await save.click();
+
+		await expect(page.getByText("Event saved")).toBeVisible();
+		await page.reload();
+		await expect(description).toHaveValue(text, { timeout: 15000 });
+	});
+
+	test("shows the event's public address beside its name", async ({ page }) => {
+		const field = page.getByRole("textbox", { name: "Event route" });
+		await expect(field).toBeVisible({ timeout: 15000 });
+
+		// The host is fixed text; only the part after the slash is editable.
+		const route = await field.inputValue();
+		expect(route).not.toBe("");
+
+		const open = page.getByRole("link", { name: "Open event page" });
+		await expect(open).toHaveAttribute("href", `/b/register/${route}`);
+		await expect(open).toHaveAttribute("target", "_blank");
+		await expect(page.getByRole("button", { name: "Copy" })).toBeVisible();
+	});
+
+	test("swaps the venue for a meeting link when the event turns virtual", async ({ page }) => {
+		const venue = page.getByRole("combobox", { name: "Search venues, or add one" });
+		await expect(venue).toBeVisible({ timeout: 15000 });
+
+		await page.getByRole("button", { name: "Virtual" }).click();
+
+		await expect(venue).toHaveCount(0);
+		const link = page.getByRole("textbox", { name: "Meeting link" });
+		await expect(link).toBeVisible();
+		// Nothing to copy until a link is there.
+		await expect(page.getByRole("button", { name: "Copy meeting link" })).toBeDisabled();
+
+		await page.getByRole("button", { name: "In person" }).click();
+		await expect(venue).toBeVisible();
+	});
+
+	test("swaps the sidebar for the event's own destinations", async ({ page }) => {
+		for (const label of ["Back", "Details", "Attendees", "Talks"]) {
+			await expect(page.getByRole("link", { name: label })).toBeVisible({ timeout: 15000 });
+		}
+		await expect(page.getByRole("link", { name: "My Tickets" })).toHaveCount(0);
+	});
+
+	test("moves between sections", async ({ page }) => {
+		await page.getByRole("link", { name: "Talks" }).click();
+
+		await expect(page).toHaveURL(/\/b\/manage\/events\/\d+\/talks$/);
+		await expect(page.getByText("Work in progress")).toBeVisible();
+	});
+
+	test("leaves the workspace through the back item", async ({ page }) => {
+		await page.getByRole("link", { name: "Back" }).click();
+
+		await expect(page).toHaveURL(/\/b\/manage\/events$/, { timeout: 15000 });
+		await expect(page.getByRole("heading", { name: "Events", level: 1 })).toBeVisible();
+	});
+});
+
+// The shared event has no venue, and a switch has to have one to lose, so this block
+// seeds its own.
+test.describe("Switching an event's medium", () => {
+	let eventId: string;
+
+	test.beforeEach(async ({ page, request }) => {
+		const team = await ensureTestTeam(request);
+		// Event Venue is autonamed by prompt, so the docname is the venue's own name.
+		const venue = `E2E Venue ${Date.now()}`;
+		await createDoc(request, "Event Venue", {
+			__newname: venue,
+			address: "1 Test Street",
+			team,
+		});
+		const event = await callMethod<{ name: string }>(request, "buzz.api.events.create_event", {
+			event: {
+				team,
+				title: `Medium Event ${Date.now()}`,
+				start_date: "2030-01-01",
+				start_time: "09:00:00",
+				end_time: "17:00:00",
+				venue,
+			},
+		});
+		eventId = String(event.name);
+		await page.goto(`/b/manage/events/${eventId}/details`);
+	});
+
+	test("drops the venue when the event turns virtual", async ({ page, request }) => {
+		await expect(page.getByRole("combobox", { name: "Search venues, or add one" })).toBeVisible({
+			timeout: 15000,
+		});
+
+		await page.getByRole("button", { name: "Virtual" }).click();
+		await page.getByRole("button", { name: "Save" }).click();
+		await expect(page.getByText("Event saved")).toBeVisible();
+
+		// The calendar invite and the booking page read the venue whatever the medium is,
+		// so it has to be gone from the record, not just from the form.
+		const saved = await getDoc<{ medium: string; venue: string | null }>(
+			request,
+			"Buzz Event",
+			eventId
+		);
+		expect(saved.medium).toBe("Online");
+		expect(saved.venue).toBeFalsy();
+	});
+});
+
+// An event with no route yet has to claim one, so this block seeds its own rather than
+// reusing the shared event, which already has one.
+test.describe("Claiming a route", () => {
+	let eventId: string;
+
+	test.beforeEach(async ({ page, request }) => {
+		const team = await ensureTestTeam(request);
+		// Through the app's own endpoint: it fills the category and host that a bare
+		// insert would be missing.
+		const event = await callMethod<{ name: string }>(request, "buzz.api.events.create_event", {
+			event: {
+				team,
+				title: `Routeless Event ${Date.now()}`,
+				start_date: "2030-01-01",
+				start_time: "09:00:00",
+				end_time: "17:00:00",
+			},
+		});
+		eventId = String(event.name);
+		await page.goto(`/b/manage/events/${eventId}/details`);
+	});
+
+	test("reports whether a typed route is free", async ({ page }) => {
+		const field = page.getByRole("textbox", { name: "Event route" });
+		await expect(field).toBeVisible({ timeout: 15000 });
+
+		await field.fill(`free-route-${Date.now()}`);
+		await expect(page.getByText("This route is available.")).toBeVisible();
+
+		// The shared event already answers to this one.
+		await field.fill("test-event-e2e");
+		await expect(page.getByText("This route is already taken.")).toBeVisible();
+
+		// Reserved so an event cannot shadow /b/account.
+		await field.fill("account");
+		await expect(page.getByText("reserved")).toBeVisible();
+	});
+});
+
+// A team's own events are all manageable, so those cards drop the button and become
+// the link themselves.
+test.describe("Team events card", () => {
+	test("opens the workspace on click, with no Manage button of its own", async ({ page }) => {
+		await page.goto("/b/manage/events");
+		await page.getByRole("link", { name: "Events", exact: true }).click();
+		await expect(page).toHaveURL(/\/b\/manage\/team\/events$/, { timeout: 15000 });
+
+		// Keyed on the href, not a title: which events the team owns varies by site.
+		const card = page.locator('a[href^="/b/manage/events/"]').first();
+		await expect(card).toBeVisible({ timeout: 15000 });
+		await expect(page.getByRole("link", { name: "Manage" })).toHaveCount(0);
+		await card.click();
+
+		await expect(page).toHaveURL(/\/b\/manage\/events\/\d+\/details$/);
+	});
+});