diff --git a/src/app/admin/events/page.tsx b/src/app/admin/events/page.tsx
index 47d7144..83bfda3 100644
--- a/src/app/admin/events/page.tsx
+++ b/src/app/admin/events/page.tsx
@@ -1,7 +1,7 @@
 "use client";
 
-import { useState } from "react";
-import { FilePlus2 } from "lucide-react";
+import { useEffect, useState } from "react";
+import { Award, FilePlus2, Pencil, Trash2, Undo2 } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
 import { SectionCard } from "@/components/admin/section-card";
@@ -10,7 +10,22 @@ import {
   adminButtonClass,
   adminInputClass,
 } from "@/components/admin/admin-field";
+import {
+  BadgeFormDialog,
+  type BadgeDraft,
+} from "@/components/admin/badge-form-dialog";
 import { useAdmin } from "@/components/admin/use-admin";
+import type { Badge } from "@/lib/schemas/badge";
+import BadgesService from "@/services/badges/badges-service";
+
+/** Fills the badge form from a saved badge, for editing. */
+const draftFromBadge = (badge: Badge): BadgeDraft => ({
+  name: badge.name,
+  description: badge.description,
+  criteria: badge.criteria,
+  imageFile: null,
+  imagePreviewUrl: badge.imageurl,
+});
 
 const formatDateString = (value?: string | null) =>
   value ? new Date(value).toLocaleString() : "N/A";
@@ -41,9 +56,50 @@ export default function AdminEventsPage() {
   const [imageFile, setImageFile] = useState<File | null>(null);
   const [imagePreviewUrl, setImagePreviewUrl] = useState<string | null>(null);
   const [imageUrl, setImageUrl] = useState<string | null>(null);
-  const [imageUploading, setImageUploading] = useState(false);
-  const [imageError, setImageError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
   const [editingId, setEditingId] = useState<string | null>(null);
+  // The badge only exists here until the event is saved; the server then
+  // creates the event and badge together, or neither.
+  const [badgeDraft, setBadgeDraft] = useState<BadgeDraft | null>(null);
+  const [badgeDialogOpen, setBadgeDialogOpen] = useState(false);
+  // Badges linked to an event, keyed by event id. badges.eventid is unique, so
+  // an event has at most one.
+  const [eventBadges, setEventBadges] = useState<Record<string, Badge>>({});
+  const [badgesError, setBadgesError] = useState<string | null>(null);
+  // The badge the event being edited already has, as saved.
+  const [existingBadge, setExistingBadge] = useState<Badge | null>(null);
+  // Set when the admin removes the existing badge: on save it is deleted,
+  // along with every member's award of it.
+  const [removeBadge, setRemoveBadge] = useState(false);
+
+  // Badges are public, so they are read directly rather than through an
+  // admin route. Reloaded whenever the event list is, i.e. after every save.
+  useEffect(() => {
+    let cancelled = false;
+
+    new BadgesService()
+      .getAllBadges()
+      .then((badges) => {
+        if (cancelled) return;
+
+        const byEvent: Record<string, Badge> = {};
+        for (const badge of badges) {
+          if (badge.eventid) byEvent[badge.eventid] = badge;
+        }
+        setEventBadges(byEvent);
+        setBadgesError(null);
+      })
+      .catch((error) => {
+        console.error("Failed to load badges", error);
+        if (!cancelled) {
+          setBadgesError("Couldn't load existing badges. Refresh before editing one.");
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [events]);
 
   /** Clears every event field and leaves edit mode. Backs the Reset button. */
   const resetForm = () => {
@@ -60,69 +116,45 @@ export default function AdminEventsPage() {
     setImageFile(null);
     setImagePreviewUrl(null);
     setImageUrl(null);
-    setImageError(null);
-  };
-
-  const uploadImage = async (): Promise<{
-    event_path: string;
-    event_url: string;
-  } | null> => {
-    if (!imageFile) return null;
-    setImageError(null);
-    setImageUploading(true);
-
-    try {
-      const formData = new FormData();
-      formData.append("image", imageFile);
-
-      const res = await adminFetch("/api/admin/events/image", {
-        method: "POST",
-        body: formData,
-      });
-
-      if (!res.ok) {
-        const err = await res.json().catch(() => ({ error: "Unknown error" }));
-        throw new Error(err.error || "Failed to upload image");
-      }
-
-      return await res.json();
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      setImageError(message || "Image upload failed");
-      return null;
-    } finally {
-      setImageUploading(false);
-    }
+    setBadgeDraft(null);
+    setExistingBadge(null);
+    setRemoveBadge(false);
   };
 
   const createEvent = async () => {
+    setSaving(true);
     try {
-      let uploadedImage: { event_path: string; event_url: string } | null =
-        null;
-      if (imageFile) {
-        uploadedImage = await uploadImage();
-        if (!uploadedImage) {
-          throw new Error("Unable to upload image before saving event");
-        }
-      }
-
-      const payload: Record<string, unknown> = {
+      const event: Record<string, unknown> = {
         title,
         description,
         location: location.trim() || null,
         capacity: capacity.trim() ? Number(capacity) : null,
         start_time: startTime ? new Date(startTime).toISOString() : null,
         end_time: endTime ? new Date(endTime).toISOString() : null,
-        event_url: uploadedImage?.event_url ?? imageUrl,
-        event_path: uploadedImage?.event_path ?? undefined,
+        // Keeps the current image when no new file is chosen. A new file is
+        // sent as event_image below and replaces both URL and path.
+        event_url: imageUrl,
       };
 
-      if (editingId) payload.id = editingId;
+      if (editingId) event.id = editingId;
 
       if (checkInOpen)
-        payload.check_in_open_time = new Date(checkInOpen).toISOString();
+        event.check_in_open_time = new Date(checkInOpen).toISOString();
       if (checkInClose)
-        payload.check_in_close_time = new Date(checkInClose).toISOString();
+        event.check_in_close_time = new Date(checkInClose).toISOString();
+
+      const payload: Record<string, unknown> = { event };
+
+      if (removeBadge) {
+        payload.remove_badge = true;
+      } else if (badgeDraft) {
+        // Creates the event's badge, or updates the one it already has.
+        payload.badge = {
+          name: badgeDraft.name,
+          description: badgeDraft.description,
+          criteria: badgeDraft.criteria,
+        };
+      }
 
       const assigned = assignedEmailsText
         .split(",")
@@ -130,9 +162,17 @@ export default function AdminEventsPage() {
         .filter(Boolean);
       if (assigned.length) payload.assignedEmails = assigned;
 
+      // One request carries the event, the badge and both images, so the
+      // server can save all of it or none of it.
+      const formData = new FormData();
+      formData.append("payload", JSON.stringify(payload));
+      if (imageFile) formData.append("event_image", imageFile);
+      if (badgeDraft?.imageFile)
+        formData.append("badge_image", badgeDraft.imageFile);
+
       const res = await adminFetch("/api/admin/events", {
         method: "PUT",
-        body: JSON.stringify(payload),
+        body: formData,
       });
 
       if (!res.ok) {
@@ -146,13 +186,22 @@ export default function AdminEventsPage() {
       fetchData();
       alert(wasEditing ? "Event saved" : "Event created");
     } catch (err: unknown) {
+      // The form is left as it was, badge included, so the admin can fix the
+      // problem and try again. Nothing was saved.
       const message = err instanceof Error ? err.message : String(err);
       alert(message || "Failed to create event");
+    } finally {
+      setSaving(false);
     }
   };
 
   const handleDeleteEvent = async (eventId: string) => {
-    if (!confirm("Are you sure you want to delete this event?")) return;
+    const badge = eventBadges[eventId];
+    const message = badge
+      ? `Are you sure you want to delete this event? Its badge "${badge.name}" will also be deleted, and every member who earned it will lose it.`
+      : "Are you sure you want to delete this event?";
+
+    if (!confirm(message)) return;
 
     try {
       const res = await adminFetch("/api/admin/events", {
@@ -262,61 +311,149 @@ export default function AdminEventsPage() {
             />
           </AdminField>
 
-          <div>
-            <span className="block text-sm font-bold text-black dark:text-white">
-              Event Image
-            </span>
-            {/* Native input is hidden; the label is the visible button. */}
-            <label
-              className={`${adminButtonClass} mt-2 inline-flex h-10 cursor-pointer items-center gap-2 px-4 text-sm`}
-            >
-              <FilePlus2 className="size-4" />
-              {imageFile ? "Change File" : "Add File"}
-              <input
-                type="file"
-                accept="image/*"
-                className="sr-only"
-                onChange={(e) => {
-                  const file = e.target.files?.[0] ?? null;
-                  setImageFile(file);
-                  setImageError(null);
-
-                  if (file) {
-                    setImagePreviewUrl(URL.createObjectURL(file));
-                  } else {
-                    setImagePreviewUrl(imageUrl);
-                  }
-                }}
-              />
-            </label>
-
-            {imagePreviewUrl && (
-              <img
-                src={imagePreviewUrl}
-                alt="Event preview"
-                className="mt-3 h-40 w-full rounded-xl object-cover"
-              />
-            )}
-            {imageError && (
-              <p className="mt-2 text-sm font-medium text-red-700 dark:text-red-200">
-                {imageError}
-              </p>
-            )}
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div>
+              <span className="block text-sm font-bold text-black dark:text-white">
+                Event Image
+              </span>
+              {/* Native input is hidden; the label is the visible button. */}
+              <label
+                className={`${adminButtonClass} mt-2 inline-flex h-10 cursor-pointer items-center gap-2 px-4 text-sm`}
+              >
+                <FilePlus2 className="size-4" />
+                {imageFile ? "Change File" : "Add File"}
+                <input
+                  type="file"
+                  accept="image/*"
+                  className="sr-only"
+                  onChange={(e) => {
+                    const file = e.target.files?.[0] ?? null;
+                    setImageFile(file);
+
+                    if (file) {
+                      setImagePreviewUrl(URL.createObjectURL(file));
+                    } else {
+                      setImagePreviewUrl(imageUrl);
+                    }
+                  }}
+                />
+              </label>
+
+              {imagePreviewUrl && (
+                <img
+                  src={imagePreviewUrl}
+                  alt="Event preview"
+                  className="mt-3 h-40 w-full rounded-xl object-cover"
+                />
+              )}
+            </div>
+
+            <div>
+              <span className="block text-sm font-bold text-black dark:text-white">
+                Event Badge (optional)
+              </span>
+
+              {badgeDraft ? (
+                <div className="mt-2 flex flex-col items-start gap-3">
+                  <div className="flex items-center gap-3">
+                    <div className="flex size-16 shrink-0 items-center justify-center overflow-hidden rounded-full bg-[#DAF2FB] dark:bg-[#3F58AA]">
+                      {badgeDraft.imagePreviewUrl ? (
+                        <img
+                          src={badgeDraft.imagePreviewUrl}
+                          alt={`${badgeDraft.name} badge`}
+                          className="h-full w-full object-cover"
+                        />
+                      ) : (
+                        <Award className="size-7 text-web3" />
+                      )}
+                    </div>
+                    <p className="font-bold break-words text-black dark:text-white">
+                      {badgeDraft.name}
+                    </p>
+                  </div>
+
+                  <div className="flex gap-2">
+                    <Button
+                      size="sm"
+                      className={`${adminButtonClass} h-9 gap-1.5 px-3 text-sm`}
+                      onClick={() => setBadgeDialogOpen(true)}
+                    >
+                      <Pencil className="size-3.5" />
+                      Edit
+                    </Button>
+                    <Button
+                      size="sm"
+                      className={`${adminButtonClass} h-9 gap-1.5 px-3 text-sm !bg-[#DAF2FB]/60 dark:!bg-[#405084]/60`}
+                      onClick={() => {
+                        setBadgeDraft(null);
+                        // A saved badge is deleted on save; an unsaved one
+                        // simply goes away.
+                        if (existingBadge) setRemoveBadge(true);
+                      }}
+                    >
+                      <Trash2 className="size-3.5" />
+                      Remove
+                    </Button>
+                  </div>
+                </div>
+              ) : removeBadge && existingBadge ? (
+                // Removing and adding a new badge can't happen in one save, so
+                // Add Badge waits until this one has been saved.
+                <div className="mt-2 flex flex-col items-start gap-3">
+                  <p className="text-sm font-medium text-red-700 dark:text-red-200">
+                    &ldquo;{existingBadge.name}&rdquo; will be deleted when you
+                    save, and every member who earned it will lose it.
+                  </p>
+                  <Button
+                    size="sm"
+                    className={`${adminButtonClass} h-9 gap-1.5 px-3 text-sm`}
+                    onClick={() => {
+                      setRemoveBadge(false);
+                      setBadgeDraft(draftFromBadge(existingBadge));
+                    }}
+                  >
+                    <Undo2 className="size-3.5" />
+                    Undo
+                  </Button>
+                </div>
+              ) : (
+                <Button
+                  className={`${adminButtonClass} mt-2 h-10 gap-2 px-4 text-sm`}
+                  onClick={() => setBadgeDialogOpen(true)}
+                >
+                  <Award className="size-4" />
+                  Add Badge
+                </Button>
+              )}
+
+              {badgesError && (
+                <p className="mt-2 text-sm font-medium text-red-700 dark:text-red-200">
+                  {badgesError}
+                </p>
+              )}
+            </div>
           </div>
         </div>
       </div>
 
+      {badgeDialogOpen && (
+        <BadgeFormDialog
+          initial={badgeDraft}
+          onSave={(draft) => {
+            setBadgeDraft(draft);
+            setBadgeDialogOpen(false);
+          }}
+          onCancel={() => setBadgeDialogOpen(false)}
+        />
+      )}
+
       <div className="mt-6 flex flex-wrap items-center gap-3">
         <Button
           onClick={createEvent}
-          disabled={imageUploading}
+          disabled={saving}
           className={adminButtonClass}
         >
-          {imageUploading
-            ? "Uploading..."
-            : editingId
-              ? "Save Event"
-              : "Create Event"}
+          {saving ? "Saving..." : editingId ? "Save Event" : "Create Event"}
         </Button>
         <Button
           onClick={resetForm}
@@ -386,6 +523,14 @@ export default function AdminEventsPage() {
                     );
                     setImageUrl(ev.event_url || null);
                     setImagePreviewUrl(ev.event_url || null);
+                    // Load this event's saved badge, if any, replacing any
+                    // draft left over from another event.
+                    const savedBadge = eventBadges[ev.id] ?? null;
+                    setExistingBadge(savedBadge);
+                    setBadgeDraft(
+                      savedBadge ? draftFromBadge(savedBadge) : null,
+                    );
+                    setRemoveBadge(false);
                     window.scrollTo({ top: 0, behavior: "smooth" });
                   }}
                 >
diff --git a/src/app/api/admin/events/image/route.ts b/src/app/api/admin/badges/image/route.ts
similarity index 57%
rename from src/app/api/admin/events/image/route.ts
rename to src/app/api/admin/badges/image/route.ts
index 469d8b1..29b2632 100644
--- a/src/app/api/admin/events/image/route.ts
+++ b/src/app/api/admin/badges/image/route.ts
@@ -1,7 +1,8 @@
 import { NextRequest, NextResponse } from "next/server";
-import { EventService } from "@/services/event-service";
-import { isAllowedAdminAddress } from "@/lib/admin-auth";
 import { verifyMessage } from "viem";
+import { isAllowedAdminAddress } from "@/lib/admin-auth";
+import BadgesService from "@/services/badges/badges-service";
+import { getSupabaseAdmin } from "@/services/supabase-admin";
 
 async function verifyAdminAuth(req: NextRequest) {
   const address = req.headers.get("x-admin-address")?.toLowerCase();
@@ -26,6 +27,7 @@ async function verifyAdminAuth(req: NextRequest) {
   }
 }
 
+// POST - upload a badge image, returning the public URL to save as imageurl
 export async function POST(req: NextRequest) {
   const isAuth = await verifyAdminAuth(req);
   if (!isAuth)
@@ -33,23 +35,36 @@ export async function POST(req: NextRequest) {
 
   try {
     const formData = await req.formData();
-    const file = formData.get("image") as File | null;
+    const file = formData.get("image");
 
-    if (!file) {
+    if (!(file instanceof File)) {
       return NextResponse.json(
         { error: "Missing image file" },
         { status: 400 },
       );
     }
 
-    const uploaded = await EventService.uploadEventImage(file);
+    // Unlike the events bucket, the badges bucket has no MIME restriction of
+    // its own, so this is the only thing keeping non-images out of it.
+    if (!file.type.startsWith("image/")) {
+      return NextResponse.json(
+        { error: "Badge image must be an image file" },
+        { status: 400 },
+      );
+    }
+
+    const uploaded = await new BadgesService(
+      getSupabaseAdmin(),
+    ).uploadBadgeImage(file);
+
     return NextResponse.json({
-      event_path: uploaded.imagePath,
-      event_url: uploaded.imageUrl,
+      image_path: uploaded.imagePath,
+      imageurl: uploaded.imageUrl,
     });
-  } catch (err: any) {
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
     return NextResponse.json(
-      { error: err.message || "Image upload failed" },
+      { error: message || "Image upload failed" },
       { status: 500 },
     );
   }
diff --git a/src/app/api/admin/badges/route.ts b/src/app/api/admin/badges/route.ts
new file mode 100644
index 0000000..00e68c6
--- /dev/null
+++ b/src/app/api/admin/badges/route.ts
@@ -0,0 +1,70 @@
+import { NextRequest, NextResponse } from "next/server";
+import { verifyMessage } from "viem";
+import { z } from "zod";
+import { isAllowedAdminAddress } from "@/lib/admin-auth";
+import BadgesService from "@/services/badges/badges-service";
+import { getSupabaseAdmin } from "@/services/supabase-admin";
+
+// Postgres errors caused by the request's data rather than the server:
+// foreign key (e.g. an eventid with no matching event) and check constraints.
+const CLIENT_ERROR_CODES = new Set(["23503", "23514"]);
+
+async function verifyAdminAuth(req: NextRequest) {
+  const address = req.headers.get("x-admin-address")?.toLowerCase();
+  const signature = req.headers.get("x-admin-signature");
+  const timestamp = req.headers.get("x-admin-timestamp");
+
+  if (!address || !signature || !timestamp || !isAllowedAdminAddress(address))
+    return false;
+
+  const now = Date.now();
+  if (now - parseInt(timestamp) > 5 * 60 * 1000) return false;
+
+  try {
+    const valid = await verifyMessage({
+      address: address as `0x${string}`,
+      message: `Admin Auth ${timestamp}`,
+      signature: signature as `0x${string}`,
+    });
+    return valid;
+  } catch {
+    return false;
+  }
+}
+
+// POST - create a badge. The body is validated by badgeInsertSchema, which
+// also enforces that an EVENT badge carries an eventid.
+export async function POST(req: NextRequest) {
+  const isAuth = await verifyAdminAuth(req);
+  if (!isAuth)
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+
+  try {
+    const body = await req.json().catch(() => null);
+    if (!body || typeof body !== "object") {
+      return NextResponse.json(
+        { error: "Request body must be a JSON object" },
+        { status: 400 },
+      );
+    }
+
+    const badge = await new BadgesService(getSupabaseAdmin()).createBadge(body);
+    return NextResponse.json({ badge });
+  } catch (err: unknown) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: err.issues.map((issue) => issue.message).join("; ") },
+        { status: 400 },
+      );
+    }
+
+    const code = (err as { code?: string } | null)?.code;
+    const message =
+      (err as { message?: string } | null)?.message || "Failed to create badge";
+
+    return NextResponse.json(
+      { error: message },
+      { status: code && CLIENT_ERROR_CODES.has(code) ? 400 : 500 },
+    );
+  }
+}
diff --git a/src/app/api/admin/events/route.ts b/src/app/api/admin/events/route.ts
index f0607bb..981e72f 100644
--- a/src/app/api/admin/events/route.ts
+++ b/src/app/api/admin/events/route.ts
@@ -2,7 +2,11 @@ import { NextRequest, NextResponse } from "next/server";
 import { getSupabase } from "@/services/supabase";
 import { RegistrationService } from "@/services/registrations/registrations-service";
 import { verifyMessage } from "viem";
+import { z } from "zod";
 import { isAllowedAdminAddress } from "@/lib/admin-auth";
+import type { ClubEvent } from "@/lib/events";
+import { eventBadgeSchema } from "@/lib/schemas/badge";
+import { EventService } from "@/services/event-service";
 import { getSupabaseAdmin } from "@/services/supabase-admin";
 
 async function verifyAdminAuth(req: NextRequest) {
@@ -56,14 +60,103 @@ export async function GET(req: NextRequest) {
   }
 }
 
-// PUT - create or update event
+// Postgres errors caused by the request's data rather than the server: bad
+// parameter, invalid text/datetime representation, datetime out of range,
+// not-null, foreign key, unique and check violations.
+const CLIENT_ERROR_CODES = new Set([
+  "22023",
+  "22P02",
+  "22007",
+  "22008",
+  "23502",
+  "23503",
+  "23505",
+  "23514",
+]);
+
+class BadRequestError extends Error {}
+
+/** Returns the named form field as an image file, or null if it's absent. */
+function imageField(formData: FormData, name: string): File | null {
+  const value = formData.get(name);
+  if (value === null || value === "") return null;
+
+  if (!(value instanceof File) || !value.type.startsWith("image/")) {
+    throw new BadRequestError(`${name} must be an image file`);
+  }
+  return value;
+}
+
+/**
+ * Reads the request in either of the two shapes it may take:
+ *
+ * - multipart/form-data: a `payload` field holding JSON
+ *   `{ event, badge?, remove_badge?, assignedEmails? }`, plus optional
+ *   `event_image` and `badge_image` files. Used by the admin event form.
+ * - JSON: the flat event fields plus `assignedEmails`, as sent before badges
+ *   existed. It has no badge or image upload support.
+ */
+async function readSaveRequest(req: NextRequest) {
+  const contentType = req.headers.get("content-type") ?? "";
+
+  if (contentType.includes("multipart/form-data")) {
+    const formData = await req.formData();
+    const payload = formData.get("payload");
+
+    if (typeof payload !== "string") {
+      throw new BadRequestError("Missing payload field");
+    }
+
+    let body: unknown;
+    try {
+      body = JSON.parse(payload);
+    } catch {
+      throw new BadRequestError("payload must be valid JSON");
+    }
+
+    if (!body || typeof body !== "object") {
+      throw new BadRequestError("payload must be a JSON object");
+    }
+
+    const { event, badge, remove_badge, assignedEmails } = body as Record<
+      string,
+      unknown
+    >;
+
+    return {
+      event,
+      badge,
+      removeBadge: remove_badge === true,
+      assignedEmails,
+      eventImage: imageField(formData, "event_image"),
+      badgeImage: imageField(formData, "badge_image"),
+    };
+  }
+
+  const json = await req.json().catch(() => null);
+  if (!json || typeof json !== "object") {
+    throw new BadRequestError("Request body must be a JSON object");
+  }
+
+  const { assignedEmails, ...event } = json as Record<string, unknown>;
+  return {
+    event,
+    badge: null,
+    removeBadge: false,
+    assignedEmails,
+    eventImage: null,
+    badgeImage: null,
+  };
+}
+
+// PUT - create or update an event, and optionally its badge, all or nothing
 export async function PUT(req: NextRequest) {
   const isAuth = await verifyAdminAuth(req);
   if (!isAuth)
     return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
 
   try {
-    const body = await req.json();
+    const request = await readSaveRequest(req);
     const {
       id,
       title,
@@ -76,88 +169,68 @@ export async function PUT(req: NextRequest) {
       event_url,
       location,
       capacity,
-    } = body || {};
+    } = (request.event || {}) as Partial<ClubEvent>;
 
     if (!title || !start_time || !end_time) {
-      return NextResponse.json(
-        { error: "Missing required fields: title, start_time, end_time" },
-        { status: 400 },
+      throw new BadRequestError(
+        "Missing required fields: title, start_time, end_time",
       );
     }
 
     // Basic validation: end_time > start_time
     if (new Date(end_time) <= new Date(start_time)) {
-      return NextResponse.json(
-        { error: "end_time must be after start_time" },
-        { status: 400 },
-      );
+      throw new BadRequestError("end_time must be after start_time");
     }
 
     if (check_in_open_time && check_in_close_time) {
       if (new Date(check_in_close_time) <= new Date(check_in_open_time)) {
-        return NextResponse.json(
-          { error: "check_in_close_time must be after check_in_open_time" },
-          { status: 400 },
+        throw new BadRequestError(
+          "check_in_close_time must be after check_in_open_time",
         );
       }
     }
 
-    const supabase = getSupabase();
+    // category, eventid and imageurl are stripped here: the database function
+    // sets the first two, and imageurl only ever comes from badge_image.
+    const badge =
+      request.badge == null ? null : eventBadgeSchema.parse(request.badge);
 
-    if (id) {
-      const updatePayload: any = {
+    if (badge && request.removeBadge) {
+      throw new BadRequestError(
+        "Cannot save a badge and remove it in the same request",
+      );
+    }
+
+    if (request.badgeImage && !badge) {
+      throw new BadRequestError("badge_image was sent without a badge");
+    }
+
+    const saved = await EventService.saveEventWithBadge(getSupabaseAdmin(), {
+      // An update leaves out the columns that are undefined here, so they keep
+      // their current values.
+      event: {
+        id,
         title,
         description,
         start_time,
         end_time,
         check_in_open_time,
         check_in_close_time,
-      };
-      if (event_path !== undefined) updatePayload.event_path = event_path;
-      if (event_url !== undefined) updatePayload.event_url = event_url;
-      if (location !== undefined) updatePayload.location = location;
-      if (capacity !== undefined) updatePayload.capacity = capacity;
-
-      const { data, error } = await supabase
-        .from("events")
-        .update(updatePayload)
-        .eq("id", id)
-        .select()
-        .single();
-
-      if (error)
-        return NextResponse.json({ error: error.message }, { status: 500 });
-
-      return NextResponse.json({ event: data });
-    }
-
-    // create
-    const insertPayload: any = {
-      title,
-      description,
-      start_time,
-      end_time,
-      check_in_open_time,
-      check_in_close_time,
-    };
-    if (event_path !== undefined) insertPayload.event_path = event_path;
-    if (event_url !== undefined) insertPayload.event_url = event_url;
-    if (location !== undefined) insertPayload.location = location;
-    if (capacity !== undefined) insertPayload.capacity = capacity;
-
-    const { data, error } = await supabase
-      .from("events")
-      .insert([insertPayload])
-      .select()
-      .single();
-
-    if (error)
-      return NextResponse.json({ error: error.message }, { status: 500 });
+        event_path,
+        event_url,
+        location,
+        capacity,
+      },
+      badge,
+      removeBadge: request.removeBadge,
+      eventImage: request.eventImage,
+      badgeImage: request.badgeImage,
+    });
 
-    // If the request included assignedEmails, add the event name to each
-    // user's `events_attended` list (if that registration exists).
-    const assignedEmails: string[] | undefined = body?.assignedEmails;
-    if (assignedEmails && Array.isArray(assignedEmails) && data) {
+    // On create, add the event name to each assigned user's `events_attended`
+    // list (if that registration exists).
+    const assignedEmails = request.assignedEmails;
+    if (!id && assignedEmails && Array.isArray(assignedEmails)) {
       const eventName = title;
       for (const email of assignedEmails) {
         try {
@@ -169,16 +242,36 @@ export async function PUT(req: NextRequest) {
       }
     }
 
-    return NextResponse.json({ event: data });
-  } catch (err: any) {
-    return NextResponse.json(
-      { error: err.message || "Failed" },
-      { status: 500 },
-    );
+    return NextResponse.json(saved);
+  } catch (err: unknown) {
+    if (err instanceof BadRequestError) {
+      return NextResponse.json({ error: err.message }, { status: 400 });
+    }
+
+    if (err instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: err.issues.map((issue) => issue.message).join("; ") },
+        { status: 400 },
+      );
+    }
+
+    const code = (err as { code?: string } | null)?.code;
+    const message =
+      (err as { message?: string } | null)?.message || "Failed to save event";
+
+    const status =
+      code === "P0002"
+        ? 404
+        : code && CLIENT_ERROR_CODES.has(code)
+          ? 400
+          : 500;
+
+    return NextResponse.json({ error: message }, { status });
   }
 }
 
-// DELETE - delete event by id
+// DELETE - delete event by id, along with its badge (ON DELETE CASCADE), every
+// member's award of that badge, and both image files.
 export async function DELETE(req: NextRequest) {
   const isAuth = await verifyAdminAuth(req);
   if (!isAuth)
@@ -196,22 +289,18 @@ export async function DELETE(req: NextRequest) {
 
     if (!id) return NextResponse.json({ error: "Missing id" }, { status: 400 });
 
-    const supabase = getSupabase();
-    const { data, error } = await supabase
-      .from("events")
-      .delete()
-      .eq("id", id)
-      .select()
-      .single();
+    const event = await EventService.deleteEvent(getSupabaseAdmin(), id);
 
-    if (error)
-      return NextResponse.json({ error: error.message }, { status: 500 });
+    return NextResponse.json({ event });
+  } catch (err: unknown) {
+    const code = (err as { code?: string } | null)?.code;
+    const message =
+      (err as { message?: string } | null)?.message || "Failed to delete event";
 
-    return NextResponse.json({ event: data });
-  } catch (err: any) {
-    return NextResponse.json(
-      { error: err.message || "Failed" },
-      { status: 500 },
-    );
+    // PGRST116: .single() matched no row, i.e. there is no event with that id.
+    // 22P02: the id isn't a valid uuid.
+    const status = code === "PGRST116" ? 404 : code === "22P02" ? 400 : 500;
+
+    return NextResponse.json({ error: message }, { status });
   }
 }
diff --git a/src/app/profile/[id]/page.tsx b/src/app/profile/[id]/page.tsx
index c8a478c..5fe6efe 100644
--- a/src/app/profile/[id]/page.tsx
+++ b/src/app/profile/[id]/page.tsx
@@ -6,11 +6,15 @@ import {
   PublicProfilesService,
   type PublicProfile,
 } from "@/services/public-profiles-service";
+import MemberBadgesService from "@/services/member-badges/member-badges-service";
+import type { PublicMemberBadge } from "@/lib/schemas/member-badge";
+import { BadgeCard } from "@/components/badge-card";
 import { AttendedEvents } from "@/components/attended-events";
 
 export default function PublicProfilePage() {
   const { id } = useParams<{ id: string }>();
   const [profile, setProfile] = useState<PublicProfile | null>(null);
+  const [badges, setBadges] = useState<PublicMemberBadge[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
@@ -31,6 +35,22 @@ export default function PublicProfilePage() {
             setError("This public profile could not be found.");
           }
         }
+
+        // member_badges is keyed on registrations.id, which anon can't read,
+        // so the badges are looked up by the public profile's id instead.
+        // Fetched separately so a badge failure still leaves the profile
+        // readable.
+        if (publicProfile) {
+          try {
+            const awards =
+              await new MemberBadgesService().getBadgesForPublicProfile(
+                publicProfile.id,
+              );
+            if (!cancelled) setBadges(awards);
+          } catch (badgeError) {
+            console.error("Unable to load badges", badgeError);
+          }
+        }
       } catch (profileError) {
         console.error("Unable to load public profile", profileError);
 
@@ -109,22 +129,15 @@ export default function PublicProfilePage() {
         </div>
       </div>
 
-      <div className="flex flex-col gap-10 w-full max-w-[90vw] lg:flex-row lg:justify-center lg:items-end lg:gap-16">
-        <div className="bg-white/80 w-full lg:w-[42vw] p-8 rounded-2xl min-h-[44vh] lg:min-h-[34vh] lg:mt-10 shadow-lg dark:bg-[#404246]/85 dark:shadow-black/20">
+      <div className="flex flex-col gap-10 w-full max-w-[90vw] lg:flex-row lg:justify-center lg:items-start lg:gap-16">
+        <div className="bg-white/80 w-full lg:w-[42vw] p-8 rounded-2xl min-h-[44vh] lg:min-h-[34vh] shadow-lg dark:bg-[#404246]/85 dark:shadow-black/20">
           <p className="text-2xl font-bold">Badges</p>
 
           <div className="mt-8">
-            {profile.badges.length > 0 ? (
+            {badges.length > 0 ? (
               <div className="grid grid-cols-3 gap-4 sm:gap-6 justify-items-center">
-                {profile.badges.map((badge, index) => (
-                  <div
-                    key={`${badge}-${index}`}
-                    className="w-full min-h-[5rem] rounded-3xl border border-primary/20 bg-primary/5 p-3 flex items-center justify-center text-center dark:border-[#A3DEF4]/25 dark:bg-white/10"
-                  >
-                    <span className="text-sm font-semibold text-primary dark:text-[#A3DEF4]">
-                      {badge}
-                    </span>
-                  </div>
+                {badges.map((award) => (
+                  <BadgeCard key={award.id} award={award} />
                 ))}
               </div>
             ) : (
diff --git a/src/app/profile/page.tsx b/src/app/profile/page.tsx
index 84a1136..acfc43c 100644
--- a/src/app/profile/page.tsx
+++ b/src/app/profile/page.tsx
@@ -9,6 +9,9 @@ import { useSignMessage } from "wagmi";
 import { ProfileVisibilityToggle } from "@/components/profile-visibility-toggle";
 import { IoQrCode } from "react-icons/io5";
 import QrCode from "qrcode";
+import MemberBadgesService from "@/services/member-badges/member-badges-service";
+import type { MemberBadgeWithBadge } from "@/lib/schemas/member-badge";
+import { BadgeCard } from "@/components/badge-card";
 import { AttendedEvents } from "@/components/attended-events";
 
 const getErrorMessage = (error: unknown) => {
@@ -30,7 +33,7 @@ export default function ProfilePage() {
   const [displayName, setDisplayName] = useState("Name");
   const [isEditingName, setIsEditingName] = useState(false);
   const [profileImage, setProfileImage] = useState<string | null>(null);
-  const [badges, setBadges] = useState<string[]>([]);
+  const [badges, setBadges] = useState<MemberBadgeWithBadge[]>([]);
   const [eventsAttended, setEventsAttended] = useState<string[]>([]);
   const [profileLoading, setProfileLoading] = useState(true);
   const [walletRegistered, setWalletRegistered] = useState(false);
@@ -157,7 +160,6 @@ export default function ProfilePage() {
         });
 
       setProfileImage(result.profilePictureUrl);
-      setBadges(result.record.badges ?? []);
       setStatusMessage("Profile picture saved.");
     } catch (error) {
       const message = getErrorMessage(error);
@@ -172,6 +174,24 @@ export default function ProfilePage() {
   useEffect(() => {
     let cancelled = false;
 
+    // Badges live in member_badges, keyed on registrations.id. The query embeds
+    // the parent badge, so the image, description and criteria arrive in a
+    // single round trip and the hover panel needs no follow-up request.
+    // Failures are swallowed so a badge outage leaves the profile intact.
+    const fetchBadges = async (memberId: number) => {
+      try {
+        const awards =
+          await new MemberBadgesService().getBadgesForMember(memberId);
+
+        if (!cancelled) {
+          setBadges(awards);
+        }
+      } catch (error) {
+        console.error("Failed to load badges", error);
+        if (!cancelled) setBadges([]);
+      }
+    };
+
     const loadProfile = async () => {
       if (!address) {
         setWalletRegistered(false);
@@ -220,8 +240,8 @@ export default function ProfilePage() {
           const attended = registration.events_attended || [];
           setDisplayName(displayNameFallback || "Name");
           setProfileImage(registration.profile_picture_url || null);
-          setBadges(registration.badges || []);
           setEventsAttended(attended);
+          await fetchBadges(registration.id);
           setProfileVisible(registration.profile_visible ?? true);
         } else {
           setDisplayName("Name");
@@ -279,7 +299,6 @@ export default function ProfilePage() {
 
       setIsEditingName(false);
       setDisplayName(updated.unique_name ?? displayName);
-      setBadges(updated.badges ?? badges);
       setStatusMessage("Display name saved.");
     } catch (error) {
       const message = getErrorMessage(error);
@@ -515,9 +534,9 @@ export default function ProfilePage() {
         </div>
       </div>
 
-      <div className="flex flex-col gap-10 w-full max-w-[90vw] lg:flex-row lg:justify-center lg:items-end lg:gap-16">
+      <div className="flex flex-col gap-10 w-full max-w-[90vw] lg:flex-row lg:justify-center lg:items-start lg:gap-16">
         {/* Badges*/}
-        <div className="bg-white/80 w-full lg:w-[42vw] p-8 rounded-2xl min-h-[44vh] lg:min-h-[34vh] lg:mt-10 shadow-lg dark:bg-[#404246]/85 dark:shadow-black/20">
+        <div className="bg-white/80 w-full lg:w-[42vw] p-8 rounded-2xl min-h-[44vh] lg:min-h-[34vh] shadow-lg dark:bg-[#404246]/85 dark:shadow-black/20">
           <p className="text-2xl font-bold">Badges</p>
 
           <div className="mt-8">
@@ -527,15 +546,8 @@ export default function ProfilePage() {
               </p>
             ) : badges.length > 0 ? (
               <div className="grid grid-cols-3 gap-4 sm:gap-6 justify-items-center">
-                {badges.map((badge, index) => (
-                  <div
-                    key={`${badge}-${index}`}
-                    className="w-full min-h-[5rem] rounded-3xl border border-primary/20 bg-primary/5 p-3 flex items-center justify-center text-center dark:border-[#A3DEF4]/25 dark:bg-white/10"
-                  >
-                    <span className="text-sm font-semibold text-primary dark:text-[#A3DEF4]">
-                      {badge}
-                    </span>
-                  </div>
+                {badges.map((award) => (
+                  <BadgeCard key={award.id} award={award} />
                 ))}
               </div>
             ) : (
diff --git a/src/components/admin/badge-form-dialog.tsx b/src/components/admin/badge-form-dialog.tsx
new file mode 100644
index 0000000..6edea76
--- /dev/null
+++ b/src/components/admin/badge-form-dialog.tsx
@@ -0,0 +1,213 @@
+"use client";
+
+import { useEffect, useId, useState } from "react";
+import { createPortal } from "react-dom";
+import { FilePlus2 } from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import {
+  AdminField,
+  adminButtonClass,
+  adminInputClass,
+} from "@/components/admin/admin-field";
+
+/**
+ * A badge the admin has filled in but not yet saved. It only reaches the
+ * database when the event form is submitted, together with the event.
+ */
+export type BadgeDraft = {
+  name: string;
+  description: string | null;
+  criteria: string | null;
+  /** A newly chosen image, uploaded on submit. */
+  imageFile: File | null;
+  /** What to show in the preview: the chosen file, or the saved image. */
+  imagePreviewUrl: string | null;
+};
+
+type BadgeFormDialogProps = {
+  /** The draft to edit, or null to start a new badge. */
+  initial: BadgeDraft | null;
+  onSave: (draft: BadgeDraft) => void;
+  onCancel: () => void;
+};
+
+export function BadgeFormDialog({
+  initial,
+  onSave,
+  onCancel,
+}: BadgeFormDialogProps) {
+  const titleId = useId();
+  const [isMounted, setIsMounted] = useState(false);
+
+  const [name, setName] = useState(initial?.name ?? "");
+  const [description, setDescription] = useState(initial?.description ?? "");
+  const [criteria, setCriteria] = useState(initial?.criteria ?? "");
+  const [imageFile, setImageFile] = useState<File | null>(
+    initial?.imageFile ?? null,
+  );
+  const [imagePreviewUrl, setImagePreviewUrl] = useState<string | null>(
+    initial?.imagePreviewUrl ?? null,
+  );
+  const [nameError, setNameError] = useState<string | null>(null);
+
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
+
+  useEffect(() => {
+    const handleEscape = (event: KeyboardEvent) => {
+      if (event.key === "Escape") {
+        onCancel();
+      }
+    };
+
+    document.addEventListener("keydown", handleEscape);
+
+    return () => {
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [onCancel]);
+
+  useEffect(() => {
+    document.body.style.overflow = "hidden";
+
+    return () => {
+      document.body.style.overflow = "";
+    };
+  }, []);
+
+  const handleSave = () => {
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+      setNameError("Badge name is required");
+      return;
+    }
+
+    onSave({
+      name: trimmedName,
+      description: description.trim() || null,
+      criteria: criteria.trim() || null,
+      imageFile,
+      imagePreviewUrl,
+    });
+  };
+
+  const overlay = (
+    <div className="fixed inset-0 z-50 flex items-center justify-center px-4">
+      <div
+        className="absolute inset-0 bg-black/40 backdrop-blur-sm dark:bg-black/50"
+        onClick={onCancel}
+      />
+
+      <div
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+        className="relative z-10 flex max-h-[90vh] w-full max-w-lg flex-col gap-4 overflow-y-auto rounded-[28px] bg-[#A3DEF4] p-6 text-black shadow-2xl md:p-8 dark:bg-[#3F65E2] dark:text-white"
+      >
+        <h2 id={titleId} className="text-2xl font-bold text-web3">
+          {initial ? "Edit Badge" : "Add Badge"}
+        </h2>
+
+        <AdminField label="Badge Name *">
+          <input
+            autoFocus
+            className={adminInputClass}
+            value={name}
+            onChange={(e) => {
+              setName(e.target.value);
+              setNameError(null);
+            }}
+            placeholder="Launch Night 2026"
+          />
+        </AdminField>
+        {nameError && (
+          <p className="-mt-2 text-sm font-medium text-red-700 dark:text-red-200">
+            {nameError}
+          </p>
+        )}
+
+        <AdminField label="Description">
+          <textarea
+            rows={3}
+            className={`${adminInputClass} resize-y`}
+            value={description}
+            onChange={(e) => setDescription(e.target.value)}
+            placeholder="Shown when members hover over the badge"
+          />
+        </AdminField>
+
+        <AdminField label="Criteria">
+          <input
+            className={adminInputClass}
+            value={criteria}
+            onChange={(e) => setCriteria(e.target.value)}
+            placeholder="Attend Launch Night 2026"
+          />
+        </AdminField>
+
+        <div>
+          <span className="block text-sm font-bold text-black dark:text-white">
+            Badge Image
+          </span>
+          <div className="mt-2 flex items-center gap-4">
+            {/* Round like the badge on the profile page, so the admin sees
+                how the image will be cropped. */}
+            <div className="flex size-20 shrink-0 items-center justify-center overflow-hidden rounded-full bg-[#DAF2FB] dark:bg-[#3F58AA]">
+              {imagePreviewUrl ? (
+                <img
+                  src={imagePreviewUrl}
+                  alt="Badge preview"
+                  className="h-full w-full object-cover"
+                />
+              ) : (
+                <span className="text-xs text-black/50 dark:text-white/60">
+                  No image
+                </span>
+              )}
+            </div>
+
+            {/* Native input is hidden; the label is the visible button. */}
+            <label
+              className={`${adminButtonClass} inline-flex h-10 cursor-pointer items-center gap-2 px-4 text-sm`}
+            >
+              <FilePlus2 className="size-4" />
+              {imagePreviewUrl ? "Change Image" : "Add Image"}
+              <input
+                type="file"
+                accept="image/*"
+                className="sr-only"
+                onChange={(e) => {
+                  const file = e.target.files?.[0] ?? null;
+                  if (!file) return;
+
+                  setImageFile(file);
+                  setImagePreviewUrl(URL.createObjectURL(file));
+                }}
+              />
+            </label>
+          </div>
+        </div>
+
+        <div className="mt-2 flex flex-wrap items-center gap-3">
+          <Button onClick={handleSave} className={adminButtonClass}>
+            Save Badge
+          </Button>
+          <Button
+            onClick={onCancel}
+            className={`${adminButtonClass} !bg-[#DAF2FB]/60 dark:!bg-[#405084]/60`}
+          >
+            Cancel
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+
+  if (!isMounted) {
+    return null;
+  }
+
+  return createPortal(overlay, document.body);
+}
diff --git a/src/components/badge-card.tsx b/src/components/badge-card.tsx
new file mode 100644
index 0000000..7e23e99
--- /dev/null
+++ b/src/components/badge-card.tsx
@@ -0,0 +1,96 @@
+"use client";
+
+import { useState } from "react";
+
+import type { PublicMemberBadge } from "@/lib/schemas/member-badge";
+
+// Badge images are arbitrary Supabase/storage URLs and next.config.ts declares
+// no remotePatterns, so next/image would throw on them. Plain <img> is what the
+// rest of the profile uses for remote images for the same reason.
+
+const CATEGORY_LABELS: Record<string, string> = {
+  EVENT: "Event",
+  ACHIEVEMENT: "Achievement",
+  SPECIAL: "Special",
+};
+
+const formatAwardedAt = (awardedAt: string) => {
+  const date = new Date(awardedAt);
+  if (Number.isNaN(date.getTime())) return null;
+
+  return date.toLocaleDateString(undefined, {
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+  });
+};
+
+export function BadgeCard({ award }: { award: PublicMemberBadge }) {
+  const { badge } = award;
+  const awardedOn = formatAwardedAt(award.awardedat);
+  const category = CATEGORY_LABELS[badge.category] ?? badge.category;
+
+  // A dead or unreachable image URL would otherwise leave a broken-image icon
+  // in the circle. Dropping the image falls back to the badge's initial.
+  const [imageBroken, setImageBroken] = useState(false);
+  const showImage = Boolean(badge.imageurl) && !imageBroken;
+
+  return (
+    <div className="group relative w-full flex justify-center">
+      {/* A button rather than a div so the detail panel is reachable by keyboard
+          and by tap, not just by mouse hover. The badge is shown as the image
+          alone; its name and details live in the hover panel below. */}
+      <button
+        type="button"
+        className="w-4/5 max-w-[10rem] aspect-square rounded-full overflow-hidden flex items-center justify-center transition-transform hover:scale-105 focus:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+        aria-label={`${badge.name}${awardedOn ? `, awarded ${awardedOn}` : ""}`}
+      >
+        {showImage ? (
+          // alt is empty on purpose: the button's aria-label already announces
+          // the badge, and an alt here would be overridden by it anyway.
+          <img
+            src={badge.imageurl!}
+            alt=""
+            onError={() => setImageBroken(true)}
+            className="w-full h-full object-cover"
+          />
+        ) : (
+          // With no artwork there is nothing else in the circle, so the initial
+          // keeps badges without images distinguishable at a glance.
+          <span className="w-full h-full flex items-center justify-center bg-primary/15 text-2xl font-bold text-primary dark:bg-[#A3DEF4]/20 dark:text-[#A3DEF4]">
+            {badge.name.charAt(0).toUpperCase()}
+          </span>
+        )}
+      </button>
+
+      <div
+        role="tooltip"
+        className="pointer-events-none absolute bottom-full left-1/2 z-30 mb-2 w-56 -translate-x-1/2 rounded-2xl bg-white p-4 text-left shadow-xl opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100 dark:bg-[#2f3136]"
+      >
+        <p className="text-sm font-bold">{badge.name}</p>
+
+        <p className="mt-1 text-xs font-medium text-primary dark:text-[#A3DEF4]">
+          {category}
+        </p>
+
+        {badge.description ? (
+          <p className="mt-2 text-xs text-muted-foreground dark:text-white/70">
+            {badge.description}
+          </p>
+        ) : null}
+
+        {badge.criteria ? (
+          <p className="mt-2 text-xs italic text-muted-foreground dark:text-white/60">
+            {badge.criteria}
+          </p>
+        ) : null}
+
+        {awardedOn ? (
+          <p className="mt-2 text-xs text-muted-foreground dark:text-white/70">
+            Awarded {awardedOn}
+          </p>
+        ) : null}
+      </div>
+    </div>
+  );
+}
diff --git a/src/lib/schemas/badge.ts b/src/lib/schemas/badge.ts
new file mode 100644
index 0000000..d33bd3f
--- /dev/null
+++ b/src/lib/schemas/badge.ts
@@ -0,0 +1,71 @@
+import { z } from "zod";
+
+/** Values of the `badge_enum` Postgres type. */
+export enum BadgeType {
+  Event = "EVENT",
+  Achievement = "ACHIEVEMENT",
+  Special = "SPECIAL",
+}
+
+// Field names match the Supabase column names exactly (`imageurl`, `eventid`,
+// `isactive`). PostgREST matches JSON keys to columns case-sensitively, so a
+// camelCase `imageUrl` is rejected as an unknown column.
+const badgeFieldsSchema = z.object({
+  name: z.string().trim().min(1, "Badge name is required"),
+  category: z.nativeEnum(BadgeType),
+  description: z.string().trim().nullable(),
+  imageurl: z.string().trim().nullable(),
+  criteria: z.string().trim().nullable(),
+  eventid: z.uuid().nullable(),
+  isactive: z.boolean(),
+});
+
+// Defaults are layered on here rather than declared on the shared field schema,
+// because `.partial()` makes a key optional but still applies its default — so
+// a default on `badgeFieldsSchema` would leak into `badgeUpdateSchema` and make
+// every patch silently overwrite the columns the caller never mentioned.
+//
+// The EVENT rule is checked at creation only; nothing in the database enforces
+// it. An event badge normally can't lose its event, since deleting the event
+// deletes the badge (ON DELETE CASCADE), but rows unlinked under the earlier
+// ON DELETE SET NULL rule may still exist, so badgeUpdateSchema doesn't apply
+// the rule either.
+const badgeInsertSchema = badgeFieldsSchema
+  .extend({
+    description: badgeFieldsSchema.shape.description.default(null),
+    imageurl: badgeFieldsSchema.shape.imageurl.default(null),
+    criteria: badgeFieldsSchema.shape.criteria.default(null),
+    eventid: badgeFieldsSchema.shape.eventid.default(null),
+    isactive: badgeFieldsSchema.shape.isactive.default(true),
+  })
+  .refine(
+    (badge) => badge.category !== BadgeType.Event || badge.eventid !== null,
+    { path: ["eventid"], message: "An EVENT badge must reference an event" },
+  );
+
+const badgeUpdateSchema = badgeFieldsSchema.partial();
+
+// The badge half of an event save (PUT /api/admin/events). category and eventid
+// are absent because save_event_with_badge sets them itself, and imageurl is
+// absent because it only ever comes from an image the route uploaded — so it is
+// always a URL that getBadgeImagePath can map back to a file for cleanup.
+// An omitted optional field keeps its current value when updating.
+const eventBadgeSchema = badgeFieldsSchema
+  .pick({ name: true, description: true, criteria: true, isactive: true })
+  .partial({ description: true, criteria: true, isactive: true });
+
+const badgeSchema = badgeFieldsSchema.extend({
+  id: z.uuid(),
+  created_at: z.string(),
+});
+
+/** A badge row as it comes back from the database. */
+export type Badge = z.infer<typeof badgeSchema>;
+/** The payload accepted by `createBadge` — defaulted fields may be omitted. */
+export type BadgeInsert = z.input<typeof badgeInsertSchema>;
+/** A partial patch accepted by `updateBadgeById`. */
+export type BadgeUpdate = z.input<typeof badgeUpdateSchema>;
+/** The badge fields an admin fills in alongside an event. */
+export type EventBadge = z.infer<typeof eventBadgeSchema>;
+
+export { badgeSchema, badgeInsertSchema, badgeUpdateSchema, eventBadgeSchema };
diff --git a/src/lib/schemas/member-badge.ts b/src/lib/schemas/member-badge.ts
new file mode 100644
index 0000000..d60b2cd
--- /dev/null
+++ b/src/lib/schemas/member-badge.ts
@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+import { badgeSchema } from "./badge";
+
+// As with `badge.ts`, field names mirror the `member_badges` columns verbatim.
+// memberid is an int8 referencing registrations(id), via the existing
+// member_badges_memberid_fkey. It is deliberately *not* public_profiles.id:
+// that row is deleted when a member hides their profile, which would take
+// their badges with it, whereas the registration outlives visibility changes.
+const memberBadgeFieldsSchema = z.object({
+  badgeid: z.uuid(),
+  memberid: z.number().int().positive(),
+});
+
+const memberBadgeInsertSchema = memberBadgeFieldsSchema;
+
+const memberBadgeSchema = memberBadgeFieldsSchema.extend({
+  id: z.uuid(),
+  awardedat: z.string(),
+});
+
+// Returned by the queries that embed the badge via PostgREST's foreign-key
+// join, so callers get the badge's name and image without a second round trip.
+const memberBadgeWithBadgeSchema = memberBadgeSchema.extend({
+  badge: badgeSchema,
+});
+
+/** A member_badges row as it comes back from the database. */
+export type MemberBadge = z.infer<typeof memberBadgeSchema>;
+/** A member_badges row with its parent badge embedded. */
+export type MemberBadgeWithBadge = z.infer<typeof memberBadgeWithBadgeSchema>;
+/**
+ * An award as shown on a public profile: memberid is left out, since it is the
+ * member's registrations.id, which anon isn't allowed to read.
+ */
+export type PublicMemberBadge = Omit<MemberBadgeWithBadge, "memberid">;
+/** The payload accepted by `awardBadge`. */
+export type MemberBadgeInsert = z.input<typeof memberBadgeInsertSchema>;
+
+export {
+  memberBadgeSchema,
+  memberBadgeInsertSchema,
+  memberBadgeWithBadgeSchema,
+};
diff --git a/src/services/badges/badges-service.test.ts b/src/services/badges/badges-service.test.ts
new file mode 100644
index 0000000..156894a
--- /dev/null
+++ b/src/services/badges/badges-service.test.ts
@@ -0,0 +1,500 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { describe, expect, it, vi } from "vitest";
+
+import { Badge, BadgeType } from "../../lib/schemas/badge";
+import BadgesService from "./badges-service";
+
+const BADGE_ID = "3f7c1e2a-1b4d-4c6f-9a2e-8d5b0c7f1a33";
+const EVENT_ID = "ed6707c8-232b-403e-ac17-6e64eef72790";
+
+type MockFn = ReturnType<typeof vi.fn>;
+
+interface QueryResult {
+  data: unknown;
+  error: unknown;
+}
+
+interface Builder {
+  select: MockFn;
+  insert: MockFn;
+  update: MockFn;
+  delete: MockFn;
+  eq: MockFn;
+  order: MockFn;
+  single: MockFn;
+  maybeSingle: MockFn;
+  then: PromiseLike<QueryResult>["then"];
+}
+
+/**
+ * A stand-in for the Supabase client that records the query it was asked to
+ * build and resolves to a canned result. Pass an array to serve one result per
+ * query; the last one repeats once the queue runs dry.
+ *
+ * Real PostgREST builders are thenable, which is why `await from(x).select()`
+ * resolves without a terminal `.single()` — hence the `then` below.
+ */
+function fakeSupabase(results: QueryResult | QueryResult[]) {
+  const queue = Array.isArray(results) ? [...results] : [results];
+  const next = (): QueryResult => (queue.length > 1 ? queue.shift()! : queue[0]);
+
+  const chainable = (): MockFn => vi.fn(() => builder);
+
+  const builder: Builder = {
+    select: chainable(),
+    insert: chainable(),
+    update: chainable(),
+    delete: chainable(),
+    eq: chainable(),
+    order: chainable(),
+    single: vi.fn(() => Promise.resolve(next())),
+    maybeSingle: vi.fn(() => Promise.resolve(next())),
+    then: (onFulfilled, onRejected) =>
+      Promise.resolve(next()).then(onFulfilled, onRejected),
+  };
+
+  const from = vi.fn(() => builder);
+
+  return { client: { from } as unknown as SupabaseClient, from, builder };
+}
+
+/** A Postgres error shaped the way supabase-js surfaces it. */
+function dbError(code: string, message = "stubbed failure") {
+  return { code, message, details: null, hint: null };
+}
+
+const PUBLIC_URL = "https://example.supabase.co/storage/v1/object/public";
+
+/**
+ * A stand-in for supabase.storage that records the calls it was given.
+ * getPublicUrl mirrors storage-js, which returns
+ * encodeURI(`${storageUrl}/object/public/${bucket}/${path}`).
+ */
+function fakeStorage({
+  uploadError = null,
+  removeError = null,
+}: { uploadError?: unknown; removeError?: unknown } = {}) {
+  const upload = vi.fn(() => Promise.resolve({ error: uploadError }));
+  const remove = vi.fn(() =>
+    Promise.resolve({ data: removeError ? null : [], error: removeError }),
+  );
+  const getPublicUrl = vi.fn((path: string) => ({
+    data: { publicUrl: encodeURI(`${PUBLIC_URL}/badges/${path}`) },
+  }));
+  const bucket = vi.fn(() => ({ upload, remove, getPublicUrl }));
+
+  return {
+    client: { storage: { from: bucket } } as unknown as SupabaseClient,
+    bucket,
+    upload,
+    remove,
+  };
+}
+
+function badgeRow(overrides: Partial<Badge> = {}): Badge {
+  return {
+    id: BADGE_ID,
+    created_at: "2026-08-03T00:00:00+00:00",
+    name: "Testing Badge",
+    category: BadgeType.Achievement,
+    description: "Awarded for shipping the badge system",
+    imageurl: null,
+    criteria: "Our code works fine",
+    eventid: null,
+    isactive: true,
+    ...overrides,
+  };
+}
+
+describe("BadgesService", () => {
+  describe("createBadge", () => {
+    it("inserts into the badges table and returns the created row", async () => {
+      const fake = fakeSupabase({ data: badgeRow(), error: null });
+
+      const created = await new BadgesService(fake.client).createBadge({
+        name: "Testing Badge",
+        category: BadgeType.Achievement,
+        criteria: "Our code works fine",
+      });
+
+      expect(fake.from).toHaveBeenCalledWith("badges");
+      expect(created.id).toBe(BADGE_ID);
+    });
+
+    it("fills in defaults for the optional fields the caller omitted", async () => {
+      const fake = fakeSupabase({ data: badgeRow(), error: null });
+
+      await new BadgesService(fake.client).createBadge({
+        name: "Testing Badge",
+        category: BadgeType.Achievement,
+      });
+
+      expect(fake.builder.insert).toHaveBeenCalledWith({
+        name: "Testing Badge",
+        category: BadgeType.Achievement,
+        description: null,
+        imageurl: null,
+        criteria: null,
+        eventid: null,
+        isactive: true,
+      });
+    });
+
+    it("never sends an id or created_at — the database generates those", async () => {
+      const fake = fakeSupabase({ data: badgeRow(), error: null });
+
+      await new BadgesService(fake.client).createBadge({
+        name: "Testing Badge",
+        category: BadgeType.Achievement,
+      });
+
+      const [payload] = fake.builder.insert.mock.calls[0];
+      expect(payload).not.toHaveProperty("id");
+      expect(payload).not.toHaveProperty("created_at");
+    });
+
+    it("trims the badge name", async () => {
+      const fake = fakeSupabase({ data: badgeRow(), error: null });
+
+      await new BadgesService(fake.client).createBadge({
+        name: "   Testing Badge   ",
+        category: BadgeType.Achievement,
+      });
+
+      const [payload] = fake.builder.insert.mock.calls[0];
+      expect(payload.name).toBe("Testing Badge");
+    });
+
+    it("rejects a blank name without touching the database", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new BadgesService(fake.client).createBadge({
+          name: "   ",
+          category: BadgeType.Achievement,
+        }),
+      ).rejects.toThrow(/Badge name is required/);
+
+      expect(fake.from).not.toHaveBeenCalled();
+    });
+
+    it("rejects an EVENT badge that references no event", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new BadgesService(fake.client).createBadge({
+          name: "Hackathon 2026",
+          category: BadgeType.Event,
+        }),
+      ).rejects.toThrow(/must reference an event/);
+
+      expect(fake.from).not.toHaveBeenCalled();
+    });
+
+    it("accepts an EVENT badge that does reference an event", async () => {
+      const fake = fakeSupabase({
+        data: badgeRow({ category: BadgeType.Event, eventid: EVENT_ID }),
+        error: null,
+      });
+
+      const created = await new BadgesService(fake.client).createBadge({
+        name: "Hackathon 2026",
+        category: BadgeType.Event,
+        eventid: EVENT_ID,
+      });
+
+      expect(created.eventid).toBe(EVENT_ID);
+    });
+
+    it("throws the database error when the insert fails", async () => {
+      const fake = fakeSupabase({
+        data: null,
+        error: dbError("42501", "row-level security policy"),
+      });
+
+      await expect(
+        new BadgesService(fake.client).createBadge({
+          name: "Testing Badge",
+          category: BadgeType.Achievement,
+        }),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+
+  describe("getBadgeById", () => {
+    it("filters on the id and returns the badge", async () => {
+      const fake = fakeSupabase({ data: badgeRow(), error: null });
+
+      const badge = await new BadgesService(fake.client).getBadgeById(BADGE_ID);
+
+      expect(fake.builder.eq).toHaveBeenCalledWith("id", BADGE_ID);
+      expect(badge?.name).toBe("Testing Badge");
+    });
+
+    it("returns null when no badge has that id", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      const badge = await new BadgesService(fake.client).getBadgeById(BADGE_ID);
+
+      expect(badge).toBeNull();
+    });
+  });
+
+  describe("getAllBadges", () => {
+    it("returns every row", async () => {
+      const fake = fakeSupabase({
+        data: [badgeRow(), badgeRow({ id: EVENT_ID, name: "Second" })],
+        error: null,
+      });
+
+      const badges = await new BadgesService(fake.client).getAllBadges();
+
+      expect(badges).toHaveLength(2);
+    });
+
+    it("returns an empty array rather than null when there are none", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new BadgesService(fake.client).getAllBadges(),
+      ).resolves.toEqual([]);
+    });
+  });
+
+  describe("getAllBadgesByName", () => {
+    it("trims the name before matching", async () => {
+      const fake = fakeSupabase({ data: [badgeRow()], error: null });
+
+      await new BadgesService(fake.client).getAllBadgesByName(
+        "  Testing Badge  ",
+      );
+
+      expect(fake.builder.eq).toHaveBeenCalledWith("name", "Testing Badge");
+    });
+
+    it("returns the badges that matched", async () => {
+      const fake = fakeSupabase({ data: [badgeRow()], error: null });
+
+      const badges = await new BadgesService(fake.client).getAllBadgesByName(
+        "Testing Badge",
+      );
+
+      expect(badges).toHaveLength(1);
+      expect(badges[0].id).toBe(BADGE_ID);
+    });
+  });
+
+  describe("updateBadgeById", () => {
+    it("sends only the fields the caller supplied", async () => {
+      const fake = fakeSupabase({
+        data: badgeRow({ name: "Updated Testing Badge" }),
+        error: null,
+      });
+
+      const updated = await new BadgesService(fake.client).updateBadgeById(
+        BADGE_ID,
+        { name: "Updated Testing Badge" },
+      );
+
+      expect(fake.builder.update).toHaveBeenCalledWith({
+        name: "Updated Testing Badge",
+      });
+      expect(fake.builder.eq).toHaveBeenCalledWith("id", BADGE_ID);
+      expect(updated.name).toBe("Updated Testing Badge");
+    });
+
+    it("drops keys explicitly set to undefined", async () => {
+      const fake = fakeSupabase({ data: badgeRow(), error: null });
+
+      await new BadgesService(fake.client).updateBadgeById(BADGE_ID, {
+        name: "Still Here",
+        description: undefined,
+      });
+
+      expect(fake.builder.update).toHaveBeenCalledWith({ name: "Still Here" });
+    });
+
+    it("can null out an optional field", async () => {
+      const fake = fakeSupabase({
+        data: badgeRow({ criteria: null }),
+        error: null,
+      });
+
+      await new BadgesService(fake.client).updateBadgeById(BADGE_ID, {
+        criteria: null,
+      });
+
+      expect(fake.builder.update).toHaveBeenCalledWith({ criteria: null });
+    });
+
+    it("refuses an empty patch instead of issuing a no-op query", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new BadgesService(fake.client).updateBadgeById(BADGE_ID, {}),
+      ).rejects.toThrow(/no fields to update/);
+
+      expect(fake.from).not.toHaveBeenCalled();
+    });
+
+    it("throws the database error when the update fails", async () => {
+      const fake = fakeSupabase({ data: null, error: dbError("42501") });
+
+      await expect(
+        new BadgesService(fake.client).updateBadgeById(BADGE_ID, {
+          name: "Nope",
+        }),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+
+  describe("deleteBadgeById", () => {
+    it("deletes the row matching the id", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await new BadgesService(fake.client).deleteBadgeById(BADGE_ID);
+
+      expect(fake.builder.delete).toHaveBeenCalled();
+      expect(fake.builder.eq).toHaveBeenCalledWith("id", BADGE_ID);
+    });
+
+    it("throws the database error when the delete fails", async () => {
+      const fake = fakeSupabase({ data: null, error: dbError("42501") });
+
+      await expect(
+        new BadgesService(fake.client).deleteBadgeById(BADGE_ID),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+
+  describe("uploadBadgeImage", () => {
+    const image = (name = "Trophy.PNG") =>
+      new File(["png-bytes"], name, { type: "image/png" });
+
+    it("uploads to the badges bucket under badge_image with a random name", async () => {
+      const fake = fakeStorage();
+
+      const { imagePath } = await new BadgesService(
+        fake.client,
+      ).uploadBadgeImage(image());
+
+      expect(fake.bucket).toHaveBeenCalledWith("badges");
+      expect(imagePath).toMatch(/^badge_image\/[0-9a-f-]{36}\.png$/);
+      expect(fake.upload).toHaveBeenCalledWith(
+        imagePath,
+        expect.any(File),
+        expect.objectContaining({ upsert: false, contentType: "image/png" }),
+      );
+    });
+
+    it("returns the public URL of the uploaded file", async () => {
+      const fake = fakeStorage();
+
+      const { imagePath, imageUrl } = await new BadgesService(
+        fake.client,
+      ).uploadBadgeImage(image());
+
+      expect(imageUrl).toBe(`${PUBLIC_URL}/badges/${imagePath}`);
+    });
+
+    it("rejects a file with no extension without uploading", async () => {
+      const fake = fakeStorage();
+
+      await expect(
+        new BadgesService(fake.client).uploadBadgeImage(image("trophy")),
+      ).rejects.toThrow("Badge image must have a file extension.");
+
+      expect(fake.upload).not.toHaveBeenCalled();
+    });
+
+    it("throws the storage error when the upload fails", async () => {
+      const fake = fakeStorage({
+        uploadError: { message: "Bucket not found" },
+      });
+
+      await expect(
+        new BadgesService(fake.client).uploadBadgeImage(image()),
+      ).rejects.toMatchObject({ message: "Bucket not found" });
+    });
+  });
+
+  describe("getBadgeImagePath", () => {
+    const pathOf = (url: string | null | undefined) =>
+      new BadgesService(fakeStorage().client).getBadgeImagePath(url);
+
+    it("recovers the path from a public URL this service produced", async () => {
+      const fake = fakeStorage();
+      const service = new BadgesService(fake.client);
+      const file = new File(["png-bytes"], "Trophy.png", { type: "image/png" });
+
+      const { imagePath, imageUrl } = await service.uploadBadgeImage(file);
+
+      expect(service.getBadgeImagePath(imageUrl)).toBe(imagePath);
+    });
+
+    it("decodes characters that getPublicUrl encoded", () => {
+      expect(pathOf(encodeURI(`${PUBLIC_URL}/badges/badge_image/my badge.png`))).toBe(
+        "badge_image/my badge.png",
+      );
+    });
+
+    it("ignores a query string", () => {
+      expect(pathOf(`${PUBLIC_URL}/badges/badge_image/a.png?download=`)).toBe(
+        "badge_image/a.png",
+      );
+    });
+
+    it("returns null for a signed URL", () => {
+      expect(
+        pathOf(
+          "https://example.supabase.co/storage/v1/object/sign/badges/badge_image/Trophy.png?token=abc",
+        ),
+      ).toBeNull();
+    });
+
+    it("returns null for another bucket, host or folder", () => {
+      expect(pathOf(`${PUBLIC_URL}/events/badge_image/a.png`)).toBeNull();
+      expect(
+        pathOf("https://elsewhere.example.com/storage/v1/object/public/badges/badge_image/a.png"),
+      ).toBeNull();
+      expect(pathOf(`${PUBLIC_URL}/badges/other/a.png`)).toBeNull();
+    });
+
+    it("returns null for a path that climbs out of the folder", () => {
+      expect(pathOf(`${PUBLIC_URL}/badges/badge_image/../secret.png`)).toBeNull();
+    });
+
+    it("returns null for the bare folder", () => {
+      expect(pathOf(`${PUBLIC_URL}/badges/badge_image/`)).toBeNull();
+    });
+
+    it("returns null for a malformed escape", () => {
+      expect(pathOf(`${PUBLIC_URL}/badges/badge_image/%E0%A4%A.png`)).toBeNull();
+    });
+
+    it("returns null when there is no URL", () => {
+      expect(pathOf(null)).toBeNull();
+      expect(pathOf(undefined)).toBeNull();
+      expect(pathOf("")).toBeNull();
+    });
+  });
+
+  describe("deleteBadgeImage", () => {
+    it("removes the file from the badges bucket", async () => {
+      const fake = fakeStorage();
+
+      await new BadgesService(fake.client).deleteBadgeImage("badge_image/a.png");
+
+      expect(fake.bucket).toHaveBeenCalledWith("badges");
+      expect(fake.remove).toHaveBeenCalledWith(["badge_image/a.png"]);
+    });
+
+    it("throws the storage error when the delete fails", async () => {
+      const fake = fakeStorage({ removeError: { message: "Access denied" } });
+
+      await expect(
+        new BadgesService(fake.client).deleteBadgeImage("badge_image/a.png"),
+      ).rejects.toMatchObject({ message: "Access denied" });
+    });
+  });
+});
diff --git a/src/services/badges/badges-service.tsx b/src/services/badges/badges-service.tsx
new file mode 100644
index 0000000..5eb8376
--- /dev/null
+++ b/src/services/badges/badges-service.tsx
@@ -0,0 +1,214 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+
+import {
+  Badge,
+  BadgeInsert,
+  BadgeUpdate,
+  badgeInsertSchema,
+  badgeUpdateSchema,
+} from "../../lib/schemas/badge";
+import { getSupabase } from "../supabase";
+
+const TABLE = "badges";
+
+// The bucket must be public: imageurl stores a plain public URL, the same way
+// event images do, rather than a signed URL that would eventually expire.
+const IMAGE_BUCKET = "badges";
+const IMAGE_FOLDER = "badge_image";
+
+/** Drops keys the caller left undefined so a patch never clears a column by accident. */
+function definedFields<T extends object>(patch: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(patch).filter(([, value]) => value !== undefined),
+  ) as Partial<T>;
+}
+
+export default class BadgesService {
+  /**
+   * @param client Supabase client to use. Defaults to the shared anon client.
+   * Injecting one lets unit tests pass a stub, and lets the integration tests
+   * pass a service-role client that can write past RLS.
+   */
+  constructor(private readonly client?: SupabaseClient) {}
+
+  private get db(): SupabaseClient {
+    return this.client ?? getSupabase();
+  }
+
+  /**
+   * Creates a new {@link Badge} in the database.
+   * @param badge The badge to create. `id` and `created_at` are set by the database.
+   * @returns The created badge.
+   */
+  public async createBadge(badge: BadgeInsert): Promise<Badge> {
+    const payload = badgeInsertSchema.parse(badge);
+
+    const { data, error } = await this.db
+      .from(TABLE)
+      .insert(payload)
+      .select()
+      .single();
+
+    if (error) throw error;
+    return data as Badge;
+  }
+
+  /**
+   * Retrieves a {@link Badge} by its ID.
+   * @param id The ID of the badge to retrieve.
+   * @returns The matching badge, or `null` if no badge has that ID.
+   */
+  public async getBadgeById(id: string): Promise<Badge | null> {
+    const { data, error } = await this.db
+      .from(TABLE)
+      .select()
+      .eq("id", id)
+      .maybeSingle();
+
+    if (error) throw error;
+    return data as Badge | null;
+  }
+
+  /**
+   * Retrieves all {@link Badge}s from the database.
+   * @returns An array of all badges, newest first.
+   */
+  public async getAllBadges(): Promise<Badge[]> {
+    const { data, error } = await this.db
+      .from(TABLE)
+      .select()
+      .order("created_at", { ascending: false });
+
+    if (error) throw error;
+    return (data ?? []) as Badge[];
+  }
+
+  /**
+   * Retrieves all {@link Badge}s with the given name.
+   * @param name The exact name to match.
+   * @returns An array of badges with that name.
+   */
+  public async getAllBadgesByName(name: string): Promise<Badge[]> {
+    const { data, error } = await this.db
+      .from(TABLE)
+      .select()
+      .eq("name", name.trim());
+
+    if (error) throw error;
+    return (data ?? []) as Badge[];
+  }
+
+  /**
+   * Updates a {@link Badge} by its ID.
+   * @param id The ID of the badge to update.
+   * @param patch The fields to change. Omitted fields are left untouched.
+   * @returns The updated badge.
+   */
+  public async updateBadgeById(id: string, patch: BadgeUpdate): Promise<Badge> {
+    const payload = definedFields(badgeUpdateSchema.parse(patch));
+
+    if (Object.keys(payload).length === 0) {
+      throw new Error("updateBadgeById was called with no fields to update");
+    }
+
+    const { data, error } = await this.db
+      .from(TABLE)
+      .update(payload)
+      .eq("id", id)
+      .select()
+      .single();
+
+    if (error) throw error;
+    return data as Badge;
+  }
+
+  /**
+   * Uploads a badge image to storage under a random name, so two badges whose
+   * files share a name can't overwrite each other.
+   * @param file The image to upload.
+   * @returns The storage path and the public URL to store in `imageurl`.
+   */
+  public async uploadBadgeImage(
+    file: File,
+  ): Promise<{ imagePath: string; imageUrl: string }> {
+    const extension = file.name.split(".").pop()?.toLowerCase();
+    if (!extension || extension === file.name.toLowerCase()) {
+      throw new Error("Badge image must have a file extension.");
+    }
+
+    const imagePath = `${IMAGE_FOLDER}/${crypto.randomUUID()}.${extension}`;
+
+    const { error } = await this.db.storage
+      .from(IMAGE_BUCKET)
+      .upload(imagePath, file, {
+        cacheControl: "3600",
+        upsert: false,
+        contentType: file.type,
+      });
+
+    if (error) throw error;
+
+    const { data } = this.db.storage.from(IMAGE_BUCKET).getPublicUrl(imagePath);
+    return { imagePath, imageUrl: data.publicUrl };
+  }
+
+  /**
+   * Recovers the storage path of a badge image from its `imageurl`, so the file
+   * can be deleted. badges has no path column, but a public URL is just the
+   * path appended to a fixed prefix.
+   *
+   * Only public URLs into this bucket's badge_image folder qualify. Anything
+   * else, such as an older signed URL or an image hosted elsewhere, returns
+   * `null`, so callers never delete a file this service didn't upload.
+   * @param imageUrl The badge's `imageurl`.
+   * @returns The storage path, or `null` if the URL isn't one of ours.
+   */
+  public getBadgeImagePath(imageUrl: string | null | undefined): string | null {
+    if (!imageUrl) return null;
+
+    // getPublicUrl builds encodeURI(`${storageUrl}/object/public/${bucket}/${path}`),
+    // so an empty path yields exactly the prefix every badge image URL shares.
+    const prefix = this.db.storage.from(IMAGE_BUCKET).getPublicUrl("").data
+      .publicUrl;
+    if (!imageUrl.startsWith(prefix)) return null;
+
+    let path: string;
+    try {
+      path = decodeURI(imageUrl.slice(prefix.length).split("?")[0]);
+    } catch {
+      return null;
+    }
+
+    const insideFolder =
+      path.startsWith(`${IMAGE_FOLDER}/`) &&
+      path.length > IMAGE_FOLDER.length + 1 &&
+      !path.split("/").includes("..");
+
+    return insideFolder ? path : null;
+  }
+
+  /**
+   * Deletes a badge image from storage.
+   * @param imagePath The storage path, as returned by {@link uploadBadgeImage}
+   * or {@link getBadgeImagePath}.
+   */
+  public async deleteBadgeImage(imagePath: string): Promise<void> {
+    const { error } = await this.db.storage
+      .from(IMAGE_BUCKET)
+      .remove([imagePath]);
+
+    if (error) throw error;
+  }
+
+  /**
+   * Deletes a {@link Badge} by its ID. Any member_badges rows referencing it
+   * are removed too, via the foreign key's ON DELETE CASCADE (added in
+   * migration 20261001120000). The image file is not deleted; pass the badge's
+   * imageurl through {@link getBadgeImagePath} and {@link deleteBadgeImage}.
+   * @param id The ID of the badge to delete.
+   */
+  public async deleteBadgeById(id: string): Promise<void> {
+    const { error } = await this.db.from(TABLE).delete().eq("id", id);
+    if (error) throw error;
+  }
+}
diff --git a/src/services/event-service.ts b/src/services/event-service.ts
index 589894e..0a97f16 100644
--- a/src/services/event-service.ts
+++ b/src/services/event-service.ts
@@ -1,9 +1,55 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+
 import { getSupabase } from "./supabase";
+import BadgesService from "./badges/badges-service";
 import type { ClubEvent } from "../lib/events";
+import type { Badge, EventBadge } from "../lib/schemas/badge";
 
 const EVENT_IMAGE_BUCKET = "events";
 const EVENT_IMAGE_FOLDER = "events";
 
+/** What {@link EventService.saveEventWithBadge} needs, already validated. */
+export type SaveEventWithBadgeInput = {
+  /**
+   * Event columns. With an `id` the event is updated, and any column left
+   * out keeps its current value; without one, a new event is created.
+   */
+  event: Partial<ClubEvent>;
+  /** Create or update the event's badge. Omit to leave it as it is. */
+  badge?: EventBadge | null;
+  /** Delete the event's current badge, and every member's award of it. */
+  removeBadge?: boolean;
+  /** A new event image, replacing any current one. */
+  eventImage?: File | null;
+  /** A new badge image, replacing any current one. Requires `badge`. */
+  badgeImage?: File | null;
+};
+
+/** The jsonb returned by the save_event_with_badge database function. */
+type SaveEventWithBadgeResult = {
+  event: ClubEvent;
+  badge: Badge | null;
+  replaced_event_path: string | null;
+  replaced_badge_imageurl: string | null;
+  removed_badge_imageurl: string | null;
+};
+
+/**
+ * Runs storage cleanups without letting a failure escape: by the time they
+ * run, the outcome of the save is already decided, and a leftover file is
+ * better than reporting a save that succeeded as failed (or masking the error
+ * that made it fail).
+ */
+async function cleanUpQuietly(
+  cleanups: Array<() => Promise<void>>,
+  context: string,
+) {
+  const results = await Promise.allSettled(cleanups.map((cleanup) => cleanup()));
+  for (const result of results) {
+    if (result.status === "rejected") console.error(context, result.reason);
+  }
+}
+
 export type AttendedEvent = {
   id: string;
   title: string;
@@ -127,11 +173,17 @@ export const EventService = {
     return `${EVENT_IMAGE_FOLDER}/${crypto.randomUUID()}.${fileExtension}`;
   },
 
-  uploadEventImage: async (file: File) => {
-    const supabase = getSupabase();
+  /**
+   * @param client Supabase client to use. Defaults to the shared anon client;
+   * server routes pass the service-role client.
+   */
+  uploadEventImage: async (
+    file: File,
+    client: SupabaseClient = getSupabase(),
+  ) => {
     const imagePath = EventService.getEventImagePath(file);
 
-    const { error } = await supabase.storage
+    const { error } = await client.storage
       .from(EVENT_IMAGE_BUCKET)
       .upload(imagePath, file, {
         cacheControl: "3600",
@@ -143,7 +195,7 @@ export const EventService = {
       throw error;
     }
 
-    const { data } = supabase.storage
+    const { data } = client.storage
       .from(EVENT_IMAGE_BUCKET)
       .getPublicUrl(imagePath);
 
@@ -152,4 +204,175 @@ export const EventService = {
       imageUrl: data.publicUrl,
     };
   },
+
+  /**
+   * Deletes an event image from storage.
+   * @param imagePath The storage path, as stored in `events.event_path`.
+   * @param client Supabase client to use. Defaults to the shared anon client.
+   */
+  deleteEventImage: async (
+    imagePath: string,
+    client: SupabaseClient = getSupabase(),
+  ) => {
+    const { error } = await client.storage
+      .from(EVENT_IMAGE_BUCKET)
+      .remove([imagePath]);
+
+    if (error) {
+      throw error;
+    }
+  },
+
+  /**
+   * Creates or updates an event and, optionally, its badge, all or nothing.
+   *
+   * Images are uploaded first, since the rows store their URLs. If anything
+   * after that fails, the files uploaded here are deleted again, so a failed
+   * save leaves nothing behind. After a successful save, any image this save
+   * replaced, or that belonged to a badge it removed, is deleted too.
+   *
+   * @param client A client allowed to call save_event_with_badge, i.e. the
+   * service-role client. The function is not executable by anon.
+   */
+  saveEventWithBadge: async (
+    client: SupabaseClient,
+    {
+      event,
+      badge = null,
+      removeBadge = false,
+      eventImage = null,
+      badgeImage = null,
+    }: SaveEventWithBadgeInput,
+  ): Promise<{ event: ClubEvent; badge: Badge | null }> => {
+    if (badgeImage && !badge) {
+      throw new Error("A badge image was given without a badge.");
+    }
+
+    const badges = new BadgesService(client);
+    const eventPayload: Record<string, unknown> = { ...event };
+    const badgePayload: Record<string, unknown> | null = badge
+      ? { ...badge }
+      : null;
+    const uploadedCleanups: Array<() => Promise<void>> = [];
+
+    let result: SaveEventWithBadgeResult;
+
+    try {
+      if (eventImage) {
+        const uploaded = await EventService.uploadEventImage(eventImage, client);
+        uploadedCleanups.push(() =>
+          EventService.deleteEventImage(uploaded.imagePath, client),
+        );
+        eventPayload.event_path = uploaded.imagePath;
+        eventPayload.event_url = uploaded.imageUrl;
+      }
+
+      if (badgeImage && badgePayload) {
+        const uploaded = await badges.uploadBadgeImage(badgeImage);
+        uploadedCleanups.push(() => badges.deleteBadgeImage(uploaded.imagePath));
+        badgePayload.imageurl = uploaded.imageUrl;
+      }
+
+      const { data, error } = await client.rpc("save_event_with_badge", {
+        p_event: eventPayload,
+        p_badge: badgePayload,
+        p_remove_badge: removeBadge,
+      });
+
+      if (error) throw error;
+      result = data as SaveEventWithBadgeResult;
+    } catch (error) {
+      await cleanUpQuietly(
+        uploadedCleanups,
+        "Failed to delete an image uploaded for an event save that failed",
+      );
+      throw error;
+    }
+
+    const replacedCleanups: Array<() => Promise<void>> = [];
+
+    // Only delete paths inside the folder uploads go to, in case an older row
+    // points somewhere else in the bucket.
+    const replacedEventPath = result.replaced_event_path;
+    if (replacedEventPath?.startsWith(`${EVENT_IMAGE_FOLDER}/`)) {
+      replacedCleanups.push(() =>
+        EventService.deleteEventImage(replacedEventPath, client),
+      );
+    }
+
+    for (const imageUrl of [
+      result.replaced_badge_imageurl,
+      result.removed_badge_imageurl,
+    ]) {
+      const badgePath = badges.getBadgeImagePath(imageUrl);
+      if (badgePath) {
+        replacedCleanups.push(() => badges.deleteBadgeImage(badgePath));
+      }
+    }
+
+    await cleanUpQuietly(
+      replacedCleanups,
+      "Failed to delete an image replaced or removed by an event save",
+    );
+
+    return { event: result.event, badge: result.badge };
+  },
+
+  /**
+   * Deletes an event, its badge, and then their image files.
+   *
+   * The badge goes with the event: badges_eventid_fkey is ON DELETE CASCADE,
+   * and so is member_badges_badgeid_fkey, so every member's award of it is
+   * deleted too. All of that happens in the one delete statement.
+   *
+   * @param client A client allowed to delete events, i.e. the service-role
+   * client.
+   * @returns The deleted event.
+   */
+  deleteEvent: async (
+    client: SupabaseClient,
+    id: string,
+  ): Promise<ClubEvent> => {
+    // Read first: once the cascade has run, the badge row and the URL of its
+    // image are gone.
+    const { data: badge, error: badgeError } = await client
+      .from("badges")
+      .select("imageurl")
+      .eq("eventid", id)
+      .maybeSingle();
+
+    if (badgeError) throw badgeError;
+
+    const { data, error } = await client
+      .from("events")
+      .delete()
+      .eq("id", id)
+      .select()
+      .single();
+
+    if (error) throw error;
+
+    const event = data as ClubEvent;
+    const cleanups: Array<() => Promise<void>> = [];
+
+    // Only delete paths inside the folder uploads go to, in case an older row
+    // points somewhere else in the bucket.
+    const imagePath = event.event_path;
+    if (imagePath?.startsWith(`${EVENT_IMAGE_FOLDER}/`)) {
+      cleanups.push(() => EventService.deleteEventImage(imagePath, client));
+    }
+
+    const badges = new BadgesService(client);
+    const badgeImagePath = badges.getBadgeImagePath(badge?.imageurl);
+    if (badgeImagePath) {
+      cleanups.push(() => badges.deleteBadgeImage(badgeImagePath));
+    }
+
+    await cleanUpQuietly(
+      cleanups,
+      "Failed to delete an image of a deleted event or its badge",
+    );
+
+    return event;
+  },
 };
diff --git a/src/services/member-badges/member-badges-service.test.ts b/src/services/member-badges/member-badges-service.test.ts
new file mode 100644
index 0000000..b11d119
--- /dev/null
+++ b/src/services/member-badges/member-badges-service.test.ts
@@ -0,0 +1,436 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { describe, expect, it, vi } from "vitest";
+
+import { Badge, BadgeType } from "../../lib/schemas/badge";
+import { MemberBadge } from "../../lib/schemas/member-badge";
+import MemberBadgesService from "./member-badges-service";
+
+const AWARD_ID = "9c1d7b3e-5a2f-4e18-b7d0-2c6a4f9e8b11";
+const BADGE_ID = "3f7c1e2a-1b4d-4c6f-9a2e-8d5b0c7f1a33";
+const MEMBER_ID = 42;
+const PROFILE_ID = "5e8a2c4b-6d31-4f97-a02e-1b7c9d4e6f85";
+
+type MockFn = ReturnType<typeof vi.fn>;
+
+interface QueryResult {
+  data: unknown;
+  error: unknown;
+}
+
+interface Builder {
+  select: MockFn;
+  insert: MockFn;
+  update: MockFn;
+  delete: MockFn;
+  eq: MockFn;
+  order: MockFn;
+  single: MockFn;
+  maybeSingle: MockFn;
+  then: PromiseLike<QueryResult>["then"];
+}
+
+/**
+ * A stand-in for the Supabase client that records the query it was asked to
+ * build and resolves to a canned result. Pass an array to serve one result per
+ * query; the last one repeats once the queue runs dry, which is what the
+ * duplicate-award path needs since it issues a second query after the conflict.
+ *
+ * Real PostgREST builders are thenable, which is why `await from(x).select()`
+ * resolves without a terminal `.single()` — hence the `then` below.
+ */
+function fakeSupabase(results: QueryResult | QueryResult[]) {
+  const queue = Array.isArray(results) ? [...results] : [results];
+  const next = (): QueryResult => (queue.length > 1 ? queue.shift()! : queue[0]);
+
+  const chainable = (): MockFn => vi.fn(() => builder);
+
+  const builder: Builder = {
+    select: chainable(),
+    insert: chainable(),
+    update: chainable(),
+    delete: chainable(),
+    eq: chainable(),
+    order: chainable(),
+    single: vi.fn(() => Promise.resolve(next())),
+    maybeSingle: vi.fn(() => Promise.resolve(next())),
+    then: (onFulfilled, onRejected) =>
+      Promise.resolve(next()).then(onFulfilled, onRejected),
+  };
+
+  const from = vi.fn(() => builder);
+  const rpc = vi.fn(() => Promise.resolve(next()));
+
+  return {
+    client: { from, rpc } as unknown as SupabaseClient,
+    from,
+    rpc,
+    builder,
+  };
+}
+
+/** A Postgres error shaped the way supabase-js surfaces it. */
+function dbError(code: string, message = "stubbed failure") {
+  return { code, message, details: null, hint: null };
+}
+
+function awardRow(overrides: Partial<MemberBadge> = {}): MemberBadge {
+  return {
+    id: AWARD_ID,
+    awardedat: "2026-08-03T00:00:00+00:00",
+    badgeid: BADGE_ID,
+    memberid: MEMBER_ID,
+    ...overrides,
+  };
+}
+
+function badgeRow(overrides: Partial<Badge> = {}): Badge {
+  return {
+    id: BADGE_ID,
+    created_at: "2026-08-03T00:00:00+00:00",
+    name: "Testing Badge",
+    category: BadgeType.Achievement,
+    description: "Awarded for shipping the badge system",
+    imageurl: null,
+    criteria: "Our code works fine",
+    eventid: null,
+    isactive: true,
+    ...overrides,
+  };
+}
+
+describe("MemberBadgesService", () => {
+  describe("awardBadge", () => {
+    it("inserts into the member_badges table and returns the award", async () => {
+      const fake = fakeSupabase({ data: awardRow(), error: null });
+
+      const award = await new MemberBadgesService(fake.client).awardBadge({
+        badgeid: BADGE_ID,
+        memberid: MEMBER_ID,
+      });
+
+      expect(fake.from).toHaveBeenCalledWith("member_badges");
+      expect(award.id).toBe(AWARD_ID);
+    });
+
+    it("inserts just the badge and the member", async () => {
+      const fake = fakeSupabase({ data: awardRow(), error: null });
+
+      await new MemberBadgesService(fake.client).awardBadge({
+        badgeid: BADGE_ID,
+        memberid: MEMBER_ID,
+      });
+
+      expect(fake.builder.insert).toHaveBeenCalledWith({
+        badgeid: BADGE_ID,
+        memberid: MEMBER_ID,
+      });
+    });
+
+    it("never sends an id or awardedat — the database generates those", async () => {
+      const fake = fakeSupabase({ data: awardRow(), error: null });
+
+      await new MemberBadgesService(fake.client).awardBadge({
+        badgeid: BADGE_ID,
+        memberid: MEMBER_ID,
+      });
+
+      const [payload] = fake.builder.insert.mock.calls[0];
+      expect(payload).not.toHaveProperty("id");
+      expect(payload).not.toHaveProperty("awardedat");
+    });
+
+    it("rejects a badgeid that isn't a uuid without touching the database", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).awardBadge({
+          badgeid: "not-a-uuid",
+          memberid: MEMBER_ID,
+        }),
+      ).rejects.toThrow();
+
+      expect(fake.from).not.toHaveBeenCalled();
+    });
+
+    it("rejects a memberid passed as a public_profiles uuid", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).awardBadge({
+          badgeid: BADGE_ID,
+          // memberid is registrations.id, not a public_profiles uuid — this is
+          // the confusion the schema guards against.
+          memberid: "5e8a2c4b-6d31-4f97-a02e-1b7c9d4e6f85" as unknown as number,
+        }),
+      ).rejects.toThrow();
+
+      expect(fake.from).not.toHaveBeenCalled();
+    });
+
+    it("is idempotent — a duplicate award returns the existing row", async () => {
+      const fake = fakeSupabase([
+        { data: null, error: dbError("23505", "duplicate key value") },
+        { data: awardRow(), error: null },
+      ]);
+
+      const award = await new MemberBadgesService(fake.client).awardBadge({
+        badgeid: BADGE_ID,
+        memberid: MEMBER_ID,
+      });
+
+      expect(award.id).toBe(AWARD_ID);
+    });
+
+    it("looks the existing award up by badge and member after a conflict", async () => {
+      const fake = fakeSupabase([
+        { data: null, error: dbError("23505") },
+        { data: awardRow(), error: null },
+      ]);
+
+      await new MemberBadgesService(fake.client).awardBadge({
+        badgeid: BADGE_ID,
+        memberid: MEMBER_ID,
+      });
+
+      expect(fake.builder.eq).toHaveBeenCalledWith("badgeid", BADGE_ID);
+      expect(fake.builder.eq).toHaveBeenCalledWith("memberid", MEMBER_ID);
+    });
+
+    it("rethrows the conflict if the existing award can't be found", async () => {
+      const fake = fakeSupabase([
+        { data: null, error: dbError("23505") },
+        { data: null, error: null },
+      ]);
+
+      await expect(
+        new MemberBadgesService(fake.client).awardBadge({
+          badgeid: BADGE_ID,
+          memberid: MEMBER_ID,
+        }),
+      ).rejects.toMatchObject({ code: "23505" });
+    });
+
+    it("rethrows errors that aren't unique violations", async () => {
+      const fake = fakeSupabase({
+        data: null,
+        error: dbError("23503", "foreign key violation"),
+      });
+
+      await expect(
+        new MemberBadgesService(fake.client).awardBadge({
+          badgeid: BADGE_ID,
+          memberid: MEMBER_ID,
+        }),
+      ).rejects.toMatchObject({ code: "23503" });
+    });
+  });
+
+  describe("getAward", () => {
+    it("filters on both the badge and the member", async () => {
+      const fake = fakeSupabase({ data: awardRow(), error: null });
+
+      const award = await new MemberBadgesService(fake.client).getAward(
+        BADGE_ID,
+        MEMBER_ID,
+      );
+
+      expect(fake.builder.eq).toHaveBeenCalledWith("badgeid", BADGE_ID);
+      expect(fake.builder.eq).toHaveBeenCalledWith("memberid", MEMBER_ID);
+      expect(award?.id).toBe(AWARD_ID);
+    });
+
+    it("returns null when the member doesn't hold the badge", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).getAward(BADGE_ID, MEMBER_ID),
+      ).resolves.toBeNull();
+    });
+
+    it("throws the database error when the lookup fails", async () => {
+      const fake = fakeSupabase({ data: null, error: dbError("42501") });
+
+      await expect(
+        new MemberBadgesService(fake.client).getAward(BADGE_ID, MEMBER_ID),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+
+  describe("hasBadge", () => {
+    it("is true when an award exists", async () => {
+      const fake = fakeSupabase({ data: awardRow(), error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).hasBadge(BADGE_ID, MEMBER_ID),
+      ).resolves.toBe(true);
+    });
+
+    it("is false when no award exists", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).hasBadge(BADGE_ID, MEMBER_ID),
+      ).resolves.toBe(false);
+    });
+  });
+
+  describe("getBadgesForMember", () => {
+    it("embeds the badge, filters on the member and orders by award date", async () => {
+      const fake = fakeSupabase({ data: [], error: null });
+
+      await new MemberBadgesService(fake.client).getBadgesForMember(MEMBER_ID);
+
+      expect(fake.builder.select).toHaveBeenCalledWith("*, badge:badges(*)");
+      expect(fake.builder.eq).toHaveBeenCalledWith("memberid", MEMBER_ID);
+      expect(fake.builder.order).toHaveBeenCalledWith("awardedat", {
+        ascending: false,
+      });
+    });
+
+    it("returns the awards with their badge attached", async () => {
+      const fake = fakeSupabase({
+        data: [{ ...awardRow(), badge: badgeRow() }],
+        error: null,
+      });
+
+      const held = await new MemberBadgesService(
+        fake.client,
+      ).getBadgesForMember(MEMBER_ID);
+
+      expect(held).toHaveLength(1);
+      expect(held[0].badge.name).toBe("Testing Badge");
+    });
+
+    it("returns an empty array rather than null when the member holds none", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).getBadgesForMember(MEMBER_ID),
+      ).resolves.toEqual([]);
+    });
+  });
+
+  describe("getBadgesForPublicProfile", () => {
+    it("calls get_public_profile_badges with the public profile's id", async () => {
+      const fake = fakeSupabase({ data: [], error: null });
+
+      await new MemberBadgesService(fake.client).getBadgesForPublicProfile(
+        PROFILE_ID,
+      );
+
+      expect(fake.rpc).toHaveBeenCalledWith("get_public_profile_badges", {
+        p_profile_id: PROFILE_ID,
+      });
+      expect(fake.from).not.toHaveBeenCalled();
+    });
+
+    it("returns the awards with their badge attached", async () => {
+      const { id, badgeid, awardedat } = awardRow();
+      const fake = fakeSupabase({
+        data: [{ id, badgeid, awardedat, badge: badgeRow() }],
+        error: null,
+      });
+
+      const held = await new MemberBadgesService(
+        fake.client,
+      ).getBadgesForPublicProfile(PROFILE_ID);
+
+      expect(held).toHaveLength(1);
+      expect(held[0].badge.name).toBe("Testing Badge");
+    });
+
+    it("returns an empty array rather than null when the profile holds none", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).getBadgesForPublicProfile(
+          PROFILE_ID,
+        ),
+      ).resolves.toEqual([]);
+    });
+
+    it("throws the database error when the call fails", async () => {
+      const fake = fakeSupabase({ data: null, error: dbError("42501") });
+
+      await expect(
+        new MemberBadgesService(fake.client).getBadgesForPublicProfile(
+          PROFILE_ID,
+        ),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+
+  describe("getMembersWithBadge", () => {
+    it("filters on the badge and orders by award date", async () => {
+      const fake = fakeSupabase({ data: [awardRow()], error: null });
+
+      const holders = await new MemberBadgesService(
+        fake.client,
+      ).getMembersWithBadge(BADGE_ID);
+
+      expect(fake.builder.eq).toHaveBeenCalledWith("badgeid", BADGE_ID);
+      expect(fake.builder.order).toHaveBeenCalledWith("awardedat", {
+        ascending: false,
+      });
+      expect(holders).toHaveLength(1);
+    });
+
+    it("returns an empty array rather than null when nobody holds it", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).getMembersWithBadge(BADGE_ID),
+      ).resolves.toEqual([]);
+    });
+  });
+
+  describe("revokeBadge", () => {
+    it("deletes the row matching both the badge and the member", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await new MemberBadgesService(fake.client).revokeBadge(
+        BADGE_ID,
+        MEMBER_ID,
+      );
+
+      expect(fake.builder.delete).toHaveBeenCalled();
+      expect(fake.builder.eq).toHaveBeenCalledWith("badgeid", BADGE_ID);
+      expect(fake.builder.eq).toHaveBeenCalledWith("memberid", MEMBER_ID);
+    });
+
+    it("resolves without error when the member doesn't hold the badge", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await expect(
+        new MemberBadgesService(fake.client).revokeBadge(BADGE_ID, MEMBER_ID),
+      ).resolves.toBeUndefined();
+    });
+
+    it("throws the database error when the delete fails", async () => {
+      const fake = fakeSupabase({ data: null, error: dbError("42501") });
+
+      await expect(
+        new MemberBadgesService(fake.client).revokeBadge(BADGE_ID, MEMBER_ID),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+
+  describe("revokeAwardById", () => {
+    it("deletes by the join row's own id", async () => {
+      const fake = fakeSupabase({ data: null, error: null });
+
+      await new MemberBadgesService(fake.client).revokeAwardById(AWARD_ID);
+
+      expect(fake.builder.delete).toHaveBeenCalled();
+      expect(fake.builder.eq).toHaveBeenCalledWith("id", AWARD_ID);
+    });
+
+    it("throws the database error when the delete fails", async () => {
+      const fake = fakeSupabase({ data: null, error: dbError("42501") });
+
+      await expect(
+        new MemberBadgesService(fake.client).revokeAwardById(AWARD_ID),
+      ).rejects.toMatchObject({ code: "42501" });
+    });
+  });
+});
diff --git a/src/services/member-badges/member-badges-service.tsx b/src/services/member-badges/member-badges-service.tsx
new file mode 100644
index 0000000..611e74c
--- /dev/null
+++ b/src/services/member-badges/member-badges-service.tsx
@@ -0,0 +1,156 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+
+import {
+  MemberBadge,
+  MemberBadgeInsert,
+  MemberBadgeWithBadge,
+  PublicMemberBadge,
+  memberBadgeInsertSchema,
+} from "../../lib/schemas/member-badge";
+import { getSupabase } from "../supabase";
+
+const TABLE = "member_badges";
+
+// Raised by Postgres when the unique(badgeid, memberid) constraint is violated.
+const UNIQUE_VIOLATION = "23505";
+
+// Pulls the parent badge in with the join row, via the badgeid foreign key.
+const WITH_BADGE = "*, badge:badges(*)";
+
+export default class MemberBadgesService {
+  /**
+   * @param client Supabase client to use. Defaults to the shared anon client.
+   * @see BadgesService for why this is injectable.
+   */
+  constructor(private readonly client?: SupabaseClient) {}
+
+  private get db(): SupabaseClient {
+    return this.client ?? getSupabase();
+  }
+
+  /**
+   * Awards a badge to a member. Idempotent: awarding a badge the member
+   * already holds returns the existing row rather than throwing.
+   * @param award The badge and the member receiving it.
+   * @returns The member_badges row.
+   */
+  public async awardBadge(award: MemberBadgeInsert): Promise<MemberBadge> {
+    const payload = memberBadgeInsertSchema.parse(award);
+
+    const { data, error } = await this.db
+      .from(TABLE)
+      .insert(payload)
+      .select()
+      .single();
+
+    if (error) {
+      if (error.code === UNIQUE_VIOLATION) {
+        const existing = await this.getAward(payload.badgeid, payload.memberid);
+        if (existing) return existing;
+      }
+      throw error;
+    }
+
+    return data as MemberBadge;
+  }
+
+  /**
+   * Retrieves the award linking a badge to a member.
+   * @returns The member_badges row, or `null` if the member doesn't hold the badge.
+   */
+  public async getAward(
+    badgeId: string,
+    memberId: number,
+  ): Promise<MemberBadge | null> {
+    const { data, error } = await this.db
+      .from(TABLE)
+      .select()
+      .eq("badgeid", badgeId)
+      .eq("memberid", memberId)
+      .maybeSingle();
+
+    if (error) throw error;
+    return data as MemberBadge | null;
+  }
+
+  /**
+   * Checks whether a member holds a badge.
+   */
+  public async hasBadge(badgeId: string, memberId: number): Promise<boolean> {
+    return (await this.getAward(badgeId, memberId)) !== null;
+  }
+
+  /**
+   * Retrieves every badge a member holds, with the badge details embedded.
+   * @param memberId The registrations.id of the member.
+   */
+  public async getBadgesForMember(
+    memberId: number,
+  ): Promise<MemberBadgeWithBadge[]> {
+    const { data, error } = await this.db
+      .from(TABLE)
+      .select(WITH_BADGE)
+      .eq("memberid", memberId)
+      .order("awardedat", { ascending: false });
+
+    if (error) throw error;
+    return (data ?? []) as unknown as MemberBadgeWithBadge[];
+  }
+
+  /**
+   * Retrieves every badge a visible public profile holds, with the badge
+   * details embedded. Goes through the get_public_profile_badges database
+   * function, because anon can't read the registration id the awards are
+   * keyed on.
+   * @param profileId The public_profiles.id of the member.
+   */
+  public async getBadgesForPublicProfile(
+    profileId: string,
+  ): Promise<PublicMemberBadge[]> {
+    const { data, error } = await this.db.rpc("get_public_profile_badges", {
+      p_profile_id: profileId,
+    });
+
+    if (error) throw error;
+    return (data ?? []) as PublicMemberBadge[];
+  }
+
+  /**
+   * Retrieves every award of a given badge, i.e. everyone who holds it.
+   */
+  public async getMembersWithBadge(badgeId: string): Promise<MemberBadge[]> {
+    const { data, error } = await this.db
+      .from(TABLE)
+      .select()
+      .eq("badgeid", badgeId)
+      .order("awardedat", { ascending: false });
+
+    if (error) throw error;
+    return (data ?? []) as MemberBadge[];
+  }
+
+  /**
+   * Takes a badge away from a member by deleting the join row. Deleting a badge
+   * the member doesn't hold is a no-op.
+   *
+   * This is a hard delete — the table's `revokedat`/`revokedby` columns are
+   * deliberately unused until the admin model exists to populate them.
+   */
+  public async revokeBadge(badgeId: string, memberId: number): Promise<void> {
+    const { error } = await this.db
+      .from(TABLE)
+      .delete()
+      .eq("badgeid", badgeId)
+      .eq("memberid", memberId);
+
+    if (error) throw error;
+  }
+
+  /**
+   * Deletes a member_badges row by its own ID.
+   */
+  public async revokeAwardById(id: string): Promise<void> {
+    const { error } = await this.db.from(TABLE).delete().eq("id", id);
+    if (error) throw error;
+  }
+}
diff --git a/supabase/migrations/20261001120000_badge_event_links_and_save_function.sql b/supabase/migrations/20261001120000_badge_event_links_and_save_function.sql
new file mode 100644
index 0000000..e3241a0
--- /dev/null
+++ b/supabase/migrations/20261001120000_badge_event_links_and_save_function.sql
@@ -0,0 +1,212 @@
+-- Badge <-> event relationship rules, plus a function that saves an event and
+-- its badge in one transaction.
+--
+-- Run once in the Supabase SQL Editor. Wrapped in a transaction so a failure
+-- part-way through leaves the database untouched.
+
+begin;
+
+-- Deleting an event keeps its badge (and everyone's awards of it); the badge
+-- just stops being linked to an event. Previously NO ACTION, which made
+-- deleting any event that had a badge fail.
+alter table public.badges
+  drop constraint if exists badges_eventid_fkey,
+  add constraint badges_eventid_fkey
+    foreign key (eventid) references public.events (id) on delete set null;
+
+-- Deleting a badge deletes every award of it. Previously NO ACTION, which made
+-- deleting any badge someone held fail.
+alter table public.member_badges
+  drop constraint if exists member_badges_badgeid_fkey,
+  add constraint member_badges_badgeid_fkey
+    foreign key (badgeid) references public.badges (id) on delete cascade;
+
+-- A member can hold a given badge only once. MemberBadgesService.awardBadge
+-- relies on this: it treats the unique violation as "already awarded".
+alter table public.member_badges
+  drop constraint if exists member_badges_badgeid_memberid_key,
+  add constraint member_badges_badgeid_memberid_key unique (badgeid, memberid);
+
+-- Creates or updates an event and, optionally, its badge, atomically: if any
+-- part fails, nothing is saved.
+--
+-- p_event: event columns. With an "id" key the event is updated, otherwise it
+--   is created. On update, a column whose key is absent is left unchanged,
+--   matching PUT /api/admin/events, which omits undefined fields.
+-- p_badge: badge columns (name, description, criteria, imageurl, isactive), or
+--   null to leave the event's badge as it is. Creates the event's badge if it
+--   has none, otherwise updates it. category is always EVENT and eventid is
+--   always this event; neither is read from p_badge.
+-- p_unlink_badge: detach the event's current badge (eventid -> null) without
+--   deleting it, so members keep what they earned.
+--
+-- Returns { event, badge, replaced_event_path, replaced_badge_imageurl }. The
+-- replaced_* keys hold the previous image when this call swapped it for a new
+-- one, so the caller can delete the old file from storage; otherwise null.
+create or replace function public.save_event_with_badge(
+  p_event jsonb,
+  p_badge jsonb default null,
+  p_unlink_badge boolean default false
+)
+returns jsonb
+language plpgsql
+set search_path = ''
+as $$
+declare
+  v_event public.events;
+  v_old_event public.events;
+  v_is_update boolean := p_event ? 'id';
+  v_badge public.badges;
+  v_old_badge public.badges;
+  v_had_badge boolean := false;
+  v_has_badge boolean := false;
+begin
+  if p_badge is not null and p_unlink_badge then
+    raise exception 'Cannot save and unlink a badge in the same call'
+      using errcode = '22023';
+  end if;
+
+  if v_is_update then
+    select * into v_old_event
+    from public.events
+    where id = (p_event ->> 'id')::uuid
+    for update;
+
+    if not found then
+      raise exception 'Event % not found', p_event ->> 'id'
+        using errcode = 'P0002';
+    end if;
+
+    update public.events set
+      title = case when p_event ? 'title'
+        then p_event ->> 'title' else title end,
+      description = case when p_event ? 'description'
+        then p_event ->> 'description' else description end,
+      start_time = case when p_event ? 'start_time'
+        then (p_event ->> 'start_time')::timestamptz else start_time end,
+      end_time = case when p_event ? 'end_time'
+        then (p_event ->> 'end_time')::timestamptz else end_time end,
+      check_in_open_time = case when p_event ? 'check_in_open_time'
+        then (p_event ->> 'check_in_open_time')::timestamptz
+        else check_in_open_time end,
+      check_in_close_time = case when p_event ? 'check_in_close_time'
+        then (p_event ->> 'check_in_close_time')::timestamptz
+        else check_in_close_time end,
+      event_url = case when p_event ? 'event_url'
+        then p_event ->> 'event_url' else event_url end,
+      event_path = case when p_event ? 'event_path'
+        then p_event ->> 'event_path' else event_path end,
+      location = case when p_event ? 'location'
+        then p_event ->> 'location' else location end,
+      capacity = case when p_event ? 'capacity'
+        then (p_event ->> 'capacity')::integer else capacity end
+    where id = v_old_event.id
+    returning * into v_event;
+  else
+    insert into public.events (
+      title,
+      description,
+      start_time,
+      end_time,
+      check_in_open_time,
+      check_in_close_time,
+      event_url,
+      event_path,
+      location,
+      capacity
+    )
+    values (
+      p_event ->> 'title',
+      p_event ->> 'description',
+      (p_event ->> 'start_time')::timestamptz,
+      (p_event ->> 'end_time')::timestamptz,
+      (p_event ->> 'check_in_open_time')::timestamptz,
+      (p_event ->> 'check_in_close_time')::timestamptz,
+      p_event ->> 'event_url',
+      p_event ->> 'event_path',
+      p_event ->> 'location',
+      (p_event ->> 'capacity')::integer
+    )
+    returning * into v_event;
+  end if;
+
+  -- badges.eventid is unique, so an event has at most one badge.
+  select * into v_old_badge
+  from public.badges
+  where eventid = v_event.id
+  for update;
+  v_had_badge := found;
+
+  if p_unlink_badge then
+    if v_had_badge then
+      update public.badges set eventid = null where id = v_old_badge.id;
+    end if;
+  elsif p_badge is not null then
+    if v_had_badge then
+      update public.badges set
+        name = case when p_badge ? 'name'
+          then p_badge ->> 'name' else name end,
+        description = case when p_badge ? 'description'
+          then p_badge ->> 'description' else description end,
+        criteria = case when p_badge ? 'criteria'
+          then p_badge ->> 'criteria' else criteria end,
+        imageurl = case when p_badge ? 'imageurl'
+          then p_badge ->> 'imageurl' else imageurl end,
+        isactive = case when p_badge ? 'isactive'
+          then (p_badge ->> 'isactive')::boolean else isactive end
+      where id = v_old_badge.id
+      returning * into v_badge;
+    else
+      insert into public.badges (
+        name,
+        description,
+        criteria,
+        imageurl,
+        category,
+        eventid,
+        isactive
+      )
+      values (
+        p_badge ->> 'name',
+        p_badge ->> 'description',
+        p_badge ->> 'criteria',
+        p_badge ->> 'imageurl',
+        'EVENT',
+        v_event.id,
+        coalesce((p_badge ->> 'isactive')::boolean, true)
+      )
+      returning * into v_badge;
+    end if;
+    v_has_badge := true;
+  elsif v_had_badge then
+    v_badge := v_old_badge;
+    v_has_badge := true;
+  end if;
+
+  return jsonb_build_object(
+    'event', to_jsonb(v_event),
+    'badge', case when v_has_badge then to_jsonb(v_badge) end,
+    'replaced_event_path', case
+      when v_is_update
+        and v_old_event.event_path is distinct from v_event.event_path
+      then v_old_event.event_path
+    end,
+    'replaced_badge_imageurl', case
+      when v_had_badge
+        and p_badge is not null
+        and v_old_badge.imageurl is distinct from v_badge.imageurl
+      then v_old_badge.imageurl
+    end
+  );
+end;
+$$;
+
+-- Supabase grants EXECUTE on new public functions to anon and authenticated
+-- by default, which would let anyone call this with the public key and skip
+-- the admin check. Only the server (service role) may call it.
+revoke all on function public.save_event_with_badge(jsonb, jsonb, boolean)
+  from public, anon, authenticated;
+grant execute on function public.save_event_with_badge(jsonb, jsonb, boolean)
+  to service_role;
+
+commit;
diff --git a/supabase/migrations/20261007120000_delete_event_badge_with_event.sql b/supabase/migrations/20261007120000_delete_event_badge_with_event.sql
new file mode 100644
index 0000000..b6ce298
--- /dev/null
+++ b/supabase/migrations/20261007120000_delete_event_badge_with_event.sql
@@ -0,0 +1,213 @@
+-- An event's badge now goes with the event, instead of being kept unlinked:
+--
+-- - Deleting an event deletes its badge, and with it every member's award of
+--   that badge (member_badges_badgeid_fkey is already ON DELETE CASCADE).
+-- - Removing the badge while editing an event deletes it the same way, so
+--   save_event_with_badge's p_unlink_badge becomes p_remove_badge.
+--
+-- Replaces the behaviour from 20261001120000_badge_event_links_and_save_function.
+-- Run once in the Supabase SQL Editor. Wrapped in a transaction so a failure
+-- part-way through leaves the database untouched.
+
+begin;
+
+-- Previously ON DELETE SET NULL.
+alter table public.badges
+  drop constraint if exists badges_eventid_fkey,
+  add constraint badges_eventid_fkey
+    foreign key (eventid) references public.events (id) on delete cascade;
+
+-- A parameter can't be renamed by CREATE OR REPLACE, so the function is
+-- dropped and recreated; the grants below are re-applied for the same reason.
+drop function if exists public.save_event_with_badge(jsonb, jsonb, boolean);
+
+-- Creates or updates an event and, optionally, its badge, atomically: if any
+-- part fails, nothing is saved.
+--
+-- p_event: event columns. With an "id" key the event is updated, otherwise it
+--   is created. On update, a column whose key is absent is left unchanged,
+--   matching PUT /api/admin/events, which omits undefined fields.
+-- p_badge: badge columns (name, description, criteria, imageurl, isactive), or
+--   null to leave the event's badge as it is. Creates the event's badge if it
+--   has none, otherwise updates it. category is always EVENT and eventid is
+--   always this event; neither is read from p_badge.
+-- p_remove_badge: delete the event's current badge, and with it every
+--   member's award of it.
+--
+-- Returns { event, badge, replaced_event_path, replaced_badge_imageurl,
+-- removed_badge_imageurl }. The replaced_* keys hold the previous image when
+-- this call swapped it for a new one, and removed_badge_imageurl the image of
+-- a badge this call deleted, so the caller can delete those files from
+-- storage; otherwise null.
+create function public.save_event_with_badge(
+  p_event jsonb,
+  p_badge jsonb default null,
+  p_remove_badge boolean default false
+)
+returns jsonb
+language plpgsql
+set search_path = ''
+as $$
+declare
+  v_event public.events;
+  v_old_event public.events;
+  v_is_update boolean := p_event ? 'id';
+  v_badge public.badges;
+  v_old_badge public.badges;
+  v_had_badge boolean := false;
+  v_has_badge boolean := false;
+begin
+  if p_badge is not null and p_remove_badge then
+    raise exception 'Cannot save and remove a badge in the same call'
+      using errcode = '22023';
+  end if;
+
+  if v_is_update then
+    select * into v_old_event
+    from public.events
+    where id = (p_event ->> 'id')::uuid
+    for update;
+
+    if not found then
+      raise exception 'Event % not found', p_event ->> 'id'
+        using errcode = 'P0002';
+    end if;
+
+    update public.events set
+      title = case when p_event ? 'title'
+        then p_event ->> 'title' else title end,
+      description = case when p_event ? 'description'
+        then p_event ->> 'description' else description end,
+      start_time = case when p_event ? 'start_time'
+        then (p_event ->> 'start_time')::timestamptz else start_time end,
+      end_time = case when p_event ? 'end_time'
+        then (p_event ->> 'end_time')::timestamptz else end_time end,
+      check_in_open_time = case when p_event ? 'check_in_open_time'
+        then (p_event ->> 'check_in_open_time')::timestamptz
+        else check_in_open_time end,
+      check_in_close_time = case when p_event ? 'check_in_close_time'
+        then (p_event ->> 'check_in_close_time')::timestamptz
+        else check_in_close_time end,
+      event_url = case when p_event ? 'event_url'
+        then p_event ->> 'event_url' else event_url end,
+      event_path = case when p_event ? 'event_path'
+        then p_event ->> 'event_path' else event_path end,
+      location = case when p_event ? 'location'
+        then p_event ->> 'location' else location end,
+      capacity = case when p_event ? 'capacity'
+        then (p_event ->> 'capacity')::integer else capacity end
+    where id = v_old_event.id
+    returning * into v_event;
+  else
+    insert into public.events (
+      title,
+      description,
+      start_time,
+      end_time,
+      check_in_open_time,
+      check_in_close_time,
+      event_url,
+      event_path,
+      location,
+      capacity
+    )
+    values (
+      p_event ->> 'title',
+      p_event ->> 'description',
+      (p_event ->> 'start_time')::timestamptz,
+      (p_event ->> 'end_time')::timestamptz,
+      (p_event ->> 'check_in_open_time')::timestamptz,
+      (p_event ->> 'check_in_close_time')::timestamptz,
+      p_event ->> 'event_url',
+      p_event ->> 'event_path',
+      p_event ->> 'location',
+      (p_event ->> 'capacity')::integer
+    )
+    returning * into v_event;
+  end if;
+
+  -- badges.eventid is unique, so an event has at most one badge.
+  select * into v_old_badge
+  from public.badges
+  where eventid = v_event.id
+  for update;
+  v_had_badge := found;
+
+  if p_remove_badge then
+    if v_had_badge then
+      -- member_badges_badgeid_fkey cascades, deleting every award of it.
+      delete from public.badges where id = v_old_badge.id;
+    end if;
+  elsif p_badge is not null then
+    if v_had_badge then
+      update public.badges set
+        name = case when p_badge ? 'name'
+          then p_badge ->> 'name' else name end,
+        description = case when p_badge ? 'description'
+          then p_badge ->> 'description' else description end,
+        criteria = case when p_badge ? 'criteria'
+          then p_badge ->> 'criteria' else criteria end,
+        imageurl = case when p_badge ? 'imageurl'
+          then p_badge ->> 'imageurl' else imageurl end,
+        isactive = case when p_badge ? 'isactive'
+          then (p_badge ->> 'isactive')::boolean else isactive end
+      where id = v_old_badge.id
+      returning * into v_badge;
+    else
+      insert into public.badges (
+        name,
+        description,
+        criteria,
+        imageurl,
+        category,
+        eventid,
+        isactive
+      )
+      values (
+        p_badge ->> 'name',
+        p_badge ->> 'description',
+        p_badge ->> 'criteria',
+        p_badge ->> 'imageurl',
+        'EVENT',
+        v_event.id,
+        coalesce((p_badge ->> 'isactive')::boolean, true)
+      )
+      returning * into v_badge;
+    end if;
+    v_has_badge := true;
+  elsif v_had_badge then
+    v_badge := v_old_badge;
+    v_has_badge := true;
+  end if;
+
+  return jsonb_build_object(
+    'event', to_jsonb(v_event),
+    'badge', case when v_has_badge then to_jsonb(v_badge) end,
+    'replaced_event_path', case
+      when v_is_update
+        and v_old_event.event_path is distinct from v_event.event_path
+      then v_old_event.event_path
+    end,
+    'replaced_badge_imageurl', case
+      when v_had_badge
+        and p_badge is not null
+        and v_old_badge.imageurl is distinct from v_badge.imageurl
+      then v_old_badge.imageurl
+    end,
+    'removed_badge_imageurl', case
+      when v_had_badge and p_remove_badge
+      then v_old_badge.imageurl
+    end
+  );
+end;
+$$;
+
+-- Supabase grants EXECUTE on new public functions to anon and authenticated
+-- by default, which would let anyone call this with the public key and skip
+-- the admin check. Only the server (service role) may call it.
+revoke all on function public.save_event_with_badge(jsonb, jsonb, boolean)
+  from public, anon, authenticated;
+grant execute on function public.save_event_with_badge(jsonb, jsonb, boolean)
+  to service_role;
+
+commit;
diff --git a/supabase/migrations/20261008120000_get_public_profile_badges.sql b/supabase/migrations/20261008120000_get_public_profile_badges.sql
new file mode 100644
index 0000000..cfec691
--- /dev/null
+++ b/supabase/migrations/20261008120000_get_public_profile_badges.sql
@@ -0,0 +1,47 @@
+-- Lets the public profile page (/profile/[id]) load a member's badges.
+--
+-- member_badges.memberid refers to registrations.id, but anon can't read
+-- public_profiles.registration_id, so the page can't get from a public profile
+-- to its badges by itself. This function does that step in the database and
+-- returns the awards without memberid, so the registration id never reaches
+-- the browser.
+--
+-- Only visible profiles are found: hiding a profile deletes its
+-- public_profiles row.
+--
+-- Run once in the Supabase SQL Editor.
+
+create or replace function public.get_public_profile_badges(p_profile_id uuid)
+returns table (
+  id uuid,
+  badgeid uuid,
+  awardedat timestamptz,
+  badge jsonb
+)
+language sql
+stable
+security definer
+set search_path = ''
+as $function$
+  select
+    member_award.id,
+    member_award.badgeid,
+    member_award.awardedat,
+    pg_catalog.to_jsonb(awarded_badge)
+  from public.public_profiles as visible_profile
+  join public.member_badges as member_award
+    on member_award.memberid = visible_profile.registration_id
+  join public.badges as awarded_badge
+    on awarded_badge.id = member_award.badgeid
+  where visible_profile.id = p_profile_id
+  order by member_award.awardedat desc;
+$function$;
+
+comment on function public.get_public_profile_badges(uuid) is
+  'Returns the badges of a visible public profile, without exposing its registration id.';
+
+revoke all on function public.get_public_profile_badges(uuid)
+  from public;
+
+grant execute on function public.get_public_profile_badges(uuid)
+  to anon, authenticated, service_role;
diff --git a/{, b/{,
new file mode 100644
index 0000000..e69de29