# Source to screen (/templates/sourcing-and-screening)

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

<p className="desk-kicker">Source to screen</p>

<h1>Know why you’re calling.</h1>

A profile got your attention. What do you still need to find out? The sourcing and screening desk keeps the evidence, your question and the candidate’s answer together, from longlist review through the first call.

<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/sourcing-screening.webp" alt="The sample job in Recruit’s job layout, with the current brief, Source and Screen tabs, and a searchable, graded candidate queue." width="1748" height="1478" />
<figcaption>Relay Foundry · Sample sourcing desk</figcaption>
</figure>
</div>

<div className="desk-story">
<div>

## Give the first call a starting point [#give-the-first-call-a-starting-point]

Riley built the outbound system at Fieldnote. Then a sales hire joined. The launch write-up tells you what Riley shipped, but who actually ran the campaigns?

In **Source**, leave that question with your decision. Choose **Yes** and the recruiter opening **Screen** sees exactly what to ask. The sample transcript gives them an answer they can bring back to the shortlist.

</div>
<figure className="desk-screen-art">
<img src="/templates/riley-screen.webp" alt="Riley’s call card carries the question “Which campaigns did you own after launch?” into screening." width="755" height="381" />
<blockquote>“I ran the first three myself. After the sales hire started, we split research and copy, but I kept the weekly experiment log.”</blockquote>
<figcaption>Riley Okafor · Sample call transcript</figcaption>
</figure>
</div>

<section className="desk-demo">

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

You’re hiring a founding GTM engineer for Relay Foundry. Read the brief, then pick someone from the Source queue, send them to screening, then open their sample transcript. Save what you learned and check their review card again. All six candidates are fictional. Changes stay in this tab.

<DeskPreview />

</section>

<section className="desk-audit">

## Where does your handoff break down? [#where-does-your-handoff-break-down]

Bring a longlist and the notes your team uses on a first call. In a workflow audit, we’ll trace one candidate through both and map out what your own desk should carry forward.

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

</section>

Built from the [longlist review](/blocks/longlist-review), [screening list](/blocks/screen-list) and [call list](/blocks/call-list) blocks.
## Build prompt
Build my sourcing and screening desk for one role. Let me read the brief, say Yes or No on each sourced candidate and leave a question for the first call. Then let me work the screening queue: open a call, save what I learned and see the outcome on the candidate’s review card.
Use the React source and fictional records at https://docs.kith.contact/templates/sourcing-and-screening.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/ScreeningDesk.tsx"
"use client";

import { useEffect, useState } from "react";
import { Badge } from "@epicbagel/saas-kit/primitives/badge";
import { Button } from "@epicbagel/saas-kit/primitives/button";
import { CallCard } from "@epicbagel/saas-kit/primitives/call-card";
import { CountBadge } from "@epicbagel/saas-kit/primitives/count-badge";
import { Callout } from "@epicbagel/saas-kit/primitives/callout";
import { Eyebrow } from "@epicbagel/saas-kit/primitives/eyebrow";
import { PageHeader } from "@epicbagel/saas-kit/primitives/page-header";
import { StatusBadge } from "@epicbagel/saas-kit/primitives/status-badge";
import { CandidateCardList } from "@recruiteros/recruit-ui/recruit/candidate-card-list";
import { JobBriefCard, jobBriefView } from "@recruiteros/recruit-ui/recruit/job-brief-card";
import { PageTabs } from "@epicbagel/saas-kit/primitives/page-tabs";
import { PersonAvatar } from "@epicbagel/saas-kit/primitives/person-avatar";
import { Textarea } from "@epicbagel/saas-kit/primitives/textarea";
import { TooltipProvider } from "@epicbagel/saas-kit/primitives/tooltip";
import { CandidateClientDecision } from "@recruiteros/recruit-ui/recruit/candidate-client-decision";
import { CandidateQuote } from "@recruiteros/recruit-ui/recruit/candidate-quote";
import { CandidateReviewCard } from "@recruiteros/recruit-ui/recruit/candidate-review-card";
import { CandidateStageActions } from "@recruiteros/recruit-ui/recruit/candidate-stage-actions";
import { candidates, freshDesk, readDesk, STORAGE_KEY, type Desk, type Review, type View } from "@/lib/screeningDesk";

const job = {
  roleTitle: "Founding GTM Engineer", companyName: "Relay Foundry", location: "London, UK · Hybrid",
  roleDescription: "Own the first outbound campaigns alongside the founders. Build the account lists and enrichment tools, write the approach, and use weekly experiments to learn which buyers respond.",
  salaryMin: 90000, salaryMax: 110000, currency: "GBP",
  mustHaves: ["Built outbound from scratch", "Writes and maintains enrichment tools", "Owns campaigns after launch"],
  niceToHaves: ["Has sold to engineering teams"], redFlags: ["All execution was outsourced"],
};
const grades = ["A", "B", "C", "D"];
const stages = ["Queued", "Contacted", "Replied", "Screened"];
const reviewOptions = [{ value: "pending", label: "To review" }, { value: "reviewed", label: "Reviewed" }];
type Person = typeof candidates[number];
type Update = (id: string, patch: Partial<Review>, view?: View) => void;

function isInScreen(review: Review) {
  return review.stage !== "Longlisted" && review.stage !== "Passed";
}

function ReviewCard({ person, review, update, source }: { person: Person; review: Review; update: Update; source: boolean }) {
  const passed = review.stage === "Passed";
  const inQueue = isInScreen(review);
  return <CandidateReviewCard data-candidate={person.id} name={person.name} headline={person.role} coverSize="compact"
    cover={<div className={`desk-cover cover-${person.colour}`}><span>{person.company}</span></div>}
    avatar={<PersonAvatar name={person.name} photoUrl={person.photo} size={48} decorative />}
    beforeFacts={source && <div className="space-y-3 px-6 pb-5">
      <div className="flex flex-wrap gap-2"><Badge variant="success">{person.signal}</Badge><Badge variant="warning">{person.gap}</Badge></div>
      <CandidateQuote attribution={person.source}>{person.quote}</CandidateQuote>
    </div>}
    facts={[{ label: "Company", value: person.company }, { label: "Grade", value: person.grade }, { label: "Location", value: person.location }, { label: "Stage", value: review.stage }]}
    insight={{ label: "Why", value: person.evidence }}
    actions={source ? <>
      {review.stage === "Screened" && <p className="px-6 py-3"><strong>Screening outcome</strong><br />{review.outcome}</p>}
      <details className="border-t px-6 py-3 text-sm"><summary className="cursor-pointer">Question for the screen</summary>
        <Textarea className="mt-2" aria-label={`Screening question for ${person.name}`} value={review.question} onChange={e => update(person.id, { question: e.target.value })} />
      </details>
      <CandidateClientDecision candidateName={person.name} decision={passed ? "no" : inQueue ? "yes" : undefined}
        reason={review.reason} reasonOptional suggestions={{ yes: [person.signal], no: [person.gap] }}
        labels={{ confirmYes: "Send to screening", confirmNo: "Pass for this role" }}
        onDecide={async (choice, reason) => update(person.id, {
          stage: choice === "no" ? "Passed" : inQueue ? review.stage : "Queued", reason,
        }, choice === "yes" ? "Screening" : undefined)} />
      {inQueue && <div className="px-6 pb-3"><Button size="sm" variant="outline" onClick={() => update(person.id, {}, "Screening")}>Open screen</Button></div>}
      {passed && <div className="px-6 pb-3"><Button size="sm" variant="outline" onClick={() => update(person.id, { stage: "Longlisted", reason: undefined })}>Return to review</Button></div>}
    </> : <div className="border-t p-4"><ScreenCard person={person} review={review} update={update} /></div>} />;
}

function ScreenCard({ person, review, update }: { person: Person; review: Review; update: Update }) {
  const nextStage = review.stage === "Queued" ? "Contacted" : review.stage === "Contacted" ? "Replied" : undefined;
  return <div className="space-y-4">
    <CallCard title={`Screening call with ${person.name}`} source={review.stage}
      participants={[{ name: person.name, avatarUrl: person.photo }, { name: "Jordan Mbeki", avatarUrl: "/people/jordan-mbeki.jpg" }]}
      segments={[{ speaker: "Jordan Mbeki", text: person.question }, { speaker: person.name, text: person.answer }]}
      summary={<><strong>Question for the screen</strong><br />{review.question || "No question added."}
        {review.reason && <><br />Reason for screening: {review.reason}</>}</>} />
    <label className="block space-y-2"><span className="text-sm font-medium">Screening outcome</span>
      <Textarea value={review.outcome} placeholder="What did you learn on the call?" onChange={e => update(person.id, { outcome: e.target.value })} />
    </label>
    <div className="flex flex-wrap gap-2">
      {nextStage && <CandidateStageActions advance={{ label: nextStage === "Contacted" ? "Mark contacted" : "Mark replied",
        outline: true, onAdvance: () => update(person.id, { stage: nextStage }) }} />}
      {review.stage === "Screened" ?
        <Button variant="outline" onClick={() => update(person.id, {}, "Longlist")}>View in Source</Button> :
        <Button disabled={!review.outcome.trim()} onClick={() => update(person.id, { stage: "Screened" })}>Mark screened</Button>}
    </div>
  </div>;
}

export function ScreeningDesk() {
  const [desk, setDesk] = useState<Desk | null>(null);
  const [search, setSearch] = useState("");
  const [filters, setFilters] = useState<Record<string, unknown>>({ review: "pending" });
  const [jump, setJump] = useState<string | null>(null);
  const [lastPassed, setLastPassed] = useState<string | null>(null);
  useEffect(() => {
    if (!jump) return;
    const card = document.getElementById(`demo-person-${jump}`);
    card?.focus({ preventScroll: true });
    card?.scrollIntoView({ block: "start" });
    setJump(null);
  }, [jump]);
  useEffect(() => {
    let saved: string | null = null;
    try { saved = sessionStorage.getItem(STORAGE_KEY); } catch { /* Use in-memory records. */ }
    const restored = readDesk(saved);
    setDesk(restored);
    setFilters(restored.view === "Longlist" ? {
      review: restored.reviews[restored.selected]?.stage === "Longlisted" ? "pending" : "reviewed",
    } : {});
  }, []);
  useEffect(() => {
    if (desk) try { sessionStorage.setItem(STORAGE_KEY, JSON.stringify(desk)); } catch { /* Keep working in memory. */ }
  }, [desk]);
  if (!desk) return <p role="status">Loading sample candidates…</p>;
  const source = desk.view === "Longlist";
  const queue = candidates.filter(person => isInScreen(desk.reviews[person.id]!));
  const toReview = candidates.filter(person => desk.reviews[person.id]!.stage === "Longlisted").length;
  const openView = (view: View, id?: string) => {
    setSearch("");
    setLastPassed(null);
    setFilters(view === "Longlist" ? { review: id ? "reviewed" : "pending" } : {});
    setDesk(current => current && ({ ...current, view, selected: id ?? current.selected }));
    if (id) setJump(id);
  };
  const update: Update = (id, patch, view) => {
    setDesk(current => current && ({
      ...current, selected: id, reviews: { ...current.reviews, [id]: { ...current.reviews[id]!, ...patch } },
    }));
    if (patch.stage) setLastPassed(patch.stage === "Passed" ? id : null);
    if (view) openView(view, id);
  };
  const filterField = source ? "grade" : "stage";
  const choices = source ? grades : stages;
  const passedPerson = candidates.find(person => person.id === lastPassed);
  return <TooltipProvider><section aria-label="Job workflow" data-theme="minimal" className="mx-auto w-full max-w-5xl space-y-5">
    <PageHeader title={job.roleTitle} description={job.location} actionsLayout="responsive" spacing="none">
      <Button size="sm" variant="ghost" onClick={() => {
        if (window.confirm("Reset the sample candidates and their decisions?")) {
          setDesk(freshDesk()); setSearch(""); setFilters({ review: "pending" }); setLastPassed(null);
          window.scrollTo(0, 0);
        }
      }}>Reset demo</Button>
    </PageHeader>
    <Callout padding="compact">
      <div className="flex flex-wrap items-center gap-2"><Eyebrow>Kith</Eyebrow>
        <StatusBadge tone={toReview ? "info" : "success"}>{toReview ? "Ready to review" : "Review complete"}</StatusBadge>
        <span className="text-sm">Who built the outbound system and kept running campaigns after launch?</span>
      </div>
    </Callout>
    <JobBriefCard {...jobBriefView(job, { title: "role" })} presentation="preview" version={{ number: 1, current: true }} />
    <PageTabs<View> ariaLabel="Job sections" layout="scroll" value={desk.view}
      items={[{ value: "Longlist", label: "Source", badge: toReview ? <CountBadge value={toReview} /> : undefined },
        { value: "Screening", label: "Screen" }]} onValueChange={view => openView(view)} />
    {source && passedPerson && <div role="status" className="flex flex-wrap items-center gap-3 text-sm">
      Passed on {passedPerson.name}.
      <Button size="sm" variant="outline" onClick={() => update(passedPerson.id, { stage: "Longlisted", reason: undefined })}>Return to review</Button>
    </div>}
    <CandidateCardList<Person> key={desk.view} title={source ? "Sourced candidates" : "Screening queue"}
      columnsViewId="sample-job-candidate-grid" getItemKey={person => person.id}
      scrollNavigation={{ label: source ? "Browse sourced candidates" : "Browse screening candidates",
        getItem: person => ({ label: person.name, imageSrc: person.photo }) }}
      data={source ? candidates : queue} loading={false} error={null} refetch={() => {}}
      searchTerm={search} onSearchChange={setSearch} searchPlaceholder="Search name, company, role…"
      searchPredicate={(person, query) => [person.name, person.company, person.role].join(" ").toLowerCase().includes(query.toLowerCase())}
      filters={filters} onFiltersChange={setFilters} showFilters quickFiltersShowLabel={false}
      filterSchema={[
        ...(source ? [{ id: "review", type: "enum" as const, label: "Review status", field: "review", options: reviewOptions }] : []),
        { id: filterField, type: "enum", label: source ? "Grade" : "Stage", field: filterField,
          options: choices.map(value => ({ value, label: value })) },
      ]}
      quickFilters={[{ id: "all", label: "All", group: filterField, filters: {} },
        ...choices.map(value => ({ id: value, label: value, group: filterField, filters: { [filterField]: value } }))]}
      filterPredicate={(person, active) => {
        const stage = desk.reviews[person.id]!.stage;
        if (source && active.review && active.review !== (stage === "Longlisted" ? "pending" : "reviewed")) return false;
        return !active[filterField] || active[filterField] === (source ? person.grade : stage);
      }}
      renderEmpty={() => <p role="status">No candidates in this view.</p>}
      renderItem={person => <div id={`demo-person-${person.id}`} tabIndex={-1}>
        <ReviewCard person={person} review={desk.reviews[person.id]!} update={update} source={source} />
      </div>} />
  </section></TooltipProvider>;
}
```

```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;
}
```