diff --git a/.env.example b/.env.example
index c2499ff..a0dacb5 100644
--- a/.env.example
+++ b/.env.example
@@ -45,6 +45,9 @@ RESEND_FROM=moshcoding <noreply@moshcoding.com>
 # OpenAI — AI hero image for ?style=<genre> tenant pages (gpt-image-*).
 OPENAI_API_KEY=sk-xxx
 OPENAI_IMAGE_MODEL=gpt-image-2
-# Where generated images are cached. Mount a Railway volume here to persist
-# across deploys (otherwise images regenerate after each deploy).
+# Where generated images are cached AND uploaded reels (dashboard → Videos) are
+# stored. Mount a Railway volume here to persist across deploys (otherwise
+# generated images regenerate and uploaded videos are lost after each deploy).
 DATA_DIR=.data
+# Max size per uploaded reel, in bytes (default 100 MB).
+# MEDIA_MAX_BYTES=104857600
diff --git a/README.md b/README.md
index 661513f..4530f55 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,10 @@ while (alive) {
 
 ## Brand kit
 
-Everything in `images/` and `videos/` is the visual identity.
+Everything in `images/` and `videos/` is the visual identity. A curated pair of
+brand reels is served at [`/videos`](https://moshcoding.com/videos) (from
+`public/videos/`); page owners can also upload their own mp4 reels per parked
+domain from the dashboard.
 
 | Asset | File |
 |-------|------|
diff --git a/app/api/account/route.ts b/app/api/account/route.ts
index ac0c5ac..d39f730 100644
--- a/app/api/account/route.ts
+++ b/app/api/account/route.ts
@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
-import { readSession, authConfigured, SESSION_COOKIE } from "@/lib/session";
-import { getAccountById, updateAccountProfile, updateAccountConfig, findOrCreateAccountByEmail, setAccountDomain, listParkedDomains } from "@/lib/db";
+import { getAccountById, updateAccountProfile, updateAccountConfig, setAccountDomain, listParkedDomains } from "@/lib/db";
+import { resolveAccountId } from "@/lib/api";
 import { normalizeHandle, normalizeUrl, coerceRgba, parseHashtags, safeDomain } from "@/lib/config";
 import { payUrl } from "@/lib/coinpay";
 import { provisionTenant } from "@/lib/provision";
@@ -12,16 +12,6 @@ export const dynamic = "force-dynamic";
 const PLATFORMS = ["x", "bluesky", "instagram", "tiktok", "github", "youtube"];
 const TEXT_FIELDS = ["brand", "headline", "tagline", "sub"] as const;
 
-/** Resolves the tenant account for the session: native (acct:) or CoinPay (by email). */
-async function resolveAccountId(req: NextRequest): Promise<string | null> {
-  if (!authConfigured()) return null;
-  const s = readSession(req.cookies.get(SESSION_COOKIE)?.value);
-  if (!s) return null;
-  if (s.sub?.startsWith("acct:")) return s.sub.slice("acct:".length);
-  if (s.email) return (await findOrCreateAccountByEmail(s.email)).id;
-  return null;
-}
-
 function cleanWallet(v: unknown): string | null {
   if (typeof v !== "string") return null;
   const w = v.trim();
diff --git a/app/api/media/[id]/route.ts b/app/api/media/[id]/route.ts
new file mode 100644
index 0000000..5e09d72
--- /dev/null
+++ b/app/api/media/[id]/route.ts
@@ -0,0 +1,64 @@
+import { NextRequest, NextResponse } from "next/server";
+import { Readable } from "node:stream";
+import { resolveAccountId, bad, unauthorized } from "@/lib/api";
+import { accountOwnsDomain, getMedia, deleteMedia } from "@/lib/db";
+import { mediaSize, mediaStream, deleteMediaFile } from "@/lib/media";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+// Stream a reel with HTTP range support so <video> can seek/scrub.
+export async function GET(req: NextRequest, ctx: { params: Promise<{ id: string }> }) {
+  const { id } = await ctx.params;
+  const m = await getMedia(id);
+  if (!m) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const size = mediaSize(m.filename);
+  if (size == null) return NextResponse.json({ error: "File missing" }, { status: 404 });
+
+  const baseHeaders: Record<string, string> = {
+    "content-type": m.content_type,
+    "accept-ranges": "bytes",
+    "cache-control": "public, max-age=31536000, immutable",
+  };
+
+  const range = req.headers.get("range");
+  const m2 = range ? /^bytes=(\d*)-(\d*)$/.exec(range.trim()) : null;
+  if (m2) {
+    let start = m2[1] ? parseInt(m2[1], 10) : 0;
+    let end = m2[2] ? parseInt(m2[2], 10) : size - 1;
+    if (Number.isNaN(start) || Number.isNaN(end) || start > end || start >= size) {
+      return new NextResponse(null, {
+        status: 416,
+        headers: { "content-range": `bytes */${size}`, "accept-ranges": "bytes" },
+      });
+    }
+    end = Math.min(end, size - 1);
+    const stream = Readable.toWeb(mediaStream(m.filename, start, end)) as ReadableStream;
+    return new NextResponse(stream, {
+      status: 206,
+      headers: {
+        ...baseHeaders,
+        "content-range": `bytes ${start}-${end}/${size}`,
+        "content-length": String(end - start + 1),
+      },
+    });
+  }
+
+  const stream = Readable.toWeb(mediaStream(m.filename)) as ReadableStream;
+  return new NextResponse(stream, { status: 200, headers: { ...baseHeaders, "content-length": String(size) } });
+}
+
+// Delete a reel (owner of its domain, or admin).
+export async function DELETE(req: NextRequest, ctx: { params: Promise<{ id: string }> }) {
+  const accountId = await resolveAccountId(req);
+  if (!accountId) return unauthorized();
+  const { id } = await ctx.params;
+  const m = await getMedia(id);
+  if (!m) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (!(await accountOwnsDomain(accountId, m.dn))) return bad("You don't own that domain.", 403);
+
+  const removed = await deleteMedia(id);
+  if (removed) deleteMediaFile(removed.filename);
+  return NextResponse.json({ ok: true });
+}
diff --git a/app/api/media/route.ts b/app/api/media/route.ts
new file mode 100644
index 0000000..251dba7
--- /dev/null
+++ b/app/api/media/route.ts
@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomBytes } from "node:crypto";
+import { resolveAccountId, bad, unauthorized } from "@/lib/api";
+import { accountOwnsDomain, addMedia, listMedia, type Media } from "@/lib/db";
+import { safeDomain } from "@/lib/config";
+import { writeMedia, ALLOWED_TYPES, MAX_UPLOAD_BYTES } from "@/lib/media";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/** Public view of a reel — the streaming URL + safe metadata. */
+function mediaView(m: Media) {
+  return {
+    id: m.id,
+    dn: m.dn,
+    title: m.title || m.orig_name || "reel",
+    content_type: m.content_type,
+    size: m.size,
+    created_at: m.created_at,
+    url: `/api/media/${m.id}`,
+  };
+}
+
+// List reels for a domain (public — reels are public content).
+export async function GET(req: NextRequest) {
+  const dn = safeDomain(req.nextUrl.searchParams.get("dn") || "moshcoding.com");
+  if (!dn) return bad("valid dn required");
+  const rows = await listMedia(dn);
+  return NextResponse.json({ dn, media: rows.map(mediaView) });
+}
+
+// Upload a reel to a parked domain the signed-in account owns (or as admin).
+export async function POST(req: NextRequest) {
+  const accountId = await resolveAccountId(req);
+  if (!accountId) return unauthorized();
+
+  const form = await req.formData().catch(() => null);
+  if (!form) return bad("expected multipart/form-data");
+
+  const dn = safeDomain(form.get("dn"));
+  if (!dn) return bad("valid dn required");
+  if (!(await accountOwnsDomain(accountId, dn))) {
+    return bad("You don't own that domain.", 403);
+  }
+
+  const file = form.get("file");
+  if (!(file instanceof File) || file.size === 0) return bad("file required");
+
+  const type = file.type || "video/mp4";
+  const ext = ALLOWED_TYPES[type];
+  if (!ext) return bad("Only mp4, webm or mov videos are allowed.");
+  if (file.size > MAX_UPLOAD_BYTES) {
+    return bad(`File too large (max ${Math.floor(MAX_UPLOAD_BYTES / (1024 * 1024))} MB).`);
+  }
+
+  const bytes = Buffer.from(await file.arrayBuffer());
+  const id = randomBytes(16).toString("hex");
+  const filename = `${id}${ext}`;
+  await writeMedia(filename, bytes);
+
+  const title = String(form.get("title") || "").trim().slice(0, 120) || file.name;
+  const media = await addMedia({
+    id,
+    dn,
+    accountId,
+    filename,
+    origName: file.name,
+    title,
+    contentType: type,
+    size: bytes.length,
+  });
+  return NextResponse.json({ media: mediaView(media) }, { status: 201 });
+}
diff --git a/app/dashboard/page.tsx b/app/dashboard/page.tsx
index aed271e..8900570 100644
--- a/app/dashboard/page.tsx
+++ b/app/dashboard/page.tsx
@@ -1,5 +1,5 @@
 "use client";
-import { useEffect, useState, useCallback } from "react";
+import { useEffect, useState, useCallback, useRef } from "react";
 import { copyText } from "@/lib/clipboard";
 
 type Org = { id: string; name: string };
@@ -29,7 +29,7 @@ export default function Dashboard() {
   const [teamOrg, setTeamOrg] = useState("");
   const [projName, setProjName] = useState("");
   const [projTeam, setProjTeam] = useState("");
-  const [tab, setTab] = useState<"page" | "waitlist" | "auctions" | "webhooks" | "affiliates">("page");
+  const [tab, setTab] = useState<"page" | "videos" | "waitlist" | "auctions" | "webhooks" | "affiliates">("page");
 
   const say = (t: string, ok = true) => setMsg({ t, ok });
 
@@ -84,6 +84,7 @@ export default function Dashboard() {
 
       <div className="tabs">
         <button className={`tab${tab === "page" ? " on" : ""}`} onClick={() => setTab("page")}>Domains</button>
+        <button className={`tab${tab === "videos" ? " on" : ""}`} onClick={() => setTab("videos")}>Videos</button>
         <button className={`tab${tab === "waitlist" ? " on" : ""}`} onClick={() => setTab("waitlist")}>Waitlist</button>
         <button className={`tab${tab === "auctions" ? " on" : ""}`} onClick={() => setTab("auctions")}>Auctions</button>
         <button className={`tab${tab === "webhooks" ? " on" : ""}`} onClick={() => setTab("webhooks")}>Webhooks</button>
@@ -96,6 +97,8 @@ export default function Dashboard() {
         <DomainWebhooksPanel onError={(m) => say(m, false)} onOk={(m) => say(m, true)} />
       ) : tab === "auctions" ? (
         <AuctionsPanel onError={(m) => say(m, false)} onOk={(m) => say(m, true)} />
+      ) : tab === "videos" ? (
+        <VideosPanel onError={(m) => say(m, false)} onOk={(m) => say(m, true)} />
       ) : tab === "waitlist" ? (
         <WaitlistPanel onError={(m) => say(m, false)} />
       ) : (
@@ -418,6 +421,115 @@ function AccountPanel({ onError, onOk }: { onError: (m: string) => void; onOk: (
   );
 }
 
+function VideosPanel({ onError, onOk }: { onError: (m: string) => void; onOk: (m: string) => void }) {
+  const [domains, setDomains] = useState<any[] | undefined>(undefined);
+  const [active, setActive] = useState<string | null>(null);
+  const [reels, setReels] = useState<any[] | null>(null);
+  const [title, setTitle] = useState("");
+  const [file, setFile] = useState<File | null>(null);
+  const [busy, setBusy] = useState(false);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const load = async (dn: string) => {
+    setActive(dn); setReels(null);
+    try {
+      const r = await fetch(`/api/media?dn=${encodeURIComponent(dn)}`);
+      const d = await r.json();
+      if (!r.ok) throw new Error(d.error);
+      setReels(d.media || []);
+    } catch (e: any) { onError(e.message || "Failed to load."); setReels([]); }
+  };
+
+  useEffect(() => {
+    fetch("/api/account").then((r) => r.json()).then((d) => {
+      const list = [...(d.parkedDomains || [])];
+      // Admins can also populate the public moshcoding.com /videos gallery.
+      if (d.account?.is_admin && !list.some((x: any) => x.domain === "moshcoding.com")) {
+        list.unshift({ domain: "moshcoding.com" });
+      }
+      setDomains(list);
+      if (list[0]) load(list[0].domain);
+    }).catch(() => setDomains([]));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const upload = async () => {
+    if (!active || !file) return;
+    setBusy(true);
+    try {
+      const fd = new FormData();
+      fd.append("dn", active);
+      fd.append("file", file);
+      if (title.trim()) fd.append("title", title.trim());
+      const r = await fetch("/api/media", { method: "POST", body: fd });
+      const d = await r.json();
+      if (!r.ok) throw new Error(d.error);
+      onOk("Reel uploaded. 🤘");
+      setTitle(""); setFile(null);
+      if (inputRef.current) inputRef.current.value = "";
+      await load(active);
+    } catch (e: any) { onError(e.message || "Upload failed."); } finally { setBusy(false); }
+  };
+
+  const del = async (id: string) => {
+    if (typeof window !== "undefined" && !window.confirm("Delete this reel?")) return;
+    setBusy(true);
+    try {
+      const r = await fetch(`/api/media/${id}`, { method: "DELETE" });
+      const d = await r.json().catch(() => ({}));
+      if (!r.ok) throw new Error(d.error || "Delete failed.");
+      onOk("Deleted.");
+      if (active) await load(active);
+    } catch (e: any) { onError(e.message || "Delete failed."); } finally { setBusy(false); }
+  };
+
+  if (domains === undefined) return <section className="card2"><p className="sub">Loading…</p></section>;
+  if (!domains.length) {
+    return <section className="card2"><h2>Videos</h2><p className="sub">No parked domains yet — claim one on the “Domains” tab and you can upload reels for it here.</p></section>;
+  }
+
+  return (
+    <section className="card2">
+      <h2>Videos</h2>
+      <p className="sub">Upload mp4 reels per parked domain. Reels for moshcoding.com also show on the public <a href="/videos">/videos</a> gallery.</p>
+      <div className="tabs" style={{ flexWrap: "wrap" }}>
+        {domains.map((d) => (
+          <button key={d.domain} className={`tab${active === d.domain ? " on" : ""}`} onClick={() => load(d.domain)}>{d.domain}</button>
+        ))}
+      </div>
+      {active && (
+        <>
+          <h3 className="ed-h">Upload a reel <span className="muted">(mp4 / webm / mov, max 100 MB)</span></h3>
+          <div className="row"><input className="inp" placeholder="Title (optional)" value={title} onChange={(e) => setTitle(e.target.value)} /></div>
+          <div className="row">
+            <input ref={inputRef} className="inp" type="file" accept="video/mp4,video/webm,video/quicktime" onChange={(e) => setFile(e.target.files?.[0] || null)} />
+            <button className="btn2" disabled={busy || !file} onClick={upload}>{busy ? "Uploading…" : "Upload"}</button>
+          </div>
+
+          <h3 className="ed-h" style={{ marginTop: 18 }}>Reels ({reels ? reels.length : "…"})</h3>
+          {reels === null ? (
+            <p className="sub">Loading…</p>
+          ) : reels.length === 0 ? (
+            <p className="sub">No reels yet — upload one above.</p>
+          ) : (
+            <div className="video-grid">
+              {reels.map((m) => (
+                <figure key={m.id} className="video-cell">
+                  <video src={m.url} controls preload="metadata" playsInline />
+                  <figcaption className="row" style={{ justifyContent: "space-between", alignItems: "center" }}>
+                    <span>{m.title}</span>
+                    <button className="btn2 ghost" disabled={busy} onClick={() => del(m.id)}>Delete</button>
+                  </figcaption>
+                </figure>
+              ))}
+            </div>
+          )}
+        </>
+      )}
+    </section>
+  );
+}
+
 function WaitlistPanel({ onError }: { onError: (m: string) => void }) {
   const [domains, setDomains] = useState<any[] | undefined>(undefined);
   const [active, setActive] = useState<string | null>(null);
diff --git a/app/globals.css b/app/globals.css
index 5d6eb36..50a175f 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -330,6 +330,14 @@ h2 { font-family: var(--display); font-weight: 400; text-transform: uppercase; f
 .badge-cell:hover { border-color: var(--acid); transform: translateY(-2px); }
 .badge-cell img { max-width: 100%; max-height: 100%; object-fit: contain; display: block; }
 
+/* /videos gallery + dashboard reel tiles */
+.video-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); gap: 16px; margin-top: 24px; }
+.video-cell { margin: 0; background: #111214; border: 1px solid #262629; border-radius: 12px; overflow: hidden; transition: border-color .15s ease; }
+.video-cell:hover { border-color: var(--acid); }
+.video-cell video { display: block; width: 100%; max-height: 60vh; background: #000; aspect-ratio: 16 / 9; object-fit: contain; }
+.video-cell.portrait video { aspect-ratio: 9 / 16; }
+.video-cell figcaption { font-family: var(--mono); font-size: 11px; color: var(--ash); padding: 8px 10px; text-transform: uppercase; letter-spacing: .08em; word-break: break-word; }
+
 /* Tenant "Post it" share row */
 .share { max-width: 460px; margin: 18px auto 0; width: 100%; }
 .share-h { font-family: var(--mono); font-size: 11px; letter-spacing: 0.18em; text-transform: uppercase; color: var(--ash); margin: 0 0 8px; text-align: center; }
diff --git a/app/videos/page.tsx b/app/videos/page.tsx
new file mode 100644
index 0000000..aef0d7f
--- /dev/null
+++ b/app/videos/page.tsx
@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Metadata } from "next";
+import { listMedia } from "@/lib/db";
+
+export const dynamic = "force-dynamic";
+
+export const metadata: Metadata = {
+  title: "#VIDEOS — moshcoding reels",
+  description: "moshcoding mp4 reels & clips. Code hard, mosh harder — watch the pit.",
+};
+
+type Reel = { src: string; title: string; portrait: boolean };
+
+/** Built-in brand reels shipped in public/videos. */
+function builtinReels(): Reel[] {
+  try {
+    const dir = path.join(process.cwd(), "public", "videos");
+    return fs
+      .readdirSync(dir)
+      .filter((f) => f.toLowerCase().endsWith(".mp4"))
+      .sort()
+      .map((f) => ({
+        src: `/videos/${f}`,
+        title: f.replace(/\.mp4$/i, "").replace(/-/g, " ").trim(),
+        portrait: /9x16/i.test(f),
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/** Reels uploaded to the main gallery from the dashboard (best-effort; DB may be off in dev). */
+async function uploadedReels(): Promise<Reel[]> {
+  try {
+    const rows = await listMedia("moshcoding.com");
+    return rows.map((m) => ({
+      src: `/api/media/${m.id}`,
+      title: m.title || m.orig_name || "reel",
+      portrait: false,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export default async function VideosPage() {
+  const reels = [...(await uploadedReels()), ...builtinReels()];
+  return (
+    <div className="dash">
+      <div className="row" style={{ justifyContent: "space-between" }}>
+        <div>
+          <h1>#VIDEOS</h1>
+          <p className="sub">
+            mp4 reels &amp; clips — code hard, mosh harder. {reels.length} clip{reels.length === 1 ? "" : "s"}.
+          </p>
+        </div>
+        <a className="btn2 ghost" href="/">← home</a>
+      </div>
+
+      {reels.length === 0 ? (
+        <p className="sub">No videos yet.</p>
+      ) : (
+        <div className="video-grid">
+          {reels.map((r) => (
+            <figure key={r.src} className={`video-cell${r.portrait ? " portrait" : ""}`}>
+              <video src={r.src} controls preload="metadata" playsInline />
+              <figcaption>{r.title}</figcaption>
+            </figure>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/components/Landing.tsx b/components/Landing.tsx
index 4fa06d2..9147314 100644
--- a/components/Landing.tsx
+++ b/components/Landing.tsx
@@ -72,7 +72,7 @@ export default function Landing() {
         <a href="/badges"><figure><img src="/assets/badge-code-hard.png" alt="Code Hard badge" /><figcaption>Code Hard</figcaption></figure></a>
         <a href="/badges"><figure><img src="/assets/badge-no-bugs.png" alt="No Bugs, Just Features badge" /><figcaption>No Bugs, Just Features</figcaption></figure></a>
         <a href="/badges"><figure><img src="/assets/badge-push-code.png" alt="Push Code, Start Pits badge" /><figcaption>Push Code, Start Pits</figcaption></figure></a>
-        <p className="badges-cta"><a href="/badges">Get the full media kit →</a></p>
+        <p className="badges-cta"><a href="/badges">Get the full media kit →</a> · <a href="/videos">Watch the reels →</a></p>
       </section>
 
       <section id="waitlist" className="waitlist">
diff --git a/components/Nav.tsx b/components/Nav.tsx
index 2842a22..41f42ed 100644
--- a/components/Nav.tsx
+++ b/components/Nav.tsx
@@ -22,6 +22,7 @@ export default function Nav() {
         <a href="#chaos">The one-liner</a>
         <a href="#waitlist">Waitlist</a>
         <a href="/badges">Badges</a>
+        <a href="/videos">Videos</a>
         <a className="ghost" href="https://github.com/moshcoder/moshcoding" target="_blank" rel="noopener noreferrer">GitHub</a>
         <AuthSlot />
       </nav>
diff --git a/lib/api.ts b/lib/api.ts
index 5166754..088ecd1 100644
--- a/lib/api.ts
+++ b/lib/api.ts
@@ -1,5 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { sessionUser, getOrCreateUser } from "./authz";
+import { readSession, authConfigured, SESSION_COOKIE } from "./session";
+import { findOrCreateAccountByEmail } from "./db";
 
 /** Resolve the authenticated user (provisioning a default org/team on first hit). */
 export async function requireUser(req: NextRequest) {
@@ -9,5 +11,19 @@ export async function requireUser(req: NextRequest) {
   return s;
 }
 
+/**
+ * Resolves the tenant *account* id for the session — native (`acct:<id>`) or a
+ * CoinPay-OAuth user (looked up / created by email). This is the identity the
+ * dashboard's page/waitlist/auctions/media features are scoped to.
+ */
+export async function resolveAccountId(req: NextRequest): Promise<string | null> {
+  if (!authConfigured()) return null;
+  const s = readSession(req.cookies.get(SESSION_COOKIE)?.value);
+  if (!s) return null;
+  if (s.sub?.startsWith("acct:")) return s.sub.slice("acct:".length);
+  if (s.email) return (await findOrCreateAccountByEmail(s.email)).id;
+  return null;
+}
+
 export const unauthorized = () => NextResponse.json({ error: "Sign in first." }, { status: 401 });
 export const bad = (msg: string, status = 400) => NextResponse.json({ error: msg }, { status });
diff --git a/lib/db.ts b/lib/db.ts
index 737d26e..27f8bf0 100644
--- a/lib/db.ts
+++ b/lib/db.ts
@@ -285,6 +285,26 @@ async function initSchema(): Promise<void> {
     )
   `);
   await d.execute(`CREATE INDEX IF NOT EXISTS idx_domain_inbound_dn ON domain_inbound_events (dn, created_at)`);
+
+  // ---- uploaded media: mp4 reels & clips, one row per file -----------------
+  // Bytes live on the DATA_DIR volume (lib/media.ts); this is just metadata so
+  // the gallery + dashboard can list, order, and stream them. `dn` is the parked
+  // domain the reel belongs to ('moshcoding.com' for the main /videos gallery).
+  await d.execute(`
+    CREATE TABLE IF NOT EXISTS media (
+      id           TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      dn           TEXT NOT NULL,
+      account_id   TEXT,
+      kind         TEXT NOT NULL DEFAULT 'video',
+      filename     TEXT NOT NULL,
+      orig_name    TEXT,
+      title        TEXT,
+      content_type TEXT NOT NULL DEFAULT 'video/mp4',
+      size         INTEGER NOT NULL DEFAULT 0,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await d.execute(`CREATE INDEX IF NOT EXISTS idx_media_dn ON media (dn, created_at)`);
 }
 
 /** Adds ADD COLUMN, ignoring the error when the column already exists. */
@@ -1044,6 +1064,88 @@ export async function listReferrals(code: string): Promise<{ email: string; doma
   }));
 }
 
+// ---- uploaded media (mp4 reels) -------------------------------------------
+
+export type Media = {
+  id: string;
+  dn: string;
+  account_id: string | null;
+  kind: string;
+  filename: string;
+  orig_name: string | null;
+  title: string | null;
+  content_type: string;
+  size: number;
+  created_at: string;
+};
+
+function rowToMedia(r: any): Media {
+  return {
+    id: String(r.id),
+    dn: String(r.dn),
+    account_id: r.account_id ? String(r.account_id) : null,
+    kind: String(r.kind || "video"),
+    filename: String(r.filename),
+    orig_name: r.orig_name ? String(r.orig_name) : null,
+    title: r.title ? String(r.title) : null,
+    content_type: String(r.content_type || "video/mp4"),
+    size: Number(r.size || 0),
+    created_at: String(r.created_at),
+  };
+}
+
+/** Inserts a media row. The caller has already written the bytes to the volume. */
+export async function addMedia(opts: {
+  id: string;
+  dn: string;
+  accountId: string | null;
+  filename: string;
+  origName?: string | null;
+  title?: string | null;
+  contentType?: string;
+  size?: number;
+}): Promise<Media> {
+  await ensureSchema();
+  const res = await db().execute({
+    sql: `INSERT INTO media (id, dn, account_id, filename, orig_name, title, content_type, size)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+    args: [
+      opts.id,
+      opts.dn.trim().toLowerCase(),
+      opts.accountId,
+      opts.filename,
+      opts.origName ?? null,
+      opts.title ?? null,
+      opts.contentType || "video/mp4",
+      opts.size || 0,
+    ],
+  });
+  return rowToMedia(res.rows[0]);
+}
+
+/** Reels for a domain, newest first. */
+export async function listMedia(dn: string, limit = 200): Promise<Media[]> {
+  await ensureSchema();
+  const res = await db().execute({
+    sql: `SELECT * FROM media WHERE dn = ? ORDER BY created_at DESC LIMIT ?`,
+    args: [dn.trim().toLowerCase(), Math.min(limit, 500)],
+  });
+  return res.rows.map(rowToMedia);
+}
+
+export async function getMedia(id: string): Promise<Media | null> {
+  await ensureSchema();
+  const res = await db().execute({ sql: `SELECT * FROM media WHERE id = ?`, args: [id] });
+  return res.rows[0] ? rowToMedia(res.rows[0]) : null;
+}
+
+/** Deletes the row and returns it (so the caller can unlink the file), or null. */
+export async function deleteMedia(id: string): Promise<Media | null> {
+  await ensureSchema();
+  const res = await db().execute({ sql: `DELETE FROM media WHERE id = ? RETURNING *`, args: [id] });
+  return res.rows[0] ? rowToMedia(res.rows[0]) : null;
+}
+
 /** Loads the override config for a provisioned tenant, or null if none. */
 export async function getTenantConfig(domain: string): Promise<Record<string, unknown> | null> {
   await ensureSchema();
diff --git a/lib/media.ts b/lib/media.ts
new file mode 100644
index 0000000..433dd29
--- /dev/null
+++ b/lib/media.ts
@@ -0,0 +1,55 @@
+// Uploaded media (mp4 reels & clips). Bytes live on the filesystem under
+// DATA_DIR — the SAME Railway volume that caches generated hero images
+// (see lib/genart.ts) — while the row metadata lives in Turso (lib/db.ts).
+// Mount a volume at DATA_DIR in production or uploads won't survive a redeploy.
+import fs from "node:fs";
+import path from "node:path";
+
+const DATA_DIR = process.env.DATA_DIR || path.join(process.cwd(), ".data");
+const MEDIA_DIR = path.join(DATA_DIR, "media");
+
+/** Cap per upload. Reels are short; keep them small enough to stream cheaply. */
+export const MAX_UPLOAD_BYTES = Number(process.env.MEDIA_MAX_BYTES || 100 * 1024 * 1024); // 100 MB
+
+/** Accepted video mime types → file extension. mp4 is the primary target. */
+export const ALLOWED_TYPES: Record<string, string> = {
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "video/quicktime": ".mov",
+};
+
+function ensureDir(): void {
+  fs.mkdirSync(MEDIA_DIR, { recursive: true });
+}
+
+/** Absolute path for a stored file. `basename` guards against path traversal. */
+export function mediaPath(filename: string): string {
+  return path.join(MEDIA_DIR, path.basename(filename));
+}
+
+export async function writeMedia(filename: string, bytes: Buffer): Promise<void> {
+  ensureDir();
+  await fs.promises.writeFile(mediaPath(filename), bytes);
+}
+
+/** File size on disk, or null when the file is missing. */
+export function mediaSize(filename: string): number | null {
+  try {
+    return fs.statSync(mediaPath(filename)).size;
+  } catch {
+    return null;
+  }
+}
+
+/** Opens a (possibly partial) read stream for range-aware streaming. */
+export function mediaStream(filename: string, start?: number, end?: number): fs.ReadStream {
+  return fs.createReadStream(mediaPath(filename), start != null && end != null ? { start, end } : {});
+}
+
+export function deleteMediaFile(filename: string): void {
+  try {
+    fs.unlinkSync(mediaPath(filename));
+  } catch {
+    /* already gone — fine */
+  }
+}
diff --git a/public/videos/moshcoding-reel-16x9.mp4 b/public/videos/moshcoding-reel-16x9.mp4
new file mode 100644
index 0000000..da3060a
Binary files /dev/null and b/public/videos/moshcoding-reel-16x9.mp4 differ
diff --git a/public/videos/moshcoding-reel-9x16.mp4 b/public/videos/moshcoding-reel-9x16.mp4
new file mode 100644
index 0000000..a40f973
Binary files /dev/null and b/public/videos/moshcoding-reel-9x16.mp4 differ