diff --git a/.github/scripts/src/db/migrate.ts b/.github/scripts/src/db/migrate.ts
index a3255601..41dc5e5c 100644
--- a/.github/scripts/src/db/migrate.ts
+++ b/.github/scripts/src/db/migrate.ts
@@ -26,7 +26,7 @@ async function main() {
     DATABASE_PORT,
     DATABASE_USER,
     DATABASE_PASSWORD,
-  })`./mvnw flyway:migrate -Dflyway.locations=filesystem:db`;
+  })`./mvnw flyway:migrate -Dflyway.locations=filesystem:db/migration`;
 }
 
 function parseCiEnv(environment: string) {
diff --git a/Justfile b/Justfile
index b29dda3a..bcf79693 100644
--- a/Justfile
+++ b/Justfile
@@ -2,11 +2,11 @@ set shell := ["bash", "-uc"]
 
 # Migrate to local DB
 migrate *args:
-  dotenvx run -- ./mvnw flyway:migrate -Dflyway.locations=filesystem:./db {{args}}
+  dotenvx run -- ./mvnw flyway:migrate -Dflyway.locations=filesystem:./db/migration,filesystem:./db/repeated {{args}}
 
 # Drop local DB
 drop *args:
-  dotenvx run -- ./mvnw flyway:clean -Dflyway.locations=filesystem:./db -Dflyway.cleanDisabled=false {{args}}
+  dotenvx run -- ./mvnw flyway:clean -Dflyway.locations=filesystem:./db/migration,filesystem:./db/repeated -Dflyway.cleanDisabled=false {{args}}
 
 # Run the backend Spring server
 backend-dev *args:
diff --git a/db/README.md b/db/README.md
index c0929078..02580b38 100644
--- a/db/README.md
+++ b/db/README.md
@@ -99,7 +99,7 @@ Versioned migrations are under `db/migration/`
 
 - Versioned migrations will only run once.
 - You can use these migrations to define tables, schemas, columns (otherwise known as DDL) OR define insertions/updates/deletes of certain columns (otherwise known as DML).
-> If you need to generate mock data **that does not need to be in production**, please look at the docs on [repeatable migrations](#repeatable-migrations)
+> If you need mock data **only for local development**, see [local repeatable migrations](#local-repeatable-migrations).
 
 ### Naming Scheme
 
@@ -122,18 +122,17 @@ V0642__Insert_new_tag_enums.SQL
 V9999__Delete_user_table.SQL
 ```
 
-## Repeatable Migrations
+## Local Repeatable Migrations
 
-Repeated migrations are under `db/repeated/`
+Local repeatable migrations are under `db/repeated/`.
 
 > [!NOTE]
-> Repeatable migrations are only applied to local & CI databases. <br />
-> Repeatable migrations are **NOT** applied to the production & staging database.
+> `just migrate` explicitly includes this directory. Production and staging migrations only scan `db/migration`, so local seed data is never applied to remote databases.
 
 ### Explanation
 
 1. Instead of being run just once, repeatable migrations are (re-)applied to a database on [migrate](https://documentation.red-gate.com/fd/migrate-277578887.html) every time their checksum changes.
-1. Our main use for repeatable migrations are to generate mock data to use locally and in our CI database, but **is not needed for our production or staging database**.
+1. These migrations generate mock data for local development and are excluded from production and staging migrations.
 
 #### Requirements
 
diff --git a/db/repeated/R__Mock_V0001_Insert_test_members.sql b/db/repeated/R__Mock_V0001_Insert_test_members.sql
new file mode 100644
index 00000000..ccc5a528
--- /dev/null
+++ b/db/repeated/R__Mock_V0001_Insert_test_members.sql
@@ -0,0 +1,167 @@
+INSERT INTO members (
+    id,
+    first_name,
+    last_name,
+    email,
+    linked_in_url,
+    introduction,
+    referral_source,
+    active,
+    match_pref,
+    industry_pref,
+    role_pref,
+    topics,
+    extra_notes
+)
+VALUES
+    (
+        '10000000-0000-4000-8000-000000000001',
+        'Avery',
+        'Chen',
+        'avery.chen@example.com',
+        'https://www.linkedin.com/in/avery-chen-example',
+        'Product designer interested in making financial tools easier to use.',
+        'Patina Network newsletter',
+        TRUE,
+        'Peer - I want to meet someone with similar experience',
+        'Financial Technology',
+        'Product Designer',
+        'Design systems, Financial literacy, Career growth',
+        'Available for coffee in Manhattan or a virtual chat.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000002',
+        'Jordan',
+        'Williams',
+        'jordan.williams@example.com',
+        'https://www.linkedin.com/in/jordan-williams-example',
+        'Backend engineer building reliable systems for healthcare teams.',
+        'Friend',
+        TRUE,
+        'Mentor - I am looking for guidance from someone with more experience',
+        'Healthcare Technology',
+        'Software Engineer',
+        'Distributed systems, Leadership, Open source',
+        'Usually available after work on Tuesdays and Thursdays.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000003',
+        'Priya',
+        'Patel',
+        'priya.patel@example.com',
+        'https://www.linkedin.com/in/priya-patel-example',
+        'Founder working on software that helps small businesses measure emissions.',
+        'Patina Network event',
+        TRUE,
+        'Peer - I want to exchange ideas with another builder',
+        'Climate Technology',
+        'Founder',
+        'Fundraising, Sustainability, Product strategy',
+        'Happy to meet virtually or in Brooklyn.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000004',
+        'Marcus',
+        'Johnson',
+        'marcus.johnson@example.com',
+        NULL,
+        'Data analyst focused on improving outcomes for public school students.',
+        'Colleague',
+        FALSE,
+        'Mentor - I can offer guidance to someone earlier in their career',
+        'Education',
+        'Data Analyst',
+        'Analytics, Public policy, Mentorship',
+        'Taking a break from matching this month.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000005',
+        'Sofia',
+        'Rodriguez',
+        'sofia.rodriguez@example.com',
+        'https://www.linkedin.com/in/sofia-rodriguez-example',
+        'Community program director connecting volunteers with neighborhood nonprofits.',
+        'Community partner',
+        TRUE,
+        'Open - I am happy to meet a peer, mentor, or mentee',
+        'Nonprofit',
+        'Program Director',
+        'Community building, Social impact, Volunteer engagement',
+        'Prefers an in-person conversation when possible.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000006',
+        'Ethan',
+        'Kim',
+        'ethan.kim@example.com',
+        'https://www.linkedin.com/in/ethan-kim-example',
+        'Graduate student researching responsible machine learning applications.',
+        'University alumni group',
+        TRUE,
+        'Mentor - I am looking for guidance from someone with more experience',
+        'Artificial Intelligence',
+        'Graduate Researcher',
+        'Responsible AI, Research careers, Entrepreneurship',
+        NULL
+    ),
+    (
+        '10000000-0000-4000-8000-000000000007',
+        'Nia',
+        'Thompson',
+        'nia.thompson@example.com',
+        NULL,
+        'Marketing strategist helping independent creators grow sustainable audiences.',
+        'LinkedIn',
+        TRUE,
+        'Peer - I want to meet someone with similar experience',
+        'Media',
+        'Marketing Strategist',
+        'Brand strategy, Creator economy, Storytelling',
+        'Virtual chats work best during weekday mornings.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000008',
+        'Leo',
+        'Martinez',
+        'leo.martinez@example.com',
+        'https://www.linkedin.com/in/leo-martinez-example',
+        'Operations manager interested in technology-enabled hospitality experiences.',
+        'Friend',
+        TRUE,
+        'Open - I am happy to meet a peer, mentor, or mentee',
+        'Hospitality',
+        'Operations Manager',
+        'Operations, Customer experience, Small business',
+        'Available in Queens or by video call.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000009',
+        'Maya',
+        'Brooks',
+        'maya.brooks@example.com',
+        'https://www.linkedin.com/in/maya-brooks-example',
+        'People operations leader building inclusive teams at growing companies.',
+        'Patina Network event',
+        TRUE,
+        'Mentor - I can offer guidance to someone earlier in their career',
+        'Professional Services',
+        'People Operations Director',
+        'Inclusive hiring, Management, Organizational design',
+        'Open to meeting anywhere near a major subway line.'
+    ),
+    (
+        '10000000-0000-4000-8000-000000000010',
+        'Noah',
+        'Okafor',
+        'noah.okafor@example.com',
+        NULL,
+        'Independent consultant helping local retailers modernize their operations.',
+        'Community partner',
+        FALSE,
+        'Peer - I want to exchange ideas with another builder',
+        'Retail',
+        'Business Consultant',
+        'Digital transformation, Consulting, Local business',
+        'Inactive seed record for testing member status filters.'
+    )
+ON CONFLICT (email) DO NOTHING;
diff --git a/js/src/app/router/router.tsx b/js/src/app/router/router.tsx
index caed8b67..0d2e9c9e 100644
--- a/js/src/app/router/router.tsx
+++ b/js/src/app/router/router.tsx
@@ -11,6 +11,7 @@ import { EmailHistoryPage } from "@/features/emails/EmailHistoryPage";
 import { EmailProgressPage } from "@/features/emails/EmailProgressPage";
 import { EmailSendPage } from "@/features/emails/EmailSendPage";
 import HomePage from "@/features/home/Home.page";
+import { MembersPage } from "@/features/members/Members.page";
 import SamplePage from "@/features/sample/Sample.page";
 import SampleAdminPage from "@/features/sample/SampleAdmin.page";
 import { SignUpPage } from "@/features/sign-up/SignUp.page";
@@ -61,6 +62,7 @@ export const router = createBrowserRouter([
             element: <AdminLayout />,
             children: [
               { path: "admin", element: <AdminPage /> },
+              { path: "admin/members", element: <MembersPage /> },
               {
                 path: "admin/email",
                 element: <EmailAdminPage />,
diff --git a/js/src/features/members/Members.page.test.tsx b/js/src/features/members/Members.page.test.tsx
new file mode 100644
index 00000000..1c2544a5
--- /dev/null
+++ b/js/src/features/members/Members.page.test.tsx
@@ -0,0 +1,125 @@
+import { MembersPage } from "@/features/members/Members.page";
+import {
+  fireEvent,
+  renderWithProviders,
+  screen,
+  within,
+} from "@/lib/test/render";
+import { server } from "@/lib/test/server";
+import { waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { http, HttpResponse } from "msw";
+import { expect, test } from "vitest";
+
+test("renders every member returned by the API", async () => {
+  renderWithProviders(<MembersPage />);
+
+  expect(await screen.findByText("Alex Morgan")).toBeInTheDocument();
+  expect(screen.getByText("Jordan Lee")).toBeInTheDocument();
+  expect(screen.getByText("2 members")).toBeInTheDocument();
+  const membersTable = screen.getByRole("table");
+  expect(within(membersTable).getByText("Active")).toBeInTheDocument();
+  expect(within(membersTable).getByText("Inactive")).toBeInTheDocument();
+});
+
+test("renders an empty state when there are no members", async () => {
+  server.use(
+    http.get("/api/members", () =>
+      HttpResponse.json({
+        message: "Members retrieved successfully",
+        payload: [],
+        success: true,
+      }),
+    ),
+  );
+
+  renderWithProviders(<MembersPage />);
+
+  expect(await screen.findByText("No members found.")).toBeInTheDocument();
+  expect(screen.getByText("0 members")).toBeInTheDocument();
+});
+
+test("applies form filters as API request parameters", async () => {
+  const user = userEvent.setup();
+  const requestedUrls: URL[] = [];
+  server.use(
+    http.get("/api/members", ({ request }) => {
+      requestedUrls.push(new URL(request.url));
+      return HttpResponse.json({
+        message: "Members retrieved successfully",
+        payload: [],
+        success: true,
+      });
+    }),
+  );
+
+  renderWithProviders(<MembersPage />, { route: "/admin/members" });
+
+  expect(await screen.findByText("No members found.")).toBeInTheDocument();
+
+  await user.type(screen.getByLabelText("First name"), "  Alex  ");
+  await user.type(screen.getByLabelText("Last name"), "Morgan");
+  await user.type(screen.getByLabelText("Email"), "alex@example.com");
+  await user.click(screen.getByPlaceholderText("Any status"));
+  fireEvent.click(screen.getByRole("option", { hidden: true, name: "Active" }));
+  await user.type(screen.getByLabelText("Match preference"), "Peer");
+  await user.type(screen.getByLabelText("Industry"), "Technology");
+  await user.type(screen.getByLabelText("Role"), "Engineering");
+  await user.type(screen.getByLabelText("Topics"), "Community building");
+  await user.click(screen.getByRole("button", { name: "Apply filters" }));
+
+  await waitFor(() => expect(requestedUrls).toHaveLength(2));
+  const requestedUrl = requestedUrls[1];
+  expect(requestedUrl.searchParams.get("firstName")).toBe("Alex");
+  expect(requestedUrl.searchParams.get("lastName")).toBe("Morgan");
+  expect(requestedUrl.searchParams.get("email")).toBe("alex@example.com");
+  expect(requestedUrl.searchParams.get("active")).toBe("true");
+  expect(requestedUrl.searchParams.get("matchPref")).toBe("Peer");
+  expect(requestedUrl.searchParams.get("industryPref")).toBe("Technology");
+  expect(requestedUrl.searchParams.get("rolePref")).toBe("Engineering");
+  expect(requestedUrl.searchParams.get("topics")).toBe("Community building");
+});
+
+test("allows status to be deselected and clears it with the other filters", async () => {
+  const user = userEvent.setup();
+  const requestedUrls: URL[] = [];
+  server.use(
+    http.get("/api/members", ({ request }) => {
+      requestedUrls.push(new URL(request.url));
+      return HttpResponse.json({
+        message: "Members retrieved successfully",
+        payload: [],
+        success: true,
+      });
+    }),
+  );
+
+  renderWithProviders(<MembersPage />);
+
+  expect(await screen.findByText("No members found.")).toBeInTheDocument();
+  const statusInput = screen.getByRole("textbox", { name: "Status" });
+  await user.click(statusInput);
+  fireEvent.click(screen.getByRole("option", { hidden: true, name: "Active" }));
+  expect(statusInput).toHaveValue("Active");
+
+  await user.click(screen.getByRole("button", { name: "Clear status" }));
+  expect(statusInput).toHaveValue("");
+  await user.type(screen.getByLabelText("First name"), "Alex");
+  await user.click(screen.getByRole("button", { name: "Apply filters" }));
+
+  await waitFor(() => expect(requestedUrls).toHaveLength(2));
+  expect(requestedUrls[1].searchParams.get("firstName")).toBe("Alex");
+  expect(requestedUrls[1].searchParams.has("active")).toBe(false);
+
+  const renderedStatusInput = await screen.findByRole("textbox", {
+    name: "Status",
+  });
+  await user.click(renderedStatusInput);
+  fireEvent.click(
+    screen.getByRole("option", { hidden: true, name: "Inactive" }),
+  );
+  await user.click(screen.getByRole("button", { name: "Clear filters" }));
+
+  expect(renderedStatusInput).toHaveValue("");
+  expect(screen.getByLabelText("First name")).toHaveValue("");
+});
diff --git a/js/src/features/members/Members.page.tsx b/js/src/features/members/Members.page.tsx
new file mode 100644
index 00000000..b5383fca
--- /dev/null
+++ b/js/src/features/members/Members.page.tsx
@@ -0,0 +1,244 @@
+import { MemberFilters, useMembers } from "@/features/members/api/useMembers";
+import {
+  Alert,
+  Anchor,
+  Badge,
+  Button,
+  Center,
+  Group,
+  Loader,
+  Paper,
+  Select,
+  SimpleGrid,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+  Title,
+} from "@mantine/core";
+import { useForm } from "@mantine/form";
+import { zodResolver } from "mantine-form-zod-resolver";
+import { useState } from "react";
+import { z } from "zod";
+
+const dateFormatter = new Intl.DateTimeFormat(undefined, {
+  dateStyle: "medium",
+});
+
+const memberFiltersSchema = z.object({
+  active: z.enum(["true", "false"]).nullable(),
+  email: z.string(),
+  firstName: z.string(),
+  industryPref: z.string(),
+  lastName: z.string(),
+  matchPref: z.string(),
+  rolePref: z.string(),
+  topics: z.string(),
+});
+
+type MemberFilterValues = z.infer<typeof memberFiltersSchema>;
+
+const initialFilterValues: MemberFilterValues = {
+  active: null,
+  email: "",
+  firstName: "",
+  industryPref: "",
+  lastName: "",
+  matchPref: "",
+  rolePref: "",
+  topics: "",
+};
+
+function toMemberFilters(values: MemberFilterValues): MemberFilters {
+  const normalize = (value: string | null) => value?.trim() || undefined;
+
+  return {
+    active: normalize(values.active),
+    email: normalize(values.email),
+    firstName: normalize(values.firstName),
+    industryPref: normalize(values.industryPref),
+    lastName: normalize(values.lastName),
+    matchPref: normalize(values.matchPref),
+    rolePref: normalize(values.rolePref),
+    topics: normalize(values.topics),
+  };
+}
+
+export function MembersPage() {
+  const [filters, setFilters] = useState<MemberFilters>({});
+  const form = useForm<MemberFilterValues>({
+    initialValues: initialFilterValues,
+    validate: zodResolver(memberFiltersSchema),
+  });
+  const { data: members, isError, isPending } = useMembers(filters);
+
+  const clearFilters = () => {
+    form.reset();
+    setFilters({});
+  };
+
+  if (isPending) {
+    return (
+      <Center py="xl">
+        <Loader aria-label="Loading members" />
+      </Center>
+    );
+  }
+
+  if (isError) {
+    return (
+      <Alert color="red" title="Members could not be loaded">
+        Try refreshing the page. If the problem continues, check that the
+        backend is running.
+      </Alert>
+    );
+  }
+
+  return (
+    <Stack>
+      <Group justify="space-between">
+        <div>
+          <Title order={2}>Members</Title>
+          <Text c="dimmed">Everyone registered for PatChats.</Text>
+        </div>
+        <Badge size="lg" variant="light">
+          {members.length} {members.length === 1 ? "member" : "members"}
+        </Badge>
+      </Group>
+      <Paper p="md" withBorder>
+        <form
+          onSubmit={form.onSubmit((values) =>
+            setFilters(toMemberFilters(values)),
+          )}
+        >
+          <Stack gap="md">
+            <div>
+              <Text fw={600}>Filter members</Text>
+              <Text c="dimmed" size="sm">
+                Text filters match the full value and are not case-sensitive.
+              </Text>
+            </div>
+            <SimpleGrid cols={{ base: 1, sm: 2, lg: 4 }}>
+              <TextInput
+                label="First name"
+                placeholder="Alex"
+                {...form.getInputProps("firstName")}
+              />
+              <TextInput
+                label="Last name"
+                placeholder="Morgan"
+                {...form.getInputProps("lastName")}
+              />
+              <TextInput
+                label="Email"
+                placeholder="alex@example.com"
+                {...form.getInputProps("email")}
+              />
+              <Select
+                clearable
+                clearButtonProps={{
+                  "aria-hidden": false,
+                  "aria-label": "Clear status",
+                }}
+                data={[
+                  { label: "Active", value: "true" },
+                  { label: "Inactive", value: "false" },
+                ]}
+                label="Status"
+                placeholder="Any status"
+                {...form.getInputProps("active")}
+              />
+              <TextInput
+                label="Match preference"
+                placeholder="Peer"
+                {...form.getInputProps("matchPref")}
+              />
+              <TextInput
+                label="Industry"
+                placeholder="Technology"
+                {...form.getInputProps("industryPref")}
+              />
+              <TextInput
+                label="Role"
+                placeholder="Engineering"
+                {...form.getInputProps("rolePref")}
+              />
+              <TextInput
+                label="Topics"
+                placeholder="Community, Technology"
+                {...form.getInputProps("topics")}
+              />
+            </SimpleGrid>
+            <Group justify="flex-end">
+              <Button color="gray" onClick={clearFilters} variant="subtle">
+                Clear filters
+              </Button>
+              <Button type="submit">Apply filters</Button>
+            </Group>
+          </Stack>
+        </form>
+      </Paper>
+      {members.length === 0 ?
+        <Paper p="xl" withBorder>
+          <Text c="dimmed" ta="center">
+            No members found.
+          </Text>
+        </Paper>
+      : <Table.ScrollContainer minWidth={1100}>
+          <Table highlightOnHover striped withTableBorder>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>Name</Table.Th>
+                <Table.Th>Email</Table.Th>
+                <Table.Th>LinkedIn</Table.Th>
+                <Table.Th>Status</Table.Th>
+                <Table.Th>Match preference</Table.Th>
+                <Table.Th>Industry</Table.Th>
+                <Table.Th>Role</Table.Th>
+                <Table.Th>Topics</Table.Th>
+                <Table.Th>Joined</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {members.map((member) => (
+                <Table.Tr key={member.id}>
+                  <Table.Td fw={600}>
+                    {member.firstName} {member.lastName}
+                  </Table.Td>
+                  <Table.Td>
+                    <Anchor href={`mailto:${member.email}`}>
+                      {member.email}
+                    </Anchor>
+                  </Table.Td>
+                  <Table.Td>
+                    {member.linkedInUrl ?
+                      <Anchor
+                        href={member.linkedInUrl}
+                        rel="noreferrer"
+                        target="_blank"
+                      >
+                        Profile
+                      </Anchor>
+                    : "—"}
+                  </Table.Td>
+                  <Table.Td>
+                    <Badge color={member.active ? "green" : "gray"}>
+                      {member.active ? "Active" : "Inactive"}
+                    </Badge>
+                  </Table.Td>
+                  <Table.Td>{member.matchPref ?? "—"}</Table.Td>
+                  <Table.Td>{member.industryPref ?? "—"}</Table.Td>
+                  <Table.Td>{member.rolePref ?? "—"}</Table.Td>
+                  <Table.Td>{member.topics ?? "—"}</Table.Td>
+                  <Table.Td>
+                    {dateFormatter.format(new Date(member.createdAt))}
+                  </Table.Td>
+                </Table.Tr>
+              ))}
+            </Table.Tbody>
+          </Table>
+        </Table.ScrollContainer>
+      }
+    </Stack>
+  );
+}
diff --git a/js/src/features/members/api/members.mock.ts b/js/src/features/members/api/members.mock.ts
new file mode 100644
index 00000000..3ade4da2
--- /dev/null
+++ b/js/src/features/members/api/members.mock.ts
@@ -0,0 +1,46 @@
+import { http, HttpResponse } from "msw";
+
+export const membersHandlers = [
+  http.get("/api/members", () =>
+    HttpResponse.json({
+      message: "Members retrieved successfully",
+      payload: [
+        {
+          active: true,
+          createdAt: "2026-01-15T14:30:00Z",
+          email: "alex@example.com",
+          extraNotes: null,
+          firstName: "Alex",
+          id: "50ecf8a0-6345-40f8-b59f-438c3f338b82",
+          industryPref: "Technology",
+          introduction: "I build community-focused software.",
+          lastName: "Morgan",
+          linkedInUrl: "https://www.linkedin.com/in/alex-morgan",
+          matchPref: "Peer",
+          referralSource: "Patina Network",
+          rolePref: "Engineering",
+          topics: "Community, Technology",
+          updatedAt: "2026-01-15T14:30:00Z",
+        },
+        {
+          active: false,
+          createdAt: "2025-12-10T09:00:00Z",
+          email: "jordan@example.com",
+          extraNotes: "Prefers virtual chats.",
+          firstName: "Jordan",
+          id: "db827ce4-5ed1-4649-98ca-3e5fb538d22e",
+          industryPref: "Design",
+          introduction: "I am a product designer.",
+          lastName: "Lee",
+          linkedInUrl: null,
+          matchPref: "Mentor",
+          referralSource: null,
+          rolePref: "Product design",
+          topics: "Design systems",
+          updatedAt: "2026-02-01T11:00:00Z",
+        },
+      ],
+      success: true,
+    }),
+  ),
+];
diff --git a/js/src/features/members/api/useMembers.ts b/js/src/features/members/api/useMembers.ts
new file mode 100644
index 00000000..2d95d4ab
--- /dev/null
+++ b/js/src/features/members/api/useMembers.ts
@@ -0,0 +1,61 @@
+import { apiFetch } from "@/lib/api/client";
+import { useQuery } from "@tanstack/react-query";
+
+export interface Member {
+  active: boolean;
+  createdAt: string;
+  email: string;
+  extraNotes: string | null;
+  firstName: string;
+  id: string;
+  industryPref: string | null;
+  introduction: string;
+  lastName: string;
+  linkedInUrl: string | null;
+  matchPref: string | null;
+  referralSource: string | null;
+  rolePref: string | null;
+  topics: string | null;
+  updatedAt: string;
+}
+
+interface MembersResponse {
+  message: string;
+  payload: Member[];
+  success: boolean;
+}
+
+export interface MemberFilters {
+  active?: string;
+  email?: string;
+  firstName?: string;
+  industryPref?: string;
+  lastName?: string;
+  matchPref?: string;
+  page?: string;
+  pageSize?: string;
+  rolePref?: string;
+  topics?: string;
+}
+
+export const membersQueryKey = ["members"] as const;
+
+/** Fetches members matching the supplied filters for the admin members page. */
+export function useMembers(filters: MemberFilters = {}) {
+  return useQuery({
+    queryKey: [...membersQueryKey, filters],
+    queryFn: async () => {
+      const searchParams = new URLSearchParams();
+      Object.entries(filters).forEach(([name, value]) => {
+        if (value !== undefined) {
+          searchParams.set(name, value);
+        }
+      });
+
+      const query = searchParams.toString();
+      const path = query ? `/members?${query}` : "/members";
+      const response = await apiFetch<MembersResponse>(path);
+      return response.payload;
+    },
+  });
+}
diff --git a/js/src/lib/api/useSession.ts b/js/src/lib/api/useSession.ts
index f48ec697..bcbcfc62 100644
--- a/js/src/lib/api/useSession.ts
+++ b/js/src/lib/api/useSession.ts
@@ -19,7 +19,20 @@ export const sessionQueryKey = ["session"] as const;
 export function useSession() {
   return useQuery({
     queryKey: sessionQueryKey,
-    queryFn: () => apiFetch<Session>("/session"),
+    queryFn: () => {
+      // Authentication is not wired yet. Local development uses an admin
+      // identity so guarded pages can be exercised; production still fails
+      // closed when the session endpoint is unavailable.
+      if (import.meta.env.DEV) {
+        return Promise.resolve({
+          id: "local-dev-admin",
+          isAdmin: true,
+          name: "Local admin",
+        });
+      }
+
+      return apiFetch<Session>("/session");
+    },
     retry: false,
     staleTime: Infinity,
   });
diff --git a/js/src/lib/test/render.tsx b/js/src/lib/test/render.tsx
index 946079d3..031c84c8 100644
--- a/js/src/lib/test/render.tsx
+++ b/js/src/lib/test/render.tsx
@@ -9,7 +9,7 @@ import { MemoryRouter } from "react-router-dom";
  * A fresh QueryClient per render so tests never share cache. Retries are off so
  * failed requests surface immediately instead of hanging the test.
  */
-function createWrapper() {
+function createWrapper(route: string) {
   const queryClient = new QueryClient({
     defaultOptions: { queries: { retry: false } },
   });
@@ -18,19 +18,23 @@ function createWrapper() {
     return (
       <QueryClientProvider client={queryClient}>
         <MantineProvider theme={themeOverride} forceColorScheme="dark">
-          <MemoryRouter>{children}</MemoryRouter>
+          <MemoryRouter initialEntries={[route]}>{children}</MemoryRouter>
         </MantineProvider>
       </QueryClientProvider>
     );
   };
 }
 
+interface RenderWithProvidersOptions extends Omit<RenderOptions, "wrapper"> {
+  route?: string;
+}
+
 /** Render a component wrapped in the app's providers (Query, Mantine, Router). */
 export function renderWithProviders(
   ui: ReactElement,
-  options?: Omit<RenderOptions, "wrapper">,
+  { route = "/", ...options }: RenderWithProvidersOptions = {},
 ) {
-  return render(ui, { wrapper: createWrapper(), ...options });
+  return render(ui, { wrapper: createWrapper(route), ...options });
 }
 
 // eslint-disable-next-line react-refresh/only-export-components
diff --git a/js/src/lib/test/server.ts b/js/src/lib/test/server.ts
index 3c2f2130..f51ed1c8 100644
--- a/js/src/lib/test/server.ts
+++ b/js/src/lib/test/server.ts
@@ -1,3 +1,4 @@
+import { membersHandlers } from "@/features/members/api/members.mock";
 import { sampleHandlers } from "@/features/sample/api/sample.mock";
 import { setupServer } from "msw/node";
 
@@ -5,4 +6,4 @@ import { setupServer } from "msw/node";
  * MSW server for tests. Each domain owns its request handlers in
  * `features/<domain>/api/<domain>.mock.ts`; compose them here.
  */
-export const server = setupServer(...sampleHandlers);
+export const server = setupServer(...membersHandlers, ...sampleHandlers);
diff --git a/src/main/java/org/patinanetwork/patchats/api/auth/security/SecurityConfig.java b/src/main/java/org/patinanetwork/patchats/api/auth/security/SecurityConfig.java
index 3b9bab1b..4191a96c 100644
--- a/src/main/java/org/patinanetwork/patchats/api/auth/security/SecurityConfig.java
+++ b/src/main/java/org/patinanetwork/patchats/api/auth/security/SecurityConfig.java
@@ -11,7 +11,7 @@
 public class SecurityConfig {
 
     /**
-     * Default/production chain. Sending email is admin-only.
+     * Default/production chain. Sending email and listing members are admin-only.
      *
      * <p>NOTE: authentication (OAuth2 login / roles) is not yet wired, so this rule currently fails closed — every
      * caller is denied because no security context is populated. Once the auth domain authenticates admins, the rule
@@ -22,6 +22,8 @@ public class SecurityConfig {
     SecurityFilterChain securityFilterChain(final HttpSecurity http) throws Exception {
         return http.csrf(csrf -> csrf.disable())
                 .authorizeHttpRequests(auth -> auth.requestMatchers(HttpMethod.POST, "/api/email/**")
+                        .hasRole("ADMIN")
+                        .requestMatchers(HttpMethod.GET, "/api/members")
                         .hasRole("ADMIN")
                         .anyRequest()
                         .permitAll())
diff --git a/src/main/java/org/patinanetwork/patchats/api/match/db/repos/MatchFilterCriteria.java b/src/main/java/org/patinanetwork/patchats/api/match/db/repos/MatchFilterCriteria.java
index 1e4cc128..a1f01423 100644
--- a/src/main/java/org/patinanetwork/patchats/api/match/db/repos/MatchFilterCriteria.java
+++ b/src/main/java/org/patinanetwork/patchats/api/match/db/repos/MatchFilterCriteria.java
@@ -11,16 +11,4 @@ public record MatchFilterCriteria(
         Optional<UUID> memberId,
         Optional<Integer> matchCycleId,
         Optional<String> memberIndustry,
-        Optional<String> status) {
-
-    public static MatchFilterCriteria empty() {
-        return new MatchFilterCriteria(
-                Optional.empty(),
-                Optional.empty(),
-                Optional.empty(),
-                Optional.empty(),
-                Optional.empty(),
-                Optional.empty(),
-                Optional.empty());
-    }
-}
+        Optional<String> status) {}
diff --git a/src/main/java/org/patinanetwork/patchats/api/member/MemberController.java b/src/main/java/org/patinanetwork/patchats/api/member/MemberController.java
index c46f4497..2fdc762f 100644
--- a/src/main/java/org/patinanetwork/patchats/api/member/MemberController.java
+++ b/src/main/java/org/patinanetwork/patchats/api/member/MemberController.java
@@ -1,9 +1,15 @@
 package org.patinanetwork.patchats.api.member;
 
+import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
+import org.patinanetwork.patchats.api.member.db.repos.MemberFilterCriteria;
 import org.patinanetwork.patchats.api.member.dto.CreateMemberRequest;
 import org.patinanetwork.patchats.api.member.dto.MemberDto;
 import org.patinanetwork.patchats.api.member.dto.UpdateMemberRequest;
@@ -15,6 +21,7 @@
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
@@ -31,6 +38,28 @@ public ResponseEntity<ApiResponder<MemberDto>> createMember(@Valid @RequestBody
         return ResponseEntity.ok(ApiResponder.success("Member created successfully", response));
     }
 
+    @GetMapping
+    @Operation(
+            summary = "List members",
+            description = "Returns a page of members matching the supplied filters, ordered by creation date. Pages "
+                    + "are one-based; pageSize defaults to 25 and cannot exceed 100.")
+    public ResponseEntity<ApiResponder<List<MemberDto>>> getMembers(
+            @RequestParam final Optional<String> firstName,
+            @RequestParam final Optional<String> lastName,
+            @RequestParam final Optional<String> email,
+            @RequestParam final Optional<Boolean> active,
+            @RequestParam final Optional<String> matchPref,
+            @RequestParam final Optional<String> industryPref,
+            @RequestParam final Optional<String> rolePref,
+            @RequestParam final Optional<String> topics,
+            @RequestParam(defaultValue = "1") @Min(1) final int page,
+            @RequestParam(defaultValue = "25") @Min(1) @Max(100) final int pageSize) {
+        final MemberFilterCriteria criteria = new MemberFilterCriteria(
+                firstName, lastName, email, active, matchPref, industryPref, rolePref, topics, page, pageSize);
+        final List<MemberDto> response = memberService.getMembersByFilters(criteria);
+        return ResponseEntity.ok(ApiResponder.success("Members retrieved successfully", response));
+    }
+
     @PatchMapping("/{id}")
     public ResponseEntity<ApiResponder<MemberDto>> updateMember(
             @Valid @RequestBody final UpdateMemberRequest request, @PathVariable final UUID id) {
diff --git a/src/main/java/org/patinanetwork/patchats/api/member/MemberService.java b/src/main/java/org/patinanetwork/patchats/api/member/MemberService.java
index dbf4bd15..c1246dbe 100644
--- a/src/main/java/org/patinanetwork/patchats/api/member/MemberService.java
+++ b/src/main/java/org/patinanetwork/patchats/api/member/MemberService.java
@@ -7,6 +7,7 @@
 import java.util.stream.Stream;
 import lombok.RequiredArgsConstructor;
 import org.patinanetwork.patchats.api.member.db.models.Member;
+import org.patinanetwork.patchats.api.member.db.repos.MemberFilterCriteria;
 import org.patinanetwork.patchats.api.member.db.repos.MemberRepo;
 import org.patinanetwork.patchats.api.member.dto.CreateMemberRequest;
 import org.patinanetwork.patchats.api.member.dto.MemberDto;
@@ -46,8 +47,10 @@ public MemberDto createMember(CreateMemberRequest request) {
         return MemberDto.from(createdMember);
     }
 
-    public List<MemberDto> getMembers() {
-        return memberRepo.getMembers().stream().map(MemberDto::from).toList();
+    public List<MemberDto> getMembersByFilters(MemberFilterCriteria criteria) {
+        return memberRepo.getMembersByFilters(criteria).stream()
+                .map(MemberDto::from)
+                .toList();
     }
 
     public MemberDto updateMember(UpdateMemberRequest request, UUID id) {
diff --git a/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberFilterCriteria.java b/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberFilterCriteria.java
new file mode 100644
index 00000000..1bd12146
--- /dev/null
+++ b/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberFilterCriteria.java
@@ -0,0 +1,40 @@
+package org.patinanetwork.patchats.api.member.db.repos;
+
+import java.util.Optional;
+import lombok.Builder;
+
+@Builder
+public record MemberFilterCriteria(
+        Optional<String> firstName,
+        Optional<String> lastName,
+        Optional<String> email,
+        Optional<Boolean> active,
+        Optional<String> matchPref,
+        Optional<String> industryPref,
+        Optional<String> rolePref,
+        Optional<String> topics,
+        int page,
+        int pageSize) {
+
+    public static final int DEFAULT_PAGE = 1;
+    public static final int DEFAULT_PAGE_SIZE = 25;
+    public static final int MAX_PAGE_SIZE = 100;
+
+    public static class MemberFilterCriteriaBuilder {
+        private int page = DEFAULT_PAGE;
+        private int pageSize = DEFAULT_PAGE_SIZE;
+    }
+
+    public MemberFilterCriteria {
+        if (page < 1) {
+            throw new IllegalArgumentException("page must be at least 1");
+        }
+        if (pageSize < 1 || pageSize > MAX_PAGE_SIZE) {
+            throw new IllegalArgumentException("pageSize must be between 1 and " + MAX_PAGE_SIZE);
+        }
+    }
+
+    public long offset() {
+        return (long) (page - 1) * pageSize;
+    }
+}
diff --git a/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberRepo.java b/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberRepo.java
index 8d280e6b..9a3b70d1 100644
--- a/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberRepo.java
+++ b/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberRepo.java
@@ -22,7 +22,7 @@ public interface MemberRepo {
      */
     Member createMember(Member member);
 
-    List<Member> getMembers();
+    List<Member> getMembersByFilters(MemberFilterCriteria criteria);
 
     /**
      * @note - The provided object's methods will be overridden with any returned data from the database.
diff --git a/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepo.java b/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepo.java
index cabf9a8d..0c7225cb 100644
--- a/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepo.java
+++ b/src/main/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepo.java
@@ -3,11 +3,15 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.OffsetDateTime;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import org.patinanetwork.patchats.api.member.db.models.Member;
+import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.simple.JdbcClient;
 import org.springframework.stereotype.Repository;
 
@@ -15,9 +19,82 @@
 @RequiredArgsConstructor
 public class MemberSqlRepo implements MemberRepo {
 
+    public static final String CREATE_MEMBER_SQL = """
+        INSERT INTO "members" (
+            "id",
+            "first_name",
+            "last_name",
+            "email",
+            "linked_in_url",
+            "introduction",
+            "referral_source",
+            "active",
+            "match_pref",
+            "industry_pref",
+            "role_pref",
+            "topics",
+            "extra_notes"
+        )
+        VALUES(
+            :id,
+            :first_name,
+            :last_name,
+            :email,
+            :linked_in_url,
+            :introduction,
+            :referral_source,
+            :active ,
+            :match_pref,
+            :industry_pref,
+            :role_pref,
+            :topics,
+            :extra_notes
+        )
+        RETURNING
+            *
+        """;
+
+    public static final String GET_MEMBERS_BY_FILTERS_SQL = """
+        SELECT
+            *
+        FROM
+            members
+        %sORDER BY
+            created_at DESC,
+            id
+        LIMIT
+            :page_size
+        OFFSET
+            :offset
+        """;
+
+    public static final String UPDATE_MEMBER_SQL = """
+        UPDATE "members" SET
+            "first_name" = :first_name,
+            "last_name" = :last_name,
+            "email" = :email,
+            "linked_in_url" = :linked_in_url,
+            "introduction" = :introduction,
+            "referral_source" = :referral_source,
+            "active" = :active,
+            "match_pref" = :match_pref,
+            "industry_pref" = :industry_pref,
+            "role_pref" = :role_pref,
+            "topics" = :topics,
+            "extra_notes" = :extra_notes,
+            "updated_at" = NOW()
+        WHERE "id" = :id
+        RETURNING *
+        """;
+
+    public static final String GET_MEMBER_BY_ID_SQL = "SELECT * FROM members WHERE id = :id";
+    public static final String GET_MEMBER_BY_EMAIL_SQL = "SELECT * FROM members WHERE email = :email";
+
+    private static final RowMapper<Member> MEMBER_ROW_MAPPER = (rs, rowNum) -> parseResultSetToMember(rs);
+
     private final JdbcClient jdbc;
 
-    private Member parseResultSetToMember(final ResultSet rs) throws SQLException {
+    private static Member parseResultSetToMember(final ResultSet rs) throws SQLException {
         return Member.builder()
                 .id(UUID.fromString(rs.getString("id")))
                 .firstName(rs.getString("first_name"))
@@ -55,91 +132,68 @@ private JdbcClient.StatementSpec bindMemberParams(JdbcClient.StatementSpec spec,
 
     @Override
     public Member createMember(Member member) {
-        String sql = """
-            INSERT INTO "members" (
-                "id",
-                "first_name",
-                "last_name",
-                "email",
-                "linked_in_url",
-                "introduction",
-                "referral_source",
-                "active",
-                "match_pref",
-                "industry_pref",
-                "role_pref",
-                "topics",
-                "extra_notes"
-            )
-            VALUES(
-                :id,
-                :first_name,
-                :last_name,
-                :email,
-                :linked_in_url,
-                :introduction,
-                :referral_source,
-                :active ,
-                :match_pref,
-                :industry_pref,
-                :role_pref,
-                :topics,
-                :extra_notes
-            )
-            RETURNING
-                *
-        """;
-        return bindMemberParams(jdbc.sql(sql), member)
-                .query((rs, rowNum) -> parseResultSetToMember(rs))
+        return bindMemberParams(jdbc.sql(CREATE_MEMBER_SQL), member)
+                .query(MEMBER_ROW_MAPPER)
                 .single();
     }
 
     @Override
-    public List<Member> getMembers() {
-        String sql = "SELECT * FROM members ORDER BY created_at DESC, id";
-        return jdbc.sql(sql).query((rs, rowNum) -> parseResultSetToMember(rs)).list();
+    public List<Member> getMembersByFilters(MemberFilterCriteria criteria) {
+        final Map<String, Object> filters = getMemberFilters(criteria);
+
+        JdbcClient.StatementSpec statement = jdbc.sql(buildGetMembersByFiltersSql(filters));
+        if (!filters.isEmpty()) {
+            statement = statement.params(filters);
+        }
+        statement = statement.param("page_size", criteria.pageSize()).param("offset", criteria.offset());
+
+        return statement.query(MEMBER_ROW_MAPPER).list();
+    }
+
+    private static Map<String, Object> getMemberFilters(MemberFilterCriteria criteria) {
+        final Map<String, Object> filters = new LinkedHashMap<>();
+        criteria.firstName().ifPresent(value -> filters.put("first_name", value));
+        criteria.lastName().ifPresent(value -> filters.put("last_name", value));
+        criteria.email().ifPresent(value -> filters.put("email", value));
+        criteria.active().ifPresent(value -> filters.put("active", value));
+        criteria.matchPref().ifPresent(value -> filters.put("match_pref", value));
+        criteria.industryPref().ifPresent(value -> filters.put("industry_pref", value));
+        criteria.rolePref().ifPresent(value -> filters.put("role_pref", value));
+        criteria.topics().ifPresent(value -> filters.put("topics", value));
+        return filters;
+    }
+
+    private static String buildGetMembersByFiltersSql(Map<String, Object> filters) {
+        final String whereClause = filters.isEmpty()
+                ? ""
+                : filters.keySet().stream()
+                        .map(column -> "active".equals(column)
+                                ? "    active = :active"
+                                : "    LOWER(" + column + ") = LOWER(:" + column + ")")
+                        .collect(Collectors.joining("\nAND\n", "WHERE\n", "\n"));
+        return GET_MEMBERS_BY_FILTERS_SQL.formatted(whereClause);
     }
 
     @Override
     public Optional<Member> updateMember(Member member) {
-        String sql = """
-            UPDATE "members" SET
-                "first_name" = :first_name,
-                "last_name" = :last_name,
-                "email" = :email,
-                "linked_in_url" = :linked_in_url,
-                "introduction" = :introduction,
-                "referral_source" = :referral_source,
-                "active" = :active,
-                "match_pref" = :match_pref,
-                "industry_pref" = :industry_pref,
-                "role_pref" = :role_pref,
-                "topics" = :topics,
-                "extra_notes" = :extra_notes,
-                "updated_at" = NOW()
-            WHERE "id" = :id
-            RETURNING *
-        """;
-        return bindMemberParams(jdbc.sql(sql), member)
-                .query((rs, rowNum) -> parseResultSetToMember(rs))
+        return bindMemberParams(jdbc.sql(UPDATE_MEMBER_SQL), member)
+                .query(MEMBER_ROW_MAPPER)
                 .optional();
     }
 
     @Override
     public Optional<Member> getMemberById(UUID id) {
-        String sql = "SELECT * FROM members WHERE id = :id";
-        return jdbc.sql(sql)
+        return jdbc.sql(GET_MEMBER_BY_ID_SQL)
                 .param("id", id)
-                .query((rs, rowNum) -> parseResultSetToMember(rs))
+                .query(MEMBER_ROW_MAPPER)
                 .optional();
     }
 
     @Override
     public Optional<Member> getMemberByEmail(String email) {
-        String sql = "SELECT * FROM members WHERE email = :email";
-        return jdbc.sql(sql)
+        return jdbc.sql(GET_MEMBER_BY_EMAIL_SQL)
                 .param("email", email)
-                .query((rs, rowNum) -> parseResultSetToMember(rs))
+                .query(MEMBER_ROW_MAPPER)
                 .optional();
     }
 
diff --git a/src/main/java/org/patinanetwork/patchats/common/web/ApiExceptionHandler.java b/src/main/java/org/patinanetwork/patchats/common/web/ApiExceptionHandler.java
index 0c75e400..32ddab0a 100644
--- a/src/main/java/org/patinanetwork/patchats/common/web/ApiExceptionHandler.java
+++ b/src/main/java/org/patinanetwork/patchats/common/web/ApiExceptionHandler.java
@@ -14,6 +14,8 @@
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.method.annotation.HandlerMethodValidationException;
+import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 
 /** Maps framework exceptions to the standard {@link ApiResponder} envelope. */
 @RestControllerAdvice
@@ -28,6 +30,18 @@ public ResponseEntity<ApiResponder<Void>> handleValidation(final MethodArgumentN
         return ResponseEntity.badRequest().body(ApiResponder.failure(message));
     }
 
+    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
+    public ResponseEntity<ApiResponder<Void>> handleParameterTypeMismatch(
+            final MethodArgumentTypeMismatchException ex) {
+        final String message = "Invalid value for query parameter '" + ex.getName() + "'";
+        return ResponseEntity.badRequest().body(ApiResponder.failure(message));
+    }
+
+    @ExceptionHandler(HandlerMethodValidationException.class)
+    public ResponseEntity<ApiResponder<Void>> handleParameterValidation(final HandlerMethodValidationException ex) {
+        return ResponseEntity.badRequest().body(ApiResponder.failure("Invalid query parameters"));
+    }
+
     @ExceptionHandler(MemberNotFoundException.class)
     public ResponseEntity<ApiResponder<Void>> handleMemberNotFound(final MemberNotFoundException ex) {
         return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ApiResponder.failure(ex.getMessage()));
diff --git a/src/test/java/org/patinanetwork/patchats/api/member/MemberControllerTest.java b/src/test/java/org/patinanetwork/patchats/api/member/MemberControllerTest.java
index 984f6f3a..f2fa06ef 100644
--- a/src/test/java/org/patinanetwork/patchats/api/member/MemberControllerTest.java
+++ b/src/test/java/org/patinanetwork/patchats/api/member/MemberControllerTest.java
@@ -12,10 +12,12 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.time.OffsetDateTime;
+import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.patinanetwork.patchats.api.member.db.repos.MemberFilterCriteria;
 import org.patinanetwork.patchats.api.member.dto.CreateMemberRequest;
 import org.patinanetwork.patchats.api.member.dto.MemberDto;
 import org.patinanetwork.patchats.api.member.dto.UpdateMemberRequest;
@@ -69,11 +71,9 @@ void createMember_returnsOkAndMemberDto() throws Exception {
                         .topics(request.topics())
                         .extraNotes(request.extraNotes())
                         .build());
-        mockMvc.perform(
-                        post("/api/members")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(
-                                        "{\"firstName\":\"John\",\"lastName\":\"Doe\",\"email\":\"john.doe@example.com\",\"linkedInUrl\":\"https://www.linkedin.com/in/johndoe\",\"introduction\":\"Hello, I'm John!\",\"referralSource\":\"Friend\",\"matchPref\":\"Mentor - I am looking for guidance from someone with more experience\",\"industryPref\":\"Technology\",\"rolePref\":\"Software Engineer\",\"topics\":\"College, Career Development\",\"extraNotes\":\"I want to be meet someone in person in NYC\"}"))
+        mockMvc.perform(post("/api/members")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(memberRequestJson("John")))
                 .andExpect(status().isOk())
                 .andExpect(jsonPath("$.success").value(true))
                 .andExpect(jsonPath("$.payload.firstName").value(request.firstName()))
@@ -93,11 +93,9 @@ void createMember_returnsOkAndMemberDto() throws Exception {
 
     @Test
     void createMemberReturnsBadRequestWhenFirstNameIsBlank() throws Exception {
-        mockMvc.perform(
-                        post("/api/members")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(
-                                        "{\"firstName\":\"\",\"lastName\":\"Doe\",\"email\":\"john.doe@example.com\",\"linkedInUrl\":\"https://www.linkedin.com/in/johndoe\",\"introduction\":\"Hello, I'm John!\",\"referralSource\":\"Friend\",\"matchPref\":\"Mentor - I am looking for guidance from someone with more experience\",\"industryPref\":\"Technology\",\"rolePref\":\"Software Engineer\",\"topics\":\"College, Career Development\",\"extraNotes\":\"I want to be meet someone in person in NYC\"}"))
+        mockMvc.perform(post("/api/members")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(memberRequestJson("")))
                 .andExpect(status().isBadRequest())
                 .andExpect(jsonPath("$.success").value(false));
     }
@@ -105,11 +103,9 @@ void createMemberReturnsBadRequestWhenFirstNameIsBlank() throws Exception {
     @Test
     void createMemberReturnsConflictOnDuplicateEmail() throws Exception {
         when(memberService.createMember(any())).thenThrow(new MemberDuplicateException("john.doe@example.com"));
-        mockMvc.perform(
-                        post("/api/members")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(
-                                        "{\"firstName\":\"John\",\"lastName\":\"Doe\",\"email\":\"john.doe@example.com\",\"linkedInUrl\":\"https://www.linkedin.com/in/johndoe\",\"introduction\":\"Hello, I'm John!\",\"referralSource\":\"Friend\",\"matchPref\":\"Mentor - I am looking for guidance from someone with more experience\",\"industryPref\":\"Technology\",\"rolePref\":\"Software Engineer\",\"topics\":\"College, Career Development\",\"extraNotes\":\"I want to be meet someone in person in NYC\"}"))
+        mockMvc.perform(post("/api/members")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(memberRequestJson("John")))
                 .andExpect(status().isConflict())
                 .andExpect(jsonPath("$.success").value(false));
     }
@@ -354,4 +350,117 @@ void updateMember_badRequestWhenInvalidUuid() throws Exception {
                         .content(objectMapper.writeValueAsString(request)))
                 .andExpect(status().isBadRequest());
     }
+
+    @Test
+    void getMembersReturnsAllMembers() throws Exception {
+        final MemberDto firstMember = MemberDto.builder()
+                .id(UUID.randomUUID())
+                .firstName("John")
+                .lastName("Doe")
+                .email("john.doe@example.com")
+                .active(true)
+                .build();
+        final MemberDto secondMember = MemberDto.builder()
+                .id(UUID.randomUUID())
+                .firstName("Jane")
+                .lastName("Doe")
+                .email("jane.doe@example.com")
+                .active(false)
+                .build();
+        when(memberService.getMembersByFilters(emptyCriteria())).thenReturn(List.of(firstMember, secondMember));
+
+        mockMvc.perform(get("/api/members"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.payload.length()").value(2))
+                .andExpect(jsonPath("$.payload[0].firstName").value("John"))
+                .andExpect(jsonPath("$.payload[0].lastName").value("Doe"))
+                .andExpect(jsonPath("$.payload[1].email").value("jane.doe@example.com"));
+    }
+
+    @Test
+    void getMembersCreatesCriteriaFromQueryParameters() throws Exception {
+        final MemberFilterCriteria criteria = new MemberFilterCriteria(
+                Optional.of("John"),
+                Optional.of("Doe"),
+                Optional.of("john.doe@example.com"),
+                Optional.of(true),
+                Optional.of("Peer"),
+                Optional.of("Technology"),
+                Optional.of("Software Engineer"),
+                Optional.of("Career Development"),
+                2,
+                10);
+        when(memberService.getMembersByFilters(criteria)).thenReturn(List.of());
+
+        mockMvc.perform(get("/api/members")
+                        .queryParam("firstName", "John")
+                        .queryParam("lastName", "Doe")
+                        .queryParam("email", "john.doe@example.com")
+                        .queryParam("active", "true")
+                        .queryParam("matchPref", "Peer")
+                        .queryParam("industryPref", "Technology")
+                        .queryParam("rolePref", "Software Engineer")
+                        .queryParam("topics", "Career Development")
+                        .queryParam("page", "2")
+                        .queryParam("pageSize", "10"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.payload.length()").value(0));
+
+        verify(memberService).getMembersByFilters(criteria);
+    }
+
+    @Test
+    void getMembersReturnsBadRequestWhenActiveIsInvalid() throws Exception {
+        mockMvc.perform(get("/api/members").queryParam("active", "tru"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.success").value(false))
+                .andExpect(jsonPath("$.message").value("Invalid value for query parameter 'active'"));
+    }
+
+    @Test
+    void getMembersReturnsBadRequestWhenPaginationIsOutOfRange() throws Exception {
+        mockMvc.perform(get("/api/members").queryParam("page", "0"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.success").value(false))
+                .andExpect(jsonPath("$.message").value("Invalid query parameters"));
+
+        mockMvc.perform(get("/api/members").queryParam("pageSize", "101"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.success").value(false))
+                .andExpect(jsonPath("$.message").value("Invalid query parameters"));
+    }
+
+    private static String memberRequestJson(String firstName) {
+        return """
+                {
+                  "firstName": "%s",
+                  "lastName": "Doe",
+                  "email": "john.doe@example.com",
+                  "linkedInUrl": "https://www.linkedin.com/in/johndoe",
+                  "introduction": "Hello, I'm John!",
+                  "referralSource": "Friend",
+                  "matchPref": "Mentor - I am looking for guidance from someone with more experience",
+                  "industryPref": "Technology",
+                  "rolePref": "Software Engineer",
+                  "topics": "College, Career Development",
+                  "extraNotes": "I want to be meet someone in person in NYC"
+                }
+                """.formatted(firstName);
+    }
+
+    private static MemberFilterCriteria emptyCriteria() {
+        return new MemberFilterCriteria(
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                MemberFilterCriteria.DEFAULT_PAGE,
+                MemberFilterCriteria.DEFAULT_PAGE_SIZE);
+    }
 }
diff --git a/src/test/java/org/patinanetwork/patchats/api/member/MemberServiceTest.java b/src/test/java/org/patinanetwork/patchats/api/member/MemberServiceTest.java
index e53c68a6..f14a39c9 100644
--- a/src/test/java/org/patinanetwork/patchats/api/member/MemberServiceTest.java
+++ b/src/test/java/org/patinanetwork/patchats/api/member/MemberServiceTest.java
@@ -10,11 +10,13 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
 import org.patinanetwork.patchats.api.member.db.models.Member;
+import org.patinanetwork.patchats.api.member.db.repos.MemberFilterCriteria;
 import org.patinanetwork.patchats.api.member.db.repos.MemberRepo;
 import org.patinanetwork.patchats.api.member.dto.CreateMemberRequest;
 import org.patinanetwork.patchats.api.member.dto.MemberDto;
@@ -143,7 +145,7 @@ void getMemberById_throwsExceptionWhenMemberNotFound() {
     }
 
     @Test
-    void updateMember_throwsExceptionWhenMemberNotFound() {
+    void updateMemberThrowsExceptionWhenMemberNotFound() {
         final UUID id = UUID.randomUUID();
         final UpdateMemberRequest request = MemberTestFixtures.UPDATE_REQUEST_ALL_FIELDS;
 
@@ -154,7 +156,7 @@ void updateMember_throwsExceptionWhenMemberNotFound() {
     }
 
     @Test
-    void updateMember_successWithOnlyNameField() {
+    void updateMemberSuccessWithOnlyNameField() {
         final UUID id = UUID.randomUUID();
         final UpdateMemberRequest request = new UpdateMemberRequest(
                 Optional.of("UpdatedFirstName"),
@@ -199,7 +201,7 @@ void updateMember_successWithOnlyNameField() {
     }
 
     @Test
-    void updateMember_successWithAllNullFields() {
+    void updateMemberSuccessWithAllNullFields() {
         final UUID id = UUID.randomUUID();
         final UpdateMemberRequest request = new UpdateMemberRequest(
                 Optional.empty(),
@@ -240,7 +242,7 @@ void updateMember_successWithAllNullFields() {
     }
 
     @Test
-    void updateMember_successWithAllFields() {
+    void updateMemberSuccessWithAllFields() {
         final UUID id = UUID.randomUUID();
         final UpdateMemberRequest request = MemberTestFixtures.UPDATE_REQUEST_ALL_FIELDS;
 
@@ -347,4 +349,75 @@ void updateMember_successWhenUpdatingWithSameEmail() {
         assertEquals("john@example.com", captured.getEmail());
         verify(memberRepo, never()).getMemberByEmail(any());
     }
+
+    @Test
+    void getMembers_returnsEveryMemberAsDto() {
+        final MemberFilterCriteria criteria = emptyCriteria();
+
+        final Member firstMember = Member.builder()
+                .id(UUID.randomUUID())
+                .firstName("John")
+                .lastName("Doe")
+                .email("john.doe@example.com")
+                .active(true)
+                .build();
+        final Member secondMember = Member.builder()
+                .id(UUID.randomUUID())
+                .firstName("Jane")
+                .lastName("Doe")
+                .email("jane.doe@example.com")
+                .active(false)
+                .build();
+        when(memberRepo.getMembersByFilters(criteria)).thenReturn(List.of(firstMember, secondMember));
+
+        final List<MemberDto> response = memberService.getMembersByFilters(criteria);
+
+        assertEquals(2, response.size());
+        assertEquals(firstMember.getId(), response.get(0).getId());
+        assertEquals("John", response.get(0).getFirstName());
+        assertEquals("Doe", response.get(0).getLastName());
+        assertEquals("jane.doe@example.com", response.get(1).getEmail());
+    }
+
+    @Test
+    void getMembersReturnsEveryMemberAsDto() {
+        final MemberFilterCriteria criteria = emptyCriteria();
+        final Member firstMember = Member.builder()
+                .id(UUID.randomUUID())
+                .firstName("John")
+                .lastName("Doe")
+                .email("john.doe@example.com")
+                .active(true)
+                .build();
+        final Member secondMember = Member.builder()
+                .id(UUID.randomUUID())
+                .firstName("Jane")
+                .lastName("Doe")
+                .email("jane.doe@example.com")
+                .active(false)
+                .build();
+        when(memberRepo.getMembersByFilters(criteria)).thenReturn(List.of(firstMember, secondMember));
+
+        final List<MemberDto> response = memberService.getMembersByFilters(criteria);
+
+        assertEquals(2, response.size());
+        assertEquals(firstMember.getId(), response.get(0).getId());
+        assertEquals("John", response.get(0).getFirstName());
+        assertEquals("Doe", response.get(0).getLastName());
+        assertEquals("jane.doe@example.com", response.get(1).getEmail());
+    }
+
+    private static MemberFilterCriteria emptyCriteria() {
+        return new MemberFilterCriteria(
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                MemberFilterCriteria.DEFAULT_PAGE,
+                MemberFilterCriteria.DEFAULT_PAGE_SIZE);
+    }
 }
diff --git a/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberFilterCriteriaTest.java b/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberFilterCriteriaTest.java
new file mode 100644
index 00000000..e812138a
--- /dev/null
+++ b/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberFilterCriteriaTest.java
@@ -0,0 +1,88 @@
+package org.patinanetwork.patchats.api.member.db.repos;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+
+class MemberFilterCriteriaTest {
+
+    @Test
+    void defaultCriteriaHasDefaultPagination() {
+        final MemberFilterCriteria criteria = MemberFilterCriteria.builder().build();
+
+        assertAll(
+                () -> assertEquals(MemberFilterCriteria.DEFAULT_PAGE, criteria.page()),
+                () -> assertEquals(MemberFilterCriteria.DEFAULT_PAGE_SIZE, criteria.pageSize()));
+    }
+
+    @Test
+    void criteriaWithoutFiltersHasExpectedValues() {
+        final MemberFilterCriteria criteria =
+                criteriaWithPagination(MemberFilterCriteria.DEFAULT_PAGE, MemberFilterCriteria.DEFAULT_PAGE_SIZE);
+
+        assertAll(
+                () -> assertTrue(criteria.firstName().isEmpty()),
+                () -> assertTrue(criteria.lastName().isEmpty()),
+                () -> assertTrue(criteria.email().isEmpty()),
+                () -> assertTrue(criteria.active().isEmpty()),
+                () -> assertTrue(criteria.matchPref().isEmpty()),
+                () -> assertTrue(criteria.industryPref().isEmpty()),
+                () -> assertTrue(criteria.rolePref().isEmpty()),
+                () -> assertTrue(criteria.topics().isEmpty()),
+                () -> assertEquals(MemberFilterCriteria.DEFAULT_PAGE, criteria.page()),
+                () -> assertEquals(MemberFilterCriteria.DEFAULT_PAGE_SIZE, criteria.pageSize()),
+                () -> assertEquals(0, criteria.offset()));
+    }
+
+    @Test
+    void calculatesOffsetFromPageAndPageSize() {
+        final MemberFilterCriteria criteria = new MemberFilterCriteria(
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                3,
+                20);
+
+        assertEquals(40, criteria.offset());
+    }
+
+    @Test
+    void rejectsPageSizeGreaterThanMaxPageSize() {
+        assertThrows(
+                IllegalArgumentException.class,
+                () -> criteriaWithPagination(
+                        MemberFilterCriteria.DEFAULT_PAGE, MemberFilterCriteria.MAX_PAGE_SIZE + 1));
+    }
+
+    @Test
+    void rejectsInvalidPagination() {
+        assertAll(
+                () -> assertThrows(
+                        IllegalArgumentException.class,
+                        () -> criteriaWithPagination(0, MemberFilterCriteria.DEFAULT_PAGE_SIZE)),
+                () -> assertThrows(IllegalArgumentException.class, () -> criteriaWithPagination(1, 0)));
+    }
+
+    private static MemberFilterCriteria criteriaWithPagination(int page, int pageSize) {
+        return new MemberFilterCriteria(
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                page,
+                pageSize);
+    }
+}
diff --git a/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepoTest.java b/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepoTest.java
index f40a80ea..3bd12d95 100644
--- a/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepoTest.java
+++ b/src/test/java/org/patinanetwork/patchats/api/member/db/repos/MemberSqlRepoTest.java
@@ -6,8 +6,11 @@
 import static org.mockito.Mockito.when;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.ArgumentMatchers;
 import org.patinanetwork.patchats.api.member.db.models.Member;
 import org.springframework.jdbc.core.RowMapper;
@@ -15,13 +18,12 @@
 
 class MemberSqlRepoTest {
 
-    private static final String GET_MEMBERS_SQL = "SELECT * FROM members ORDER BY created_at DESC, id";
-
     @Test
-    void getMembersReturnsRowsFromDatabase() {
+    void getMembersAllReturnsRowsFromDatabase() {
         final JdbcClient jdbc = mock(JdbcClient.class);
         final JdbcClient.StatementSpec statement = mock(JdbcClient.StatementSpec.class);
         final JdbcClient.MappedQuerySpec<Member> query = mock(JdbcClient.MappedQuerySpec.class);
+        final MemberFilterCriteria criteria = emptyCriteria();
         final Member member = Member.builder()
                 .id(UUID.randomUUID())
                 .firstName("Alex")
@@ -30,14 +32,125 @@ void getMembersReturnsRowsFromDatabase() {
                 .active(true)
                 .build();
 
-        when(jdbc.sql(GET_MEMBERS_SQL)).thenReturn(statement);
+        when(jdbc.sql(ArgumentMatchers.anyString())).thenReturn(statement);
+        when(statement.param(ArgumentMatchers.anyString(), ArgumentMatchers.any()))
+                .thenReturn(statement);
         when(statement.query(ArgumentMatchers.<RowMapper<Member>>any())).thenReturn(query);
         when(query.list()).thenReturn(List.of(member));
 
-        final List<Member> result = new MemberSqlRepo(jdbc).getMembers();
+        final List<Member> result = new MemberSqlRepo(jdbc).getMembersByFilters(criteria);
 
         assertEquals(List.of(member), result);
-        verify(jdbc).sql(GET_MEMBERS_SQL);
+        verify(jdbc).sql(ArgumentMatchers.anyString());
+        verify(statement).param("page_size", MemberFilterCriteria.DEFAULT_PAGE_SIZE);
+        verify(statement).param("offset", 0L);
+        verify(query).list();
+    }
+
+    @Test
+    void getMembersByFiltersAppliesEveryProvidedCriterion() {
+        final JdbcClient jdbc = mock(JdbcClient.class);
+        final JdbcClient.StatementSpec statement = mock(JdbcClient.StatementSpec.class);
+        final JdbcClient.MappedQuerySpec<Member> query = mock(JdbcClient.MappedQuerySpec.class);
+        final MemberFilterCriteria criteria = new MemberFilterCriteria(
+                Optional.of("Alex"),
+                Optional.of("Morgan"),
+                Optional.of("alex@example.com"),
+                Optional.of(true),
+                Optional.of("Peer"),
+                Optional.of("Technology"),
+                Optional.of("Engineering"),
+                Optional.of("Community"),
+                3,
+                20);
+
+        when(jdbc.sql(ArgumentMatchers.anyString())).thenReturn(statement);
+        when(statement.params(ArgumentMatchers.anyMap())).thenReturn(statement);
+        when(statement.param(ArgumentMatchers.anyString(), ArgumentMatchers.any()))
+                .thenReturn(statement);
+        when(statement.query(ArgumentMatchers.<RowMapper<Member>>any())).thenReturn(query);
+        when(query.list()).thenReturn(List.of());
+
+        final List<Member> result = new MemberSqlRepo(jdbc).getMembersByFilters(criteria);
+
+        assertEquals(List.of(), result);
+        verify(jdbc).sql(ArgumentMatchers.anyString());
+        verify(statement)
+                .params(Map.of(
+                        "first_name", "Alex",
+                        "last_name", "Morgan",
+                        "email", "alex@example.com",
+                        "active", true,
+                        "match_pref", "Peer",
+                        "industry_pref", "Technology",
+                        "role_pref", "Engineering",
+                        "topics", "Community"));
+        verify(statement).param("page_size", 20);
+        verify(statement).param("offset", 40L);
         verify(query).list();
     }
+
+    @Test
+    void getMembersByFiltersOnlyIncludesProvidedCriteriaInWhereClause() {
+        final JdbcClient jdbc = mock(JdbcClient.class);
+        final JdbcClient.StatementSpec statement = mock(JdbcClient.StatementSpec.class);
+        final JdbcClient.MappedQuerySpec<Member> query = mock(JdbcClient.MappedQuerySpec.class);
+        final MemberFilterCriteria criteria = new MemberFilterCriteria(
+                Optional.of("Alex"),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.of(true),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.of("Community"),
+                MemberFilterCriteria.DEFAULT_PAGE,
+                MemberFilterCriteria.DEFAULT_PAGE_SIZE);
+        final ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
+
+        when(jdbc.sql(ArgumentMatchers.anyString())).thenReturn(statement);
+        when(statement.params(ArgumentMatchers.anyMap())).thenReturn(statement);
+        when(statement.param(ArgumentMatchers.anyString(), ArgumentMatchers.any()))
+                .thenReturn(statement);
+        when(statement.query(ArgumentMatchers.<RowMapper<Member>>any())).thenReturn(query);
+        when(query.list()).thenReturn(List.of());
+
+        new MemberSqlRepo(jdbc).getMembersByFilters(criteria);
+
+        verify(jdbc).sql(sqlCaptor.capture());
+        assertEquals("""
+                SELECT
+                    *
+                FROM
+                    members
+                WHERE
+                    LOWER(first_name) = LOWER(:first_name)
+                AND
+                    active = :active
+                AND
+                    LOWER(topics) = LOWER(:topics)
+                ORDER BY
+                    created_at DESC,
+                    id
+                LIMIT
+                    :page_size
+                OFFSET
+                    :offset
+                """, sqlCaptor.getValue());
+        verify(statement).params(Map.of("first_name", "Alex", "active", true, "topics", "Community"));
+    }
+
+    private static MemberFilterCriteria emptyCriteria() {
+        return new MemberFilterCriteria(
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                Optional.empty(),
+                MemberFilterCriteria.DEFAULT_PAGE,
+                MemberFilterCriteria.DEFAULT_PAGE_SIZE);
+    }
 }