diff --git a/src/app/volunteers/instructions/page.tsx b/src/app/volunteers/instructions/page.tsx
index 6dd5e019..db66d07c 100644
--- a/src/app/volunteers/instructions/page.tsx
+++ b/src/app/volunteers/instructions/page.tsx
@@ -57,8 +57,8 @@ export default async function VolunteersInstructionsPage(): Promise<React.JSX.El
                   Avoid exporting or sharing personal information unless needed.
                 </li>
                 <li>
-                  Double-check notes and role/cohort tags before confirming
-                  save.
+                  Double-check notes and tags (training, position, committee,
+                  language) before confirming save.
                 </li>
               </ul>
             </section>
diff --git a/src/components/settings/ManageTagsContent.tsx b/src/components/settings/ManageTagsContent.tsx
index d2015c11..44747777 100644
--- a/src/components/settings/ManageTagsContent.tsx
+++ b/src/components/settings/ManageTagsContent.tsx
@@ -2,103 +2,67 @@
 
 import React, { useEffect, useState, useTransition } from "react";
 import { useRouter } from "next/navigation";
-import { Calendar, ChevronDown, Plus, Tag, Trash2, User } from "lucide-react";
+import {
+  Briefcase,
+  ChevronDown,
+  GraduationCap,
+  Languages,
+  Plus,
+  Tag,
+  Trash2,
+  Users,
+} from "lucide-react";
 import clsx from "clsx";
 import toast from "react-hot-toast";
-import type { CohortRow, RoleRow } from "@/components/volunteers/types";
+import type { RoleRow } from "@/components/volunteers/types";
 import {
-  createCohortTagAction,
   createRoleTagAction,
-  removeAllCohortTagsAction,
-  removeAllRoleTagsAction,
-  removeCohortTagAction,
   removeRoleTagAction,
-  updateCohortTagAction,
   updateRoleTagAction,
 } from "@/lib/api/actions";
+import {
+  ROLE_TAG_COLUMN_LABEL,
+  roleTagColumnLabel,
+  type RoleTagDbType,
+} from "@/lib/volunteers/roleTagLabels";
 
-const ROLE_TYPES = [
-  { value: "current", label: "Current" },
-  { value: "prior", label: "Prior" },
-  { value: "future_interest", label: "Future interest" },
-] as const;
-
-const COHORT_TERMS = ["Fall", "Spring", "Summer", "Winter"] as const;
+const ROLE_TAG_SECTIONS: {
+  type: RoleTagDbType;
+  title: string;
+  subtitle: string;
+  icon: React.ElementType;
+}[] = [
+  {
+    type: "training",
+    title: "Training",
+    subtitle: "Free-text tags shown in the Training column",
+    icon: GraduationCap,
+  },
+  {
+    type: "prior",
+    title: "Position",
+    subtitle: "Tags shown in the Position column",
+    icon: Briefcase,
+  },
+  {
+    type: "current",
+    title: "Committee",
+    subtitle: "Tags shown in the Committee column",
+    icon: Users,
+  },
+  {
+    type: "future_interest",
+    title: "Language",
+    subtitle: "Tags shown in the Language column",
+    icon: Languages,
+  },
+];
 
 const inputClass =
   "rounded-lg border border-gray-200/90 bg-white px-2.5 py-2 text-sm text-gray-900 shadow-sm " +
   "focus:outline-none focus:ring-2 focus:ring-purple-500/30 focus:border-purple-400";
 
-const selectBase =
-  "rounded-lg border border-gray-200/90 bg-white py-2 text-sm text-gray-900 shadow-sm " +
-  "focus:outline-none focus:ring-2 focus:ring-purple-500/30 focus:border-purple-400";
-
-/** Kind / Term selects: hide native arrow and show a chevron inset from the right edge. */
-const selectKindClass = selectBase + " appearance-none pl-2.5 pr-8";
-
-function KindSelect({
-  value,
-  onChange,
-  widthClassName,
-}: {
-  value: string;
-  onChange: (next: string) => void;
-  /** e.g. `max-w-[11rem] w-full` for table rows */
-  widthClassName: string;
-}): React.JSX.Element {
-  return (
-    <div className={clsx("relative", widthClassName)}>
-      <select
-        className={clsx(selectKindClass, "w-full")}
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-      >
-        {ROLE_TYPES.map((opt) => (
-          <option key={opt.value} value={opt.value}>
-            {opt.label}
-          </option>
-        ))}
-      </select>
-      <ChevronDown
-        className="pointer-events-none absolute right-2 top-1/2 h-4 w-4 -translate-y-1/2 text-gray-500"
-        aria-hidden
-      />
-    </div>
-  );
-}
-
-function TermSelect({
-  value,
-  onChange,
-  widthClassName,
-}: {
-  value: string;
-  onChange: (next: string) => void;
-  widthClassName: string;
-}): React.JSX.Element {
-  return (
-    <div className={clsx("relative", widthClassName)}>
-      <select
-        className={clsx(selectKindClass, "w-full")}
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-      >
-        {COHORT_TERMS.map((t) => (
-          <option key={t} value={t}>
-            {t}
-          </option>
-        ))}
-      </select>
-      <ChevronDown
-        className="pointer-events-none absolute right-2 top-1/2 h-4 w-4 -translate-y-1/2 text-gray-500"
-        aria-hidden
-      />
-    </div>
-  );
-}
-
-type RoleDraft = { name: string; type: string };
-type CohortDraft = { term: string; year: string };
+type RoleDraft = { name: string };
 
 function CollapsibleSection({
   sectionId,
@@ -198,7 +162,6 @@ function CollapsibleSection({
 
 interface ManageTagsContentProps {
   initialRoles: RoleRow[];
-  initialCohorts: CohortRow[];
   loadError: string | null;
   /** When set (e.g. from the volunteers table modal), refreshes client data instead of the Next router. */
   onRefresh?: () => void;
@@ -208,7 +171,6 @@ interface ManageTagsContentProps {
 
 export function ManageTagsContent({
   initialRoles,
-  initialCohorts,
   loadError,
   onRefresh,
   embedded = false,
@@ -217,47 +179,36 @@ export function ManageTagsContent({
   const [isPending, startTransition] = useTransition();
 
   const [roles, setRoles] = useState(initialRoles);
-  const [cohorts, setCohorts] = useState(initialCohorts);
   const [roleDrafts, setRoleDrafts] = useState<Record<number, RoleDraft>>({});
-  const [cohortDrafts, setCohortDrafts] = useState<Record<number, CohortDraft>>(
-    {}
-  );
 
-  const [newRoleName, setNewRoleName] = useState("");
-  const [newRoleType, setNewRoleType] = useState<string>("current");
-  const [newCohortTerm, setNewCohortTerm] =
-    useState<(typeof COHORT_TERMS)[number]>("Fall");
-  const [newCohortYear, setNewCohortYear] = useState(
-    String(new Date().getFullYear())
-  );
-
-  const [openRoles, setOpenRoles] = useState(true);
-  const [openCohorts, setOpenCohorts] = useState(true);
+  const [newTagNameByType, setNewTagNameByType] = useState<
+    Record<RoleTagDbType, string>
+  >({
+    training: "",
+    prior: "",
+    current: "",
+    future_interest: "",
+  });
+
+  const [openRoleSection, setOpenRoleSection] = useState<
+    Record<RoleTagDbType, boolean>
+  >({
+    training: true,
+    prior: true,
+    current: true,
+    future_interest: true,
+  });
 
   useEffect(() => {
     setRoles(initialRoles);
   }, [initialRoles]);
 
-  useEffect(() => {
-    setCohorts(initialCohorts);
-  }, [initialCohorts]);
-
   useEffect(() => {
     setRoleDrafts(
-      Object.fromEntries(
-        roles.map((r) => [r.id, { name: r.name, type: r.type }])
-      )
+      Object.fromEntries(roles.map((r) => [r.id, { name: r.name }]))
     );
   }, [roles]);
 
-  useEffect(() => {
-    setCohortDrafts(
-      Object.fromEntries(
-        cohorts.map((c) => [c.id, { term: c.term, year: String(c.year) }])
-      )
-    );
-  }, [cohorts]);
-
   const refresh = (): void => {
     if (onRefresh) {
       onRefresh();
@@ -273,17 +224,17 @@ export function ManageTagsContent({
     startTransition(async () => {
       const res = await updateRoleTagAction(id, {
         name: draft.name,
-        type: draft.type,
+        type: row.type,
         is_active: row.is_active,
       });
       if (res.success) {
-        toast.success("Role saved");
+        toast.success("Tag saved");
         refresh();
       } else {
-        toast.error(res.error ?? "Could not save role");
+        toast.error(res.error ?? "Could not save tag");
         setRoleDrafts((prev) => ({
           ...prev,
-          [id]: { name: row.name, type: row.type },
+          [id]: { name: row.name },
         }));
       }
     });
@@ -294,7 +245,7 @@ export function ManageTagsContent({
     if (!row) return;
     if (
       !window.confirm(
-        `Delete role "${row.name}" (${row.type})? Volunteer links to this role will be removed if the database is set up to cascade.`
+        `Delete tag "${row.name}" (${roleTagColumnLabel(row.type)})? Volunteer links to this tag will be removed if the database is set up to cascade.`
       )
     ) {
       return;
@@ -302,163 +253,68 @@ export function ManageTagsContent({
     startTransition(async () => {
       const res = await removeRoleTagAction(row.id);
       if (res.success) {
-        toast.success("Role removed");
+        toast.success("Tag removed");
         refresh();
       } else {
-        toast.error(res.error ?? "Could not remove role");
+        toast.error(res.error ?? "Could not remove tag");
         setRoleDrafts((prev) => ({
           ...prev,
-          [id]: { name: row.name, type: row.type },
+          [id]: { name: row.name },
         }));
       }
     });
   };
 
-  const handleCreateRole = (e: React.FormEvent): void => {
+  const handleCreateRoleForType = (
+    e: React.FormEvent,
+    type: RoleTagDbType
+  ): void => {
     e.preventDefault();
-    const name = newRoleName.trim();
+    const name = newTagNameByType[type].trim();
     if (!name) {
-      toast.error("Enter a role name");
+      toast.error("Enter a tag name");
       return;
     }
     startTransition(async () => {
       const res = await createRoleTagAction({
         name,
-        type: newRoleType,
+        type,
         is_active: true,
       });
       if (res.success) {
-        toast.success("Role created");
-        setNewRoleName("");
-        setNewRoleType("current");
+        toast.success("Tag created");
+        setNewTagNameByType((prev) => ({ ...prev, [type]: "" }));
         refresh();
       } else {
-        toast.error(res.error ?? "Could not create role");
+        toast.error(res.error ?? "Could not create tag");
       }
     });
   };
 
-  const handleSaveCohort = (id: number): void => {
-    const draft = cohortDrafts[id];
-    const row = cohorts.find((c) => c.id === id);
-    if (!draft || !row) return;
-    const y = parseInt(draft.year.trim(), 10);
-    if (!Number.isInteger(y) || y < 1900 || y > 2100) {
-      toast.error("Enter a valid year (1900–2100)");
-      return;
-    }
-    startTransition(async () => {
-      const res = await updateCohortTagAction(id, {
-        term: draft.term,
-        year: y,
-        is_active: row.is_active,
-      });
-      if (res.success) {
-        toast.success("Cohort saved");
-        refresh();
-      } else {
-        toast.error(res.error ?? "Could not save cohort");
-        setCohortDrafts((prev) => ({
-          ...prev,
-          [id]: { term: row.term, year: String(row.year) },
-        }));
-      }
-    });
-  };
-
-  const handleDeleteCohort = (id: number): void => {
-    const row = cohorts.find((c) => c.id === id);
-    if (!row) return;
+  const handleRemoveAllRolesForType = (type: RoleTagDbType): void => {
+    const inColumn = roles.filter((r) => r.type === type);
+    if (inColumn.length === 0) return;
+    const label = ROLE_TAG_COLUMN_LABEL[type];
     if (
       !window.confirm(
-        `Delete cohort "${row.term} ${row.year}"? Volunteer links may be removed if the database cascades deletes.`
+        `Remove all ${label} tags (${inColumn.length})? This cannot be undone. Links between volunteers and these tags will be removed if the database cascades deletes.`
       )
     ) {
       return;
     }
     startTransition(async () => {
-      const res = await removeCohortTagAction(row.year, row.term);
-      if (res.success) {
-        toast.success("Cohort removed");
-        refresh();
-      } else {
-        toast.error(res.error ?? "Could not remove cohort");
-        setCohortDrafts((prev) => ({
-          ...prev,
-          [id]: { term: row.term, year: String(row.year) },
-        }));
-      }
-    });
-  };
-
-  const handleRemoveAllRoles = (): void => {
-    if (roles.length === 0) return;
-    if (
-      !window.confirm(
-        "Remove all roles? This cannot be undone. Links between volunteers and these roles will be deleted."
-      )
-    ) {
-      return;
-    }
-    startTransition(async () => {
-      const res = await removeAllRoleTagsAction();
-      if (res.success) {
-        toast.success(
-          res.removed === 0
-            ? "No roles to remove"
-            : `Removed ${res.removed} role(s)`
-        );
-        refresh();
-      } else {
-        toast.error(res.error);
-      }
-    });
-  };
-
-  const handleRemoveAllCohorts = (): void => {
-    if (cohorts.length === 0) return;
-    if (
-      !window.confirm(
-        "Remove all cohorts? This cannot be undone. Links between volunteers and these cohorts will be deleted."
-      )
-    ) {
-      return;
-    }
-    startTransition(async () => {
-      const res = await removeAllCohortTagsAction();
-      if (res.success) {
-        toast.success(
-          res.removed === 0
-            ? "No cohorts to remove"
-            : `Removed ${res.removed} cohort(s)`
-        );
-        refresh();
-      } else {
-        toast.error(res.error);
-      }
-    });
-  };
-
-  const handleCreateCohort = (e: React.FormEvent): void => {
-    e.preventDefault();
-    const y = parseInt(newCohortYear.trim(), 10);
-    if (!Number.isInteger(y) || y < 1900 || y > 2100) {
-      toast.error("Enter a valid year (1900–2100)");
-      return;
-    }
-    startTransition(async () => {
-      const res = await createCohortTagAction({
-        term: newCohortTerm,
-        year: y,
-        is_active: true,
-      });
-      if (res.success) {
-        toast.success("Cohort created");
-        setNewCohortYear(String(new Date().getFullYear()));
-        refresh();
-      } else {
-        toast.error(res.error ?? "Could not create cohort");
+      for (const r of inColumn) {
+        const res = await removeRoleTagAction(r.id);
+        if (!res.success) {
+          toast.error(res.error ?? `Could not remove tag "${r.name}"`);
+          refresh();
+          return;
+        }
       }
+      toast.success(
+        `Removed ${inColumn.length} ${label} tag${inColumn.length === 1 ? "" : "s"}`
+      );
+      refresh();
     });
   };
 
@@ -466,15 +322,7 @@ export function ManageTagsContent({
     const row = roles.find((r) => r.id === id);
     const d = roleDrafts[id];
     if (!row || !d) return false;
-    return row.name !== d.name || row.type !== d.type;
-  };
-
-  const cohortDirty = (id: number): boolean => {
-    const row = cohorts.find((c) => c.id === id);
-    const d = cohortDrafts[id];
-    if (!row || !d) return false;
-    const y = parseInt(d.year, 10);
-    return row.term !== d.term || row.year !== y;
+    return row.name !== d.name;
   };
 
   if (loadError) {
@@ -500,323 +348,163 @@ export function ManageTagsContent({
         </h1>
       ) : null}
 
-      <CollapsibleSection
-        sectionId="manage-tags-roles"
-        title="Roles"
-        subtitle="Prior, current, and future-interest labels"
-        icon={User}
-        count={roles.length}
-        open={openRoles}
-        onToggle={() => setOpenRoles((o) => !o)}
-        embedded={embedded}
-      >
-        <div className="overflow-x-auto rounded-xl border border-gray-200/90 bg-white shadow-inner shadow-gray-100/80">
-          <table className="w-full text-sm text-left">
-            <thead className="bg-gray-100/70 text-[11px] font-semibold uppercase tracking-wider text-gray-500 border-b border-gray-200/90">
-              <tr>
-                <th className="px-3 py-2.5 pl-4">Name</th>
-                <th className="px-3 py-2.5">Kind</th>
-                <th className="px-3 py-2.5 pr-4 text-right whitespace-nowrap w-[1%] min-w-48">
-                  Actions
-                </th>
-              </tr>
-            </thead>
-            <tbody className="divide-y divide-gray-100/90 bg-white">
-              {roles.length === 0 ? (
-                <tr>
-                  <td colSpan={3} className="px-4 py-10">
-                    <div className="flex flex-col items-center justify-center gap-2 text-center text-gray-500">
-                      <span className="flex h-11 w-11 items-center justify-center rounded-full bg-gray-100 text-gray-400">
-                        <Tag className="h-5 w-5" aria-hidden />
-                      </span>
-                      <p className="text-sm font-medium text-gray-600">
-                        No roles yet
-                      </p>
-                      <p className="text-xs text-gray-500 max-w-xs">
-                        Add a role below — it will appear in filters and when
-                        editing volunteers.
-                      </p>
-                    </div>
-                  </td>
-                </tr>
-              ) : (
-                roles.map((r) => {
-                  const d = roleDrafts[r.id];
-                  if (!d) return null;
-                  return (
-                    <tr
-                      key={r.id}
-                      className="hover:bg-purple-50/25 transition-colors"
-                    >
-                      <td className="px-3 py-2.5 pl-4 align-middle">
-                        <input
-                          type="text"
-                          className={inputClass + " w-full min-w-32"}
-                          value={d.name}
-                          onChange={(e) =>
-                            setRoleDrafts((prev) => ({
-                              ...prev,
-                              [r.id]: { ...d, name: e.target.value },
-                            }))
-                          }
-                        />
-                      </td>
-                      <td className="px-3 py-2.5 align-middle">
-                        <KindSelect
-                          value={d.type}
-                          onChange={(next) =>
-                            setRoleDrafts((prev) => ({
-                              ...prev,
-                              [r.id]: { ...d, type: next },
-                            }))
-                          }
-                          widthClassName="w-full max-w-[11rem] min-w-0"
-                        />
-                      </td>
-                      <td className="px-3 py-2.5 pr-4 align-middle text-right whitespace-nowrap w-[1%]">
-                        <div className="inline-flex flex-nowrap items-center justify-end gap-1.5 shrink-0">
-                          <button
-                            type="button"
-                            disabled={isPending || !roleDirty(r.id)}
-                            onClick={() => handleSaveRole(r.id)}
-                            className="shrink-0 rounded-lg bg-accent-purple px-2.5 py-1.5 text-xs font-medium text-white shadow-sm hover:bg-dark-accent-purple disabled:opacity-40"
-                          >
-                            Save
-                          </button>
-                          <button
-                            type="button"
-                            disabled={isPending}
-                            onClick={() => handleDeleteRole(r.id)}
-                            className="inline-flex shrink-0 items-center gap-1 rounded-lg border border-red-200/90 bg-white px-2 py-1.5 text-xs font-medium text-red-700 hover:bg-red-50"
-                            title="Remove role"
-                          >
-                            <Trash2
-                              className="h-3.5 w-3.5 shrink-0"
-                              aria-hidden
-                            />
-                            Remove
-                          </button>
-                        </div>
-                      </td>
-                    </tr>
-                  );
-                })
-              )}
-            </tbody>
-          </table>
-        </div>
-
-        <div className="rounded-xl border border-dashed border-purple-200/70 bg-purple-50/25 p-4 sm:p-5">
-          <p className="flex items-center gap-2 text-xs font-semibold uppercase tracking-wide text-purple-900/80 mb-3">
-            <Plus className="h-3.5 w-3.5" aria-hidden />
-            Add a role
-          </p>
-          <form
-            onSubmit={handleCreateRole}
-            className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-end"
-          >
-            <div className="flex flex-col gap-1 flex-1 min-w-40">
-              <label className="text-xs font-medium text-gray-600">Name</label>
-              <input
-                type="text"
-                className={inputClass + " w-full"}
-                value={newRoleName}
-                onChange={(e) => setNewRoleName(e.target.value)}
-                placeholder="e.g. Greeter"
-              />
-            </div>
-            <div className="flex flex-col gap-1 w-full sm:w-44">
-              <label className="text-xs font-medium text-gray-600">Kind</label>
-              <KindSelect
-                value={newRoleType}
-                onChange={setNewRoleType}
-                widthClassName="w-full"
-              />
-            </div>
-            <button
-              type="submit"
-              disabled={isPending}
-              className="inline-flex items-center justify-center gap-2 rounded-xl bg-accent-purple px-4 py-2.5 text-sm font-medium text-white shadow-md shadow-purple-900/10 hover:bg-dark-accent-purple disabled:opacity-50 sm:shrink-0"
-            >
-              <Plus className="h-4 w-4" aria-hidden />
-              Create
-            </button>
-          </form>
-        </div>
-
-        <div className="flex flex-wrap items-center justify-end gap-2 border-t border-gray-200/80 pt-3 mt-3">
-          <button
-            type="button"
-            disabled={roles.length === 0 || isPending}
-            onClick={handleRemoveAllRoles}
-            className="inline-flex items-center gap-1.5 rounded-lg border border-red-200/90 bg-white px-3 py-1.5 text-xs font-medium text-red-800 shadow-sm hover:bg-red-50 disabled:opacity-40"
+      {ROLE_TAG_SECTIONS.map(({ type, title, subtitle, icon: SectionIcon }) => {
+        const columnRoles = roles
+          .filter((r) => r.type === type)
+          .sort((a, b) =>
+            a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+          );
+        return (
+          <CollapsibleSection
+            key={type}
+            sectionId={`manage-tags-${type}`}
+            title={title}
+            subtitle={subtitle}
+            icon={SectionIcon}
+            count={columnRoles.length}
+            open={openRoleSection[type]}
+            onToggle={() =>
+              setOpenRoleSection((prev) => ({
+                ...prev,
+                [type]: !prev[type],
+              }))
+            }
+            embedded={embedded}
           >
-            <Trash2 className="h-3.5 w-3.5 shrink-0" aria-hidden />
-            Remove all roles
-          </button>
-        </div>
-      </CollapsibleSection>
-
-      <CollapsibleSection
-        sectionId="manage-tags-cohorts"
-        title="Cohorts"
-        subtitle="Term + year (e.g. Fall 2025)"
-        icon={Calendar}
-        count={cohorts.length}
-        open={openCohorts}
-        onToggle={() => setOpenCohorts((o) => !o)}
-        embedded={embedded}
-      >
-        <div className="overflow-x-auto rounded-xl border border-gray-200/90 bg-white shadow-inner shadow-gray-100/80">
-          <table className="w-full text-sm text-left">
-            <thead className="bg-gray-100/70 text-[11px] font-semibold uppercase tracking-wider text-gray-500 border-b border-gray-200/90">
-              <tr>
-                <th className="px-3 py-2.5 pl-4">Term</th>
-                <th className="px-3 py-2.5 w-28">Year</th>
-                <th className="px-3 py-2.5 pr-4 text-right whitespace-nowrap w-[1%] min-w-48">
-                  Actions
-                </th>
-              </tr>
-            </thead>
-            <tbody className="divide-y divide-gray-100/90 bg-white">
-              {cohorts.length === 0 ? (
-                <tr>
-                  <td colSpan={3} className="px-4 py-10">
-                    <div className="flex flex-col items-center justify-center gap-2 text-center text-gray-500">
-                      <span className="flex h-11 w-11 items-center justify-center rounded-full bg-gray-100 text-gray-400">
-                        <Calendar className="h-5 w-5" aria-hidden />
-                      </span>
-                      <p className="text-sm font-medium text-gray-600">
-                        No cohorts yet
-                      </p>
-                      <p className="text-xs text-gray-500 max-w-xs">
-                        Create a cohort below to use it when linking volunteers.
-                      </p>
-                    </div>
-                  </td>
-                </tr>
-              ) : (
-                cohorts.map((c) => {
-                  const d = cohortDrafts[c.id];
-                  if (!d) return null;
-                  return (
-                    <tr
-                      key={c.id}
-                      className="hover:bg-purple-50/25 transition-colors"
-                    >
-                      <td className="px-3 py-2.5 pl-4 align-middle">
-                        <TermSelect
-                          value={d.term}
-                          onChange={(next) =>
-                            setCohortDrafts((prev) => ({
-                              ...prev,
-                              [c.id]: { ...d, term: next },
-                            }))
-                          }
-                          widthClassName="w-full max-w-[9rem] min-w-0"
-                        />
-                      </td>
-                      <td className="px-3 py-2.5 align-middle">
-                        <input
-                          type="number"
-                          min={1900}
-                          max={2100}
-                          className={inputClass + " w-28 tabular-nums"}
-                          value={d.year}
-                          onChange={(e) =>
-                            setCohortDrafts((prev) => ({
-                              ...prev,
-                              [c.id]: { ...d, year: e.target.value },
-                            }))
-                          }
-                        />
-                      </td>
-                      <td className="px-3 py-2.5 pr-4 align-middle text-right whitespace-nowrap w-[1%]">
-                        <div className="inline-flex flex-nowrap items-center justify-end gap-1.5 shrink-0">
-                          <button
-                            type="button"
-                            disabled={isPending || !cohortDirty(c.id)}
-                            onClick={() => handleSaveCohort(c.id)}
-                            className="shrink-0 rounded-lg bg-accent-purple px-2.5 py-1.5 text-xs font-medium text-white shadow-sm hover:bg-dark-accent-purple disabled:opacity-40"
-                          >
-                            Save
-                          </button>
-                          <button
-                            type="button"
-                            disabled={isPending}
-                            onClick={() => handleDeleteCohort(c.id)}
-                            className="inline-flex shrink-0 items-center gap-1 rounded-lg border border-red-200/90 bg-white px-2 py-1.5 text-xs font-medium text-red-700 hover:bg-red-50"
-                            title="Remove cohort"
-                          >
-                            <Trash2
-                              className="h-3.5 w-3.5 shrink-0"
-                              aria-hidden
-                            />
-                            Remove
-                          </button>
+            <div className="overflow-x-auto rounded-xl border border-gray-200/90 bg-white shadow-inner shadow-gray-100/80">
+              <table className="w-full text-sm text-left">
+                <thead className="bg-gray-100/70 text-[11px] font-semibold uppercase tracking-wider text-gray-500 border-b border-gray-300">
+                  <tr>
+                    <th className="px-3 py-2.5 pl-4">Name</th>
+                    <th className="px-3 py-2.5 pr-4 text-right whitespace-nowrap w-[1%] min-w-48">
+                      Actions
+                    </th>
+                  </tr>
+                </thead>
+                <tbody className="divide-y divide-gray-300 bg-white">
+                  {columnRoles.length === 0 ? (
+                    <tr>
+                      <td colSpan={2} className="px-4 py-10">
+                        <div className="flex flex-col items-center justify-center gap-2 text-center text-gray-500">
+                          <span className="flex h-11 w-11 items-center justify-center rounded-full bg-gray-100 text-gray-400">
+                            <Tag className="h-5 w-5" aria-hidden />
+                          </span>
+                          <p className="text-sm font-medium text-gray-600">
+                            No {title.toLowerCase()} tags yet
+                          </p>
+                          <p className="text-xs text-gray-500 max-w-xs">
+                            Add a tag below — it will appear in filters and when
+                            editing volunteers.
+                          </p>
                         </div>
                       </td>
                     </tr>
-                  );
-                })
-              )}
-            </tbody>
-          </table>
-        </div>
-
-        <div className="rounded-xl border border-dashed border-purple-200/70 bg-purple-50/25 p-4 sm:p-5">
-          <p className="flex items-center gap-2 text-xs font-semibold uppercase tracking-wide text-purple-900/80 mb-3">
-            <Plus className="h-3.5 w-3.5" aria-hidden />
-            Add a cohort
-          </p>
-          <form
-            onSubmit={handleCreateCohort}
-            className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-end"
-          >
-            <div className="flex flex-col gap-1 w-full sm:w-40">
-              <label className="text-xs font-medium text-gray-600">Term</label>
-              <TermSelect
-                value={newCohortTerm}
-                onChange={(next) =>
-                  setNewCohortTerm(next as (typeof COHORT_TERMS)[number])
-                }
-                widthClassName="w-full"
-              />
+                  ) : (
+                    columnRoles.map((r) => {
+                      const d = roleDrafts[r.id];
+                      if (!d) return null;
+                      return (
+                        <tr
+                          key={r.id}
+                          className="hover:bg-purple-50/25 transition-colors"
+                        >
+                          <td className="px-3 py-2.5 pl-4 align-middle">
+                            <input
+                              type="text"
+                              className={inputClass + " w-full min-w-32"}
+                              value={d.name}
+                              onChange={(e) =>
+                                setRoleDrafts((prev) => ({
+                                  ...prev,
+                                  [r.id]: { name: e.target.value },
+                                }))
+                              }
+                            />
+                          </td>
+                          <td className="px-3 py-2.5 pr-4 align-middle text-right whitespace-nowrap w-[1%]">
+                            <div className="inline-flex flex-nowrap items-center justify-end gap-1.5 shrink-0">
+                              <button
+                                type="button"
+                                disabled={isPending || !roleDirty(r.id)}
+                                onClick={() => handleSaveRole(r.id)}
+                                className="shrink-0 rounded-lg bg-accent-purple px-2.5 py-1.5 text-xs font-medium text-white shadow-sm hover:bg-dark-accent-purple disabled:opacity-40"
+                              >
+                                Save
+                              </button>
+                              <button
+                                type="button"
+                                disabled={isPending}
+                                onClick={() => handleDeleteRole(r.id)}
+                                className="inline-flex shrink-0 items-center gap-1 rounded-lg border border-red-200/90 bg-white px-2 py-1.5 text-xs font-medium text-red-700 hover:bg-red-50"
+                                title="Remove tag"
+                              >
+                                <Trash2
+                                  className="h-3.5 w-3.5 shrink-0"
+                                  aria-hidden
+                                />
+                                Remove
+                              </button>
+                            </div>
+                          </td>
+                        </tr>
+                      );
+                    })
+                  )}
+                </tbody>
+              </table>
             </div>
-            <div className="flex flex-col gap-1 w-full sm:w-28">
-              <label className="text-xs font-medium text-gray-600">Year</label>
-              <input
-                type="number"
-                min={1900}
-                max={2100}
-                className={inputClass + " w-full tabular-nums"}
-                value={newCohortYear}
-                onChange={(e) => setNewCohortYear(e.target.value)}
-              />
+
+            <div className="rounded-xl border border-dashed border-purple-200/70 bg-purple-50/25 p-4 sm:p-5">
+              <p className="flex items-center gap-2 text-xs font-semibold uppercase tracking-wide text-purple-900/80 mb-3">
+                <Plus className="h-3.5 w-3.5" aria-hidden />
+                Add {title.toLowerCase()} tag
+              </p>
+              <form
+                onSubmit={(e) => handleCreateRoleForType(e, type)}
+                className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-end"
+              >
+                <div className="flex flex-col gap-1 flex-1 min-w-40">
+                  <label className="text-xs font-medium text-gray-600">
+                    Name
+                  </label>
+                  <input
+                    type="text"
+                    className={inputClass + " w-full"}
+                    value={newTagNameByType[type]}
+                    onChange={(e) =>
+                      setNewTagNameByType((prev) => ({
+                        ...prev,
+                        [type]: e.target.value,
+                      }))
+                    }
+                    placeholder={"Type here"}
+                  />
+                </div>
+                <button
+                  type="submit"
+                  disabled={isPending}
+                  className="inline-flex items-center justify-center gap-2 rounded-xl bg-accent-purple px-4 py-2.5 text-sm font-medium text-white shadow-md shadow-purple-900/10 hover:bg-dark-accent-purple disabled:opacity-50 sm:shrink-0"
+                >
+                  <Plus className="h-4 w-4" aria-hidden />
+                  Create
+                </button>
+              </form>
             </div>
-            <button
-              type="submit"
-              disabled={isPending}
-              className="inline-flex items-center justify-center gap-2 rounded-xl bg-accent-purple px-4 py-2.5 text-sm font-medium text-white shadow-md shadow-purple-900/10 hover:bg-dark-accent-purple disabled:opacity-50 sm:shrink-0"
-            >
-              <Plus className="h-4 w-4" aria-hidden />
-              Create
-            </button>
-          </form>
-        </div>
 
-        <div className="flex flex-wrap items-center justify-end gap-2 border-t border-gray-200/80 pt-3 mt-3">
-          <button
-            type="button"
-            disabled={cohorts.length === 0 || isPending}
-            onClick={handleRemoveAllCohorts}
-            className="inline-flex items-center gap-1.5 rounded-lg border border-red-200/90 bg-white px-3 py-1.5 text-xs font-medium text-red-800 shadow-sm hover:bg-red-50 disabled:opacity-40"
-          >
-            <Trash2 className="h-3.5 w-3.5 shrink-0" aria-hidden />
-            Remove all cohorts
-          </button>
-        </div>
-      </CollapsibleSection>
+            <div className="flex flex-wrap items-center justify-end gap-2 border-t border-gray-200/80 pt-3 mt-3">
+              <button
+                type="button"
+                disabled={columnRoles.length === 0 || isPending}
+                onClick={() => handleRemoveAllRolesForType(type)}
+                className="inline-flex items-center gap-1.5 rounded-lg border border-red-200/90 bg-white px-3 py-1.5 text-xs font-medium text-red-800 shadow-sm hover:bg-red-50 disabled:opacity-40"
+              >
+                <Trash2 className="h-3.5 w-3.5 shrink-0" aria-hidden />
+                Remove all {title.toLowerCase()} tags
+              </button>
+            </div>
+          </CollapsibleSection>
+        );
+      })}
     </div>
   );
 }
diff --git a/src/components/volunteers/AddVolunteerModal.tsx b/src/components/volunteers/AddVolunteerModal.tsx
index af9eb0a4..271e56ec 100644
--- a/src/components/volunteers/AddVolunteerModal.tsx
+++ b/src/components/volunteers/AddVolunteerModal.tsx
@@ -4,14 +4,11 @@ import React, { useState, useEffect, useCallback, useId } from "react";
 import { X, UserPlus } from "lucide-react";
 import clsx from "clsx";
 import { createVolunteerAction } from "@/lib/api/actions";
-import type { CohortTerm } from "@/lib/api/createVolunteer";
 import { NEW_VOLUNTEER_FORM_COLUMNS } from "./volunteerColumns";
 import type { Volunteer } from "./types";
 import { VolunteerTag } from "./VolunteerTag";
 import { OPT_IN_OPTIONS } from "./utils";
 
-const COHORT_TERMS: CohortTerm[] = ["Fall", "Winter", "Spring", "Summer"];
-
 const inputClass =
   "w-full rounded-lg border border-gray-200 bg-white px-3 py-2.5 text-sm text-gray-900 placeholder:text-gray-400 shadow-sm transition " +
   "focus:outline-none focus:ring-2 focus:ring-purple-500/25 focus:border-purple-500";
@@ -39,11 +36,13 @@ const FORM_SECTIONS: {
     columnIds: ["name_org", "pseudonym", "pronouns", "email", "phone"],
   },
   {
-    title: "Cohorts",
+    title: "Training",
+    description:
+      "Add any text labels (same idea as Position). Suggestions come from tags your admins created.",
     columnIds: ["cohorts"],
   },
   {
-    title: "Roles",
+    title: "Position, committee, and language",
     columnIds: ["prior_roles", "current_roles", "future_interests"],
   },
   {
@@ -52,20 +51,6 @@ const FORM_SECTIONS: {
   },
 ];
 
-type CohortFormRow = { term: CohortTerm; year: string };
-
-function parseCohortLabel(
-  label: string
-): { term: CohortTerm; year: string } | null {
-  const parts = label.trim().split(/\s+/);
-  if (parts.length < 2) return null;
-  const year = parts[parts.length - 1]!;
-  const term = parts.slice(0, -1).join(" ");
-  if (!/^\d{4}$/.test(year)) return null;
-  if (!COHORT_TERMS.includes(term as CohortTerm)) return null;
-  return { term: term as CohortTerm, year };
-}
-
 function SectionCard({
   title,
   description,
@@ -163,7 +148,7 @@ function MultiRoleField({
           type="text"
           className="flex-1 min-w-40 border-0 bg-transparent py-1 px-1 text-sm outline-none placeholder:text-gray-400"
           placeholder={
-            values.length > 0 ? "Add another…" : "Type a role, then press Enter"
+            values.length > 0 ? "Add another…" : "Type a tag, then press Enter"
           }
           value={draft}
           list={suggestionOptions.length > 0 ? datalistId : undefined}
@@ -187,138 +172,12 @@ function MultiRoleField({
   );
 }
 
-function CohortField({
-  label,
-  icon: Icon,
-  cohortLabels,
-  cohortRows,
-  setCohortRows,
-  currentYear,
-}: {
-  label: string;
-  icon: React.ElementType;
-  cohortLabels: string[];
-  cohortRows: CohortFormRow[];
-  setCohortRows: React.Dispatch<React.SetStateAction<CohortFormRow[]>>;
-  currentYear: number;
-}): React.JSX.Element {
-  const [term, setTerm] = useState<CohortTerm>("Fall");
-  const [year, setYear] = useState(String(currentYear));
-
-  const addDraft = useCallback((): void => {
-    const y = parseInt(year.trim(), 10);
-    if (!Number.isInteger(y) || y < 1900 || y > 2100) return;
-    const yStr = String(y);
-    setCohortRows((rows) => {
-      if (rows.some((r) => r.term === term && r.year === yStr)) return rows;
-      return [...rows, { term, year: yStr }];
-    });
-  }, [term, year, setCohortRows]);
-
-  const applyPreset = useCallback(
-    (presetLabel: string): void => {
-      const parsed = parseCohortLabel(presetLabel);
-      if (!parsed) return;
-      setCohortRows((rows) => {
-        if (
-          rows.some((r) => r.term === parsed.term && r.year === parsed.year)
-        ) {
-          return rows;
-        }
-        return [...rows, parsed];
-      });
-    },
-    [setCohortRows]
-  );
-
-  const removeAt = (index: number): void => {
-    setCohortRows((rows) => rows.filter((_, i) => i !== index));
-  };
-
-  return (
-    <div className="flex flex-col gap-2">
-      <FieldLabel icon={Icon}>{label}</FieldLabel>
-
-      <div
-        className={
-          "flex flex-wrap items-center gap-2 rounded-lg border border-gray-200 " +
-          "bg-white px-2 py-2 shadow-sm focus-within:ring-2 focus-within:ring-purple-500/25 focus-within:border-purple-400"
-        }
-      >
-        {cohortRows.map((row, i) => (
-          <VolunteerTag
-            key={`${row.term}-${row.year}-${i}`}
-            label={`${row.term} ${row.year}`}
-            onRemove={() => removeAt(i)}
-          />
-        ))}
-        <div className="flex flex-wrap items-center gap-2">
-          <select
-            value={term}
-            onChange={(e) => setTerm(e.target.value as CohortTerm)}
-            className="w-23 shrink-0 rounded-md border border-gray-200 bg-gray-50/80 py-1.5 pl-1.5 pr-6 text-sm text-gray-900 outline-none focus:border-purple-400 focus:ring-1 focus:ring-purple-500/30"
-            aria-label="Cohort term"
-          >
-            {COHORT_TERMS.map((t) => (
-              <option key={t} value={t}>
-                {t}
-              </option>
-            ))}
-          </select>
-          <input
-            type="number"
-            min={1900}
-            max={2100}
-            value={year}
-            onChange={(e) => setYear(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === "Enter") {
-                e.preventDefault();
-                addDraft();
-              }
-            }}
-            className="w-16 shrink-0 rounded-md border border-gray-200 bg-gray-50/80 py-1.5 px-1.5 text-center text-sm tabular-nums outline-none focus:border-purple-400 focus:ring-1 focus:ring-purple-500/30"
-            aria-label="Cohort year"
-          />
-          <button
-            type="button"
-            onClick={addDraft}
-            className="rounded-md bg-accent-purple px-3 py-1.5 text-sm font-medium text-white shadow-sm hover:bg-dark-accent-purple transition-colors"
-          >
-            Add
-          </button>
-        </div>
-      </div>
-
-      {cohortLabels.length > 0 ? (
-        <div className="flex flex-col gap-1.5 pt-0.5">
-          <p className="text-xs text-gray-500">Existing tags:</p>
-          <div className="flex flex-wrap gap-1.5">
-            {cohortLabels.map((presetLabel) => (
-              <button
-                key={presetLabel}
-                type="button"
-                onClick={() => applyPreset(presetLabel)}
-                className="rounded-full border border-gray-200 bg-white px-2.5 py-1 text-xs font-medium text-gray-700 shadow-sm transition hover:border-purple-300 hover:bg-purple-50/70"
-              >
-                {presetLabel}
-              </button>
-            ))}
-          </div>
-        </div>
-      ) : null}
-    </div>
-  );
-}
-
 export const AddVolunteerModal = ({
   isOpen,
   onClose,
   onSuccess,
   optionsData = {},
 }: AddVolunteerModalProps): React.JSX.Element | null => {
-  const currentYear = new Date().getFullYear();
-
   const [nameOrg, setNameOrg] = useState("");
   const [email, setEmail] = useState("");
   const [phone, setPhone] = useState("");
@@ -329,7 +188,7 @@ export const AddVolunteerModal = ({
   const [currentRoles, setCurrentRoles] = useState<string[]>([]);
   const [priorRoles, setPriorRoles] = useState<string[]>([]);
   const [futureRoles, setFutureRoles] = useState<string[]>([]);
-  const [cohortRows, setCohortRows] = useState<CohortFormRow[]>([]);
+  const [trainingRoles, setTrainingRoles] = useState<string[]>([]);
 
   const [submitting, setSubmitting] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -338,7 +197,7 @@ export const AddVolunteerModal = ({
   const currentRoleOptions = optionsData["current_roles"] ?? [];
   const priorRoleOptions = optionsData["prior_roles"] ?? [];
   const futureRoleOptions = optionsData["future_interests"] ?? [];
-  const cohortLabels = optionsData["cohorts"] ?? [];
+  const trainingTagOptions = optionsData["cohorts"] ?? [];
 
   const resetForm = useCallback((): void => {
     setNameOrg("");
@@ -351,7 +210,7 @@ export const AddVolunteerModal = ({
     setCurrentRoles([]);
     setPriorRoles([]);
     setFutureRoles([]);
-    setCohortRows([]);
+    setTrainingRoles([]);
     setError(null);
   }, []);
 
@@ -373,21 +232,11 @@ export const AddVolunteerModal = ({
     e.preventDefault();
     setError(null);
 
-    for (let i = 0; i < cohortRows.length; i++) {
-      const row = cohortRows[i]!;
-      const y = parseInt(row.year, 10);
-      if (!Number.isInteger(y) || y < 1900 || y > 2100) {
-        setError(`Cohort row ${i + 1}: enter a valid year (1900–2100).`);
-        return;
-      }
-    }
-
-    const cohorts = cohortRows.map((row) => ({
-      year: parseInt(row.year, 10),
-      term: row.term,
-    }));
-
     const roles = [
+      ...trainingRoles.map((name) => ({
+        name: name.trim(),
+        type: "training" as const,
+      })),
       ...currentRoles.map((name) => ({
         name: name.trim(),
         type: "current" as const,
@@ -415,7 +264,7 @@ export const AddVolunteerModal = ({
           notes: notes.trim() || null,
         },
         roles,
-        cohorts,
+        cohorts: [],
       });
 
       if (result.success) {
@@ -513,14 +362,13 @@ export const AddVolunteerModal = ({
         );
       case "cohorts":
         return (
-          <CohortField
+          <MultiRoleField
             key={col.id}
             label={col.label}
             icon={col.icon}
-            cohortLabels={cohortLabels}
-            cohortRows={cohortRows}
-            setCohortRows={setCohortRows}
-            currentYear={currentYear}
+            options={trainingTagOptions}
+            values={trainingRoles}
+            onChange={setTrainingRoles}
           />
         );
       case "prior_roles":
@@ -623,8 +471,8 @@ export const AddVolunteerModal = ({
                   </h2>
                 </div>
                 <p className="text-sm text-gray-600 mt-2 leading-relaxed">
-                  Add multiple cohorts and roles if you need them. You can add
-                  more later and edit the volunteer later.
+                  Add multiple training terms and tags if you need them. You can
+                  add more later by editing the volunteer.
                 </p>
               </div>
             </div>
diff --git a/src/components/volunteers/EditableCell.tsx b/src/components/volunteers/EditableCell.tsx
index bf9b7748..32c96bd3 100644
--- a/src/components/volunteers/EditableCell.tsx
+++ b/src/components/volunteers/EditableCell.tsx
@@ -36,6 +36,8 @@ export const EditableCell = ({
   const [isNotesExpanded, setIsNotesExpanded] = useState<boolean>(false);
   const [value, setValue] = useState<unknown>(initialValue);
   const [inputValue, setInputValue] = useState<string>("");
+  /** Newline-separated draft for text columns that store string[] (one line per value). */
+  const [multiLineDraft, setMultiLineDraft] = useState<string>("");
 
   const [modalCoords, setModalCoords] = useState<{
     top: number;
@@ -59,6 +61,8 @@ export const EditableCell = ({
     "future_interests",
   ].includes(info.column.id);
 
+  const isMultiLineText = type === "text" && isMulti;
+
   /** Forces a fresh DOM subtree when toggling edit mode; avoids ghost nodes from contentEditable + imperative textContent. */
   const modeKey = isEditing ? "edit" : "view";
 
@@ -87,8 +91,15 @@ export const EditableCell = ({
 
     setInputValue("");
     if (type === "text") {
-      const text = String(value ?? "");
-      draftTextRef.current = text;
+      if (isMultiLineText) {
+        const arr = Array.isArray(value) ? (value as string[]) : [];
+        const joined = arr.join("\n");
+        draftTextRef.current = joined;
+        setMultiLineDraft(joined);
+      } else {
+        const text = String(value ?? "");
+        draftTextRef.current = text;
+      }
     }
     setIsEditing(true);
   };
@@ -151,6 +162,7 @@ export const EditableCell = ({
 
   useEffect(() => {
     if (!isEditing || type !== "text") return;
+    if (isNotes || isMultiLineText) return;
     const editor = inlineEditorRef.current;
     if (!editor) return;
     editor.textContent = draftTextRef.current;
@@ -163,13 +175,21 @@ export const EditableCell = ({
     range.collapse(false);
     selection.removeAllRanges();
     selection.addRange(range);
-  }, [isEditing, type]);
+  }, [isEditing, type, isNotes, isMultiLineText]);
 
   const handleDelete = useCallback((): void => {
-    const cleared = isMulti ? [] : type === "options" ? null : "";
+    const cleared =
+      isMulti || isMultiLineText ? [] : type === "options" ? null : "";
     setValue(cleared);
     onEdit(info.row.original.id, info.column.id, cleared);
-  }, [isMulti, type, info.row.original.id, info.column.id, onEdit]);
+  }, [
+    isMulti,
+    isMultiLineText,
+    type,
+    info.row.original.id,
+    info.column.id,
+    onEdit,
+  ]);
 
   const applyValue = (val: string): void => {
     if (isMulti) {
@@ -202,7 +222,7 @@ export const EditableCell = ({
       applyValue(newTag);
       if (!alreadyExists) {
         const toastId = `new-tag-${info.column.id}-${newTag.toLowerCase()}`;
-        toast(`New tag "${newTag}" created — remember to save your changes.`, {
+        toast(`"${newTag}" added — remember to save your changes.`, {
           id: toastId,
           icon: <Tag className="h-5 w-5 shrink-0 text-gray-700" aria-hidden />,
           duration: 4000,
@@ -263,8 +283,8 @@ export const EditableCell = ({
               placeholder={
                 allowAdd
                   ? isMulti
-                    ? "Search or create..."
-                    : "Select or create..."
+                    ? "Search or add..."
+                    : "Select or add..."
                   : "Search..."
               }
               value={inputValue}
@@ -365,6 +385,45 @@ export const EditableCell = ({
       );
     }
 
+    if (isMultiLineText) {
+      const commitLinesAndExit = (): void => {
+        const lines = multiLineDraft
+          .split("\n")
+          .map((s) => s.trim())
+          .filter((s) => s.length > 0);
+        setValue(lines);
+        handleSave(lines);
+      };
+      const cancelMulti = (): void => {
+        setValue(initialValue);
+        setIsEditing(false);
+      };
+      return (
+        <textarea
+          key={modeKey}
+          className={
+            "w-full min-h-[5.5rem] max-h-52 px-2 py-1.5 text-sm outline-none " +
+            "border border-purple-200 rounded-md resize-y font-sans " +
+            "focus:ring-2 focus:ring-purple-300/40"
+          }
+          value={multiLineDraft}
+          onChange={(e) => setMultiLineDraft(e.target.value)}
+          onBlur={commitLinesAndExit}
+          onKeyDown={(e: React.KeyboardEvent<HTMLTextAreaElement>): void => {
+            if (e.key === "Escape") {
+              e.preventDefault();
+              cancelMulti();
+            }
+          }}
+          onMouseDown={(e) => e.stopPropagation()}
+          autoFocus
+          rows={5}
+          spellCheck={false}
+          aria-label="Edit values, one per line"
+        />
+      );
+    }
+
     return (
       <div
         key={modeKey}
@@ -395,7 +454,7 @@ export const EditableCell = ({
   }
 
   const renderReadOnlyTags = (): React.ReactNode => {
-    if (type === "options") {
+    if (type === "options" || isMultiLineText) {
       if (Array.isArray(value)) {
         return (value as string[]).map((v, i) => (
           <VolunteerTag key={i} label={v} />
@@ -440,7 +499,9 @@ export const EditableCell = ({
         title={
           isNotes
             ? "Double-click or press Enter to edit. Use Show more to read long notes."
-            : "Click to select, double-click or press Enter to edit"
+            : isMultiLineText
+              ? "Double-click or press Enter to edit. One line per value."
+              : "Click to select, double-click or press Enter to edit"
         }
       />
       <div className="relative z-10 w-full h-full min-h-6 cursor-text flex items-center gap-1 flex-wrap overflow-hidden pointer-events-none">
diff --git a/src/components/volunteers/FilterModal.tsx b/src/components/volunteers/FilterModal.tsx
index 4e191866..403f301c 100644
--- a/src/components/volunteers/FilterModal.tsx
+++ b/src/components/volunteers/FilterModal.tsx
@@ -75,7 +75,16 @@ export const FilterModal = ({
           (c) => c.id === initialFilter.field
         );
         if (initialColDef?.type === "text") {
-          setInputValue(initialFilter.values[0] as string);
+          if (initialFilter.field === "cohorts") {
+            const parts = initialFilter.values.map((v) => {
+              if (Array.isArray(v) && v.length === 2)
+                return `${String(v[0])} ${String(v[1])}`;
+              return String(v);
+            });
+            setInputValue(parts.join(", "));
+          } else {
+            setInputValue(String(initialFilter.values[0] ?? ""));
+          }
           setSelectedOptions([]);
         } else {
           setSelectedOptions(initialFilter.values as string[]);
@@ -226,7 +235,11 @@ export const FilterModal = ({
               <input
                 ref={valueInputRef}
                 type="text"
-                placeholder={`Type ${colDef.label}...`}
+                placeholder={
+                  colDef.isMulti
+                    ? `Text contained in ${colDef.label}…`
+                    : `Type ${colDef.label}…`
+                }
                 value={inputValue}
                 onChange={(e) => setInputValue(e.target.value)}
                 onKeyDown={(e) => {
diff --git a/src/components/volunteers/ManageTagsModal.tsx b/src/components/volunteers/ManageTagsModal.tsx
index a9504906..7d008e8d 100644
--- a/src/components/volunteers/ManageTagsModal.tsx
+++ b/src/components/volunteers/ManageTagsModal.tsx
@@ -3,13 +3,12 @@
 import React, { useEffect } from "react";
 import { Tags, X } from "lucide-react";
 import { ManageTagsContent } from "@/components/settings/ManageTagsContent";
-import type { CohortRow, RoleRow } from "./types";
+import type { RoleRow } from "./types";
 
 interface ManageTagsModalProps {
   isOpen: boolean;
   onClose: () => void;
   roles: RoleRow[];
-  cohorts: CohortRow[];
   onRefresh: () => void;
 }
 
@@ -17,7 +16,6 @@ export function ManageTagsModal({
   isOpen,
   onClose,
   roles,
-  cohorts,
   onRefresh,
 }: ManageTagsModalProps): React.JSX.Element | null {
   useEffect(() => {
@@ -63,8 +61,9 @@ export function ManageTagsModal({
                   id="manage-tags-modal-desc"
                   className="text-sm text-gray-600 mt-1.5 leading-relaxed max-w-xl"
                 >
-                  Edit role names and cohort terms used in filters, imports, and
-                  the spreadsheet editor.
+                  Edit tag names for Training, Position, Committee, and Language
+                  — the same tags used in filters, CSV import, and the
+                  spreadsheet editor.
                 </p>
               </div>
             </div>
@@ -80,7 +79,6 @@ export function ManageTagsModal({
           <div className="flex-1 min-h-0 overflow-y-auto px-4 py-4 sm:px-5 sm:py-5 bg-linear-to-b from-gray-50/90 to-white">
             <ManageTagsContent
               initialRoles={roles}
-              initialCohorts={cohorts}
               loadError={null}
               onRefresh={onRefresh}
               embedded
diff --git a/src/components/volunteers/VolunteersShortcutsModal.tsx b/src/components/volunteers/VolunteersShortcutsModal.tsx
index 32c50532..679a9103 100644
--- a/src/components/volunteers/VolunteersShortcutsModal.tsx
+++ b/src/components/volunteers/VolunteersShortcutsModal.tsx
@@ -676,8 +676,8 @@ export const VolunteersShortcutsModal = ({
                 </span>
                 . If the second value has no{" "}
                 <span className="font-mono">@</span>, it is stored as phone.
-                Avoid commas inside names. New volunteers have no roles or
-                cohorts until you edit them.
+                Avoid commas inside names. New volunteers have no tags or
+                training until you edit them.
               </p>
               <textarea
                 value={batchText}
diff --git a/src/components/volunteers/VolunteersTable.tsx b/src/components/volunteers/VolunteersTable.tsx
index fcbe57af..4abaa8d6 100644
--- a/src/components/volunteers/VolunteersTable.tsx
+++ b/src/components/volunteers/VolunteersTable.tsx
@@ -38,12 +38,7 @@ import { VolunteersTableHelpModal } from "./VolunteersTableHelpModal";
 import { VolunteersShortcutsModal } from "./VolunteersShortcutsModal";
 import { getCurrentUser } from "@/lib/api/getCurrentUser";
 import { removeVolunteersAction } from "@/lib/api/actions";
-import {
-  PRONOUN_OPTIONS,
-  OPT_IN_OPTIONS,
-  sortCohorts,
-  sortRoles,
-} from "./utils";
+import { PRONOUN_OPTIONS, OPT_IN_OPTIONS, sortRoles } from "./utils";
 import { useVolunteersData } from "./useVolunteersData";
 import { useVolunteerEdits } from "./useVolunteerEdits";
 import type { CopyCellFormat } from "./copySelectedCells";
@@ -125,7 +120,6 @@ const VolunteersTableContent = ({
     setData,
     allVolunteers,
     allRoles,
-    allCohorts,
     loading,
     setLoading,
     filters,
@@ -163,7 +157,6 @@ const VolunteersTableContent = ({
     setEditedRows,
     allVolunteers,
     allRoles,
-    allCohorts,
     setData,
     setAllVolunteers,
     bumpDisplayRefresh,
@@ -178,11 +171,9 @@ const VolunteersTableContent = ({
       if (col.type === "options") options[col.id] = new Set();
     });
 
-    allCohorts.forEach((c) => {
-      if (c.is_active) options["cohorts"]?.add(`${c.term} ${c.year}`);
-    });
     allRoles.forEach((r) => {
       if (!r.is_active) return;
+      if (r.type === "training") options["cohorts"]?.add(r.name);
       if (r.type === "current") options["current_roles"]?.add(r.name);
       if (r.type === "prior") options["prior_roles"]?.add(r.name);
       if (r.type === "future_interest")
@@ -244,14 +235,12 @@ const VolunteersTableContent = ({
           if (idxB === -1) return -1;
           return idxA - idxB;
         });
-      } else if (key === "cohorts") {
-        result[key] = arr.sort(sortCohorts);
       } else {
         result[key] = arr.sort(sortRoles);
       }
     }
     return result;
-  }, [allVolunteers, allRoles, allCohorts, editedRows]);
+  }, [allVolunteers, allRoles, editedRows]);
 
   const pendingChanges = useMemo<PendingRowChange[]>(() => {
     return Object.entries(editedRows)
@@ -398,7 +387,8 @@ const VolunteersTableContent = ({
   const clearValueForColumn = useCallback((colId: string): unknown => {
     const col = COLUMNS_CONFIG.find((c) => String(c.id) === colId);
     if (!col) return "";
-    if (col.filterType === "options") return col.isMulti ? [] : null;
+    if (col.isMulti) return [];
+    if (col.filterType === "options") return null;
     return "";
   }, []);
 
@@ -724,7 +714,7 @@ const VolunteersTableContent = ({
           />
         </div>
         {(filters.length > 0 || sorting.length > 0) && (
-          <div className="border-t border-gray-100 px-3 pb-3 pt-2">
+          <div className="border-t border-gray-300 px-3 pb-3 pt-2">
             <FilterBar
               filters={filters}
               setFilters={setFilters}
@@ -772,7 +762,7 @@ const VolunteersTableContent = ({
         <div className="border border-gray-200 rounded-xl bg-white shadow-sm p-0 select-none">
           <div className="overflow-x-auto">
             <table className="w-full text-sm text-left table-fixed border-collapse">
-              <thead className="border-b border-gray-200">
+              <thead className="border-b border-gray-300">
                 {table.getHeaderGroups().map((headerGroup) => (
                   <tr key={headerGroup.id}>
                     {headerGroup.headers.map((header) => (
@@ -851,7 +841,7 @@ const VolunteersTableContent = ({
                       data-volunteer-row-id={row.original.id}
                       data-state={row.getIsSelected() ? "selected" : undefined}
                       className={clsx(
-                        "group transition-colors border-b border-gray-100 bg-white hover:bg-gray-50",
+                        "group transition-colors border-b border-gray-300 bg-white hover:bg-gray-50",
                         "data-[state=selected]:bg-blue-100/30 data-[state=selected]:hover:bg-blue-100/50"
                       )}
                     >
@@ -980,7 +970,6 @@ const VolunteersTableContent = ({
         isOpen={isManageTagsOpen}
         onClose={() => setIsManageTagsOpen(false)}
         roles={allRoles}
-        cohorts={allCohorts}
         onRefresh={() => {
           setLoading(true);
           fetchInitialData();
@@ -1008,7 +997,7 @@ const VolunteersTableContent = ({
             aria-labelledby="unsaved-changes-title"
             className="fixed left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 z-101 w-full max-w-2xl max-h-[85vh] bg-white rounded-xl shadow-2xl flex flex-col overflow-hidden"
           >
-            <div className="px-5 py-4 border-b border-gray-100 flex items-center justify-between">
+            <div className="px-5 py-4 border-b border-gray-300 flex items-center justify-between">
               <h2
                 id="unsaved-changes-title"
                 className="text-lg font-semibold text-gray-900"
@@ -1032,10 +1021,10 @@ const VolunteersTableContent = ({
                     key={row.volunteerId}
                     className="border border-gray-200 rounded-lg"
                   >
-                    <div className="px-4 py-2 border-b border-gray-100 bg-gray-50 text-sm font-medium text-gray-900">
+                    <div className="px-4 py-2 border-b border-gray-300 bg-gray-50 text-sm font-medium text-gray-900">
                       {row.volunteerLabel} ({row.changes.length})
                     </div>
-                    <div className="divide-y divide-gray-100">
+                    <div className="divide-y divide-gray-300">
                       {row.changes.map((change) => (
                         <div
                           key={`${row.volunteerId}-${change.colId}`}
diff --git a/src/components/volunteers/useVolunteerEdits.ts b/src/components/volunteers/useVolunteerEdits.ts
index 9f4d7885..7d3a9d28 100644
--- a/src/components/volunteers/useVolunteerEdits.ts
+++ b/src/components/volunteers/useVolunteerEdits.ts
@@ -2,11 +2,10 @@ import { createElement, useState, useCallback, useRef } from "react";
 import { flushSync } from "react-dom";
 import toast from "react-hot-toast";
 import { Pencil } from "lucide-react";
-import { Volunteer, RoleRow, CohortRow } from "./types";
+import { Volunteer, RoleRow } from "./types";
 import { updateVolunteer } from "@/lib/api/updateVolunteer";
 import { createRole } from "@/lib/api/createRole";
-import { createCohort } from "@/lib/api/createCohort";
-import { sortCohorts, sortRoles } from "./utils";
+import { sortRoles } from "./utils";
 
 interface UseVolunteerEditsProps {
   editedRows: Record<number, Partial<Volunteer>>;
@@ -15,7 +14,6 @@ interface UseVolunteerEditsProps {
   >;
   allVolunteers: Volunteer[];
   allRoles: RoleRow[];
-  allCohorts: CohortRow[];
   setData: React.Dispatch<React.SetStateAction<Volunteer[]>>;
   setAllVolunteers: React.Dispatch<React.SetStateAction<Volunteer[]>>;
   bumpDisplayRefresh: () => void;
@@ -82,11 +80,10 @@ const normalizeValue = (colId: string, value: unknown): unknown => {
     if (value === "No") return false;
     return null;
   }
-  if (colId === "cohorts" && Array.isArray(value)) {
-    return [...(value as string[])].sort(sortCohorts);
-  }
   if (
-    ["current_roles", "prior_roles", "future_interests"].includes(colId) &&
+    ["cohorts", "current_roles", "prior_roles", "future_interests"].includes(
+      colId
+    ) &&
     Array.isArray(value)
   ) {
     return [...(value as string[])].sort(sortRoles);
@@ -99,7 +96,6 @@ export const useVolunteerEdits = ({
   setEditedRows,
   allVolunteers,
   allRoles,
-  allCohorts,
   setData,
   setAllVolunteers,
   bumpDisplayRefresh,
@@ -331,36 +327,11 @@ export const useVolunteerEdits = ({
     let usedFullRefetchAfterFatalError = false;
 
     try {
-      const knownCohortTerms = new Set(
-        allCohorts.map((c) => `${c.term.toLowerCase()} ${c.year}`)
-      );
       const knownRoles = new Set(
         allRoles.map((r) => `${r.name.toLowerCase()}|${r.type}`)
       );
 
       for (const updates of Object.values(editedRows)) {
-        if (updates.cohorts) {
-          for (const cName of updates.cohorts) {
-            const [term, year] = cName.trim().split(/\s+/);
-            if (!term || !year)
-              throw new Error(
-                `Invalid cohort format "${cName}". Use 'Term Year'`
-              );
-            const normalizedTerm =
-              term.charAt(0).toUpperCase() + term.slice(1).toLowerCase();
-            const cohortKey = `${normalizedTerm.toLowerCase()} ${year}`;
-            if (!knownCohortTerms.has(cohortKey)) {
-              await createCohort({
-                term: normalizedTerm,
-                year: Number(year),
-                is_active: true,
-              });
-              knownCohortTerms.add(cohortKey);
-              referenceDataDirty = true;
-            }
-          }
-        }
-
         const checkAndCreateRoles = async (
           roleArray: string[] | undefined,
           type: string
@@ -381,6 +352,10 @@ export const useVolunteerEdits = ({
           }
         };
 
+        await checkAndCreateRoles(
+          updates.cohorts as string[] | undefined,
+          "training"
+        );
         await checkAndCreateRoles(
           updates.current_roles as string[] | undefined,
           "current"
@@ -403,24 +378,13 @@ export const useVolunteerEdits = ({
 
           if (!volunteer) throw new Error(`Volunteer ID ${id} not found`);
 
-          if (updates.cohorts !== undefined) {
-            payload["cohorts"] = (updates.cohorts as string[]).map(
-              (cName: string) => {
-                const [term, year] = cName.trim().split(/\s+/);
-                const safeTerm = term || "";
-                const normalizedTerm =
-                  safeTerm.charAt(0).toUpperCase() +
-                  safeTerm.slice(1).toLowerCase();
-                return { term: normalizedTerm, year: Number(year) };
-              }
-            );
-          }
-
-          if (
+          const needsRoleMerge =
+            updates.cohorts !== undefined ||
             updates.current_roles !== undefined ||
             updates.prior_roles !== undefined ||
-            updates.future_interests !== undefined
-          ) {
+            updates.future_interests !== undefined;
+
+          if (needsRoleMerge) {
             const mergedRoles: { name: string; type: string }[] = [];
             const appendRoles = (
               roleArray: string[] | undefined,
@@ -433,6 +397,11 @@ export const useVolunteerEdits = ({
               );
             };
 
+            appendRoles(
+              updates.cohorts as string[] | undefined,
+              volunteer.cohorts,
+              "training"
+            );
             appendRoles(
               updates.current_roles as string[] | undefined,
               volunteer.current_roles,
@@ -450,6 +419,7 @@ export const useVolunteerEdits = ({
             );
 
             payload["roles"] = mergedRoles;
+            delete payload["cohorts"];
             delete payload["current_roles"];
             delete payload["prior_roles"];
             delete payload["future_interests"];
diff --git a/src/components/volunteers/useVolunteersData.ts b/src/components/volunteers/useVolunteersData.ts
index 0fa377f7..aad64658 100644
--- a/src/components/volunteers/useVolunteersData.ts
+++ b/src/components/volunteers/useVolunteersData.ts
@@ -6,16 +6,15 @@ import {
   type Dispatch,
   type SetStateAction,
 } from "react";
-import { Volunteer, CohortRow, RoleRow } from "./types";
+import { Volunteer, RoleRow } from "./types";
 import {
   FilterTuple,
   getVolunteersByMultipleColumns,
 } from "@/lib/api/getVolunteersByMultipleColumns";
 import { getVolunteersTable } from "@/lib/api/getVolunteersTable";
 import { getRoles } from "@/lib/api/getRoles";
-import { getCohorts } from "@/lib/api/getCohorts";
 import { useDebounce } from "@/hooks/useDebounce";
-import { sortCohorts, sortRoles } from "./utils";
+import { sortRoles } from "./utils";
 import { SortingState, RowSelectionState } from "@tanstack/react-table";
 
 export const DEFAULT_OPT_IN_FILTER: FilterTuple = {
@@ -25,15 +24,6 @@ export const DEFAULT_OPT_IN_FILTER: FilterTuple = {
 };
 
 function formatFilterTupleForApi(f: FilterTuple): FilterTuple {
-  if (f.field === "cohorts") {
-    return {
-      ...f,
-      values: (f.values as string[]).map((v) => {
-        const [term, year] = v.split(" ");
-        return [term, year] as [string, string];
-      }),
-    };
-  }
   if (f.field === DEFAULT_OPT_IN_FILTER.field) {
     return {
       ...f,
@@ -55,7 +45,6 @@ export interface UseVolunteersDataReturn {
   setData: React.Dispatch<React.SetStateAction<Volunteer[]>>;
   allVolunteers: Volunteer[];
   allRoles: RoleRow[];
-  allCohorts: CohortRow[];
   loading: boolean;
   setLoading: React.Dispatch<React.SetStateAction<boolean>>;
   filters: FilterTuple[];
@@ -87,7 +76,6 @@ export const useVolunteersData = ({
   const [loading, setLoading] = useState<boolean>(true);
 
   const [allRoles, setAllRoles] = useState<RoleRow[]>([]);
-  const [allCohorts, setAllCohorts] = useState<CohortRow[]>([]);
 
   const [filters, setFilters] = useState<FilterTuple[]>([
     DEFAULT_OPT_IN_FILTER,
@@ -109,30 +97,25 @@ export const useVolunteersData = ({
       const volunteerData = await getVolunteersTable();
 
       const formattedAll: Volunteer[] = volunteerData.map((entry) => {
-        const formatTag = (item: CohortRow | RoleRow): string => {
-          if ("term" in item && "year" in item && item.term && item.year) {
-            return `${item.term} ${item.year}`;
-          }
-          if ("name" in item && item.name) {
-            return item.name;
-          }
-          return String(item.id) || "";
-        };
+        const formatRoleName = (r: RoleRow): string => r.name;
 
         return {
           ...entry.volunteer,
-          cohorts: entry.cohorts.map(formatTag).sort(sortCohorts),
+          cohorts: entry.roles
+            .filter((r) => r.type === "training")
+            .map(formatRoleName)
+            .sort(sortRoles),
           current_roles: entry.roles
             .filter((r) => r.type === "current")
-            .map(formatTag)
+            .map(formatRoleName)
             .sort(sortRoles),
           prior_roles: entry.roles
             .filter((r) => r.type === "prior")
-            .map(formatTag)
+            .map(formatRoleName)
             .sort(sortRoles),
           future_interests: entry.roles
             .filter((r) => r.type === "future_interest")
-            .map(formatTag)
+            .map(formatRoleName)
             .sort(sortRoles),
         };
       });
@@ -141,7 +124,6 @@ export const useVolunteersData = ({
 
       if (isAdmin) {
         getRoles().then(setAllRoles).catch(console.error);
-        getCohorts().then(setAllCohorts).catch(console.error);
       }
     } catch (error) {
       console.error("Error fetching volunteer data:", error);
@@ -155,11 +137,10 @@ export const useVolunteersData = ({
   const refreshRolesAndCohorts = useCallback(async (): Promise<void> => {
     if (!isAdmin) return;
     try {
-      const [roles, cohorts] = await Promise.all([getRoles(), getCohorts()]);
+      const roles = await getRoles();
       setAllRoles(roles);
-      setAllCohorts(cohorts);
     } catch (e) {
-      console.error("Error refreshing roles/cohorts:", e);
+      console.error("Error refreshing roles:", e);
     }
   }, [isAdmin]);
 
@@ -290,7 +271,6 @@ export const useVolunteersData = ({
     setData,
     allVolunteers,
     allRoles,
-    allCohorts,
     loading,
     setLoading,
     filters,
diff --git a/src/components/volunteers/volunteerColumns.tsx b/src/components/volunteers/volunteerColumns.tsx
index 35ecd91e..65c282a5 100644
--- a/src/components/volunteers/volunteerColumns.tsx
+++ b/src/components/volunteers/volunteerColumns.tsx
@@ -6,14 +6,17 @@ import { HeaderWithIcon } from "./HeaderWithIcon";
 import { EditableCell } from "./EditableCell";
 import { NotesDisplay } from "./NotesDisplay";
 import {
+  AtSign,
+  Bell,
+  Briefcase,
   CaseSensitive,
+  GraduationCap,
   Hash,
-  User,
-  AtSign,
+  Languages,
   Phone,
-  List,
   TextAlignStart,
-  Bell,
+  User,
+  UsersRound,
 } from "lucide-react";
 
 type FilterType = "text" | "options" | null;
@@ -108,8 +111,8 @@ export const COLUMNS_CONFIG: ColumnConfig[] = [
   },
   {
     id: "cohorts",
-    label: "Cohort",
-    icon: List,
+    label: "Training",
+    icon: GraduationCap,
     filterType: "options",
     isMulti: true,
     size: 150,
@@ -117,8 +120,8 @@ export const COLUMNS_CONFIG: ColumnConfig[] = [
   },
   {
     id: "prior_roles",
-    label: "Prior Role",
-    icon: User,
+    label: "Position",
+    icon: Briefcase,
     filterType: "options",
     isMulti: true,
     size: 180,
@@ -126,8 +129,8 @@ export const COLUMNS_CONFIG: ColumnConfig[] = [
   },
   {
     id: "current_roles",
-    label: "Current Role",
-    icon: User,
+    label: "Committee",
+    icon: UsersRound,
     filterType: "options",
     isMulti: true,
     size: 180,
@@ -135,8 +138,8 @@ export const COLUMNS_CONFIG: ColumnConfig[] = [
   },
   {
     id: "future_interests",
-    label: "Future Interest",
-    icon: User,
+    label: "Language",
+    icon: Languages,
     filterType: "options",
     isMulti: true,
     size: 180,
diff --git a/src/components/volunteers/volunteersHelpContent.tsx b/src/components/volunteers/volunteersHelpContent.tsx
index 5c815861..262113a2 100644
--- a/src/components/volunteers/volunteersHelpContent.tsx
+++ b/src/components/volunteers/volunteersHelpContent.tsx
@@ -126,8 +126,8 @@ export function VolunteersHelpContent({
                 remove volunteers (you’ll confirm in a dialog).
               </li>
               <li>
-                New tags (roles, cohorts) can be typed in the cell editor; save
-                to persist them.
+                New tags (training, position, committee, language) can be typed
+                in the cell editor; save to persist them.
               </li>
             </ul>
           </section>
diff --git a/src/lib/api/createRole.ts b/src/lib/api/createRole.ts
index b8696f49..b8a2ca77 100644
--- a/src/lib/api/createRole.ts
+++ b/src/lib/api/createRole.ts
@@ -8,7 +8,12 @@ type RoleInsert = Database["public"]["Tables"]["Roles"]["Insert"];
 type RoleInput = Pick<RoleInsert, "name" | "type" | "is_active">;
 
 // Valid role types
-const VALID_ROLE_TYPES = ["prior", "current", "future_interest"] as const;
+const VALID_ROLE_TYPES = [
+  "prior",
+  "current",
+  "future_interest",
+  "training",
+] as const;
 export type RoleType = (typeof VALID_ROLE_TYPES)[number];
 
 // Validation error type
diff --git a/src/lib/api/createVolunteer.ts b/src/lib/api/createVolunteer.ts
index f776fa64..ec2c02de 100644
--- a/src/lib/api/createVolunteer.ts
+++ b/src/lib/api/createVolunteer.ts
@@ -3,7 +3,12 @@ import { createClient } from "@/lib/client/supabase";
 import type { Json, TablesInsert } from "@/lib/client/supabase/types";
 
 // Valid role types
-const VALID_ROLE_TYPES = ["prior", "current", "future_interest"] as const;
+const VALID_ROLE_TYPES = [
+  "prior",
+  "current",
+  "future_interest",
+  "training",
+] as const;
 export type RoleType = (typeof VALID_ROLE_TYPES)[number];
 
 // Valid cohort terms
@@ -277,6 +282,14 @@ function volunteerToJson(volunteer: VolunteerInput): Record<string, unknown> {
   };
 }
 
+/** Cohorts are stored as Roles with type `training` (label: "Term Year"). */
+function cohortsToTrainingRoles(cohorts: CohortInput[]): RoleInput[] {
+  return cohorts.map((c) => ({
+    name: `${c.term} ${c.year}`,
+    type: "training",
+  }));
+}
+
 /**
  * Creates a volunteer with optional many roles and cohorts in one DB transaction.
  */
@@ -295,13 +308,17 @@ export async function createVolunteer(
 
     const { volunteer, roles, cohorts } = input;
     const client = await createClient();
+    const rolesPayload = [
+      ...roles,
+      ...cohortsToTrainingRoles(cohorts),
+    ] as unknown as Json;
 
     const { data: volunteerId, error } = await client.rpc(
       "create_volunteer_with_roles_and_cohorts",
       {
         p_volunteer: volunteerToJson(volunteer) as Json,
-        p_roles: roles as unknown as Json,
-        p_cohorts: cohorts as unknown as Json,
+        p_roles: rolesPayload,
+        p_cohorts: [] as unknown as Json,
       }
     );
 
diff --git a/src/lib/api/getVolunteersByMultipleColumns.ts b/src/lib/api/getVolunteersByMultipleColumns.ts
index 3c8ca146..34cad4b9 100644
--- a/src/lib/api/getVolunteersByMultipleColumns.ts
+++ b/src/lib/api/getVolunteersByMultipleColumns.ts
@@ -14,18 +14,6 @@ const OP = {
   OR: "OR",
 } as const;
 
-const VALID_COHORT_TERM_REGEX = /^(Fall|Spring|Summer|Winter)$/i;
-
-/** General columns where filter text should match like table search: case-insensitive substring. */
-const TEXT_SUBSTRING_MATCH_FIELDS = new Set<string>([
-  "name_org",
-  "pseudonym",
-  "email",
-  "phone",
-  "position",
-  "notes",
-]);
-
 const ALLOWED_FIELDS = [
   "name_org",
   "pseudonym",
@@ -45,6 +33,16 @@ const ALLOWED_FIELDS = [
   CONTACT_INCOMPLETE_FIELD,
 ];
 
+/** Volunteer scalar columns filtered with substring match (ilike), not exact `in()`. */
+const TEXT_SUBSTRING_MATCH_FIELDS = new Set<string>([
+  "name_org",
+  "pseudonym",
+  "email",
+  "phone",
+  "position",
+  "notes",
+]);
+
 export type FilterTuple = {
   field: string;
   miniOp: "AND" | "OR";
@@ -107,17 +105,18 @@ export async function getVolunteersByMultipleColumns(
         else if (f.field === "prior_roles") roleType = "prior";
         else roleType = "future_interest";
 
-        return filterIdsByRoles(
+        return filterIdsByRolesTextSearch(
           client,
           f.miniOp,
           f.values as string[],
           roleType
         );
       } else if (f.field === "cohorts") {
-        return filterIdsByCohorts(
+        return filterIdsByRolesTextSearch(
           client,
           f.miniOp,
-          f.values as [string, string][]
+          f.values as string[],
+          "training"
         );
       } else {
         return filterIdsByGeneral(
@@ -191,18 +190,10 @@ export async function validateMultipleColumnFilter(
       }
     } else if (f.field === "cohorts") {
       const invalid = f.values.some(
-        (v) =>
-          !Array.isArray(v) ||
-          v.length !== 2 ||
-          typeof v[0] !== "string" ||
-          !VALID_COHORT_TERM_REGEX.test(v[0]) ||
-          typeof v[1] !== "string" ||
-          isNaN(parseInt(v[1])) ||
-          !(1900 <= parseInt(v[1]) && parseInt(v[1]) <= 2100)
+        (v) => typeof v !== "string" || (v as string).trim() === ""
       );
-
       if (invalid)
-        return { valid: false, error: "Invalid cohort filter values" };
+        return { valid: false, error: "Invalid training filter values" };
     } else {
       const invalid = f.values.some((v) => typeof v !== "string");
       if (invalid)
@@ -215,72 +206,48 @@ export async function validateMultipleColumnFilter(
   return { valid: true, cleanedFiltersList };
 }
 
-function filterMatchingIds(
-  mappedData: Map<number, Set<string>>,
-  op: string,
-  targetValues: string[]
-): Set<number> {
-  const validIds = new Set<number>();
-
-  for (const [id, foundItems] of mappedData) {
-    if (op === OP.OR || targetValues.every((v) => foundItems.has(v))) {
-      validIds.add(id);
-    }
-  }
-  return validIds;
-}
-
-async function filterIdsByRoles(
+async function filterIdsByRolesTextSearch(
   client: SupabaseClient<Database>,
   op: string,
-  values: string[],
-  type: string
+  patterns: string[],
+  roleType: string
 ): Promise<Set<number>> {
+  const trimmed = patterns.map((p) => p.trim()).filter((p) => p.length > 0);
+  if (trimmed.length === 0) return new Set<number>();
+
   const { data, error } = await client
     .from("VolunteerRoles")
     .select("volunteer_id, Roles!inner(name, type)")
-    .eq("Roles.type", type)
-    .in("Roles.name", values);
+    .eq("Roles.type", roleType);
 
   if (error) throw error;
 
   const mappedRoles = new Map<number, Set<string>>();
-  for (const role of data) {
-    if (!mappedRoles.has(role.volunteer_id))
-      mappedRoles.set(role.volunteer_id, new Set());
-    mappedRoles.get(role.volunteer_id)?.add(role.Roles.name);
+  for (const row of data ?? []) {
+    const name = row.Roles?.name;
+    if (!name) continue;
+    const vid = row.volunteer_id;
+    if (!mappedRoles.has(vid)) mappedRoles.set(vid, new Set());
+    mappedRoles.get(vid)?.add(name);
   }
 
-  return filterMatchingIds(mappedRoles, op, values);
-}
-
-async function filterIdsByCohorts(
-  client: SupabaseClient<Database>,
-  op: string,
-  values: [string, string][]
-): Promise<Set<number>> {
-  const orCondition = values
-    .map((v) => `and(term.eq.${v[0]},year.eq.${v[1]})`)
-    .join(",");
-
-  const { data, error } = await client
-    .from("VolunteerCohorts")
-    .select("volunteer_id, Cohorts!inner(term, year)")
-    .or(orCondition, { referencedTable: "Cohorts" });
-
-  if (error) throw error;
+  const nameMatchesPattern = (names: Set<string>, pattern: string): boolean => {
+    const low = pattern.toLowerCase();
+    for (const n of names) {
+      if (n.toLowerCase().includes(low)) return true;
+    }
+    return false;
+  };
 
-  const mappedCohorts = new Map<number, Set<string>>();
-  for (const cohort of data) {
-    const key = `${cohort.Cohorts.term}-${cohort.Cohorts.year}`;
-    if (!mappedCohorts.has(cohort.volunteer_id))
-      mappedCohorts.set(cohort.volunteer_id, new Set());
-    mappedCohorts.get(cohort.volunteer_id)?.add(key);
+  const validIds = new Set<number>();
+  for (const [id, names] of mappedRoles) {
+    if (op === OP.OR) {
+      if (trimmed.some((p) => nameMatchesPattern(names, p))) validIds.add(id);
+    } else if (trimmed.every((p) => nameMatchesPattern(names, p))) {
+      validIds.add(id);
+    }
   }
-
-  const targetValues = values.map((v) => `${v[0]}-${v[1]}`);
-
-  return filterMatchingIds(mappedCohorts, op, targetValues);
+  return validIds;
 }
 
 function ilikeSubstringPattern(term: string): string {
diff --git a/src/lib/api/getVolunteersTable.ts b/src/lib/api/getVolunteersTable.ts
index 86ec0778..4fdcffa6 100644
--- a/src/lib/api/getVolunteersTable.ts
+++ b/src/lib/api/getVolunteersTable.ts
@@ -1,22 +1,8 @@
 /**
- * Fetches all volunteers with their associated cohorts and roles.
+ * Fetches all volunteers with their associated roles.
  *
  * @returns A Promise resolving to an array of VolunteerTableEntry objects,
- *   where each entry contains:
- *   - volunteer: The volunteer's core information
- *   - cohorts: Array of cohorts the volunteer belongs to
- *   - roles: Array of roles assigned to the volunteer
- *
- * @throws Error if the Supabase query fails
- *
- * @example
- * const volunteersData = await getVolunteersTable();
- * // Returns:
- * // [
- * //   { volunteer: Volunteer1, cohorts: [Cohort1, Cohort2], roles: [Role1, Role2] },
- * //   { volunteer: Volunteer2, cohorts: [Cohort1], roles: [Role1] },
- * //   ...
- * // ]
+ *   where each entry contains the volunteer row and joined roles.
  */
 
 "use server";
@@ -26,25 +12,20 @@ import type { Database } from "@/lib/client/supabase/types";
 import type { PostgrestError } from "@supabase/supabase-js";
 
 type VolunteerRow = Database["public"]["Tables"]["Volunteers"]["Row"];
-type CohortRow = Database["public"]["Tables"]["Cohorts"]["Row"];
 type RoleRow = Database["public"]["Tables"]["Roles"]["Row"];
 
 export interface VolunteerTableEntry {
   volunteer: VolunteerRow;
-  cohorts: CohortRow[];
   roles: RoleRow[];
 }
 
-// Explicit type for Supabase nested select response to override incorrect inferred type
 type VolunteerWithRelations = VolunteerRow & {
-  VolunteerCohorts: Array<{ Cohorts: CohortRow | null }>;
   VolunteerRoles: Array<{ Roles: RoleRow | null }>;
 };
 
 export async function getVolunteersTable(): Promise<VolunteerTableEntry[]> {
   const client = await createClient();
 
-  // Log connection and auth state to help debug RLS issues
   console.log(
     "[getVolunteersTable] NEXT_PUBLIC_SUPABASE_URL:",
     process.env["NEXT_PUBLIC_SUPABASE_URL"] ?? "NOT SET"
@@ -70,7 +51,6 @@ export async function getVolunteersTable(): Promise<VolunteerTableEntry[]> {
   console.log("[getVolunteersTable] auth user role:", authUser?.role ?? "NONE");
   console.log("[getVolunteersTable] auth error:", authError?.message ?? "none");
 
-  // Check RLS policies directly - query a simple count to isolate the issue
   const { count, error: countError } = await client
     .from("Volunteers")
     .select("*", { count: "exact", head: true });
@@ -81,13 +61,11 @@ export async function getVolunteersTable(): Promise<VolunteerTableEntry[]> {
     countError ? JSON.stringify(countError) : "none"
   );
 
-  // Single query with nested selects - type assertion for proper array inference
   const { data, error } = (await client
     .from("Volunteers")
     .select(
       `
       *,
-      VolunteerCohorts ( Cohorts (*) ),
       VolunteerRoles ( Roles (*) )
     `
     )
@@ -113,24 +91,15 @@ export async function getVolunteersTable(): Promise<VolunteerTableEntry[]> {
     return [];
   }
 
-  // Transform nested structure to flat format
   const result: VolunteerTableEntry[] = data.map((volunteerData) => {
-    // Extract volunteer fields and nested relation arrays
-    const { VolunteerCohorts, VolunteerRoles, ...volunteer } = volunteerData;
-
-    // Extract cohorts from nested VolunteerCohorts relation
-    const cohorts: CohortRow[] = (VolunteerCohorts ?? [])
-      .map((vc) => vc.Cohorts)
-      .filter((cohort): cohort is CohortRow => cohort !== null);
+    const { VolunteerRoles, ...volunteer } = volunteerData;
 
-    // Extract roles from nested VolunteerRoles relation
     const roles: RoleRow[] = (VolunteerRoles ?? [])
       .map((vr) => vr.Roles)
       .filter((role): role is RoleRow => role !== null);
 
     return {
       volunteer: volunteer as VolunteerRow,
-      cohorts,
       roles,
     };
   });
diff --git a/src/lib/api/import_csv.ts b/src/lib/api/import_csv.ts
index 50110c25..4607ac3b 100644
--- a/src/lib/api/import_csv.ts
+++ b/src/lib/api/import_csv.ts
@@ -47,8 +47,11 @@ enum RawCol {
   BOARD_MEMBER = "board member",
 }
 
-// Mapping of raw role types to new ones
+// Mapping of phrases in role cells to DB role types (Position / Committee / Language).
 const RAW_TO_VALID_ROLE_TYPE = new Map([
+  ["committee", "current"],
+  ["language", "future_interest"],
+  ["position", "prior"],
   ["interested", "future_interest"],
   ["active", "current"],
   ["prior", "prior"],
@@ -228,8 +231,9 @@ function parseCohort(cohort: string, result: ParsedVolunteer): boolean {
 /**
  * Parses a role field from raw CSV data and adds it to the volunteer's roles array with an appropriate status.
  * Assumes the value is not "no" or null (those should be filtered out by the caller).
- * Attempts to match the raw field value against known status indicators ("interested", "active", "prior")
- * and maps them to valid role status values ("future_interest", "current", "prior").
+ * Attempts to match the raw field value against known indicators (committee,
+ * language, position, or legacy interested / active / prior) and maps them to
+ * DB role types used for the Committee, Language, and Position columns.
  * If no matching status is found, the function returns false (parse error).
  *
  * @param value - The raw role status field value from the CSV (must not be "no" or empty)
@@ -322,7 +326,7 @@ function parseRow(
         column: RawCol.COHORT,
         value: cohortValue,
         message:
-          "Cohort not applied — format was not recognized. Volunteer was still imported without this cohort.",
+          "Training not applied — format was not recognized. Volunteer was still imported without this training.",
       });
     }
   }
@@ -343,7 +347,7 @@ function parseRow(
             rowIndex,
             column: rawRoleColumn,
             value: roleValue,
-            message: `Role not applied — could not read status for ${roleName}. Volunteer was still imported without this role.`,
+            message: `Tag not applied — could not read column for ${roleName}. Volunteer was still imported without this tag.`,
           });
         }
       }
@@ -495,10 +499,7 @@ export async function import_csv(
 
   const client = await createClient();
 
-  let dbInserted = 0;
-  let dbUpdated = 0;
-  let dbUpdatedNoChanges = 0;
-  const changedDetails: Array<{ name: string; fields: string[] }> = [];
+  let dbUpserted = 0;
 
   for (const volunteer of volunteers) {
     const { data: rpcResult, error } = await client.rpc(
@@ -529,66 +530,21 @@ export async function import_csv(
 
     dbSucceeded += 1;
 
-    // Log operation details from the RPC return value
-    const result = rpcResult as unknown as {
-      volunteer_id: number;
-      operation: string;
-      changed_fields: string[];
-      new_roles_added: number;
-      new_cohorts_added: number;
-    } | null;
-
-    if (result) {
-      const changedFields = result.changed_fields ?? [];
-      if (result.operation === "inserted") {
-        dbInserted += 1;
-        console.log(
-          `[import_csv] INSERTED: "${volunteer.name_org}" (id: ${result.volunteer_id}, roles added: ${result.new_roles_added}, cohorts added: ${result.new_cohorts_added})`
-        );
-      } else {
-        dbUpdated += 1;
-        if (
-          changedFields.length === 0 &&
-          result.new_roles_added === 0 &&
-          result.new_cohorts_added === 0
-        ) {
-          dbUpdatedNoChanges += 1;
-          console.log(
-            `[import_csv] DUPLICATE (no changes): "${volunteer.name_org}" (id: ${result.volunteer_id})`
-          );
-        } else {
-          const changes: string[] = [...changedFields];
-          if (result.new_roles_added > 0)
-            changes.push(`${result.new_roles_added} new role(s)`);
-          if (result.new_cohorts_added > 0)
-            changes.push(`${result.new_cohorts_added} new cohort(s)`);
-          changedDetails.push({
-            name: volunteer.name_org,
-            fields: changes,
-          });
-          console.log(
-            `[import_csv] UPDATED: "${volunteer.name_org}" (id: ${result.volunteer_id}, changes: ${changes.join(", ")})`
-          );
-        }
-      }
+    const volunteerId =
+      typeof rpcResult === "number" ? rpcResult : Number(rpcResult);
+    if (Number.isFinite(volunteerId)) {
+      dbUpserted += 1;
+      console.log(
+        `[import_csv] UPSERTED: "${volunteer.name_org}" (id: ${volunteerId})`
+      );
     }
   }
 
   // Log summary
   console.log("[import_csv] === IMPORT SUMMARY ===");
   console.log(`[import_csv] Total rows in CSV: ${parsed_csv.data.length}`);
-  console.log(`[import_csv] New volunteers inserted: ${dbInserted}`);
-  console.log(
-    `[import_csv] Existing volunteers updated: ${dbUpdated - dbUpdatedNoChanges}`
-  );
-  console.log(`[import_csv] Duplicates (no changes): ${dbUpdatedNoChanges}`);
+  console.log(`[import_csv] Volunteers upserted: ${dbUpserted}`);
   console.log(`[import_csv] DB failures: ${dbFailed}`);
-  if (changedDetails.length > 0) {
-    console.log("[import_csv] Changed details:");
-    changedDetails.forEach((d) =>
-      console.log(`[import_csv]   - "${d.name}": ${d.fields.join(", ")}`)
-    );
-  }
 
   // Count unique row indices that failed parsing
   const failedRowIndices = new Set<number>();
@@ -613,9 +569,9 @@ export async function import_csv(
       parseFailed,
       dbSucceeded,
       dbFailed,
-      dbInserted,
-      dbUpdated: dbUpdated - dbUpdatedNoChanges,
-      dbDuplicates: dbUpdatedNoChanges,
+      dbInserted: 0,
+      dbUpdated: dbUpserted,
+      dbDuplicates: 0,
     },
     parseErrors: [...papaParseErrors, ...rowParseErrors],
     parseWarnings: rowParseWarnings,
diff --git a/src/lib/api/updateRole.ts b/src/lib/api/updateRole.ts
index 59faf5e9..df298746 100644
--- a/src/lib/api/updateRole.ts
+++ b/src/lib/api/updateRole.ts
@@ -1,7 +1,7 @@
 import { createAdminClient } from "@/lib/client/supabase/server";
 import type { Tables, TablesUpdate } from "@/lib/client/supabase/types";
 
-const ROLE_TYPES = ["prior", "current", "future_interest"] as const;
+const ROLE_TYPES = ["prior", "current", "future_interest", "training"] as const;
 
 type RolePatch = Pick<TablesUpdate<"Roles">, "name" | "type" | "is_active">;
 
diff --git a/src/lib/api/updateVolunteer.ts b/src/lib/api/updateVolunteer.ts
index 6f56db7a..01acf356 100644
--- a/src/lib/api/updateVolunteer.ts
+++ b/src/lib/api/updateVolunteer.ts
@@ -3,15 +3,8 @@
 import { createAdminClient } from "../client/supabase/server";
 import type { Tables, TablesUpdate } from "../client/supabase/types";
 
-const ROLE_TYPES = ["prior", "current", "future_interest"] as const;
-const COHORT_TERMS = ["fall", "summer", "winter", "spring"] as const;
+const ROLE_TYPES = ["prior", "current", "future_interest", "training"] as const;
 const POSITION_VALUES = ["member", "volunteer", "staff"] as const;
-const COHORT_TERM_CANONICAL: Record<(typeof COHORT_TERMS)[number], string> = {
-  fall: "Fall",
-  summer: "Summer",
-  winter: "Winter",
-  spring: "Spring",
-};
 
 type VolunteerUpdatePayload = Pick<
   TablesUpdate<"Volunteers">,
@@ -26,7 +19,6 @@ type VolunteerUpdatePayload = Pick<
 >;
 
 type RoleInput = { name: string; type: (typeof ROLE_TYPES)[number] };
-type CohortInput = { year: number; term: string };
 
 type UpdateVolunteerResult =
   | { status: 200; body: { volunteer: Tables<"Volunteers"> } }
@@ -35,13 +27,10 @@ type UpdateVolunteerResult =
 type VolunteerValidationResult = {
   updates?: Partial<VolunteerUpdatePayload>;
   role?: RoleInput;
-  cohort?: CohortInput;
   roles?: RoleInput[];
-  cohorts?: CohortInput[];
   error?: string;
 };
 
-// keep this in sync with allowed patch fields on the volunteers table
 const ALLOWED_VOLUNTEER_FIELDS = new Set<keyof VolunteerUpdatePayload>([
   "name_org",
   "email",
@@ -55,9 +44,7 @@ const ALLOWED_VOLUNTEER_FIELDS = new Set<keyof VolunteerUpdatePayload>([
 const ALLOWED_TOP_LEVEL_FIELDS = new Set<string>([
   ...ALLOWED_VOLUNTEER_FIELDS,
   "role",
-  "cohort",
   "roles",
-  "cohorts",
 ]);
 
 function validateVolunteerUpdateBody(body: unknown): VolunteerValidationResult {
@@ -76,7 +63,6 @@ function validateVolunteerUpdateBody(body: unknown): VolunteerValidationResult {
     };
   }
 
-  // name_org is the only required patchable field; validate it eagerly
   const updates: Partial<VolunteerUpdatePayload> = {};
   if ("name_org" in payload) {
     const value = payload["name_org"];
@@ -92,7 +78,6 @@ function validateVolunteerUpdateBody(body: unknown): VolunteerValidationResult {
     updates.name_org = value;
   }
 
-  // optional string-ish fields can be patched with string or null
   const stringFields = [
     "email",
     "phone",
@@ -139,9 +124,7 @@ function validateVolunteerUpdateBody(body: unknown): VolunteerValidationResult {
 
   const hasFields = Object.keys(updates).length > 0;
   let role: RoleInput | undefined;
-  let cohort: CohortInput | undefined;
   let roles: RoleInput[] | undefined;
-  let cohorts: CohortInput[] | undefined;
 
   if ("role" in payload) {
     const r = payload["role"];
@@ -164,36 +147,6 @@ function validateVolunteerUpdateBody(body: unknown): VolunteerValidationResult {
     role = { name, type: type as RoleInput["type"] };
   }
 
-  if ("cohort" in payload) {
-    const c = payload["cohort"];
-    if (!c || typeof c !== "object" || Array.isArray(c)) {
-      return { error: "Field cohort must be an object" };
-    }
-    const { year, term } = c as Record<string, unknown>;
-    if (!Number.isInteger(year)) {
-      return { error: "Field cohort.year must be an integer" };
-    }
-    if (typeof term !== "string") {
-      return {
-        error: `Field cohort.term must be one of ${COHORT_TERMS.join(", ")}`,
-      };
-    }
-    const normalizedTerm = term.trim().toLowerCase();
-    if (
-      !COHORT_TERMS.includes(normalizedTerm as (typeof COHORT_TERMS)[number])
-    ) {
-      return {
-        error: `Field cohort.term must be one of ${COHORT_TERMS.join(", ")}`,
-      };
-    }
-    cohort = {
-      year: year as number,
-      term: COHORT_TERM_CANONICAL[
-        normalizedTerm as (typeof COHORT_TERMS)[number]
-      ],
-    };
-  }
-
   if ("roles" in payload) {
     const rs = payload["roles"];
     if (!Array.isArray(rs)) return { error: "Field roles must be an array" };
@@ -216,47 +169,16 @@ function validateVolunteerUpdateBody(body: unknown): VolunteerValidationResult {
     }
   }
 
-  if ("cohorts" in payload) {
-    const cs = payload["cohorts"];
-    if (!Array.isArray(cs)) return { error: "Field cohorts must be an array" };
-    cohorts = [];
-    for (const c of cs) {
-      if (!c || typeof c !== "object" || Array.isArray(c))
-        return { error: "Each cohort must be an object" };
-      const { year, term } = c as Record<string, unknown>;
-      if (!Number.isInteger(year))
-        return { error: "Field cohorts[].year must be an integer" };
-      if (typeof term !== "string")
-        return { error: "Field cohorts[].term must be a string" };
-      const normalizedTerm = term.trim().toLowerCase();
-      if (
-        !COHORT_TERMS.includes(normalizedTerm as (typeof COHORT_TERMS)[number])
-      ) {
-        return {
-          error: `Field cohorts[].term must be one of ${COHORT_TERMS.join(", ")}`,
-        };
-      }
-      cohorts.push({
-        year: year as number,
-        term: COHORT_TERM_CANONICAL[
-          normalizedTerm as (typeof COHORT_TERMS)[number]
-        ],
-      });
-    }
-  }
-
-  if (!hasFields && !role && !cohort && !roles && !cohorts) {
+  if (!hasFields && !role && roles === undefined) {
     return {
       error:
-        "At least one updatable field is required (volunteer fields, role, or cohort)",
+        "At least one updatable field is required (volunteer fields or roles)",
     };
   }
 
   const result: VolunteerValidationResult = { updates };
   if (role) result.role = role;
-  if (cohort) result.cohort = cohort;
-  if (roles) result.roles = roles;
-  if (cohorts) result.cohorts = cohorts;
+  if (roles !== undefined) result.roles = roles;
 
   return result;
 }
@@ -270,10 +192,10 @@ export async function updateVolunteer(
   }
 
   const validation = validateVolunteerUpdateBody(body);
-  if (!validation.updates) {
+  if (validation.error) {
     return {
       status: 400,
-      body: { error: validation.error ?? "Invalid volunteer update payload" },
+      body: { error: validation.error },
     };
   }
 
@@ -304,30 +226,6 @@ export async function updateVolunteer(
     roleRow = data;
   }
 
-  let cohortRow: { id: number } | null = null;
-  if (validation.cohort) {
-    const { year, term } = validation.cohort;
-    const { data, error } = await client
-      .from("Cohorts")
-      .select("id")
-      .eq("year", year)
-      .ilike("term", term)
-      .maybeSingle();
-
-    if (error) {
-      return { status: 500, body: { error: error.message } };
-    }
-
-    if (!data) {
-      return {
-        status: 400,
-        body: { error: `Cohort not found: ${term} ${year}` },
-      };
-    }
-
-    cohortRow = data;
-  }
-
   let roleIds: number[] = [];
   if (validation.roles !== undefined && validation.roles.length > 0) {
     const { data: foundRoles, error: rolesError } = await client
@@ -349,28 +247,6 @@ export async function updateVolunteer(
     }
   }
 
-  let cohortIds: number[] = [];
-  if (validation.cohorts !== undefined && validation.cohorts.length > 0) {
-    const { data: foundCohorts, error: cohortsError } = await client
-      .from("Cohorts")
-      .select("id, term, year");
-    if (cohortsError)
-      return { status: 500, body: { error: cohortsError.message } };
-
-    for (const c of validation.cohorts) {
-      const match = foundCohorts?.find(
-        (fc) =>
-          fc.term.toLowerCase() === c.term.toLowerCase() && fc.year === c.year
-      );
-      if (match) cohortIds.push(match.id);
-      else
-        return {
-          status: 400,
-          body: { error: `Cohort not found: ${c.term} ${c.year}` },
-        };
-    }
-  }
-
   const { data: volunteer, error: volunteerError } = await client
     .from("Volunteers")
     .update({ ...validation.updates, updated_at: timestamp })
@@ -413,33 +289,6 @@ export async function updateVolunteer(
     }
   }
 
-  if (validation.cohort && cohortRow) {
-    const { data: cohortLink, error: cohortLinkError } = await client
-      .from("VolunteerCohorts")
-      .select("cohort_id")
-      .eq("volunteer_id", volunteerId as number)
-      .eq("cohort_id", cohortRow.id)
-      .maybeSingle();
-
-    if (cohortLinkError) {
-      return { status: 500, body: { error: cohortLinkError.message } };
-    }
-
-    if (!cohortLink) {
-      const { error: cohortInsertError } = await client
-        .from("VolunteerCohorts")
-        .insert({
-          volunteer_id: volunteerId as number,
-          cohort_id: cohortRow.id,
-          created_at: timestamp,
-        });
-
-      if (cohortInsertError) {
-        return { status: 500, body: { error: cohortInsertError.message } };
-      }
-    }
-  }
-
   if (validation.roles !== undefined) {
     const { error: delError } = await client
       .from("VolunteerRoles")
@@ -461,26 +310,5 @@ export async function updateVolunteer(
     }
   }
 
-  if (validation.cohorts !== undefined) {
-    const { error: delError } = await client
-      .from("VolunteerCohorts")
-      .delete()
-      .eq("volunteer_id", volunteerId as number);
-    if (delError) return { status: 500, body: { error: delError.message } };
-
-    if (cohortIds.length > 0) {
-      cohortIds = [...new Set(cohortIds)];
-      const insertPayload = cohortIds.map((cId) => ({
-        volunteer_id: volunteerId as number,
-        cohort_id: cId,
-        created_at: timestamp,
-      }));
-      const { error: insError } = await client
-        .from("VolunteerCohorts")
-        .insert(insertPayload);
-      if (insError) return { status: 500, body: { error: insError.message } };
-    }
-  }
-
   return { status: 200, body: { volunteer } };
 }
diff --git a/src/lib/volunteers/csvImportUserHelp.ts b/src/lib/volunteers/csvImportUserHelp.ts
index 1b512861..3cbc724a 100644
--- a/src/lib/volunteers/csvImportUserHelp.ts
+++ b/src/lib/volunteers/csvImportUserHelp.ts
@@ -22,12 +22,12 @@ export const CSV_IMPORT_OPTIONAL_COLUMNS = [
   { header: "phone", label: "Phone" },
   {
     header: "cohort",
-    label: "Cohort",
+    label: "Training (CSV column: cohort)",
     note: "Optional. If filled, use a year, a space, then Fall, Winter, Spring, or Summer — e.g. 2024 Fall.",
   },
   {
     header: "position",
-    label: "Position",
+    label: "Volunteer position (CSV column: position)",
     note: "Optional. CL / EBU / Staff / Training are recognized for special roles; other titles (e.g. Volunteer, Coordinator) are saved as volunteer or member when the word “member” appears.",
   },
   {
@@ -37,8 +37,8 @@ export const CSV_IMPORT_OPTIONAL_COLUMNS = [
   },
   {
     header: "accompaniment",
-    label: "Role columns (one column each)",
-    note: "Also: chat, f2f, front desk, grants, training team, board member. Leave blank or write “no”, or use text that includes interested, active, or prior.",
+    label: "Tag columns (one column each)",
+    note: "Also: chat, f2f, front desk, grants, training team, board member. Leave blank or write “no”, or use text that includes committee, language, or position (legacy sheets: active, interested, or prior).",
   },
 ] as const;
 
@@ -80,19 +80,19 @@ export const CSV_IMPORT_TROUBLESHOOTING: ReadonlyArray<{
     ],
   },
   {
-    problem: "Invalid cohort or “cohort not applied” (yellow/blue notice)",
+    problem: "Invalid training or “training not applied” (yellow/blue notice)",
     fixes: [
-      "Use a four-digit year, a space, then Fall, Winter, Spring, or Summer — for example: 2024 Fall.",
+      "The spreadsheet column is still named cohort. Use a four-digit year, a space, then Fall, Winter, Spring, or Summer — for example: 2024 Fall.",
       "Avoid formats like 2026Winter or Winter2021; there must be a space between year and season.",
-      "The person is still saved; fix the cohort cell and use Import again if you want the cohort attached.",
+      "The person is still saved; fix that cell and use Import again if you want the training attached.",
     ],
   },
   {
-    problem: "Invalid role column (accompaniment, chat, f2f, etc.)",
+    problem: "Invalid tag column (accompaniment, chat, f2f, etc.)",
     fixes: [
-      "Leave the cell empty or write no if that role does not apply.",
-      "Otherwise use words that include interested, active, or prior (for example: 1. Active).",
-      "If you see a blue notice: that person was still imported without that role — fix the cell and Import again to attach it.",
+      "Leave the cell empty or write no if that tag does not apply.",
+      "Otherwise use text that includes committee, language, or position (legacy: active, interested, or prior — for example: 1. Active).",
+      "If you see a blue notice: that person was still imported without that tag — fix the cell and Import again to attach it.",
     ],
   },
   {
@@ -127,7 +127,7 @@ const COLUMN_KEY_TO_LABEL: Record<string, string> = {
   volunteer: "Volunteer (name)",
   email: "Email",
   position: "Position",
-  cohort: "Cohort",
+  cohort: "Training (cohort column)",
   pronouns: "Pronouns",
   phone: "Phone",
   "notes (copied from prior traning sheet)": "Notes",
@@ -170,7 +170,7 @@ function hintForParseError(
     return "Use a normal email shape, like name@example.com.";
   }
   if (message.includes("Invalid cohort")) {
-    return "Use a year, a space, then Fall, Winter, Spring, or Summer — for example: 2024 Fall.";
+    return "Use a year, a space, then Fall, Winter, Spring, or Summer — for example: 2024 Fall. (Spreadsheet column: cohort.)";
   }
   if (
     message.includes("Invalid position") ||
@@ -180,7 +180,7 @@ function hintForParseError(
   }
   if (message.includes("Invalid role status")) {
     const role = columnLabel(columnKey);
-    return `In ${role ?? "this role column"}, use text that includes interested, active, or prior — or leave it empty / use “no” if they do not have that role.`;
+    return `In ${role ?? "this tag column"}, use text that includes committee, language, or position (or legacy active, interested, prior) — or leave it empty / use “no” if it does not apply.`;
   }
   if (message.includes("missing required header")) {
     return "Add a header row with the exact column names listed under “Required columns” in the help section above (spelling can use capitals or lowercase).";
@@ -293,13 +293,13 @@ export function formatCsvImportWarningForDisplay(w: {
   let hint: string | null = null;
   if (col === "cohort") {
     hint =
-      "Use a year, a space, then Fall, Winter, Spring, or Summer — for example: 2024 Fall. You can fix the sheet and use Import again to attach a cohort.";
+      "Use a year, a space, then Fall, Winter, Spring, or Summer — for example: 2024 Fall. You can fix the sheet and use Import again to attach training (cohort column).";
   } else if (col === "email") {
     hint =
       "Use a normal email like name@example.com, or leave the cell empty. You can add the email later in the table or re-import after fixing the sheet.";
   } else if (ROLE_COLUMN_KEYS.has(col)) {
     hint =
-      "Use text that includes interested, active, or prior — or leave the cell empty or write “no”. Re-import after fixing to attach this role.";
+      "Use text that includes committee, language, or position (or legacy interested, active, prior) — or leave the cell empty or write “no”. Re-import after fixing to attach this tag.";
   }
   return {
     ...d,
diff --git a/src/lib/volunteers/roleTagLabels.ts b/src/lib/volunteers/roleTagLabels.ts
new file mode 100644
index 00000000..27128990
--- /dev/null
+++ b/src/lib/volunteers/roleTagLabels.ts
@@ -0,0 +1,28 @@
+/**
+ * DB role `type` values map to volunteer table columns (user-facing names).
+ */
+
+export type RoleTagDbType =
+  | "prior"
+  | "current"
+  | "future_interest"
+  | "training";
+
+export const ROLE_TAG_COLUMN_LABEL: Record<RoleTagDbType, string> = {
+  training: "Training",
+  prior: "Position",
+  current: "Committee",
+  future_interest: "Language",
+};
+
+export function roleTagColumnLabel(type: string): string {
+  if (
+    type === "training" ||
+    type === "prior" ||
+    type === "current" ||
+    type === "future_interest"
+  ) {
+    return ROLE_TAG_COLUMN_LABEL[type];
+  }
+  return type;
+}
diff --git a/supabase/migrations/20260510120000_training_role_tags.sql b/supabase/migrations/20260510120000_training_role_tags.sql
new file mode 100644
index 00000000..e77d7422
--- /dev/null
+++ b/supabase/migrations/20260510120000_training_role_tags.sql
@@ -0,0 +1,279 @@
+-- Training column uses Roles.type = 'training' (name = free text), not Cohorts / VolunteerCohorts.
+
+-- 1) Allow training on Roles
+ALTER TABLE public."Roles" DROP CONSTRAINT IF EXISTS roles_type_check;
+
+ALTER TABLE public."Roles"
+  ADD CONSTRAINT roles_type_check CHECK (
+    (type)::text = ANY (
+      ARRAY[
+        'prior'::text,
+        'current'::text,
+        'future_interest'::text,
+        'training'::text
+      ]
+    )
+  );
+
+-- 2) Migrate existing VolunteerCohorts links into training tags ("Term Year")
+INSERT INTO public."Roles" (name, type, is_active)
+SELECT DISTINCT
+  trim(both ' ' from (c.term || ' ' || c.year::text)),
+  'training',
+  true
+FROM public."VolunteerCohorts" vc
+JOIN public."Cohorts" c ON c.id = vc.cohort_id
+WHERE NOT EXISTS (
+  SELECT 1
+  FROM public."Roles" r
+  WHERE r.type = 'training'
+    AND lower(r.name) = lower(trim(both ' ' from (c.term || ' ' || c.year::text)))
+);
+
+INSERT INTO public."VolunteerRoles" (volunteer_id, role_id, created_at)
+SELECT vc.volunteer_id, r.id, COALESCE(vc.created_at, now())
+FROM public."VolunteerCohorts" vc
+JOIN public."Cohorts" c ON c.id = vc.cohort_id
+JOIN public."Roles" r
+  ON r.type = 'training'
+ AND lower(r.name) = lower(trim(both ' ' from (c.term || ' ' || c.year::text)))
+ON CONFLICT ON CONSTRAINT "VolunteerRoles_pkey" DO NOTHING;
+
+DELETE FROM public."VolunteerCohorts";
+
+-- 3) Upsert from CSV: cohort cell becomes a training tag; role seeding includes training
+-- Return type changed from jsonb to bigint; CREATE OR REPLACE cannot alter that (42P13).
+DROP FUNCTION IF EXISTS public.upsert_volunteer_with_roles_and_cohorts(
+  text, text, text, text, text, jsonb, jsonb, text
+);
+
+CREATE OR REPLACE FUNCTION public.upsert_volunteer_with_roles_and_cohorts(
+  p_name text,
+  p_pronouns text,
+  p_email text,
+  p_phone text,
+  p_position text,
+  p_cohort jsonb,
+  p_roles jsonb,
+  p_notes text
+)
+RETURNS bigint
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = public
+AS $$
+DECLARE
+  v_volunteer_id bigint;
+  v_role jsonb;
+  v_role_name text;
+  v_role_status text;
+  v_role_id bigint;
+  v_link_role_id bigint;
+  v_role_type_seed text;
+  v_year smallint;
+  v_term text;
+  v_training_label text;
+  v_training_role_id bigint;
+BEGIN
+  p_name := NULLIF(TRIM(p_name), '');
+  p_email := NULLIF(TRIM(p_email), '');
+  p_position := lower(NULLIF(TRIM(p_position), ''));
+  p_pronouns := NULLIF(TRIM(p_pronouns), '');
+  p_phone := NULLIF(TRIM(p_phone), '');
+  p_notes := NULLIF(TRIM(p_notes), '');
+
+  SELECT id
+  INTO v_volunteer_id
+  FROM public."Volunteers"
+  WHERE name_org = p_name
+    AND email IS NOT DISTINCT FROM p_email
+  ORDER BY id
+  LIMIT 1;
+
+  IF v_volunteer_id IS NULL THEN
+    INSERT INTO public."Volunteers" (
+      name_org,
+      pronouns,
+      email,
+      phone,
+      position,
+      notes
+    )
+    VALUES (
+      p_name,
+      p_pronouns,
+      p_email,
+      p_phone,
+      p_position,
+      p_notes
+    )
+    RETURNING id INTO v_volunteer_id;
+  ELSE
+    UPDATE public."Volunteers"
+    SET
+      pronouns = p_pronouns,
+      email = p_email,
+      phone = p_phone,
+      position = p_position,
+      notes = p_notes,
+      updated_at = now()
+    WHERE id = v_volunteer_id;
+  END IF;
+
+  FOR v_role IN
+    SELECT value FROM jsonb_array_elements(COALESCE(p_roles, '[]'::jsonb))
+  LOOP
+    v_role_name := NULLIF(TRIM(v_role ->> 'name'), '');
+    v_role_status := lower(NULLIF(TRIM(v_role ->> 'status'), ''));
+    v_link_role_id := NULL;
+
+    FOREACH v_role_type_seed IN ARRAY ARRAY['prior', 'current', 'future_interest', 'training']
+    LOOP
+      SELECT id
+      INTO v_role_id
+      FROM public."Roles"
+      WHERE name = v_role_name
+        AND type = v_role_type_seed
+        AND is_active = true
+      ORDER BY id
+      LIMIT 1;
+
+      IF v_role_id IS NULL THEN
+        INSERT INTO public."Roles" (name, type)
+        VALUES (v_role_name, v_role_type_seed)
+        RETURNING id INTO v_role_id;
+      END IF;
+
+      IF v_role_type_seed = v_role_status THEN
+        v_link_role_id := v_role_id;
+      END IF;
+    END LOOP;
+
+    IF v_link_role_id IS NOT NULL THEN
+      INSERT INTO public."VolunteerRoles" (volunteer_id, role_id)
+      VALUES (v_volunteer_id, v_link_role_id)
+      ON CONFLICT DO NOTHING;
+    END IF;
+  END LOOP;
+
+  -- Legacy cohort JSON: convert to one training tag "Season Year"
+  IF p_cohort IS NOT NULL THEN
+    IF TRIM(p_cohort ->> 'year') !~ '^\d+$' THEN
+      RAISE EXCEPTION 'Invalid cohort year in payload: %', p_cohort;
+    END IF;
+
+    v_year := (p_cohort ->> 'year')::smallint;
+    v_term := NULLIF(TRIM(p_cohort ->> 'season'), '');
+    v_training_label := v_term || ' ' || v_year::text;
+
+    SELECT id
+    INTO v_training_role_id
+    FROM public."Roles"
+    WHERE name = v_training_label
+      AND type = 'training'
+      AND is_active = true
+    ORDER BY id
+    LIMIT 1;
+
+    IF v_training_role_id IS NULL THEN
+      INSERT INTO public."Roles" (name, type)
+      VALUES (v_training_label, 'training')
+      RETURNING id INTO v_training_role_id;
+    END IF;
+
+    INSERT INTO public."VolunteerRoles" (volunteer_id, role_id)
+    VALUES (v_volunteer_id, v_training_role_id)
+    ON CONFLICT DO NOTHING;
+  END IF;
+
+  RETURN v_volunteer_id;
+END;
+$$;
+
+COMMENT ON FUNCTION public.upsert_volunteer_with_roles_and_cohorts(text, text, text, text, text, jsonb, jsonb, text) IS
+  'Upserts volunteer by (name_org, email). Roles use status prior|current|future_interest|training. Legacy p_cohort JSON adds a training tag.';
+
+GRANT EXECUTE ON FUNCTION public.upsert_volunteer_with_roles_and_cohorts(text, text, text, text, text, jsonb, jsonb, text) TO authenticated;
+GRANT EXECUTE ON FUNCTION public.upsert_volunteer_with_roles_and_cohorts(text, text, text, text, text, jsonb, jsonb, text) TO service_role;
+
+-- 4) Create volunteer RPC: ignore p_cohorts (training lives in p_roles with type training)
+CREATE OR REPLACE FUNCTION public.create_volunteer_with_roles_and_cohorts(
+  p_volunteer jsonb,
+  p_roles jsonb,
+  p_cohorts jsonb
+)
+RETURNS bigint
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path TO 'public'
+AS $$
+DECLARE
+  v_volunteer_id bigint;
+  v_role jsonb;
+  v_role_name text;
+  v_role_type text;
+  v_role_id bigint;
+BEGIN
+  INSERT INTO public."Volunteers" (
+    name_org,
+    pseudonym,
+    pronouns,
+    email,
+    phone,
+    position,
+    opt_in_communication,
+    notes
+  )
+  VALUES (
+    (p_volunteer ->> 'name_org'),
+    NULLIF(TRIM(p_volunteer ->> 'pseudonym'), ''),
+    NULLIF(TRIM(p_volunteer ->> 'pronouns'), ''),
+    NULLIF(TRIM(p_volunteer ->> 'email'), ''),
+    NULLIF(TRIM(p_volunteer ->> 'phone'), ''),
+    NULL,
+    COALESCE((p_volunteer ->> 'opt_in_communication')::boolean, true),
+    NULLIF(TRIM(p_volunteer ->> 'notes'), '')
+  )
+  RETURNING id INTO v_volunteer_id;
+
+  IF v_volunteer_id IS NULL THEN
+    RAISE EXCEPTION 'Failed to insert volunteer';
+  END IF;
+
+  FOR v_role IN
+    SELECT value FROM jsonb_array_elements(COALESCE(p_roles, '[]'::jsonb))
+  LOOP
+    v_role_name := NULLIF(TRIM(v_role ->> 'name'), '');
+    v_role_type := NULLIF(TRIM(lower(v_role ->> 'type')), '');
+    IF v_role_name IS NULL OR v_role_type IS NULL THEN
+      CONTINUE;
+    END IF;
+
+    SELECT id
+    INTO v_role_id
+    FROM public."Roles"
+    WHERE name = v_role_name
+      AND type = v_role_type
+      AND is_active = true
+    ORDER BY id
+    LIMIT 1;
+
+    IF v_role_id IS NULL THEN
+      INSERT INTO public."Roles" (name, type)
+      VALUES (v_role_name, v_role_type)
+      RETURNING id INTO v_role_id;
+    END IF;
+
+    IF v_role_id IS NOT NULL THEN
+      INSERT INTO public."VolunteerRoles" (volunteer_id, role_id)
+      VALUES (v_volunteer_id, v_role_id)
+      ON CONFLICT ON CONSTRAINT "VolunteerRoles_pkey" DO NOTHING;
+    END IF;
+  END LOOP;
+
+  RETURN v_volunteer_id;
+END;
+$$;
+
+COMMENT ON FUNCTION public.create_volunteer_with_roles_and_cohorts(jsonb, jsonb, jsonb) IS
+  'Creates a volunteer with optional roles (types include training). p_cohorts is ignored; use roles with type training.';
diff --git a/tests/lib/api/createVolunteer.test.ts b/tests/lib/api/createVolunteer.test.ts
index c7549b75..1be0fe0d 100644
--- a/tests/lib/api/createVolunteer.test.ts
+++ b/tests/lib/api/createVolunteer.test.ts
@@ -277,8 +277,7 @@ describe("createVolunteer", () => {
       expect(role).toBeTruthy();
     });
 
-    it("creates cohort when it does not exist", async () => {
-      // Use a year within smallint range and distinct from TEST_YEAR (2099)
+    it("creates training tag when cohort does not exist", async () => {
       const input: CreateVolunteerInput = {
         volunteer: {
           name_org: "TEST_Integration_Volunteer",
@@ -293,13 +292,13 @@ describe("createVolunteer", () => {
       if (result.success) {
         expect(typeof result.data.id).toBe("number");
       }
-      const { data: cohort } = await client
-        .from("Cohorts")
-        .select("id")
-        .eq("year", nonexistentYear)
-        .eq("term", "Fall")
+      const { data: trainingRole } = await client
+        .from("Roles")
+        .select("id, name, type")
+        .eq("name", `Fall ${nonexistentYear}`)
+        .eq("type", "training")
         .single();
-      expect(cohort).toBeTruthy();
+      expect(trainingRole).toBeTruthy();
     });
 
     it("successfully creates a volunteer with just name_org", async () => {
@@ -318,7 +317,7 @@ describe("createVolunteer", () => {
     });
 
     describe("RPC: junction tables and get-or-create", () => {
-      it("creates VolunteerRoles and VolunteerCohorts rows linking volunteer to role and cohort", async () => {
+      it("creates VolunteerRoles rows linking volunteer to role and training tag", async () => {
         const input: CreateVolunteerInput = {
           volunteer: {
             name_org: "TEST_RPC_Junction_Volunteer",
@@ -334,27 +333,22 @@ describe("createVolunteer", () => {
 
         const volunteerId = result.data.id;
 
-        const { data: volunteerRole, error: vrError } = await client
+        const { data: volunteerRoles, error: vrError } = await client
           .from("VolunteerRoles")
-          .select("volunteer_id, role_id")
-          .eq("volunteer_id", volunteerId)
-          .single();
+          .select("volunteer_id, role_id, Roles!inner(name, type)")
+          .eq("volunteer_id", volunteerId);
 
         expect(vrError).toBeNull();
-        expect(volunteerRole).toBeTruthy();
-        expect(volunteerRole!.volunteer_id).toBe(volunteerId);
-        expect(typeof volunteerRole!.role_id).toBe("number");
-
-        const { data: volunteerCohort, error: vcError } = await client
-          .from("VolunteerCohorts")
-          .select("volunteer_id, cohort_id")
-          .eq("volunteer_id", volunteerId)
-          .single();
-
-        expect(vcError).toBeNull();
-        expect(volunteerCohort).toBeTruthy();
-        expect(volunteerCohort!.volunteer_id).toBe(volunteerId);
-        expect(typeof volunteerCohort!.cohort_id).toBe("number");
+        expect(volunteerRoles).toHaveLength(2);
+        const roleTypes = volunteerRoles!.map(
+          (row) => (row as { Roles: { name: string; type: string } }).Roles
+        );
+        expect(roleTypes).toEqual(
+          expect.arrayContaining([
+            { name: "TEST_RPC_Junction_Role", type: "prior" },
+            { name: `Spring ${TEST_YEAR}`, type: "training" },
+          ])
+        );
       });
 
       it("reuses existing role when creating second volunteer with same role name", async () => {
@@ -401,8 +395,9 @@ describe("createVolunteer", () => {
         );
       });
 
-      it("reuses existing cohort when creating second volunteer with same year and term", async () => {
+      it("reuses existing training tag when creating second volunteer with same year and term", async () => {
         const cohortTerm = "Winter";
+        const trainingName = `${cohortTerm} ${cohortYear}`;
         const input1: CreateVolunteerInput = {
           volunteer: {
             name_org: "TEST_RPC_Cohort_Vol_One",
@@ -427,21 +422,21 @@ describe("createVolunteer", () => {
         expect(result2.success).toBe(true);
         if (!result2.success) return;
 
-        const { data: cohorts } = await client
-          .from("Cohorts")
+        const { data: trainingRoles } = await client
+          .from("Roles")
           .select("id")
-          .eq("year", cohortYear)
-          .eq("term", cohortTerm);
-        expect(cohorts?.length).toBeGreaterThanOrEqual(1);
-        const cohortId = cohorts?.[0]?.id;
-        expect(cohortId).toBeDefined();
-
-        const { data: vcRows } = await client
-          .from("VolunteerCohorts")
-          .select("volunteer_id, cohort_id")
-          .eq("cohort_id", cohortId!);
-        expect(vcRows!.length).toBeGreaterThanOrEqual(2);
-        const volunteerIds = vcRows!.map((r) => r.volunteer_id);
+          .eq("name", trainingName)
+          .eq("type", "training");
+        expect(trainingRoles).toHaveLength(1);
+        const trainingRoleId = trainingRoles?.[0]?.id;
+        expect(trainingRoleId).toBeDefined();
+
+        const { data: vrRows } = await client
+          .from("VolunteerRoles")
+          .select("volunteer_id, role_id")
+          .eq("role_id", trainingRoleId!);
+        expect(vrRows!.length).toBeGreaterThanOrEqual(2);
+        const volunteerIds = vrRows!.map((r) => r.volunteer_id);
         expect(volunteerIds).toContain(result1.data.id);
         expect(volunteerIds).toContain(result2.data.id);
       });
@@ -500,19 +495,20 @@ describe("createVolunteer", () => {
           expect(result.success).toBe(true);
           if (!result.success) return;
 
-          const { data: vc } = await client
-            .from("VolunteerCohorts")
-            .select("cohort_id")
-            .eq("volunteer_id", result.data.id)
-            .single();
+          const { data: vr } = await client
+            .from("VolunteerRoles")
+            .select("role_id, Roles!inner(name, type)")
+            .eq("volunteer_id", result.data.id);
 
-          expect(vc).toBeTruthy();
-          const { data: cohort } = await client
-            .from("Cohorts")
-            .select("term")
-            .eq("id", vc!.cohort_id)
-            .single();
-          expect(cohort!.term).toBe(term);
+          expect(vr).toBeTruthy();
+          const training = vr!.find(
+            (row) =>
+              (row as { Roles: { type: string } }).Roles.type === "training"
+          );
+          expect(training).toBeTruthy();
+          expect((training as { Roles: { name: string } }).Roles.name).toBe(
+            `${term} ${TEST_YEAR}`
+          );
         }
       });
 
@@ -525,25 +521,22 @@ describe("createVolunteer", () => {
               email: `type-${type}@example.com`,
             },
             roles: [{ name: `TEST_RPC_Type_Role_${type}`, type }],
-            cohorts: [{ year: TEST_YEAR, term: "Fall" }],
+            cohorts: [],
           };
           const result = await createVolunteer(input);
           expect(result.success).toBe(true);
           if (!result.success) return;
 
-          const { data: vr } = await client
+          const { data: vr, error: vrError } = await client
             .from("VolunteerRoles")
-            .select("role_id")
+            .select("role_id, Roles!inner(type)")
             .eq("volunteer_id", result.data.id)
+            .eq("Roles.type", type)
             .single();
 
+          expect(vrError).toBeNull();
           expect(vr).toBeTruthy();
-          const { data: role } = await client
-            .from("Roles")
-            .select("type")
-            .eq("id", vr!.role_id)
-            .single();
-          expect(role!.type).toBe(type);
+          expect((vr as { Roles: { type: string } }).Roles.type).toBe(type);
         }
       });
     });
diff --git a/tests/lib/api/getVolunteersByMultipleColumns.test.ts b/tests/lib/api/getVolunteersByMultipleColumns.test.ts
index 661c52b0..c69cbbe3 100644
--- a/tests/lib/api/getVolunteersByMultipleColumns.test.ts
+++ b/tests/lib/api/getVolunteersByMultipleColumns.test.ts
@@ -4,9 +4,8 @@ import {
   makeTestVolunteerInsert,
   makeTestRoleInsert,
   makeTestVolunteerRoleInsert,
-  makeTestCohortInsert,
-  makeTestVolunteerCohortInsert,
-  TEST_YEAR,
+  makeTestTrainingRoleInsert,
+  testTrainingLabel,
 } from "../support/factories";
 import {
   getVolunteersByMultipleColumns,
@@ -19,7 +18,7 @@ describe("validateMultipleColumnFilter (unit)", () => {
   it("accepts a valid filter", async () => {
     const filtersList: FilterTuple[] = [
       { field: "current_roles", miniOp: "OR", values: ["Role 1"] },
-      { field: "cohorts", miniOp: "AND", values: [["Winter", "2025"]] },
+      { field: "cohorts", miniOp: "AND", values: ["Winter 2025"] },
       { field: "name_org", miniOp: "OR", values: ["Volunteer1, Volunteer2"] },
     ];
     const result = await validateMultipleColumnFilter(filtersList, "AND");
@@ -43,7 +42,7 @@ describe("validateMultipleColumnFilter (unit)", () => {
     const filtersList: FilterTuple[] = [
       { field: "current_roles", miniOp: "OR", values: ["Role 1"] },
       // @ts-expect-error Test invalid mini operation type
-      { field: "cohorts", miniOp: "XOR", values: [["Winter", "2025"]] },
+      { field: "cohorts", miniOp: "XOR", values: ["Winter 2025"] },
     ];
     const result = await validateMultipleColumnFilter(filtersList, "OR");
     expect(result.valid).toBe(false);
@@ -88,21 +87,26 @@ describe("validateMultipleColumnFilter (unit)", () => {
     if (!result.valid) expect(result.error).toMatch(/Invalid filter values/);
   });
 
-  it("rejects any invalid cohort value", async () => {
+  it("accepts cohort filter as free-text substring (training column)", async () => {
+    const filtersList: FilterTuple[] = [
+      { field: "cohorts", miniOp: "OR", values: ["2024 Fall"] },
+    ];
+    const result = await validateMultipleColumnFilter(filtersList, "AND");
+    expect(result.valid).toBe(true);
+  });
+
+  it("rejects any invalid training filter value", async () => {
     const filtersList: FilterTuple[] = [
       {
         field: "cohorts",
         miniOp: "OR",
-        values: [
-          ["Winter", "2025"],
-          ["Spring", "Year"],
-        ],
+        values: ["2024 Fall", ""],
       },
     ];
     const result = await validateMultipleColumnFilter(filtersList, "OR");
     expect(result.valid).toBe(false);
     if (!result.valid)
-      expect(result.error).toMatch(/Invalid cohort filter values/);
+      expect(result.error).toMatch(/Invalid training filter values/);
   });
 
   it("rejects any invalid general or role value", async () => {
@@ -125,13 +129,12 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
   let volunteer2Id: number; // Role 2, Cohort 1, Cohort 2
   let volunteer3Id: number; // Role 1, Role 2, Cohort 2
   let role1Id: number, role2Id: number, role3Id: number, role4Id: number;
-  let cohort1Id: number, cohort2Id: number;
+  let trainingFallId: number, trainingWinterId: number;
 
   beforeAll(async () => {
     // Clean up any existing test data first to prevent unique constraint violations
     await deleteWhere(client, "Volunteers", "name_org", "TEST_%");
     await deleteWhere(client, "Roles", "name", "TEST_%");
-    await client.from("Cohorts").delete().eq("year", TEST_YEAR);
 
     const { data: v, error: vError } = await client
       .from("Volunteers")
@@ -161,17 +164,17 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
       ])
       .select();
 
-    const { data: c, error: cError } = await client
-      .from("Cohorts")
+    const { data: trainingRoles, error: trError } = await client
+      .from("Roles")
       .insert([
-        makeTestCohortInsert({ term: "Fall" }),
-        makeTestCohortInsert({ term: "Winter" }),
+        makeTestTrainingRoleInsert("Fall"),
+        makeTestTrainingRoleInsert("Winter"),
       ])
       .select();
 
     expect(vError).toBeNull();
     expect(rError).toBeNull();
-    expect(cError).toBeNull();
+    expect(trError).toBeNull();
 
     const [v1, v2, v3] = v!;
     volunteer1Id = v1!.id;
@@ -184,9 +187,9 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
     role3Id = r3!.id;
     role4Id = r4!.id;
 
-    const [c1, c2] = c!;
-    cohort1Id = c1!.id;
-    cohort2Id = c2!.id;
+    const [tFall, tWinter] = trainingRoles!;
+    trainingFallId = tFall!.id;
+    trainingWinterId = tWinter!.id;
 
     const { error: vrError } = await client
       .from("VolunteerRoles")
@@ -199,25 +202,18 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
         makeTestVolunteerRoleInsert(volunteer3Id, role2Id),
         makeTestVolunteerRoleInsert(volunteer3Id, role3Id),
         makeTestVolunteerRoleInsert(volunteer3Id, role4Id),
-      ]);
-
-    const { error: vcError } = await client
-      .from("VolunteerCohorts")
-      .insert([
-        makeTestVolunteerCohortInsert(volunteer1Id, cohort1Id),
-        makeTestVolunteerCohortInsert(volunteer2Id, cohort1Id),
-        makeTestVolunteerCohortInsert(volunteer2Id, cohort2Id),
-        makeTestVolunteerCohortInsert(volunteer3Id, cohort2Id),
+        makeTestVolunteerRoleInsert(volunteer1Id, trainingFallId),
+        makeTestVolunteerRoleInsert(volunteer2Id, trainingFallId),
+        makeTestVolunteerRoleInsert(volunteer2Id, trainingWinterId),
+        makeTestVolunteerRoleInsert(volunteer3Id, trainingWinterId),
       ]);
 
     expect(vrError).toBeNull();
-    expect(vcError).toBeNull();
   });
 
   afterAll(async () => {
     await deleteWhere(client, "Volunteers", "name_org", "TEST_%");
     await deleteWhere(client, "Roles", "name", "TEST_%");
-    await client.from("Cohorts").delete().eq("year", TEST_YEAR);
   });
 
   it("returns nothing when filters are empty", async () => {
@@ -278,9 +274,13 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
     expect(ids).not.toContain(volunteer1Id);
   });
 
-  it("cohorts by cohort with OR", async () => {
+  it("filters by training tag with OR", async () => {
     const filters: FilterTuple[] = [
-      { field: "cohorts", miniOp: "OR", values: [["Fall", String(TEST_YEAR)]] },
+      {
+        field: "cohorts",
+        miniOp: "OR",
+        values: [testTrainingLabel("Fall")],
+      },
     ];
     const { data } = await getVolunteersByMultipleColumns(filters, "AND");
     const ids = data;
@@ -290,15 +290,12 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
     expect(ids).not.toContain(volunteer3Id);
   });
 
-  it("filters by cohort with AND", async () => {
+  it("filters by training tag with AND", async () => {
     const filters: FilterTuple[] = [
       {
         field: "cohorts",
         miniOp: "AND",
-        values: [
-          ["Fall", String(TEST_YEAR)],
-          ["Winter", String(TEST_YEAR)],
-        ],
+        values: [testTrainingLabel("Fall"), testTrainingLabel("Winter")],
       },
     ];
     const { data } = await getVolunteersByMultipleColumns(filters, "AND");
@@ -339,10 +336,7 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
       {
         field: "cohorts",
         miniOp: "OR",
-        values: [
-          ["Fall", String(TEST_YEAR)],
-          ["Winter", String(TEST_YEAR)],
-        ],
+        values: [testTrainingLabel("Fall"), testTrainingLabel("Winter")],
       },
       {
         field: "name_org",
@@ -364,7 +358,7 @@ describe("getVolunteersByMultipleColumns (integration)", () => {
       {
         field: "cohorts",
         miniOp: "OR",
-        values: [["Winter", String(TEST_YEAR)]],
+        values: [testTrainingLabel("Winter")],
       },
     ];
     const { data } = await getVolunteersByMultipleColumns(filters, "OR");
diff --git a/tests/lib/api/getVolunteersTable.test.ts b/tests/lib/api/getVolunteersTable.test.ts
index afe5725e..aa979303 100644
--- a/tests/lib/api/getVolunteersTable.test.ts
+++ b/tests/lib/api/getVolunteersTable.test.ts
@@ -1,18 +1,11 @@
-// Tests the API function that fetches all volunteers with their cohorts and roles
+// Tests the API function that fetches all volunteers with their associated roles
 
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import {
-  createServiceTestClient,
-  deleteWhere,
-  deleteWhereGte,
-} from "../support/helpers";
+import { createServiceTestClient, deleteWhere } from "../support/helpers";
 import {
   makeTestVolunteerInsert,
-  makeTestCohortInsert,
   makeTestRoleInsert,
-  makeTestVolunteerCohortInsert,
   makeTestVolunteerRoleInsert,
-  TEST_YEAR,
 } from "../support/factories";
 import {
   getVolunteersTable,
@@ -22,23 +15,19 @@ import {
 describe("getVolunteersTable (integration)", () => {
   const client = createServiceTestClient();
 
-  // Cleanup before and after each test
   beforeEach(async () => {
     await deleteWhere(client, "Volunteers", "name_org", "TEST_%");
     await deleteWhere(client, "Roles", "name", "TEST_%");
-    await deleteWhereGte(client, "Cohorts", "year", TEST_YEAR);
   });
 
   afterEach(async () => {
     await deleteWhere(client, "Volunteers", "name_org", "TEST_%");
     await deleteWhere(client, "Roles", "name", "TEST_%");
-    await deleteWhereGte(client, "Cohorts", "year", TEST_YEAR);
   });
 
   describe("empty results", () => {
     it("returns empty array when no volunteers exist", async () => {
       const result = await getVolunteersTable();
-      // Filter to only TEST_ volunteers to avoid existing data interference
       const testResults = result.filter((entry) =>
         entry.volunteer.name_org.startsWith("TEST_")
       );
@@ -47,8 +36,7 @@ describe("getVolunteersTable (integration)", () => {
   });
 
   describe("volunteer without relations", () => {
-    it("returns volunteer with empty cohorts and roles arrays", async () => {
-      // Create a volunteer without any cohort or role associations
+    it("returns volunteer with empty roles array", async () => {
       await client
         .from("Volunteers")
         .insert(makeTestVolunteerInsert({ name_org: "TEST_Vol_NoRelations" }));
@@ -60,59 +48,62 @@ describe("getVolunteersTable (integration)", () => {
 
       expect(testVolunteer).toBeDefined();
       expect(testVolunteer!.volunteer.name_org).toBe("TEST_Vol_NoRelations");
-      expect(testVolunteer!.cohorts).toEqual([]);
       expect(testVolunteer!.roles).toEqual([]);
     });
   });
 
-  describe("volunteer with cohorts only", () => {
-    it("returns volunteer with their associated cohorts", async () => {
-      // Create cohorts
-      const { data: cohort1 } = await client
-        .from("Cohorts")
-        .insert(makeTestCohortInsert({ term: "Fall", year: TEST_YEAR }))
+  describe("volunteer with training roles only", () => {
+    it("returns volunteer with their associated training tags", async () => {
+      const { data: role1 } = await client
+        .from("Roles")
+        .insert(
+          makeTestRoleInsert({ name: "TEST_Training_A", type: "training" })
+        )
         .select()
         .single();
 
-      const { data: cohort2 } = await client
-        .from("Cohorts")
-        .insert(makeTestCohortInsert({ term: "Spring", year: TEST_YEAR }))
+      const { data: role2 } = await client
+        .from("Roles")
+        .insert(
+          makeTestRoleInsert({ name: "TEST_Training_B", type: "training" })
+        )
         .select()
         .single();
 
-      // Create volunteer
       const { data: vol } = await client
         .from("Volunteers")
-        .insert(makeTestVolunteerInsert({ name_org: "TEST_Vol_WithCohorts" }))
+        .insert(
+          makeTestVolunteerInsert({ name_org: "TEST_Vol_WithTrainingTags" })
+        )
         .select()
         .single();
 
-      // Link volunteer to cohorts
       await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol!.id, cohort1!.id));
+        .from("VolunteerRoles")
+        .insert(makeTestVolunteerRoleInsert(vol!.id, role1!.id));
 
       await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol!.id, cohort2!.id));
+        .from("VolunteerRoles")
+        .insert(makeTestVolunteerRoleInsert(vol!.id, role2!.id));
 
       const result = await getVolunteersTable();
       const testVolunteer = result.find(
-        (entry) => entry.volunteer.name_org === "TEST_Vol_WithCohorts"
+        (entry) => entry.volunteer.name_org === "TEST_Vol_WithTrainingTags"
       );
 
       expect(testVolunteer).toBeDefined();
-      expect(testVolunteer!.cohorts).toHaveLength(2);
-      const cohortTerms = testVolunteer!.cohorts.map((c) => c.term);
-      expect(cohortTerms).toContain("Fall");
-      expect(cohortTerms).toContain("Spring");
-      expect(testVolunteer!.roles).toEqual([]);
+      expect(testVolunteer!.roles).toHaveLength(2);
+      const names = testVolunteer!.roles.map((r) => r.name);
+      expect(names).toContain("TEST_Training_A");
+      expect(names).toContain("TEST_Training_B");
+      expect(testVolunteer!.roles.every((r) => r.type === "training")).toBe(
+        true
+      );
     });
   });
 
-  describe("volunteer with roles only", () => {
+  describe("volunteer with non-training roles only", () => {
     it("returns volunteer with their associated roles", async () => {
-      // Create roles
       const { data: role1 } = await client
         .from("Roles")
         .insert(
@@ -127,14 +118,12 @@ describe("getVolunteersTable (integration)", () => {
         .select()
         .single();
 
-      // Create volunteer
       const { data: vol } = await client
         .from("Volunteers")
         .insert(makeTestVolunteerInsert({ name_org: "TEST_Vol_WithRoles" }))
         .select()
         .single();
 
-      // Link volunteer to roles
       await client
         .from("VolunteerRoles")
         .insert(makeTestVolunteerRoleInsert(vol!.id, role1!.id));
@@ -153,26 +142,30 @@ describe("getVolunteersTable (integration)", () => {
       const roleNames = testVolunteer!.roles.map((r) => r.name);
       expect(roleNames).toContain("TEST_Role_Admin");
       expect(roleNames).toContain("TEST_Role_Member");
-      expect(testVolunteer!.cohorts).toEqual([]);
     });
   });
 
-  describe("volunteer with both cohorts and roles", () => {
-    it("returns volunteer with all associated cohorts and roles", async () => {
-      // Create cohorts
-      const { data: cohort1 } = await client
-        .from("Cohorts")
-        .insert(makeTestCohortInsert({ term: "Fall", year: TEST_YEAR }))
+  describe("volunteer with training and other roles", () => {
+    it("returns all linked roles in one array", async () => {
+      const { data: t1 } = await client
+        .from("Roles")
+        .insert(
+          makeTestRoleInsert({ name: "TEST_Training_Fall", type: "training" })
+        )
         .select()
         .single();
 
-      const { data: cohort2 } = await client
-        .from("Cohorts")
-        .insert(makeTestCohortInsert({ term: "Winter", year: TEST_YEAR }))
+      const { data: t2 } = await client
+        .from("Roles")
+        .insert(
+          makeTestRoleInsert({
+            name: "TEST_Training_Spring",
+            type: "training",
+          })
+        )
         .select()
         .single();
 
-      // Create roles
       const { data: role1 } = await client
         .from("Roles")
         .insert(
@@ -192,30 +185,17 @@ describe("getVolunteersTable (integration)", () => {
         .select()
         .single();
 
-      // Create volunteer
       const { data: vol } = await client
         .from("Volunteers")
         .insert(makeTestVolunteerInsert({ name_org: "TEST_Vol_FullRelations" }))
         .select()
         .single();
 
-      // Link to cohorts
-      await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol!.id, cohort1!.id));
-
-      await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol!.id, cohort2!.id));
-
-      // Link to roles
-      await client
-        .from("VolunteerRoles")
-        .insert(makeTestVolunteerRoleInsert(vol!.id, role1!.id));
-
-      await client
-        .from("VolunteerRoles")
-        .insert(makeTestVolunteerRoleInsert(vol!.id, role2!.id));
+      for (const rid of [t1!.id, t2!.id, role1!.id, role2!.id]) {
+        await client
+          .from("VolunteerRoles")
+          .insert(makeTestVolunteerRoleInsert(vol!.id, rid));
+      }
 
       const result = await getVolunteersTable();
       const testVolunteer = result.find(
@@ -223,31 +203,36 @@ describe("getVolunteersTable (integration)", () => {
       );
 
       expect(testVolunteer).toBeDefined();
+      expect(testVolunteer!.roles).toHaveLength(4);
 
-      // Check cohorts
-      expect(testVolunteer!.cohorts).toHaveLength(2);
-      const cohortTerms = testVolunteer!.cohorts.map((c) => c.term);
-      expect(cohortTerms).toContain("Fall");
-      expect(cohortTerms).toContain("Winter");
-
-      // Check roles
-      expect(testVolunteer!.roles).toHaveLength(2);
-      const roleNames = testVolunteer!.roles.map((r) => r.name);
-      expect(roleNames).toContain("TEST_Role_Facilitator");
-      expect(roleNames).toContain("TEST_Role_Support");
+      const training = testVolunteer!.roles.filter(
+        (r) => r.type === "training"
+      );
+      expect(training.map((r) => r.name).sort()).toEqual([
+        "TEST_Training_Fall",
+        "TEST_Training_Spring",
+      ]);
+
+      const names = testVolunteer!.roles.map((r) => r.name);
+      expect(names).toContain("TEST_Role_Facilitator");
+      expect(names).toContain("TEST_Role_Support");
     });
   });
 
   describe("multiple volunteers", () => {
     it("returns all volunteers with their respective relations", async () => {
-      // Create cohort and role
-      const { data: cohort } = await client
-        .from("Cohorts")
-        .insert(makeTestCohortInsert({ term: "Summer", year: TEST_YEAR }))
+      const { data: trainingRole } = await client
+        .from("Roles")
+        .insert(
+          makeTestRoleInsert({
+            name: "TEST_Role_Training_Shared",
+            type: "training",
+          })
+        )
         .select()
         .single();
 
-      const { data: role } = await client
+      const { data: currentRole } = await client
         .from("Roles")
         .insert(
           makeTestRoleInsert({ name: "TEST_Role_Shared", type: "current" })
@@ -255,7 +240,6 @@ describe("getVolunteersTable (integration)", () => {
         .select()
         .single();
 
-      // Create multiple volunteers with different relation configurations
       const { data: vol1 } = await client
         .from("Volunteers")
         .insert(makeTestVolunteerInsert({ name_org: "TEST_Vol_Multi_1" }))
@@ -274,25 +258,23 @@ describe("getVolunteersTable (integration)", () => {
         .select()
         .single();
 
-      // vol1: cohort + role, vol2: cohort only, vol3: role only
       await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol1!.id, cohort!.id));
+        .from("VolunteerRoles")
+        .insert(makeTestVolunteerRoleInsert(vol1!.id, trainingRole!.id));
       await client
         .from("VolunteerRoles")
-        .insert(makeTestVolunteerRoleInsert(vol1!.id, role!.id));
+        .insert(makeTestVolunteerRoleInsert(vol1!.id, currentRole!.id));
 
       await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol2!.id, cohort!.id));
+        .from("VolunteerRoles")
+        .insert(makeTestVolunteerRoleInsert(vol2!.id, trainingRole!.id));
 
       await client
         .from("VolunteerRoles")
-        .insert(makeTestVolunteerRoleInsert(vol3!.id, role!.id));
+        .insert(makeTestVolunteerRoleInsert(vol3!.id, currentRole!.id));
 
       const result = await getVolunteersTable();
 
-      // Find test volunteers
       const testVol1 = result.find(
         (entry) => entry.volunteer.name_org === "TEST_Vol_Multi_1"
       );
@@ -303,39 +285,33 @@ describe("getVolunteersTable (integration)", () => {
         (entry) => entry.volunteer.name_org === "TEST_Vol_Multi_3"
       );
 
-      // Verify vol1 has both cohort and role
       expect(testVol1).toBeDefined();
-      expect(testVol1!.cohorts).toHaveLength(1);
-      expect(testVol1!.roles).toHaveLength(1);
+      expect(testVol1!.roles).toHaveLength(2);
 
-      // Verify vol2 has cohort only
       expect(testVol2).toBeDefined();
-      expect(testVol2!.cohorts).toHaveLength(1);
-      expect(testVol2!.roles).toEqual([]);
+      expect(testVol2!.roles).toHaveLength(1);
+      expect(testVol2!.roles[0]!.type).toBe("training");
 
-      // Verify vol3 has role only
       expect(testVol3).toBeDefined();
-      expect(testVol3!.cohorts).toEqual([]);
       expect(testVol3!.roles).toHaveLength(1);
+      expect(testVol3!.roles[0]!.type).toBe("current");
     });
   });
 
   describe("return value structure", () => {
     it("returns VolunteerTableEntry objects with correct properties", async () => {
-      // Create cohort
-      const { data: cohort } = await client
-        .from("Cohorts")
+      const { data: training } = await client
+        .from("Roles")
         .insert(
-          makeTestCohortInsert({
-            term: "Fall",
-            year: TEST_YEAR,
+          makeTestRoleInsert({
+            name: "TEST_Role_Training_Structure",
+            type: "training",
             is_active: true,
           })
         )
         .select()
         .single();
 
-      // Create role
       const { data: role } = await client
         .from("Roles")
         .insert(
@@ -348,7 +324,6 @@ describe("getVolunteersTable (integration)", () => {
         .select()
         .single();
 
-      // Create volunteer with specific data
       const { data: vol } = await client
         .from("Volunteers")
         .insert(
@@ -366,10 +341,9 @@ describe("getVolunteersTable (integration)", () => {
         .select()
         .single();
 
-      // Link volunteer to cohort and role
       await client
-        .from("VolunteerCohorts")
-        .insert(makeTestVolunteerCohortInsert(vol!.id, cohort!.id));
+        .from("VolunteerRoles")
+        .insert(makeTestVolunteerRoleInsert(vol!.id, training!.id));
 
       await client
         .from("VolunteerRoles")
@@ -382,7 +356,6 @@ describe("getVolunteersTable (integration)", () => {
 
       expect(testEntry).toBeDefined();
 
-      // Verify volunteer properties
       expect(testEntry!.volunteer).toHaveProperty("id");
       expect(testEntry!.volunteer).toHaveProperty(
         "name_org",
@@ -404,20 +377,20 @@ describe("getVolunteersTable (integration)", () => {
       expect(testEntry!.volunteer).toHaveProperty("created_at");
       expect(testEntry!.volunteer).toHaveProperty("updated_at");
 
-      // Verify cohort properties
-      expect(testEntry!.cohorts).toHaveLength(1);
-      const cohortEntry = testEntry!.cohorts[0];
-      expect(cohortEntry).toHaveProperty("id");
-      expect(cohortEntry).toHaveProperty("term", "Fall");
-      expect(cohortEntry).toHaveProperty("year", TEST_YEAR);
-      expect(cohortEntry).toHaveProperty("is_active", true);
-      expect(cohortEntry).toHaveProperty("created_at");
-
-      // Verify role properties
-      expect(testEntry!.roles).toHaveLength(1);
-      const roleEntry = testEntry!.roles[0];
-      expect(roleEntry).toHaveProperty("id");
-      expect(roleEntry).toHaveProperty("name", "TEST_Role_Structure");
+      expect(testEntry!.roles).toHaveLength(2);
+
+      const trainingEntry = testEntry!.roles.find(
+        (r) => r.name === "TEST_Role_Training_Structure"
+      );
+      expect(trainingEntry).toBeDefined();
+      expect(trainingEntry).toHaveProperty("type", "training");
+      expect(trainingEntry).toHaveProperty("is_active", true);
+      expect(trainingEntry).toHaveProperty("created_at");
+
+      const roleEntry = testEntry!.roles.find(
+        (r) => r.name === "TEST_Role_Structure"
+      );
+      expect(roleEntry).toBeDefined();
       expect(roleEntry).toHaveProperty("type", "current");
       expect(roleEntry).toHaveProperty("is_active", true);
       expect(roleEntry).toHaveProperty("created_at");
@@ -426,15 +399,12 @@ describe("getVolunteersTable (integration)", () => {
     it("returns array conforming to VolunteerTableEntry type", async () => {
       const result = await getVolunteersTable();
 
-      // Type check: result should be VolunteerTableEntry[]
       expect(Array.isArray(result)).toBe(true);
 
       if (result.length > 0) {
         const entry: VolunteerTableEntry = result[0]!;
         expect(entry).toHaveProperty("volunteer");
-        expect(entry).toHaveProperty("cohorts");
         expect(entry).toHaveProperty("roles");
-        expect(Array.isArray(entry.cohorts)).toBe(true);
         expect(Array.isArray(entry.roles)).toBe(true);
       }
     });
diff --git a/tests/lib/api/import_csv.parsers.test.ts b/tests/lib/api/import_csv.parsers.test.ts
index 188e2615..699a713e 100644
--- a/tests/lib/api/import_csv.parsers.test.ts
+++ b/tests/lib/api/import_csv.parsers.test.ts
@@ -167,6 +167,34 @@ describe("import_csv helper functions", () => {
       expect(result.roles).toEqual([{ name: "Front Desk", status: "prior" }]);
     });
 
+    it("maps committee to current", () => {
+      const result = createEmptyVolunteer();
+      const ok = parseRole("committee member", "Chat Counsellor", result);
+
+      expect(ok).toBe(true);
+      expect(result.roles).toEqual([
+        { name: "Chat Counsellor", status: "current" },
+      ]);
+    });
+
+    it("maps language to future_interest", () => {
+      const result = createEmptyVolunteer();
+      const ok = parseRole("language training", "Accompaniment", result);
+
+      expect(ok).toBe(true);
+      expect(result.roles).toEqual([
+        { name: "Accompaniment", status: "future_interest" },
+      ]);
+    });
+
+    it("maps position to prior", () => {
+      const result = createEmptyVolunteer();
+      const ok = parseRole("volunteer position", "F2F", result);
+
+      expect(ok).toBe(true);
+      expect(result.roles).toEqual([{ name: "F2F", status: "prior" }]);
+    });
+
     it("returns false for unknown role status", () => {
       const result = createEmptyVolunteer();
       const ok = parseRole("maybe", "Front Desk", result);
@@ -227,7 +255,9 @@ describe("import_csv helper functions", () => {
         expect(parsed.rowWarnings).toHaveLength(1);
         expect(parsed.rowWarnings[0]?.column).toBe("cohort");
         expect(parsed.rowWarnings[0]?.value).toBe("2026Winter");
-        expect(parsed.rowWarnings[0]?.message).toContain("Cohort not applied");
+        expect(parsed.rowWarnings[0]?.message).toContain(
+          "Training not applied"
+        );
       }
     });
 
diff --git a/tests/lib/api/import_csv.test.ts b/tests/lib/api/import_csv.test.ts
index 65fe1a86..bfc14074 100644
--- a/tests/lib/api/import_csv.test.ts
+++ b/tests/lib/api/import_csv.test.ts
@@ -197,19 +197,17 @@ describe("db: import_csv (integration)", () => {
     expect(volunteer!.email).toBe("test_import_valid@example.com");
     expect(volunteer!.notes).toBe("Integration note");
 
-    const { data: volunteerCohorts, error: vcError } = await client
-      .from("VolunteerCohorts")
-      .select("volunteer_id, Cohorts!inner(year, term)")
+    const { data: trainingLinks, error: trainingError } = await client
+      .from("VolunteerRoles")
+      .select("volunteer_id, Roles!inner(name, type)")
       .eq("volunteer_id", volunteer!.id)
-      .single();
-
-    expect(vcError).toBeNull();
-    const cohort = (
-      volunteerCohorts! as { Cohorts: { year: number; term: string } }
-    ).Cohorts;
+      .eq("Roles.type", "training");
 
-    expect(cohort.year).toBe(TEST_YEAR);
-    expect(cohort.term).toBe("Fall");
+    expect(trainingError).toBeNull();
+    expect(trainingLinks).toHaveLength(1);
+    expect(
+      (trainingLinks![0] as { Roles: { name: string; type: string } }).Roles
+    ).toEqual({ name: `Fall ${TEST_YEAR}`, type: "training" });
 
     const { data: volunteerRoles, error: vrError } = await client
       .from("VolunteerRoles")
@@ -222,16 +220,17 @@ describe("db: import_csv (integration)", () => {
     const rolePairs = volunteerRoles!.map(
       (row) => (row as { Roles: { name: string; type: string } }).Roles
     );
+    const nonTrainingRoles = rolePairs.filter((r) => r.type !== "training");
 
-    expect(rolePairs.length).toEqual(2);
-    expect(rolePairs).toEqual(
+    expect(nonTrainingRoles).toHaveLength(2);
+    expect(nonTrainingRoles).toEqual(
       expect.arrayContaining([
         { name: "Accompaniment", type: "current" },
         { name: "F2F", type: "prior" },
       ])
     );
     // "4. No" on Chat should not produce a role
-    expect(rolePairs).not.toEqual(
+    expect(nonTrainingRoles).not.toEqual(
       expect.arrayContaining([{ name: "Chat Counsellor", type: "current" }])
     );
 
@@ -617,25 +616,17 @@ describe("db: import_csv (integration)", () => {
       expect(Array.from(types!)).toEqual(expect.arrayContaining(expectedTypes));
     }
 
-    // 3. verify correct cohorts created
-    const { data: cohorts, error: cohortsError } = await client
-      .from("Cohorts")
-      .select("id, year, term")
-      .eq("year", 6769)
-      .in("term", ["Summer", "Fall"]);
+    // 3. verify training tags created for imported cohorts
+    const { data: trainingRoles, error: trainingRolesError } = await client
+      .from("Roles")
+      .select("id, name, type")
+      .eq("type", "training")
+      .in("name", ["Summer 6769", "Fall 6769"]);
 
-    expect(cohortsError).toBeNull();
-    expect(cohorts).toBeTruthy();
-    expect(cohorts).toHaveLength(2);
+    expect(trainingRolesError).toBeNull();
+    expect(trainingRoles).toHaveLength(2);
 
-    expect(cohorts).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ year: 6769, term: "Summer" }),
-        expect.objectContaining({ year: 6769, term: "Fall" }),
-      ])
-    );
-
-    // 4. VERIFY COHORT AND ROLE JUNCTION TABLE ROWS
+    // 4. VERIFY TRAINING AND ROLE JUNCTION TABLE ROWS
 
     const roleId = (name: string, type: string): number =>
       roles!.find((r) => r.name === name && r.type === type)!.id;
@@ -666,28 +657,25 @@ describe("db: import_csv (integration)", () => {
       ])
     );
 
-    // 4.b Verify volunteerCohorts rows
-
-    const { data: volunteerCohorts, error: volunteerCohortsError } =
-      await client
-        .from("VolunteerCohorts")
-        .select("volunteer_id, cohort_id")
-        .in("volunteer_id", [v1!.id, v2!.id]);
-
-    expect(volunteerCohortsError).toBeNull();
-    expect(volunteerCohorts).toBeTruthy();
-
-    const summerCohortId = cohorts!.find(
-      (c) => c.year === 6769 && c.term === "Summer"
+    // 4.b Verify training links on VolunteerRoles
+    const summerTrainingId = trainingRoles!.find(
+      (r) => r.name === "Summer 6769"
     )?.id;
-    const fallCohortId = cohorts!.find(
-      (c) => c.year === 6769 && c.term === "Fall"
+    const fallTrainingId = trainingRoles!.find(
+      (r) => r.name === "Fall 6769"
     )?.id;
 
-    expect(volunteerCohorts).toEqual(
+    const { data: trainingLinks, error: trainingLinksError } = await client
+      .from("VolunteerRoles")
+      .select("volunteer_id, role_id")
+      .in("volunteer_id", [v1!.id, v2!.id])
+      .in("role_id", [summerTrainingId!, fallTrainingId!]);
+
+    expect(trainingLinksError).toBeNull();
+    expect(trainingLinks).toEqual(
       expect.arrayContaining([
-        { volunteer_id: v1!.id, cohort_id: summerCohortId! },
-        { volunteer_id: v2!.id, cohort_id: fallCohortId! },
+        { volunteer_id: v1!.id, role_id: summerTrainingId! },
+        { volunteer_id: v2!.id, role_id: fallTrainingId! },
       ])
     );
   });
diff --git a/tests/lib/api/updateVolunteer.supabase.test.ts b/tests/lib/api/updateVolunteer.supabase.test.ts
index 19105cbe..d8be6e75 100644
--- a/tests/lib/api/updateVolunteer.supabase.test.ts
+++ b/tests/lib/api/updateVolunteer.supabase.test.ts
@@ -11,7 +11,6 @@ import {
   deleteWhereGte,
 } from "../support/helpers";
 import {
-  makeTestCohortInsert,
   makeTestRoleInsert,
   makeTestVolunteerInsert,
   TEST_YEAR,
@@ -57,21 +56,6 @@ async function seedRole(): Promise<Tables<"Roles">> {
   return data;
 }
 
-async function seedCohort(): Promise<Tables<"Cohorts">> {
-  const insert = makeTestCohortInsert();
-  const { data, error } = await client
-    .from("Cohorts")
-    .insert(insert)
-    .select()
-    .single();
-
-  if (error || !data) {
-    throw error ?? new Error("Failed to seed cohort");
-  }
-
-  return data;
-}
-
 describe.skipIf(!hasServiceRole)(
   "updateVolunteer (Supabase integration)",
   () => {
@@ -104,12 +88,15 @@ describe.skipIf(!hasServiceRole)(
       expect(result.status).toBe(400);
     });
 
-    it("returns 400 for invalid cohort term", async () => {
+    it("returns 400 for unknown cohort field", async () => {
       const result = await updateVolunteer(1, {
         cohort: { year: 2024, term: "Fall" },
       });
 
       expect(result.status).toBe(400);
+      if (result.status === 400) {
+        expect(result.body.error).toMatch(/Unknown field/);
+      }
     });
 
     it("returns 400 for invalid position", async () => {
@@ -140,15 +127,13 @@ describe.skipIf(!hasServiceRole)(
       expect(updated?.updated_at).not.toBe(volunteer.updated_at);
     });
 
-    it("updates role and cohort links when provided", async () => {
+    it("updates role link when provided", async () => {
       const volunteer = await seedVolunteer();
       const role = await seedRole();
-      const cohort = await seedCohort();
 
       const result = await updateVolunteer(volunteer.id, {
         name_org: volunteer.name_org,
         role: { name: role.name, type: role.type },
-        cohort: { year: cohort.year, term: "fall" },
       });
 
       expect(result.status).toBe(200);
@@ -161,15 +146,6 @@ describe.skipIf(!hasServiceRole)(
 
       expect(roleError).toBeNull();
       expect(roleLink?.role_id).toBe(role.id);
-
-      const { data: cohortLink, error: cohortError } = await client
-        .from("VolunteerCohorts")
-        .select("cohort_id")
-        .eq("volunteer_id", volunteer.id)
-        .maybeSingle();
-
-      expect(cohortError).toBeNull();
-      expect(cohortLink?.cohort_id).toBe(cohort.id);
     });
 
     it("returns 400 when role does not exist and does not update volunteer", async () => {
@@ -192,7 +168,7 @@ describe.skipIf(!hasServiceRole)(
       expect(current?.name_org).toBe(volunteer.name_org);
     });
 
-    it("returns 400 when cohort does not exist and does not update volunteer", async () => {
+    it("returns 400 when cohort field is sent and does not update volunteer", async () => {
       const volunteer = await seedVolunteer();
 
       const result = await updateVolunteer(volunteer.id, {
diff --git a/tests/lib/support/factories.ts b/tests/lib/support/factories.ts
index 08707a95..fca18e87 100644
--- a/tests/lib/support/factories.ts
+++ b/tests/lib/support/factories.ts
@@ -13,6 +13,7 @@ export type UserInsert = Database["public"]["Tables"]["Users"]["Insert"];
 
 // Valid Values (from CHECK constraints)
 export const VALID_ROLE_TYPES = [
+  "training",
   "prior",
   "current",
   "future_interest",
@@ -39,6 +40,31 @@ export type CohortTerm = (typeof VALID_COHORT_TERMS)[number];
 // Test data markers
 export const TEST_YEAR = 2099; // Use this year for all test cohorts (easy cleanup)
 
+/** Training tag label stored on Roles.name (matches RPC/import: "Term Year"). */
+export function trainingLabel(term: string, year: number = TEST_YEAR): string {
+  return `${term} ${year}`;
+}
+
+/** Isolated training label for tests (avoids colliding with migrated/imported tags). */
+export function testTrainingLabel(
+  term: string,
+  year: number = TEST_YEAR
+): string {
+  return `TEST_${term} ${year}`;
+}
+
+export function makeTestTrainingRoleInsert(
+  term: string,
+  year: number = TEST_YEAR,
+  overrides: Partial<RoleInsert> = {}
+): RoleInsert {
+  return makeTestRoleInsert({
+    name: testTrainingLabel(term, year),
+    type: "training",
+    ...overrides,
+  });
+}
+
 // Utility Functions
 function randomToken(): string {
   return `${Date.now()}_${Math.random().toString(16).slice(2)}`;
@@ -74,7 +100,7 @@ export function makeTestRoleInsert(
   return {
     id: overrides.id ?? uniqueTestId(),
     name: overrides.name ?? `TEST_Role_${token}`,
-    // Must be one of: 'prior', 'current', 'future_interest'
+    // One of: training, prior, current, future_interest
     type: overrides.type ?? "current",
     is_active: overrides.is_active ?? true,
     ...overrides,