The Project Repository

1. Define the qualifying event: which transition fires the flow (form submit, MQL, signup) — never 'any edit'
2. Create the intake webhook carrying only the record ID; rehydrate everything else via CRM lookups
3. Run the free layer first: lookups against data you hold, formulas for normalization and disqualification
4. Add the person waterfall (email finders + one validator) and the company enrichment, all run-condition gated
5. Write back under a field contract: fill-blanks-only, source stamps, dedicated fields for discovered data
6. Pilot 20 rows; measure per-field match rate and cost per record; then open the volume

Pattern proven at a network-security vendor (88-column production build).

1. Define fit: 4–6 weighted firmographic criteria on a worksheet (weights sum to 100)
2. Define intent: the 3–5 signals you actually collect, each weighted with a decay window
3. Build both scores as formula columns over enriched fields — free math on paid data
4. Combine into tiers with sub-scores visible; never hide the components
5. Backtest against 10 recent wins and 10 losses; tune weights until winners score high
6. Write tier + components to the CRM; sanity-check tier sizes monthly

The explainability rule comes from real rep-adoption failures.

1. Pick the routing model your org runs: round-robin, territory, or ICP-based
2. Build owner assignment with active/inactive rotation (vacations shouldn't need a rebuild)
3. Compose the Slack alert payload: who, company, tier, why-routed, one-click links
4. Add the SLA ladder: what fires at 1 hour, 1 day, 3 days unworked
5. Test end to end: a form-fill lands routed, alerted, CRM-complete, zero manual touches

The alert-with-context format is what makes reps actually act.

1. Set the trigger tight: usage/spend threshold + activation — not every signup (this is a 10–40× cost lever)
2. Build the de-anonymization waterfall: free CRM/LinkedIn tier first, then person-resolution providers in cost order
3. Add the rejected-candidate accumulator so failed candidates never re-validate downstream
4. Write the discovered work email to a DEDICATED field — the signup identity stays untouched
5. Dedupe at company level before routing; one company = one sales motion
6. Route qualified accounts to sales with usage context attached

Pattern proven at a GenAI consumer platform (40× volume reduction via trigger design).

1. Import via CSV or CRM filter; map inputs immediately
2. Normalize on entry: domain, full name, title (the standard preamble columns)
3. Dedupe on domain+person key BEFORE any paid column exists
4. Look up what the CRM already knows; enrich ONLY the gaps, run-condition gated
5. Estimate with the calculator, test 20 rows, then run within budget
6. Write back fill-blanks-only with stamps — or export CSV through your routing layer

The first project most students should ship — week one material.

1. Build a master template table; color-code the input columns a non-technical operator pastes into
2. Normalize: derive names, AI-normalize job titles, stamp lead source at intake (attribution captured at entry)
3. Resolve company name → domain FIRST; the domain is your dedupe key against the CRM (net-new vs existing)
4. Run the validated email waterfall; add an aggregate override column so found-but-unvalidated addresses aren't silently lost
5. Export through your existing dedupe/routing layer with campaign membership attached
6. Duplicate the template per event; record a walkthrough so anyone can run the next one

Proven pattern — handed to a client's coordinator who ran it solo.

1. Source the list: TAM segment, signal output, or an imported slice — normalized and deduped
2. Enrich through your waterfall Function (one standard, reused, not rebuilt)
3. Build the quality gate segment: verified email + first name + a reason-to-reach-out present
4. Personalize with a base-prompt AI column: 1–2 data points max, schema'd output
5. Run the human review loop; track edit rate (>30% = fix prompt) and skip rate (>10% = fix targeting)
6. Push gated records to the sequencer; wire reply-handling (positive → CRM task, negative → suppress)

The review-loop metrics are the difference between scale and spam.

1. Pick ONE signal to start (job change converts best in B2B); define lookback + recurrence
2. Build the monitoring population: the accounts/people worth watching, deduped
3. On fire: enrich and fit-check the triggered record BEFORE anyone gets excited
4. Compose the play: alert with evidence → contact created → routed to sequence with the trigger as the angle
5. Track conversions per signal monthly; add signal #2 only after #1 pays

Ten-workbook version proven at a network-security vendor.

1. Connect the CRM to an Audience; verify field mapping on 20 records
2. Layer signals onto the audience population, each writing to its own column
3. Build action segments: signal + fit + quality conditions (GATE- prefix conventions)
4. Wire per-segment routing: enrich → alert owner → feed the sequence table
5. Set frequency caps and exclusions FIRST (customers, open opps) — before anything fires
6. Review weekly: which segments produced meetings; retire the ones that don't

The exclusions-first rule exists because someone once emailed current customers.

1. Install the intent pixel; group pages by intent level (pricing/high, docs/medium, blog/low)
2. Filter the noise first: bots, internal IPs, existing customers, open opps
3. Validate match rate for a week (20–40% of sessions is normal) before building plays on it
4. High-intent visit → company enriched → fit-checked → owner alerted with pages-viewed context
5. Feed qualified accounts into the outbound engine with the visit as the angle — speed matters; intent decays in days

Configured in production for a commercial EV manufacturer.

1. Build the monitoring list: closed-won contacts + past champions from the last 3 years, deduped
2. Configure the job-change signal (60–90 day lookback, weekly recurrence)
3. On fire: enrich the NEW company and fit-check it before celebrating
4. Alert the owning rep: who moved, where, the old relationship, the fit score
5. Create the linked contact preserving history; hand to outreach with the 'old friend' angle
6. Sibling play: 'previous customers now at new companies' as a quarterly win-back list

The highest-converting play in B2B — and the easiest signal to start with.

1. Point an AI research column at the competitor's customers/case-studies page; extract company names with a schema
2. Resolve names → domains (free lookups first, AI fallback)
3. Enrich decision-makers by title through the waterfall Function
4. Score against your ICP; tag provenance ('competitor-X customer') for the messaging angle
5. Feed the outbound engine with a displacement sequence

Twenty minutes of setup, weirdly satisfying, endlessly repeatable.

1. Trigger on meeting-booked (webhook from the CRM/calendar)
2. Enrich the account + attendee: firmographics, recent news via a research agent with source rules
3. Compose the brief with a content AI column (your key, your template): snapshot, signals, three talking points
4. Deliver where reps live: Slack DM or CRM note, 30+ minutes before the call
5. Rep-facing variant: expose the same motion through Clay MCP so reps ask their AI assistant on demand

The project that makes leadership SEE Clay working.

1. Build the taxonomy WITH your revenue team first — garbage taxonomy in, garbage classification out
2. Write the schema-constrained classifier (enum of allowed values, evidence quote, empty-on-uncertain)
3. Gate with free deterministic signals first (keywords, suffixes, TLDs); AI runs only on the remainder
4. Batch in chunks sized to budget; verify a sample per vertical before trusting any of it
5. Write to dedicated CRM fields; keep the classifier as a Function for new records forever

144-pair taxonomy version proven at a call-analytics SaaS.

1. Pull closed-lost opps with notes via the CRM integration
2. Define 6–10 canonical loss categories with sales leadership
3. Classify with a schema'd AI column: category + evidence quote + empty-on-uncertain
4. Human-verify a stratified sample before trusting the distribution
5. Write back to dedicated fields; build the loss-pattern view by segment/quarter/rep

Eight-category version proven at a network-security vendor.

1. Translate the ICP into filters (or describe it to Sculptor); refine in draft mode — drafts are free
2. Commit; dedupe on LinkedIn URL as the primary key
3. Enrich via gap segments only; score fit; assign tiers
4. Stage sourced records in their own lifecycle stage — never pollute pipeline metrics
5. Keep the filter live as a self-updating segment; for public-registry markets, add change-detection alerts on NEW entries

Registry-driven version proven for an APAC infrastructure contractor.

1. Define the committee personas: titles, seniority, certs per role
2. For each named account, run persona-filtered people-finding
3. Enrich + validate contacts through the waterfall Function
4. Classify each into a committee role (free title logic first, AI fallback)
5. Write back with associations + role fields; alert owners on gaps ('no economic buyer found at X')

Committee pattern proven at enterprise fleet/dealer accounts.

1. Build gap segments per field family ('Prospect AND Industry is blank')
2. Wire enrichment to the SEGMENTS — only gaps ever get bought
3. Set refresh cadences: contacts quarterly, firmographics monthly
4. Stamp every processed record: status + date — the engine's heartbeat
5. Monthly: review the disagreement rate between refreshed and existing values as a finding

The always-on answer to a whole class of recurring hygiene tickets.

1. Webhook-trigger validation on new/changed contacts
2. Route failures into a re-find waterfall; re-validate recoveries before write-back
3. Stamp validation status + date on every record
4. Schedule a recurring pass over the active database (quarterly)
5. Report the save rate: addresses recovered vs written off

Live in production at two clients as permanent infrastructure.

1. Normalize domains across the base; domain is the merge key
2. Find duplicates by domain + fuzzy-name; queue merges with evidence, human-approved
3. For orphaned contacts: resolve employer via enrichment; match to accounts through the ladder (ID → domain → name)
4. Create missing associations in batches; stamp what was repaired and how
5. Leave the pipeline standing — new orphans route through it automatically

Association-repair pattern live at a commercial EV manufacturer.

1. Map the source of truth for your 10 key fields: warehouse vs CRM vs enrichment
2. Create a least-privilege service account (data viewer + job user, nothing more)
3. Connect the warehouse source; validate with a 100-row pull
4. Feed usage/billing signals into scoring columns and audience segments
5. Route threshold-crossers into the PQL play (see De-Anonymization project)

BigQuery pattern proven at a GenAI consumer platform.

1. Build the EXCLUSION segment first: customers, open opps, partners, DQ — applied across every campaign
2. Build target segments from ICP fit + intent conditions
3. Seed lookalikes from closed-won accounts, not raw traffic
4. Configure the daily sync; platforms need ~48h to process before judging
5. Monitor match rates (LinkedIn 90–95% target); refresh seeds quarterly

Scoped in production for a commercial EV manufacturer; Clay's benchmark: $250→$25 CPL.

1. Connect the CRM to an Audience; test field mapping on 20 records
2. Define gap segments per field family; enrichment fires ONLY on gaps
3. Enable continuous enrichment for new records; schedule refresh for existing
4. Set the write-back window and fill-blanks-only rules
5. Watch spend weekly for the first month; then monthly

This single project retires a whole category of recurring tickets.

1. Segment the base: active customers, trials, churned, past champions
2. Enrich for expansion signals: headcount growth, funding, new departments, tech changes
3. Run 'previous customers at new companies' via the job-change signal
4. Score expansion-readiness; route to CS or sales by play
5. Refresh quarterly as a standing segment set, not a one-off list

Win-back lists proven for an enterprise marketing team.

1. Decide the split: Clay owns enrichment/scoring/CRM; n8n owns cross-app steps and complex scheduling
2. n8n → Clay: n8n posts records to a Clay intake webhook (ID-thin payloads)
3. Clay → n8n: an HTTP/webhook column pushes finished rows into an n8n workflow
4. Build one real play across the pair (e.g., enriched signal → n8n → Slack approval → CRM + calendar + doc)
5. Log every handoff with stamps so a failed run is debuggable from either side

The pattern for everything Clay can't natively reach.

1. Create the campaign object: type, channel, motion, owner, spend, dates
2. Define one member-status ladder per channel so progression is comparable
3. Lock the UTM/source taxonomy that survives the handoff between systems
4. Configure first/last/multi-touch influence on the same opportunity
5. Wire routing SLA; build the scorecard: cost per opp, velocity, pipeline per campaign
6. Monthly read: what to kill, what to scale, what to run next — evidence, not instinct

The six-part telemetry spec — the difference between marketing and measured marketing.