# Client shortlist (/templates/client-shortlist)

<div className="desk-hero">
<div className="desk-pitch">

<p className="desk-kicker">Client shortlist</p>

<h1>See the shortlist your client sees.</h1>

Open the live shortlist your client receives. See who is in the running, where each candidate stands, and the experience behind their profile.

<div className="desk-links">

[Try the sample desk](#try-the-sample-desk)

[Book your audit](https://www.kith.contact/audit)

</div>
</div>

<figure className="desk-review-art">
<img src="/templates/client-shortlist.webp" alt="The Kith ATS live shortlist for a sample role, with the hiring team, candidate names and stages." width="960" height="720" />
<figcaption>Relay Foundry · Sample live shortlist</figcaption>
</figure>
</div>

<section className="desk-demo">

## Try the sample desk [#try-the-sample-desk]

Relay Foundry is hiring a founding GTM engineer. Open Riley’s card to read their profile and experience, then choose **Back to shortlist** and open Sam’s. This is the client portal view from Kith ATS, populated with fictional people and a sample job.

<DeskPreview />

</section>

<section className="desk-audit">

## What makes it onto your shortlist? [#what-makes-it-onto-your-shortlist]

Bring a recent candidate introduction and the feedback it got. We’ll trace what the recruiter knew, what the client saw, and how the next interview got booked.

[Book your workflow audit](https://www.kith.contact/audit)

</section>

Explore the [presentation list block](/blocks/present-list).
## Build prompt
Build the live shortlist my client opens for one role. Show the hiring team and each candidate with their stage. Let the client open a candidate’s profile and go back to the shortlist.
Use the React source and fictional records at https://docs.kith.contact/templates/client-shortlist.md.
Build a working preview with sample data. Keep my changes local for now.
If you cannot fetch the page, ask me to paste its Markdown.
## React source
```tsx title="components/desks/ClientShortlist.tsx"
"use client";
import { useEffect, useSyncExternalStore } from "react";
import { ArrowLeft, ChevronRight } from "lucide-react";
import { Avatar, AvatarFallback } from "@epicbagel/saas-kit/primitives/avatar";
import { Badge } from "@epicbagel/saas-kit/primitives/badge";
import { BrandedPage } from "@epicbagel/saas-kit/primitives/branded-page";
import { Button } from "@epicbagel/saas-kit/primitives/button";
import { Heading } from "@epicbagel/saas-kit/primitives/heading";
import { Icon } from "@epicbagel/saas-kit/primitives/icon";
import { PersonAvatar } from "@epicbagel/saas-kit/primitives/person-avatar";
import { Stack } from "@epicbagel/saas-kit/primitives/stack";
import { Text } from "@epicbagel/saas-kit/primitives/text";
import { TooltipProvider } from "@epicbagel/saas-kit/primitives/tooltip";
import { CandidateInlineCard } from "@recruiteros/recruit-ui/recruit/candidate-inline-card";
import { CandidateSharedProfile } from "@recruiteros/recruit-ui/recruit/candidate-shared-profile";
import { ThemeModeSwitch } from "./PortalThemeSwitch";
import { candidates } from "@/lib/screeningDesk";

const data = {
  job: {
    title: "Founding GTM Engineer",
    companyName: "Relay Foundry",
    location: "London, UK",
  },
  brand: {
    name: "Relay Search",
    logoUrl: null,
    primaryLight: null,
    primaryDark: null,
  },
  team: [
    { name: "Jordan Mbeki", imageUrl: null },
    { name: "Casey Lane", imageUrl: null },
  ],
  candidates: candidates.slice(0, 3).map((person, index) => ({
    ...person,
    currentTitle: person.role,
    currentCompany: person.company,
    photoUrl: person.photo,
    stage: ["Shortlisted", "Screened", "Interviewing"][index],
  })),
};

const histories: Record<
  string,
  { startDate: string; summary: string; skills: string[] }
> = {
  riley: {
    startDate: "2023-01-01",
    summary:
      "Built Fieldnote’s outbound system from the first account list. Ran three campaigns with the founder, then shared research and copy with the first sales hire.",
    skills: ["Data enrichment", "Outbound operations", "SQL"],
  },
  sam: {
    startDate: "2022-09-01",
    summary:
      "Runs the weekly outbound review with two sellers at Meridian Works. Wrote the routing rules and reporting queries that show which booked meetings turn into qualified opportunities.",
    skills: ["Revenue operations", "CRM routing", "Reporting"],
  },
  alex: {
    startDate: "2024-03-01",
    summary:
      "Connects product activity to the sales queue at Aperture Robotics. Worked with sales to identify trial accounts that needed help and measured which interventions led to paid accounts.",
    skills: ["Product analytics", "Sales tooling", "Experiment design"],
  },
};

// The fixture supplies the public portal read. The list and detail use the same
// kit versions and component props as Kith ATS. Navigation stays inside the demo.
function subscribeToNavigation(notify: () => void) {
  window.addEventListener("hashchange", notify);
  return () => window.removeEventListener("hashchange", notify);
}

function openCandidate(id?: string) {
  window.location.hash = id ? "candidate-" + id : "shortlist";
}

export default function ClientShortlist() {
  const hash = useSyncExternalStore(
    subscribeToNavigation,
    () => location.hash,
    () => "",
  );
  const person = data.candidates.find((p) => hash === "#candidate-" + p.id);
  useEffect(() => {
    window.scrollTo(0, 0);
  }, [hash]);
  return (
    <TooltipProvider>
      {person ? <PublicProfile person={person} /> : <JobPortal />}
    </TooltipProvider>
  );
}

// CompanyLogo's fallback when the job has no recorded logo or website.
function CompanyLogo({ name }: { name: string }) {
  return (
    <Avatar size="md" shape="square" border className="bg-white grayscale">
      <AvatarFallback shape="square" textSize="micro">
        {name.trim()[0]?.toUpperCase()}
      </AvatarFallback>
    </Avatar>
  );
}

function PublicProfile({
  person,
}: {
  person: (typeof data.candidates)[number];
}) {
  const profile = histories[person.id]!;
  return (
    <BrandedPage
      brand={data.brand}
      headerTrailing={<ThemeModeSwitch />}
      actionBar={{
        actions: (
          <Button variant="quiet" onClick={() => openCandidate()}>
            <Icon icon={ArrowLeft} size="sm" /> Back to shortlist
          </Button>
        ),
      }}
    >
      <CandidateSharedProfile
        person={{
          name: person.name,
          avatar: (
            <PersonAvatar
              name={person.name}
              photoUrl={person.photoUrl}
              size={80}
              fallbackSize="xl"
            />
          ),
          title: person.currentTitle,
          company: person.currentCompany,
          location: person.location,
        }}
        fit={{
          roleTitle: data.job.title,
          evidence: [
            { text: person.signal, sentiment: "positive" },
            { text: person.gap, sentiment: "neutral" },
          ],
        }}
        summary={profile.summary}
        experience={[
          {
            title: person.currentTitle,
            company: person.currentCompany,
            current: true,
            startDate: profile.startDate,
            description: profile.summary,
          },
        ]}
        skills={profile.skills}
        credit={`Shared by ${data.brand.name} via Kith ATS`}
      />
    </BrandedPage>
  );
}

function JobPortal() {
  return (
    <BrandedPage
      brand={{
        name: data.brand?.name,
        logoUrl: data.brand?.logoUrl,
        logoAlt: data.brand?.name ?? "Agency",
      }}
      accent={{
        light: data.brand?.primaryLight,
        dark: data.brand?.primaryDark,
      }}
      headerTrailing={<ThemeModeSwitch />}
    >
      <Stack gap="lg">
        <Stack gap="sm">
          <Stack direction="horizontal" gap="sm" align="center">
            {data.job.companyName && (
              <CompanyLogo name={data.job.companyName} />
            )}
            <Stack gap="xs">
              <Heading level={1}>{data.job.title}</Heading>
              <Text tone="muted">
                {[data.job.companyName, data.job.location]
                  .filter(Boolean)
                  .join(" · ")}
              </Text>
            </Stack>
          </Stack>
          <Text size="sm" tone="muted">
            {data.candidates.length}{" "}
            {data.candidates.length === 1 ? "candidate" : "candidates"} ·
            Updated as your search progresses
          </Text>
        </Stack>
        {data.team.length > 0 && (
          <Stack gap="sm">
            <Heading level={3}>Your hiring team</Heading>
            <Stack direction="horizontal" gap="md" wrap>
              {data.team.map((member) => (
                <Stack
                  key={member.name}
                  direction="horizontal"
                  gap="sm"
                  align="center"
                >
                  <PersonAvatar
                    name={member.name}
                    photoUrl={member.imageUrl}
                    size={32}
                  />
                  <Text size="sm">{member.name}</Text>
                </Stack>
              ))}
            </Stack>
          </Stack>
        )}
        <Stack gap="sm">
          {data.candidates.map((candidate) => (
            <CandidateInlineCard
              key={candidate.id}
              // A short list the client reads card by card: the name as a
              // title, the employer never cut off, the chevron centred.
              nameSize="lg"
              headlineWrap
              actionsAlign="center"
              avatar={
                <PersonAvatar
                  name={candidate.name}
                  photoUrl={candidate.photoUrl}
                  size={40}
                />
              }
              name={candidate.name}
              headline={
                [candidate.currentTitle, candidate.currentCompany]
                  .filter(Boolean)
                  .join(" · ") || undefined
              }
              meta={
                <Stack
                  as="span"
                  direction="horizontal"
                  gap="sm"
                  align="center"
                  wrap
                >
                  <Badge as="span" variant="neutral">
                    {candidate.stage}
                  </Badge>
                  {candidate.location}
                </Stack>
              }
              actions={<Icon icon={ChevronRight} size="sm" />}
              onSelect={() => openCandidate(candidate.id)}
            />
          ))}
        </Stack>
        <Text size="sm" tone="muted">
          To discuss a candidate, reply to the recruiter who sent you this link.
        </Text>
      </Stack>
    </BrandedPage>
  );
}
```

```tsx title="components/desks/PortalThemeSwitch.tsx"
"use client";
import { useSyncExternalStore, type SVGProps } from "react";
import { cn } from "@epicbagel/saas-kit/lib/utils";

// Kith ATS’s ThemeModeSwitch (ui-kit 0.176.1), bound to the embedded document.
function subscribe(notify: () => void) {
  const observer = new MutationObserver(notify);
  observer.observe(document.documentElement, {
    attributes: true,
    attributeFilter: ["class"],
  });
  return () => observer.disconnect();
}

function SunIcon(props: SVGProps<SVGSVGElement>) {
  return (
    <svg
      viewBox="0 0 24 24"
      fill="none"
      stroke="currentColor"
      strokeWidth="2"
      aria-hidden="true"
      {...props}
    >
      <circle cx="12" cy="12" r="4.5" />
      <path
        d="M12 1.5v2.2M12 20.3v2.2M3.5 3.5l1.6 1.6M18.9 18.9l1.6 1.6M1.5 12h2.2M20.3 12h2.2M3.5 20.5l1.6-1.6M18.9 5.1l1.6-1.6"
        strokeLinecap="round"
      />
    </svg>
  );
}

function MoonIcon(props: SVGProps<SVGSVGElement>) {
  return (
    <svg
      viewBox="0 0 24 24"
      fill="none"
      stroke="currentColor"
      strokeWidth="2"
      aria-hidden="true"
      {...props}
    >
      <path
        d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8z"
        strokeLinejoin="round"
      />
    </svg>
  );
}

export function ThemeModeSwitch() {
  const isDark = useSyncExternalStore(
    subscribe,
    () => document.documentElement.classList.contains("dark"),
    () => false,
  );
  return (
    <button
      data-slot="theme-mode-switch"
      type="button"
      role="switch"
      aria-checked={isDark}
      aria-label={isDark ? "Switch to light mode" : "Switch to dark mode"}
      title={isDark ? "Light mode" : "Dark mode"}
      data-mode={isDark ? "dark" : "light"}
      onClick={() => document.documentElement.classList.toggle("dark", !isDark)}
      className={cn(
        "group inline-flex flex-none cursor-pointer border-0 bg-transparent p-0 focus-visible:outline-hidden",
      )}
    >
      <span className="relative flex h-[30px] w-14 items-center rounded-full border border-border bg-muted p-[3px] transition-colors duration-200 group-hover:border-foreground group-focus-visible:ring-2 group-focus-visible:ring-ring group-focus-visible:ring-offset-2 group-focus-visible:ring-offset-background">
        <span className="relative z-10 flex flex-1 items-center justify-center">
          <SunIcon
            className={cn(
              "size-[13px] transition-colors duration-200",
              isDark ? "text-muted-foreground" : "text-foreground",
            )}
          />
        </span>
        <span className="relative z-10 flex flex-1 items-center justify-center">
          <MoonIcon
            className={cn(
              "size-[13px] transition-colors duration-200",
              isDark ? "text-foreground" : "text-muted-foreground",
            )}
          />
        </span>
        <span
          aria-hidden="true"
          className={cn(
            "absolute left-1 top-[3px] z-0 size-[22px] rounded-full border border-border bg-background shadow-xs transition-transform duration-300 ease-out",
            isDark ? "translate-x-6" : "translate-x-0",
          )}
        />
      </span>
    </button>
  );
}
```

```ts title="lib/screeningDesk.ts"
export const candidates = [
  {
    id: "riley", grade: "A", name: "Riley Okafor", role: "GTM Engineer", company: "Fieldnote", location: "London, UK",
    photo: "/people/riley-okafor.jpg", colour: "teal", signal: "Built from zero", gap: "Campaign ownership",
    source: "Launch retrospective", quote: "Our first account list was a spreadsheet. I wrote the enrichment job, then sat with the founder for the first thirty emails.",
    evidence: "At Fieldnote, Riley turned the founders’ account list into a working outbound system. The launch write-up walks through a failed enrichment run and the fix. A sales hire joined six weeks later, which leaves one question about who kept the campaigns running.",
    question: "Which campaigns did you own after launch?", answer: "I ran the first three myself. After the sales hire started, we split research and copy, but I kept the weekly experiment log.",
  },
  {
    id: "sam", grade: "B", name: "Sam Lindqvist", role: "Revenue Operations Lead", company: "Meridian Works", location: "Manchester, UK",
    photo: "/people/sam-lindqvist.jpg", colour: "blue", signal: "Runs weekly experiments", gap: "Engineering depth",
    source: "Campaign teardown", quote: "Every Friday we killed one sequence and kept one. Looking at booked calls alone hid how many were the wrong accounts.",
    evidence: "Sam redesigned qualification around accepted meetings and ran the weekly outbound review with two sellers. The teardown credits an engineer for the CRM integration. Establish which changes Sam could ship alone at Relay.",
    question: "Which parts of the stack did you build yourself?", answer: "I wrote the routing rules and the reporting queries. Our engineer owned the integration and its retries.",
  },
  {
    id: "alex", grade: "B", name: "Alex Marchetti", role: "Growth Engineer", company: "Aperture Robotics", location: "Bristol, UK",
    photo: "/people/alex-marchetti.jpg", colour: "rust", signal: "Shipped growth tooling", gap: "Cold outbound",
    source: "Product experiment notes", quote: "We gave sales the five trial accounts that had hit the same setup error twice. That was a better conversation starter than a lead score.",
    evidence: "Alex connected product events to a seller’s queue and tracked which interventions converted trials. The examples start with people already using the product. Relay needs someone who can also find buyers before they sign up.",
    question: "How have you reached customers who had never used the product?", answer: "My experiments started with trial accounts. I have a cold-account hypothesis, but I haven’t run that campaign yet.",
  },
  {
    id: "kit", grade: "A", name: "Kit Silva", role: "Revenue Engineer", company: "Paper Kite Studio", location: "London, UK",
    colour: "blue", signal: "Opened a new market", gap: "Writing the approach",
    source: "Market launch notebook", quote: "The best signal was a local operations hire. It told us the expansion budget was already signed.",
    evidence: "Kit built a research feed from hiring signals and tested it across two markets. The notebook ties booked meetings back to the signal. An agency wrote the sequences, so ask how Kit would approach the first buyer directly.",
    question: "How did you choose accounts for the first market?", answer: "I started with companies hiring locally and compared their reply rates with our existing territory list.",
  },
  {
    id: "lee", grade: "C", name: "Lee Morgan", role: "Growth Lead", company: "Northline", location: "Leeds, UK",
    colour: "rust", signal: "Tested new channels", gap: "Recent hands-on work",
    source: "Founder debrief", quote: "The small roundtable beat our biggest email send. Four buyers described the same problem in their own words.",
    evidence: "Lee built Northline’s first channel plan and hired its growth analyst. The founder credits Lee with spotting a better segment after a series of buyer interviews. The latest campaign reports name the analyst as their author.",
    question: "Which experiments did you run personally?", answer: "I ran the roundtable and did the interviews. Our analyst built the lists and ran the follow-up sequences.",
  },
  {
    id: "noor", grade: "D", name: "Noor Bell", role: "Systems Engineer", company: "Arc Instruments", location: "Cambridge, UK",
    colour: "teal", signal: "Built seller tooling", gap: "Buyer conversations",
    source: "Routing project notes", quote: "The rep wanted to know why an account reached the queue. We put the source event next to every name.",
    evidence: "Noor built enrichment and routing for Arc’s first two sellers. The project notes trace a signal from ingestion to rep action. They say little about Noor’s own contact with buyers, a regular part of Relay’s founding role.",
    question: "What changed for the reps who used your routing tool?", answer: "They could see why an account was ready and tailor the message. The reps still owned the conversations.",
  },
];

export type View = "Longlist" | "Screening";
type Stage = "Longlisted" | "Queued" | "Contacted" | "Replied" | "Screened" | "Passed";
export type Review = { stage: Stage; question: string; outcome: string; reason?: string };
export type Desk = { view: View; selected: string; notes: string[]; reviews: Record<string, Review> };
export const STORAGE_KEY = "kith.sourcing-screening-desk.v1";

export function freshDesk(): Desk {
  return {
    view: "Longlist",
    selected: candidates[0]!.id,
    notes: [],
    reviews: Object.fromEntries(candidates.map(person => [
      person.id, { stage: person.id === "sam" ? "Queued" : "Longlisted", question: person.question, outcome: "" },
    ])),
  };
}

export function readDesk(saved: string | null): Desk {
  const desk = freshDesk();
  if (!saved) return desk;
  try {
    const value = JSON.parse(saved);
    for (const { id } of candidates) {
      const review = value?.reviews?.[id];
      if (review && ["Longlisted", "Queued", "Contacted", "Replied", "Screened", "Passed"].includes(review.stage) &&
          typeof review.question === "string" && typeof review.outcome === "string") {
        desk.reviews[id] = { stage: review.stage, question: review.question, outcome: review.outcome,
          ...(typeof review.reason === "string" && { reason: review.reason }) };
      }
    }
    if (Array.isArray(value?.notes)) desk.notes = value.notes.filter((note: unknown) => typeof note === "string");
    if (value?.view === "Screening") desk.view = "Screening";
    if (candidates.some(person => person.id === value?.selected)) desk.selected = value.selected;
  } catch { /* An unreadable demo starts with the fictional records. */ }
  return desk;
}
```