Most B2B companies waste half their paid ad budget showing ads to the wrong people like existing customers, open opportunities, or agencies who can’t buy.

Every marketer knows to exclude these groups. The execution is where things fall apart. Manually uploading exclusion lists to LinkedIn and Meta takes hours, and those lists go stale in days. By the time you export a fresh CSV from Salesforce, new customers have signed up and old opportunities have closed. So you pull the list again, clean it up, re-upload it, and hope nothing changed while you were doing that. It’s a bad use of your time, and it’s a bad use of your ops team’s time.

At Clay, we built our Ads feature to give marketing teams direct control over who sees their ads, pulling from CRM data, buying signals, and enrichment to build audiences that stay accurate without manual work.

We use this feature extensively internally! We sync continuously from Salesforce to both LinkedIn and Meta to maintain fresh exclusion lists, build retargeting audiences from first-party data, and create lookalike campaigns — all without manual CSV uploads.

Our cost-per-lead has dropped from $250 to $25 on LinkedIn. We even went from not being able to effectively target on Meta to getting a $10 CPL on Facebook.

Here’s what we built and how other teams can do the same.

Subscribe now

The problem: stale data kills ad performance

Before automation, Clay’s paid strategy had three issues most B2B teams will recognize.

• We wasted budget on people we couldn’t sell to. Existing customers, active opportunities, and agency partners clicked on Clay’s ads every day, burning budget on people who would never convert.

• Manual audience uploads became stale immediately. Exporting lists from Salesforce and uploading them as exclusions works, but only for about 48 hours. Then new customers sign up, opportunities move through stages, and your exclusion list is outdated. “You’d have to keep uploading exclusion lists and then removing them from the previous campaign, adding the new one,” says Talia Schliefer, on the demand generation team at Clay. “They become stale so fast.”

• Meta was unusable due to low match rates. Most B2B marketers struggle with Meta’s ad platform because their CRM data uses work emails, which Meta can’t match to personal profiles. The typical match rate is around 30%. This meant Clay was essentially locked out of Facebook and Instagram, where prospects spend significantly more time than on LinkedIn.

Three automated audience plays that work

Clay built three core workflows that run continuously, syncing fresh data from Salesforce to both LinkedIn and Meta.

1. Dynamic exclusion lists that update automatically

Clay’s exclusion workflow continuously syncs anyone who shouldn’t see ads: current customers, open opportunities in Salesforce, agencies and partners, and recent inbound leads already being worked.

These exclusions update automatically. When a lead becomes an opportunity, they’re immediately excluded. When someone signs up as a customer, ads stop showing them the next day.

Talia, our SLG growth lead, estimates this prevents wasting “50% of your budget on accounts that are going to generate zero percent of your pipeline.”

2. Retarget high-intent visitors using first-party data

Website retargeting audiences consistently outperform cold prospecting. But for PLG companies and B2B businesses, website pixels only capture a fraction of high-intent behavior.

Clay expanded retargeting beyond website visits to include product usage data, inbound interactions, contact scores, and lead scores all pulled directly from Salesforce.

3. Build lookalike audiences with enriched data for higher match rates

Meta excels at finding people similar to your best customers through 1% lookalike audiences. But most B2B companies can’t use this effectively because Meta can’t match work emails to personal profiles.

Clay solves this by automatically enriching customer lists with personal emails, phone numbers, and other data points that Meta can match. This increases match rates from the typical 30% to 70%+, making lookalike campaigns actually work for B2B.

With proper enrichment and exclusion, Meta transformed from unusable to one of Clay’s most efficient channels. One recent Meta campaign using enriched lookalike audiences with proper exclusions generated 200 leads at $10 each within 24 hours.

How it works in Clay

The basic workflow is straightforward:

1. Build your source table: Create a Clay table that pulls accounts or contacts from Salesforce based on specific criteria (customer status, lead score, opportunity stage)

2. Enrich for match rates: For Meta audiences, enrich with personal emails and phone numbers

3. Push to ad platforms: Sync the table as a matched audience to LinkedIn and/or Meta

4. Set refresh frequency: Configure how often the audience updates (daily, every two days)

5. Use in campaigns: The audience appears in your ad platform and updates automatically

“It is ridiculously fast to run a matched audience,” says Talia. “Maybe a few minutes to set up and then I can scale that out multiple times.”

The critical advantage: one table in Clay feeds multiple ad platforms. Build once, push to both. Manny explains: “You set it up to run every two days and then it’s set and forget it.”

Real impact

LinkedIn: CPL dropped from $250 to $25 (10x improvement)

Meta: From unable to target to $10 CPL

Operations: No manual CSV uploads, audiences update automatically every 2 days

Getting started

Start with exclusion lists. Build a Clay table that pulls current customers, open opportunities, recent inbound leads, and partners from your CRM. Set it to refresh daily and push to both LinkedIn and Meta. This prevents waste before you build sophisticated targeting.

Then add retargeting audiences using first-party behavioral signals: product usage, lead scores, content engagement. Finally, create enriched lookalike audiences for Meta by enriching your best customers with personal contact data.

Most B2B companies still manually export CSVs and upload them to ad platforms. Their audiences go stale within days, they can’t effectively use Meta, and they waste budget on people they shouldn’t target.

Automated audiences solve all three problems. The result isn’t just lower cost-per-lead—it’s campaigns that actually reach target accounts and budget spent on people who can actually buy.

Want to build this yourself? Watch our workshop where Talia Schleifer, Davide Grieco, and Alex Reznik walk you through our favorite Clay Plays.

Customer success and sales teams spend hours building decks for every client interaction. Quarterly business reviews, executive briefings, renewal presentations, onboarding guides, each one means pulling data from multiple systems, building slides from scratch, and hoping you caught all the relevant context.

Subscribe now

The manual work is expensive. A CS rep managing 15 accounts spends 90+ hours per quarter just on deck creation. That’s more than two full work weeks not spent talking to customers, identifying expansion opportunities, or preventing churn.

At Clay, we’ve built automated deck generation that pulls from product databases, CRM systems, and conversation intelligence to create complete presentations in minutes instead of hours. Our CS team went from 6 hours per QBR to 10 minutes of review time. Our sales team generates personalized pitch decks without touching design tools.

The system works because it solves the two hardest problems in deck creation: aggregating scattered data and transforming that data into compelling narrative content. Here’s how we built it and how your team can do the same.

Want to build this yourself? Watch our workshop where Clay GTME Bruno Radice walks through the complete implementation. You'll learn how to connect data sources, process customer intelligence, and generate finished presentations automatically.

The problem: Deck creation consumes time that should go to customers

Every go-to-market team faces the same challenges.

• Data lives in too many places

Building a thorough customer deck means pulling information from product analytics, CRM systems, conversation intelligence, support tickets, and marketing automation. No single person has access to all these systems. Even when they do, extracting the right data takes hours of querying, exporting, and manual compilation.

• Template-based approaches don’t scale

Most teams use slide templates that members fill in manually. This creates inconsistent quality—templates work well when people have time to use them properly, but under deadline pressure, slides get filled with generic content. Templates provide structure but not storytelling. Each slide addresses its section, but the deck doesn’t flow. Customer data changes constantly, and keeping decks current means rebuilding them from scratch each quarter.

• Prioritization based on account size, not need

When deck creation takes 6 hours per account, teams prioritize. Enterprise customers get thorough QBRs with custom analysis. Mid-market accounts get lighter treatment. Small customers often don’t get formal reviews at all. Sometimes your smallest customers have the highest expansion potential, but manual deck creation forces you to choose who gets attention based on current ACV rather than actual opportunity.

Use case 1: Automated QBRs that feel like strategic partnership reviews

Before automation, our CS team spent 6 hours per quarterly review, including 45 minutes pulling product usage data from Snowflake, 30 minutes reviewing CRM records, 60 minutes analyzing Gong transcripts, 90 minutes building the narrative, 2 hours just creating slides, and 30 minutes reviewing.

Now a CS rep types /generate_qbr [account_name] in Slack. Clay queries Snowflake for product usage, pulls CRM context from Salesforce, processes conversation transcripts from Gong, generates narrative content using AI, and populates a slide template with data, charts, and text. The rep receives a 90% complete deck in about 10 minutes.

• What the automated QBR includes

Our standard template contains: customer logo and branding, executive summary with 3-4 key accomplishments, enrichment and activity overview showing total accounts/contacts enriched and workflow execution volume, implemented use cases with business outcomes and conversation quotes, retrospective on joint initiatives like hackathons or training, forward-looking roadmap of discussed-but-not-implemented use cases, credit pacing with expansion recommendations, and source citations for every data point.

• Impact on renewal conversations

Renewal calls can now start with comprehensive context. The CS rep walks through concrete achievements: “You enriched 47,000 contacts this quarter using Clay’s waterfall system. Your sales team spent 60% less time on manual research. You built three new workflows that your SDRs use daily.”

The conversation shifts from justifying cost to planning expansion. When the deck shows the customer discussed implementing ABM workflows but hasn’t started yet, that becomes a natural talking point. More importantly, smaller accounts get the same quality QBRs as enterprise customers because deck creation isn’t a time constraint anymore.

Use case 2: Personalized sales decks generated from prospect research

Sales teams need personalized pitch presentations for every prospect, but building custom decks doesn’t scale when you’re running 20+ demos per week.

When a demo gets scheduled, Clay’s enrichment pipeline runs automatically, pulling firmographic data, technographic signals, recent news, and hiring patterns. Claygent analyzes the prospect’s website and LinkedIn to understand their business model and go-to-market approach. Based on this enrichment, the system identifies which Clay use cases are most relevant and generates a customized pitch deck with the prospect’s logo and branding, industry-specific examples, relevant use cases with ROI estimates, integration callouts for tools they currently use, and competitive positioning if they’re evaluating alternatives.

Use case 3: Executive briefings for account planning

Account executives managing strategic accounts need executive briefing decks for internal planning sessions. Creating these traditionally takes 4+ hours: stakeholder mapping, competitive intelligence, product usage analysis, strategic opportunity identification, and deck creation.

We automated this so account teams always have current intelligence. The workflow runs on a schedule for strategic accounts: Clay monitors LinkedIn for stakeholder changes, tracks competitor mentions in conversation transcripts, queries product database for usage trends, uses AI to identify patterns suggesting expansion or churn risk, and generates a comprehensive deck with stakeholder maps, competitive positioning, usage analysis, and strategic recommendations.

• What makes automated briefings effective

The key is connecting data that normally stays siloed. When a champion changes roles, the briefing highlights this and flags conversations where other potential champions were identified. If an account increases usage of specific features and posts jobs for roles that would use those features, the briefing flags this as an expansion signal. When competitors get mentioned as renewal approaches, the briefing creates a competitive defense strategy section with relevant case studies.

How to build automated deck generation

Step 1: Map your data sources

Start by identifying where deck information lives. For product usage data, set up API access to your data warehouse (Snowflake, BigQuery, Redshift). Define queries that pull account-level metrics, user-level activity, and workflow patterns. Connect your CRM using native integrations to access account information, contact data, opportunity context, and historical notes. Connect conversation intelligence platforms to extract implemented use cases, feature requests, pain points, and expansion signals.

Start with these three core sources (product data, CRM, conversation intelligence) and add others like support tickets or marketing automation as you refine the system.

Step 2: Define your deck templates

Use Google Slides to build content-focused templates that define slide types and content placeholders.

Here’s our QBR template structure:

Slide 1 - Cover
- Customer logo (image slot)
- "Q[X] [YEAR] Business Review" (title)
- Date range (text field)
- CS rep name and contact (text field)

Slide 2 - Executive Summary
- "Key Achievements This Quarter" (title)
- 3-4 bullet points (text fields with data placeholders)
- High-level metric callout (large number with context)

Slide 3 - Enrichment Overview
- "Accounts and Contacts Enriched" (title)
- Total enrichment volume (number + chart showing trend)
- Enrichment breakdown by data provider (bar chart)
- Credit consumption (number + percentage of allocation)

Slide 4-6 - Use Cases (one slide per active use case)
- Use case name (title)
- Business outcome achieved (text with supporting metric)
- Specific example from conversation transcript (quoted text with citation)
- Product features utilized (bullet list)

Slide 7 - Joint Initiatives
- "What We Built Together" (title)
- Hackathons attended (text list)
- Custom implementations (text list with links)
- Training sessions completed (text list)

Slide 8 - Opportunity Pipeline
- "Use Cases We've Discussed" (title)
- Use cases mentioned but not implemented (bullet list)
- Requirements for each (nested bullets)
- Expected business impact (text or metrics)

Slide 9 - Credit Pacing
- Current consumption rate (number + chart showing trend)
- Projected usage through renewal (number with confidence interval)
- Expansion recommendation (text with calculation shown)

Slide 10 - Next Steps
- Action items for customer (bullet list)
- Action items for CS team (bullet list)
- Next meeting scheduled (date field)

Each slide type includes clear data placeholders so the automation knows exactly which data goes where. In order to format this in Google Slides,so the data gets routed to the right place you want to use this format:

• {{datapoint we are mapping}}

By structuring things in {{x}} will tell the system to send the point there

For images, you’ll want to make the text box as big as you want the picture to be and follow the same format as {{image}} within that textbox.

Step 3: Build data extraction and processing

Query your product database for account-specific metrics. For QBRs, we query Snowflake for enrichment activity, workflow execution, table creation, and feature adoption:

SQL
-- Enrichment activity
SELECT 
  COUNT(DISTINCT account_id) as accounts_enriched,
  COUNT(DISTINCT contact_id) as contacts_enriched,
  SUM(credits_consumed) as total_credits,
  provider_name,
  success_rate
FROM enrichment_events
WHERE account_id = '[ACCOUNT_ID]'
  AND event_timestamp >= '[QUARTER_START]'
  AND event_timestamp <= '[QUARTER_END]'
GROUP BY provider_name

-- Workflow execution
SELECT
  workflow_name,
  COUNT(*) as execution_count,
  AVG(duration_seconds) as avg_duration,
  success_rate
FROM workflow_runs
WHERE account_id = '[ACCOUNT_ID]'
  AND run_timestamp >= '[QUARTER_START]'
  AND run_timestamp <= '[QUARTER_END]'
GROUP BY workflow_name

Process conversation transcripts through Claude to extract structured insights:

Use cases implemented:

{
  "use_case": "Automated outbound prospecting",
  "status": "fully_implemented",
  "implementation_date": "2024-08-15",
  "business_outcome": "SDR team reduced list-building time by 70%",
  "supporting_quote": "We've completely eliminated manual prospecting. Our SDRs now spend their time actually talking to prospects instead of building lists.",
  "quote_speaker": "Sarah Chen, VP Sales",
  "conversation_date": "2024-09-22"
}

Feature requests and pain points:

{

  “request_type”: “integration”,

  “description”: “Native Marketo integration for European compliance workflows”,

  “business_justification”: “Current workaround requires manual CSV exports which creates GDPR risk”,

  “priority_signal”: “mentioned in 3 separate conversations”,

  “quote”: “If we had direct Marketo integration, we could automate our entire European campaign workflow.”,

  “quote_speaker”: “Thomas Schmidt, Marketing Operations”,

  “conversation_date”: “2024-10-05”

}

Expansion signals:

{

  “signal_type”: “adjacent_use_case”,

  “description”: “Interest in ABM workflows for enterprise segment”,

  “current_usage”: “Only using Clay for prospecting currently”,

  “expansion_potential”: “Would expand to marketing team (8 additional users)”,

  “quote”: “Our marketing team keeps asking if Clay can help with our ABM campaigns. That’s not what we bought it for, but it seems like it could.”,

  “quote_speaker”: “Rachel Martinez, Director of Revenue Operations”,

  “conversation_date”: “2024-09-29”

}

These structured extractions get stored in Clay tables and become source material for deck generation.

Pull account and contact information from your CRM:

Account Context:

- Company name: [from Salesforce Account.Name]

- Industry: [from Account.Industry]

- Employee count: [from Account.NumberOfEmployees]

- Current contract value: [from Account.Annual_Contract_Value__c]

- Contract start: [from Account.Contract_Start_Date__c]

- Renewal date: [from Account.Renewal_Date__c]

Primary Stakeholders:

- Decision maker: [from Contact where Role = ‘Decision Maker’]

- Champion: [from Contact where Role = ‘Champion’]

- Primary user: [from Contact where Role = ‘Primary User’]

- Executive sponsor: [from Contact where Role = ‘Executive Sponsor’]

Use Cases (from sales):

- [from Opportunity.Use_Cases__c for closed won opportunity]

Step 4: Build narrative generation

Use Claude to transform structured data into deck content. Provide clear prompts with context, data, specific instructions, tone guidance, and examples.

Example prompt for executive summary generation:

You are writing the executive summary for a quarterly business review deck.

CONTEXT:

Account: [Company Name]

Quarter: Q3 2024

Primary Use Cases: [List from CRM]

Key Stakeholders: [Names and roles]

PRODUCT USAGE DATA:

- Accounts enriched: [number]

- Contacts enriched: [number]

- Workflows created: [number]

- Active users: [number]

- Credit consumption: [number] credits ([percentage]% of allocation)

CONVERSATION INSIGHTS:

[Paste relevant use case implementations and outcomes extracted from transcripts]

TASK:

Write 3-4 bullet points for the executive summary slide that highlight this quarter’s key achievements. Each bullet should:

- Lead with the business outcome, not the feature

- Include a specific metric

- Connect product usage to business value

- Use active voice and clear language

TONE:

- Professional but not stuffy

- Focused on partnership and collaboration

- Confident in value delivered

- Forward-looking (what this enables, not just what was accomplished)

EXAMPLE OUTPUT:

• Accelerated sales team efficiency by 70%—your SDRs now spend 40+ hours less per month on manual research, redirecting that time to prospect conversations. You enriched 47,000 contacts this quarter using Clay’s waterfall system.

• Expanded your outbound motion into two new verticals—you built targeted prospecting workflows for healthcare and financial services segments, generating 230 qualified meetings in markets you previously couldn’t reach effectively.

• Scaled your data operations without scaling your team—despite 3x growth in account volume, your RevOps team maintained the same headcount by automating enrichment, routing, and data hygiene workflows.

Create similar prompts for each slide type. You can use a Use case slides get narrative explaining the workflow and outcome achieved. Opportunity pipeline slides explain what each discussed use case would enable. Forward-looking slides analyze usage patterns to identify optimization opportunities and generate actionable recommendations.

Step 5: Automate slide population

We built this as modular Clay workflows:

Workflow 1: Data aggregation

• Trigger: Slack command /generate_qbr [account_name] or scheduled run

• Query Snowflake for product usage metrics

• Pull CRM data from Salesforce

• Retrieve processed conversation insights from Clay tables

• Store all aggregated data in a Clay table row

Workflow 2: Content generation

• Read aggregated data from workflow 1

• Generate narrative content for each slide using Claude

• Store generated content back in Clay table

Workflow 3: Deck assembly

• Create new Google Slides presentation from template

• For each slide, insert content from workflow 2

• Add charts using Google Sheets (generated from data) embedded in slides

• Insert source citations

• Save and share presentation

Workflow 4: Delivery

• Send Slack message to CS rep with link to generated deck

• Include summary of key metrics pulled

• Note any data quality issues or missing information

• Set reminder to review deck before customer meeting

This modular approach makes debugging easier and lets you improve individual steps without rebuilding the entire system.

Handle edge cases

If critical fields are empty, flag it: “No conversation transcripts found for Q3 - use case slides may be less detailed than usual.” If product usage data shows high activity but conversations don’t mention it, flag the conflict. If numbers seem unusual, flag for verification: “Credit consumption jumped 400% this quarter - verify this is accurate before presenting to customer.” Always include source citations: “[Source: Snowflake query run 2024-01-15, Salesforce Account record updated 2024-01-14]”

Step 6: Build the review process

Automated generation creates 90% complete decks. The final 10% requires human review. Create a review checklist: verify data accuracy (do metrics match your understanding?), ensure narrative coherence (does the deck tell a compelling story?), identify customization opportunities (are there specific examples you can add?), and check tone and voice (does the language match your relationship with this customer?). Review should take 10-15 minutes for a standard deck.

Make refinement easy with inline editing in Google Slides, a content library of pre-approved examples, template variations for different layouts, and reusable customizations that apply to future decks for the same customer.

What you need to build this

Required: Clay account, pProduct usage database (Snowflake, BigQuery, Redshift), CRM with solid data hygiene (Salesforce, HubSpot), presentation software with API access (Google Slides or PowerPoint), and at least one well-defined deck template.

Highly recommended: Conversation intelligence platform (Gong, Chorus, Fireflies), Slack for triggering and delivery, and structured approach to capturing use cases in your CRM.

Team roles: GTM Engineer or RevOps builds and maintains workflows, Sales/CS Operations defines requirements and provides feedback, and Sales/CS team members test and champion adoption. One GTM engineer can build the initial system in 2-3 weeks. Ongoing maintenance is a few hours per month.

Implementation roadmap

Phase 1: Single deck type, manual triggers

Pick your highest-value deck type, connect three core data sources, create a template with 5-7 key slides, build the workflow to generate decks on-demand, and have 2-3 team members test it. Success means generated decks are 80%+ accurate, review takes under 20 minutes, and the team prefers automated decks to building manually.

Common pitfalls: trying to include everything in your first template, over-engineering the review process, and perfectionism on content generation. Start with the content that matters most and improve prompts based on feedback.

Phase 2: Expand to related deck types

Add 2-3 more deck types using similar data sources, create templates for each, build tailored content generation prompts, and set up automated triggers where appropriate. If you started with QBRs, natural expansions are executive briefings, renewal presentations, and expansion pitch decks. Success means multiple deck types generating successfully with consistent review time.

Phase 3: Automate triggers and scheduling

Build automated triggers based on calendar events or CRM updates, scheduled generation (QBRs auto-generate 3 days before review meetings), proactive notifications when decks are ready, and error handling. We auto-generate QBR decks 3 days before scheduled meetings, pitch decks when opportunities reach “Demo Scheduled” stage, executive briefings weekly for strategic accounts, and onboarding decks when deals close.

Phase 4: Optimization and expansion

Build analytics on deck generation, create feedback loops to improve prompts, connect additional data sources as value becomes clear, and add team-specific customizations. Review generated decks monthly to identify systematic issues, track which data points are missing most often, get feedback on slide layouts, and look for other repetitive deck creation tasks that fit the same pattern.

Common mistakes and how to avoid them

• Starting with too many deck types: Build one deck type well, get adoption, then expand. Each deck type benefits from infrastructure built for previous ones.

• Under-investing in data quality: Automated decks are only as good as underlying data. Audit core data sources and implement hygiene processes before building automation.

• Over-relying on templates: Build flexible templates with optional sections. If a customer didn’t attend hackathons, skip that slide rather than showing empty sections.

• Insufficient review process: Always build in human review. Generated content should be 90% accurate, but that final 10% makes the difference.

• Not measuring time savings: Track deck creation time before and after automation. If review time creeps up, improve your content generation.

• Ignoring team feedback: Create regular feedback loops. Review decks with users monthly and prioritize improvements.

The business case

• Direct time savings: Our CS team spent 6 hours per QBR × 50 QBRs per quarter × $150/hour = $45,000 per quarter in labor costs. Automation reduces this to 15 minutes review × 50 decks × $150/hour = $1,875 per quarter. Quarterly savings: $43,125. The system pays for itself in the first quarter.

• Opportunity cost: Those 6 hours per account get reallocated to customer conversations, proactive outreach, implementation support, and strategic planning. If automation lets each CS rep handle 20% more accounts without quality degradation, you can scale revenue without scaling headcount.

• Consistency and quality: Manual deck quality varies by who creates it and how much time they have. Automation raises the floor—every customer gets thorough treatment regardless of who their CS rep is or how busy the team is.

• Faster response time: Manual deck creation takes days. Automated generation means same-day turnaround, which improves customer perception and speeds up decision-making cycles.

For a 50-person CS team: 200+ hours saved per quarter, ~$175K per year in cost savings, ~$40K implementation cost, $135K net savings year one, and $175K ongoing annual savings. The system pays for itself in under 3 months and delivers 4.4x ROI in year one.

To watch the entire process in action, you can check out the live workshop with Davide and Bruno here.

Sales leaders face the same territory planning problem every year: how do you divide up accounts fairly while making sure every rep can actually hit their number?

Most teams fall into two camps. They either use black-box scoring tools or build one-time scores using manual spreadsheets that become outdated the moment the market changes.

At Clay, we’ve built an always-on territory planning system that solves both problems. We use Clay to continuously score accounts based on fit and engagement, fairly distribute good-fit target accounts, and surface buying signals in real-time so reps know where to focus.

The result is territories that stay balanced when markets shift, scoring that’s clear enough for reps to trust, and automatic workflows that flag hot accounts before your competitors notice them.

Here’s how we built it and how your team can do the same.

Subscribe now

The problem: Trust in account scoring is broken

There are two big issues in territory planning that most sales teams will find familiar.

1. Scoring becomes outdated immediately

Traditional territory planning happens once a year, as sales ops teams pull firmographic data, apply some basic filters like company size and industry, then divide accounts into territories.

The problem is that the second planning wraps up, reality starts drifting from the plan. A company might raise a Series B and suddenly have a budget. Another company might hire a new CRO who wants to rebuild their stack. A third may start viewing your pricing page constantly.

Tracking account scores manually would require watching dozens of data points per account. For a team managing 10,000 accounts with 20 signals each, that’s 200,000 data points to monitor. No one has time for that.

2. Reps didn’t trust black-box scoring tools

Many tools promise automated scoring, as well as ABM campaigns on autopilot to sellers and marketers. They’re simply asked to trust a process they have very little insight into. The black-box platforms update on their own, but they create a different problem: nobody understands how accounts get scored.

A rep looks at their territory and sees Account A scored 95 and Account B scored 60. When they ask why, the answer is “proprietary algorithm” or “our machine learning model.” The rep can’t explain to their manager why they’re focusing on certain accounts. More importantly, they can’t use the score to write better messages, because they don’t know which signals created that number.

This lack of clarity kills trust. When quota is on the line, reps want to understand exactly why the system tells them to focus on specific accounts. If they can’t see the data, they ignore the scores and trust their gut.

How Clay runs continuous fit and engagement scoring

Clay solves these problems by continuously scoring accounts using custom signals and automatically shifting accounts around as things change. Clay is also able to map enterprise company hierarchies automatically so there aren’t any fights over territories.

Fit scoring based on custom AI signals

Fit scoring decides which companies should be in territories. We only put accounts in territories when they hit a minimum fit threshold (for us, a score of 65 out of 100).

We’re moving towards assigning territories based on company headquarters location and segment, but fit scoring still matters for two reasons: it determines which accounts meet the minimum bar for assignment, and it helps reps prioritize within their territory. A rep might have 200 accounts in their geographic region, but only the 150 that score 65+ actually get assigned to them. The rest stay with marketing until they improve.

Traditional fit scoring uses standard firmographic data, like employee count, industry category, revenue range. These signals matter, but they’re basic information that every competitor can access.

Your real edge, or GTM alpha, comes from signals that standard enrichment providers don’t offer. For example, here are some of the questions about companies that we use as signals:

• How they go to market: Is the company product-led, sales-led, or hybrid? We use Claygent to check their website and figure out their approach, because this tells us how they’ll evaluate and buy new tools like ours.

• Whether they’re AI-native: Does this company position itself as AI-first? We look for AI-related messaging on their site, AI engineering job postings, and AI mentions in their product descriptions. AI-native companies often buy differently and budget differently than traditional software companies.
  Who they’re hiring: Are they hiring GTM engineers? Expanding their SDR team? These job postings show both budget availability and specific problems we can help solve.

• What tools they use: Which tools do they currently run? We look at not just their CRM and marketing automation, but their data warehouse, BI tools, and enrichment providers. This shows us their technical setup and whether they have infrastructure that works with Clay.

• Funding and growth patterns: Recent fundraising, headcount growth, and expansion signals point to companies with budget and momentum—good timing for adopting new tools.

• Job descriptions: Are new job types and descriptions showing up on a company’s career page? That signal actually indicates more than just roles the company is hiring for because the descriptions also give you technographic data.

Standard enrichment tools can’t answer questions like “Is this company AI-native?” or “Do they use product-led growth?” No database has those answers. Clay lets us define these signals ourselves through web scraping, Claygent analysis, and custom formulas.

Engagement scoring based on recent activity

Fit scoring determines which accounts a rep should care about (highest ACV). Engagement scoring gives them an indication of warmth and likelihood of closing. It also tells marketing which high fit accounts need awareness marketing to warm them up as potential leads.

A rep or SDR can’t prospect into 200 high-fit accounts at once. They need to know which ones are showing buying signals right now.

We combine the following signals into an engagement score of a single, constantly updated, number:

• Website visits: Which pages are they checking out? How often? Pricing page views and feature comparison pages show higher intent than blog traffic.

• Social activity: Are they engaging with our content on LinkedIn? Commenting on posts about problems Clay solves? Following our company page? These are the sorts of signals that give us an idea of a prospect’s familiarity or engagement with Clay.

• Champions changing jobs: Did a staunch advocate just take a new role? That’s a strong signal to reach out and see how you can help them at their new company.

• Project descriptions: Did a target company just announce a new project? Did a relevant project pop up in a job description? That signal can change engagement potential.

• Product usage: For existing customers, are they expanding workspace usage? Creating new tables? These signals suggest they’re happy and might expand.

• Event attendance: Did they join our webinar? Download a guide? Register for an event? These actions show active research.

Unlike fit score (which changes slowly as company basics shift), engagement score reflects current buying behavior and can jump fast when accounts heat up.

How engagement scores direct sales and marketing behavior

On day one of the year, a rep logs into Salesforce and sees 200 accounts in their territory. Instead of randomly picking where to start, they filter for accounts with engagement scores above 90.

This might surface 15 accounts showing strong signals right now. The rep can click into each account and see exactly why it scored 90+: they hired a new CRO last month, they’ve checked the pricing page three times this week, and they attended last Thursday’s webinar.

This clarity matters. The rep isn’t just following a mysterious algorithm. They understand the specific signals creating the score and can mention them in outreach. “I noticed you recently hired a RevOps lead and your team has been researching data enrichment” works way better than “You’re scored as high-intent.”

Potential contract value scoring

Another dimension we look at is estimating how much an account might spend. Two accounts might have identical fit and engagement scores, but one could be worth 10x the revenue of the other.

We estimate potential contract value (ACV) by looking at:

• Historical deal patterns: How much have similar companies spent with us? If we’ve closed five deals with 200-person fintech companies and they all landed between $40K-$60K, that gives us a baseline for new fintech prospects of similar size.

• Usage indicators: For product-led companies, we can see product usage patterns before they become paying customers. High workspace creation, frequent table usage, and power-user behaviors signal higher potential spend.

• Technographic complexity: Companies with sophisticated data stacks (warehouses, BI tools, multiple data sources) typically need more advanced Clay capabilities and spend more than companies with basic setups.

• Team size in relevant functions: A company with 50 GTM team members will likely spend more on Clay than one with 5, simply because more people need access and they’ll run higher-volume workflows.

• Industry and business model: B2B SaaS companies with large sales teams typically have different spending patterns than B2C companies or services businesses, even at similar headcount.

We don’t try to predict exact ACV down to the dollar. Instead, we bucket accounts into ranges: $10K-$25K, $25K-$50K, $50K-$100K, $100K+. This is precise enough to inform prioritization without getting lost in false precision.

Why potential value matters for prioritization

Two accounts might both be Tier 1 (high fit, high engagement), but if one has a potential ACV of $100K and another has $15K, reps should focus more energy on the higher-value opportunity. This doesn’t mean ignoring smaller deals—it means calibrating effort to potential return.

Potential value also helps with territory balancing. A territory with 150 accounts averaging $40K potential ACV is roughly equivalent to a territory with 200 accounts averaging $30K potential ACV, even though the account counts differ.

How Clay triggers automatic workflows based on score changes

The real power comes from tying scoring to automatic actions. When an account crosses a key threshold, Clay triggers the right workflow instantly:

• New high-fit accounts get assigned automatically: If a company raises a Series B and its fit score crosses 65, Clay assigns it to the correct territory based on geography and balance. The rep doesn’t have to hunt for it — the account simply appears in their Salesforce view.

• High-engagement alerts go straight to reps: When an account’s engagement score passes 90, the assigned rep gets a real-time Slack alert showing exactly which signals caused the spike. No waiting for weekly reports that might miss the moment.

• Quarterly territory rebalancing runs on its own: Every quarter, we refresh fit scores across all accounts. If market conditions shift — industries heat up, ideal-customer patterns change — Clay automatically rebalances territories to keep them fair. No more year-long drift from the original plan.

How we tier accounts and set quarterly targets

Scoring every account is one thing. Deciding which accounts get active attention is another.

We use fit, engagement, and potential contract value together to create a three-tier system that determines how reps and marketing allocate their time:

Tier 1: High fit (65+), high engagement (75+), strong potential value ($50K+ ACV)

These are accounts showing strong product fit, active buying signals, and meaningful revenue potential. Reps should be working these accounts now—personalized outreach, custom demos, executive engagement. These accounts get weekly touchpoints and immediate follow-up on any engagement spike.

At the start of each quarter, we set explicit targets: “Each rep should have 15-20 Tier 1 accounts they’re actively working.” This number varies based on average deal size and sales cycle length, but the principle holds: Tier 1 accounts deserve concentrated, high-touch attention.

Tier 2: High fit (65+), moderate engagement (40-74) or moderate potential value ($25K-$50K ACV)

These accounts belong in your territory and could become opportunities, but they’re either not showing strong buying signals yet or represent smaller deals. Reps touch these accounts monthly through campaigns, relevant content sharing, and lighter-touch outreach. The goal is moving high-potential accounts into Tier 1 through engagement.

Marketing runs targeted campaigns to these accounts—relevant case studies, webinar invites, educational content about problems they likely face. When engagement jumps on high-value accounts, they automatically move to Tier 1 and get flagged for rep follow-up.

Tier 3: High fit (65+), low engagement (0-39), lower potential value (<$25K ACV)

These accounts meet your ICP but aren’t engaging yet or represent smaller opportunities. They stay in territories for visibility, but reps don’t actively work them. Marketing owns these accounts through broader campaigns and brand building. If engagement climbs or if potential value increases (company grows, expands team, etc.), they move up tiers automatically.

Accounts below 65 fit score don’t get assigned to territories at all. They stay in a general pool for broad marketing programs until their fit score improves.

Real impact: faster planning and fairer distribution

This system has completely changed how we approach territory planning at Clay.

Planning cycles go from weeks to days

Previous territory planning took 3-4 weeks every year. Sales ops pulled data from multiple sources, manually analyzed account quality, debated fairness, and finally handed out assignments. By the time territories were finalized, market conditions had already shifted.

Now territory planning takes 3-4 days. Fit scores are already calculated and current. Account balancing happens automatically based on scoring metrics. Sales leadership can review proposed territories, make strategic adjustments, and ship assignments while the data is still fresh.

How to build your own territory planning motion

Creating this system means connecting your data sources, defining your scoring, and setting up workflows that keep territories current over time.

Phase 1: Figure out your scoring criteria

Start by determining which signals actually predict success in your sales process. Don’t guess; look at your existing customers.

Pull your best customers from the past year. Export their data and enrich it in Clay using every signal you think might matter: company size, growth rate, tech stack, how they go to market, hiring patterns, industry, and any custom signals specific to your product.

Look for patterns. Do your best customers share similar traits? Are they all product-led companies? Do they all have data warehouses? Do they all hire for specific roles?

Create your initial fit scoring based on these patterns. Weight signals by how strongly they connect with customer success. If 80% of your best customers are PLG companies, give that high weight in your score. If their tech stack doesn’t matter much, weight it lower.

Example initial scoring weights:

• How they go to market (PLG vs sales-led): 20 points

• Company size (50-500 employees): 15 points

• Tech stack sophistication (has data warehouse): 15 points

• Growth trajectory (headcount growing >20% per year): 15 points

• Hiring for relevant roles (RevOps, GTM engineering): 15 points

• Industry fit (SaaS, professional services): 10 points

• Funding status (Series A+): 10 points

Total possible: 100 points. Minimum threshold for territory assignment: 65 points.

This scoring isn’t set in stone. You’ll improve it based on results. But start with something grounded in your actual customer data.

Phase 2: Build fit scoring in Clay

Create a Clay table that pulls all accounts from your CRM and enriches them with the signals you defined in Phase 1.

How to set this up:

1. Import existing accounts: Connect your CRM to Clay and pull all company records you want to score

2. Enrich firmographic data: Use Clay’s data providers to add employee count, revenue estimates, industry classifications, and growth metrics

3. Enrich technographic data: Pull tech stack information to understand what tools they currently use

4. Analyze how they go to market: Use Claygent to visit company websites and classify whether they’re PLG, sales-led, or hybrid based on signup flows, pricing page structure, and product positioning

5. Pull hiring signals: Use job board integrations to spot relevant job postings (RevOps roles, SDR positions, data engineering hires)

6. Calculate fit scores: Use Clay’s formula columns to apply your scoring weights to each signal and create a total fit score (0-100)

7. Write scores back to CRM: Push the fit score back to your CRM so it’s available for territory assignment and rep visibility

Set this table to refresh weekly so scores stay current as company data changes.

Phase 3: Set up engagement scoring

Engagement scoring needs more dynamic data sources that track current behavior rather than static company traits.

Data sources to connect:

• Website analytics: Connect your website analytics (Google Analytics, Segment, etc.) to track which accounts visit your site and which pages they view

• Social engagement: Track LinkedIn engagement with your company content

• Product usage: For existing customers, pull workspace creation, table usage, and feature adoption metrics

• Email and event engagement: Connect your marketing automation platform to track email opens, webinar attendance, and content downloads

• Job change data: Monitor when target accounts hire for relevant roles or when key contacts change jobs

Build a Clay table that pulls these signals for each account and calculates an engagement score. Unlike fit scoring (which is relatively static), engagement scoring should update daily to catch buying signals while they’re hot.

The engagement score formula is simpler than fit scoring because you’re measuring recent activity rather than company basics:

Example engagement scoring:

• Website activity (weighted by page value): 0-30 points

• Social engagement: 0-20 points

• Product usage trends (for customers): 0-20 points

• Recent hires in relevant roles: 0-15 points

• Event/content engagement: 0-15 points

Total possible: 100 points.

Push engagement scores back to your CRM alongside fit scores so reps see both numbers when reviewing accounts.

Phase 4: Build territory assignment logic

With scoring in place, you can now build the logic that puts accounts in territories.

Territory assignment rules we use:

1. Minimum fit threshold: Only accounts scoring 65+ on fit get assigned to territories. Everything below that threshold stays in a general pool for marketing to nurture.

2. Geographic distribution: Accounts get assigned to territories based on company headquarters location, unless there’s a specific reason to override (existing relationship, strategic account, etc.)

3. Account load balancing: We aim for roughly equal account counts per territory, adjusted for account quality. A territory with 180 accounts averaging 80 fit score equals a territory with 200 accounts averaging 72 fit score.

4. Hierarchy respect: When assigning a parent account to a territory, all subsidiaries automatically go to the same rep to prevent conflicts.

5. Strategic account exceptions: Executive leadership can manually override assignments for strategic accounts, but this should be rare.

Build these rules into a Clay table that processes your scored accounts and outputs territory assignments. Push these assignments back to your CRM so they’re visible to reps and sales leadership.

Phase 5: Set up automated workflows

The final step is connecting your scoring to workflows that automatically surface opportunities and keep territories balanced over time.

Critical workflows to build:

• New high-fit account alerts: When a company’s fit score crosses 65 (meeting your minimum threshold), automatically assign it to a territory and notify the rep via Slack. Include key details: why the score increased, relevant company information, and suggested first actions.

• Engagement spike notifications: When an account’s engagement score jumps significantly (20+ points in a week, or crosses 90), alert the assigned rep immediately with specific signals: “ABC Corp’s engagement score jumped to 93 because: 3 pricing page visits this week, new RevOps VP hired, attended Thursday’s webinar.”

• Weekly territory digests: Every Monday, send each rep a ranked list of their top 10 highest-engagement accounts with action recommendations. This focuses rep attention on accounts most likely to convert this week.

• Quarterly territory rebalancing: Every quarter, re-calculate fit scores for all accounts and check territory balance. If territories have drifted apart (one territory now has significantly higher average fit than another), flag this for sales leadership to review and rebalance.

Reps trust their territories because scoring is transparent

The biggest change is rep buy-in. When we used black-box scoring tools, reps regularly questioned why certain accounts were in their territory or complained about unfair distribution.

With transparent scoring, reps can see exactly why accounts scored the way they did. When they ask “Why is this account in my territory?” we can point to specific signals: they’re PLG, they’re hiring for RevOps, they have a data warehouse, they recently raised Series B. The rep understands the logic and trusts the assignment.

This transparency also helps reps write better outreach. Instead of generic messaging, they can reference the specific signals that made an account a good fit: “I noticed you recently hired a RevOps lead and are scaling your SDR team. Companies in similar situations have used Clay to...”

Territories stay balanced as markets shift

Markets don’t stand still, which is why Clay being dynamic and fluid helps our sales team. A sector that was cold in Q1 might be booming by Q3. Without continuous scoring, territories that looked fair in January become unbalanced by June.

Our quarterly rebalancing catches market shifts automatically. If SaaS companies suddenly become much stronger fits (maybe because we shipped a key integration), territories with higher SaaS concentration get flagged for review. Sales leadership can rebalance before one territory gets unfairly advantaged.

Common mistakes and how to avoid them

Based on our experience and conversations with other teams building similar systems, watch out for these issues:

Making initial scoring too complicated

Teams often try to build comprehensive scoring that accounts for every possible signal. This leads to analysis paralysis and delayed launches.

Start simple. Pick 5-7 signals you’re confident actually matter and build scoring around those. You can always add complexity later based on data about which scores actually predict closed deals.

Ignoring hierarchy relationships

Failing to map parent-child company relationships creates territory conflicts that waste sales time. Two reps arguing about who owns an account isn’t productive. Invest the time upfront to build proper hierarchy mapping in Clay. It prevents problems before they start.

Setting fit thresholds too high or too low

If your minimum fit threshold is too high (requiring 80+ scores for territory assignment), you artificially limit your addressable market and leave potentially good accounts unassigned.

If it’s too low (accepting 40+ scores), you water down territory quality and reps waste time on poor-fit accounts.

Start at 65 and adjust based on results. If reps consistently close deals with accounts scoring 55-65, lower your threshold. If accounts below 70 rarely convert, raise it.

Not updating scoring based on actual results

Your initial scoring weights are guesses. Some signals will prove more predictive than you expected, others less.

Every quarter, analyze which scored accounts actually closed deals. Did high-fit scores predict success? Were engagement scores accurate indicators of near-term conversion? Adjust your weights based on this data.

Forgetting to explain scoring to reps

If reps don’t understand how scoring works, they won’t trust it and won’t use engagement signals to prioritize their work.

Document your scoring methodology clearly. Show reps which signals matter and why. When scores change, explain what drove the change. This transparency builds trust and adoption.

Territory planning as a competitive advantage

Most sales teams still rely on static, once-a-year territory planning built on basic firmographic filters. They assign accounts in January and hope the market doesn’t shift too much.

But it always does — and that creates three big problems: territories go stale almost immediately, reps waste time on cold accounts because they lack engagement signals, and sales leaders can’t react quickly when new opportunities appear.

Clay solves all three issues with continuous scoring, automatic segmentation, and transparent signals. Territories stay balanced as conditions change. Reps focus on hot accounts instead of guessing. Sales leadership can reallocate attention and resources the moment new segments emerge.

Teams that adopt dynamic territory planning consistently outperform those stuck in annual assignments. It’s not magic — it’s better, fresher data about fit and engagement, and a system that updates itself as the market moves.

But we make a ton of big and small marketing bets like this at Clay, to the point we wanted to share some of our decision making process. Our co-founder Varun sat down with our head of finance Karan Parekh to talk about what guides our marketing motion without demanding perfect attribution and killing our creativity.

Some of what we cover:

• How brand and performance marketing are linked and why B2B companies invest in brand too late

• How we use attribution modeling, customer-defined attribution, and incremental analysis to measure the unmeasurable

• What marketing works as you move from Series A to scale-up to public company (and why Figma nailed it)

• Guerrilla marketing tactics from Clay’s early pre-PMF days

At the end of the video, Varun and Karan share the strategy behind Clay’s recent billboard campaign and real examples of how we’re measuring impact and ROI.

Subscribe now

Brand and performance go hand-in-hand

Most finance leaders think about marketing in two independent buckets: brand (the fluffy stuff you can’t measure) and performance (the measurable stuff that drives revenue). We think that’s the wrong way of looking at things.

Brand and performance are linked. Brand enables performance. If nobody knows who you are, you can buy all the Google Ads in the world and you won’t get conversion.

Think of it this way: you don’t invest in brand to get direct ROI from the brand investment itself. You invest in brand so that when you put $1 into performance marketing, you get more than $1 out.

Most B2B companies miss out on this, though. You need to invest in brand early. Why? Because B2B brands suck. No one invests in them. So if you do, you’re already different. And half of marketing is just being different.

Consider Figma. They built an entire community and ecosystem around their product to the point that designers have an identity around using Figma. That’s not performance marketing with direct attribution, but that community is now so embedded that they’re almost impossible to disrupt. When Figma runs performance campaigns, they’re building on a foundation that makes every dollar work harder.

The real question isn’t “what’s the ROI of this billboard?” It’s “how much should I invest in brand such that when I invest in performance, I get a higher net ROI?”

What to do at each stage

Series A / early stage: focus on inputs, not attribution

If you’re pre-product-market-fit or just finding your footing, your bias will be to measure everything. Resist that urge. Your dollars are too small to run meaningful incremental tests. Your data is too noisy to trust attribution models. What you actually need to do is create moments that people remember—a splash that people can rally around.

At this stage, it’s not about “did I get one customer for this $1 spent?” It’s about “did I create something memorable that starts spinning the flywheel?”

For Clay in the early days, this looked like:

• Taking customers to Dreamforce dressed as “Clay-gents” in full suits

• Producing absurd videos like “V for Viglietta” showing our team building Clay tables while skydiving, on the ocean, or rappelling off mountains

• Doing whatever felt creative and different, even if we couldn’t measure it perfectly

These things rely on creativity, ingenuity, and scrappiness. What they don’t rely on are big budgets. Any company can do them. They weren’t measured by pipeline dollars per creative asset. They were measured by whether people started talking about us.

Growth stage: get sophisticated about measurement

As you scale, you can and should get more rigorous. There are two lenses to apply:

1. Customer journey analysis: For any given customer, are you doing the right things at each moment to drive conversion? If a customer got in touch with you on LinkedIn, came to an event, attended your conference, and then was reached out to by sales at another conference—all of those stack up to a total cost relative to the lifetime value of that customer. You want those two sides of the equation in balance.

2. Incremental testing: Once you have a baseline, you can start testing, e.g. if you run a billboard campaign in SF but not in New York, does SF see a 10% lift in traffic? This is where you start optimizing the engine you’ve built.

The three-method approach to marketing measurement

There are three ways to understand what’s working:

1. Attribution modeling Multi-touch, last-touch, first-touch—whatever model you choose, you’re trying to understand which touchpoints contributed to a conversion. This is helpful but imperfect.

2. Customer-defined attribution Just ask customers: “How did you hear about us?” You’d be surprised how often they remember a billboard, a video, or a specific event. This qualitative data is gold.

3. Incremental analysis Test a channel in one market but not another. Measure the lift. This is the most rigorous approach, but requires scale to do well.

You need all three working together to build a complete picture. Don’t rely on just one.

A real example: how—and why—we’re spending $1M+ on billboards

We recently made a big investment in out-of-home advertising by spending seven-figures billboards, ads on the New York City subway, and other OOH surfaces. Here’s a little bit about how we’re thinking about it:

1. Know where your customers are

Spray and pray with this sort of advertising is exactly what you don’t want to do. You should be using your your own data to map exactly where your customers work. (Yes, we use Clay for this and you should too.) For something like a billboard, you should be buying space near their offices, along their commute routes, and the places they actually go.

When you go in person to verify placements, you’ll find that some billboard spots don’t even exist. Some face bathrooms. Some are behind doors. Some are in the wrong airport terminal. The lesson here is to do the homework yourself, don’t rely on someone else to do it for you.

Pro-tip: for airports, which are an extremely valuable part of the OOH landscape, you should know which terminals your customers use. Are they mostly international or domestic travelers? Do they have relationships with specific airlines or favor certain airports in a given region? Figuring out whether you’re better off spending money at LaGuardia vs. JFK or Heathrow vs. Gatwick is vital to spending this money smartly.

2. Don’t play it safe

Any OOH campaign has to be different. You need great creative talent, but you also need to do something no one else is doing.

This year, we filmed the entire process of installing our billboards and turned a physical representation of Clay into highly distributed digital content that reached a national audience. We got twice the value: the billboard itself and the content about making the billboard. We’ll be doing a deep dive on the actual process of creating and launching a billboard campaign with our schemer-in-residence Jessica Jin who came up with that idea.

3. Measure what you can

People say “you can’t measure a billboard.” That’s not true. You can’t measure it perfectly, but you can do meaningful attribution:

• Control markets: Did the SF market perform better than NYC where we didn’t run ads?

• Self-reported attribution: Are customers mentioning the billboard in conversations?

• Geographic lift: Are we seeing more product-led growth signups from areas around the billboards? More deals created in those regions?

• Traffic analysis: Can we see a lift in new customers coming from the area around the billboard?

Perfect measurement isn’t the goal here. You should be focusing on gathering enough signal to make better decisions next time, just like you would with any process.

The bottom line

Your job as a marketer isn’t to measure everything perfectly. It’s to understand the relationship between brand investment and performance returns, and to optimize that relationship over time.

Focus on inputs and creativity early one, and try to create moments worth remembering. As you scale you can start layering in attribution, self-reported data, and incremental testing to understand what’s working. You should always be investing in brand, because that’s what makes your performance dollars work harder.

And most importantly: be different. B2B marketing is boring because everyone is doing the same thing. Half the battle is just standing out.

How we built Clay’s GTM engineering function

Today’s post comes from our head of GTM engineering, Everett Berry who breaks down our Clay’s GTM engineering function was built and currently operates.

Most companies treat GTM operations as a support function. Someone to clean up Salesforce data, set up sequences, maybe build a dashboard or two. At Clay, we took a different approach from the very beginning.

At Clay, GTM Engineering sits at the core of how we run go-to-market. The team reports directly to our co-founder Varun, alongside the first line of leadership below the founders. They operate like a product engineering team, with sprints, version control, and release notes. And they’ve automated large parts of our sales process while maintaining the systems that power both our self-serve and sales-led motions.

Here’s how we structured it, why it works, and what we’ve learned building GTM infrastructure at scale.

Two types of GTM Engineers

We split GTM Engineering into two distinct teams:

• Forward-deployed GTM Engineers work directly with customers. They help prospects evaluate Clay, scope implementations, and build out their specific use cases. Many came from rev ops or growth roles before joining Clay.

• Internal GTM Engineers build and maintain all our internal operations. This team operates under Osman Sheikhnureldin and handles everything from deal automation to QBR generation to partnership workflows. They serve our customer experience team, marketing, growth, and partnerships. This is the team most people think of when they picture “ops.”

Both teams could probably swap roles if needed. The main difference is temperament. The more engineering-minded people gravitate toward internal infrastructure. The folks who like podcasts and customer conversations end up forward-deployed.

The tech stack

Our internal team runs on four core tools: Clay, Snowflake, Salesforce, and Gong. Slack rounds out the stack as the actual interface our GTMEs use day-to-day.

We built a Slack app that GTMEs interact with for most of their work. They can trigger campaigns, view signals, get pre-call research, access post-call meeting notes, and send follow-ups. All without opening another tab. The internal GTM Engineering team maintains this application using Clay’s human-in-the-loop workflows deployed to our Slack instance.

The simplicity matters. Most companies end up with 15+ tools in their GTM stack. We’ve kept it tight, which means less integration work and fewer places for things to break.

The philosophy: flexibility within standards

We let GTMEs use whatever meeting tools work for them. Some people run Gong and Granola simultaneously. Some use Attention for their personal notes. The meeting tool space moves fast, and different people have different preferences that will shift and evolve over time. We find that dictating exactly how people should work ends up leaving potential advantages on the sidelines.

We do have one hard requirement: the data has to flow into Clay.

For example, Gong always runs because it pipes into our automation infrastructure. But if someone wants to layer Granola on top for their own note-taking workflow, that’s totally fine—as long as the transcript and key information ends up where our internal GTM Engineering team can transform it in Clay, people have flexibility to experiment.

If you do nothing outside the core tools, you should have a great experience. But since we’re Clay, you should also be able to experiment with new tools that you find interesting.

Operating like an engineering team

The internal GTM Engineering team works in two-week sprints. Other teams across Clay submit tickets for things like automation requests, data quality fixes, or new workflow needs. The team triages these tickets, bundles them into releases, and ships twice a month with full release notes.

They version control their work. The Clay tables and workflows themselves get treated like code. They maintain documentation. When evaluating new vendors (we’re looking at AI sales coaching tools right now), they run the technical evaluation and handle integration.

This structure solves a problem most ops teams face: the endless queue of one-off requests. By batching work into sprints, the team can focus on larger infrastructure projects while still handling the daily asks. And by publishing release notes, the rest of the company knows what’s shipping and when.

What GTM engineers actually build

The automation we’ve shipped falls into a few categories:

• Content generation: Our growth strategy team (post-sales) gets handoff decks automatically generated when a deal closes. We pull credit consumption data from Snowflake, call recordings from Gong, and account information from Salesforce. All of that gets formatted into a Google Slide deck that publishes itself before the kickoff call.
  
  We do the same thing for QBRs now. The deck builds itself from usage data and conversation history. The growth team just shows up and presents.
  

• Follow-up automation: After discovery calls, the system drafts follow-up emails based on the call transcript. We’ve mostly solved this problem at this point.
  

• Signal-based workflows: External GTMEs get notifications in Slack when accounts hit certain triggers. Product usage patterns, intent signals, contract milestones. The Slack app surfaces these moments and prompts the right action.
  

• Pipeline operations: All the standard stuff around lead routing, data enrichment, territory assignment. But because the team operates in sprints with clear prioritization, this work doesn’t crowd out the higher-value automation.

The next frontier is harder. Moving from a pretty good follow-up email to a great follow-up email, and doing that consistently over a multi-month sales process while building a comprehensive deck as you go is a 90th-to-95th percentile problem. So is doing something like taking information from multiple calls and turning it into proposals, one-pagers, case study drafts that actually sound like they came from a human who understands the customer’s business. We’re working on all of that right now.

Subscribe now

Why this structure works for Clay

Clay is roughly 50/50 self-serve and sales-led. That split creates complexity.

On the self-serve side, everything runs through pure automation. No human touches these deals until they’re ready to expand. On the sales-led side, we have a traditional enterprise motion with forward-deployed GTMEs, discovery calls, multi-threading.

A lot of top-of-funnel activity for our sales-led business actually happens in our self-serve customer base. Someone starts using Clay on their own, gets value, then brings it to their company. The internal GTM Engineering team owns the systems that identify these expansion opportunities and route them appropriately.

This means they can’t just focus on supporting the sales team or the growth team. They need to maintain infrastructure across both motions and build the connective tissue between them.

Right now, moving customers from self-serve to sales-led isn’t as smooth as we’d like. That’s a major company priority. The fact that one team owns the systems on both sides makes that transition easier to improve.

Applicability outside tech

People assume Clay only works for tech companies doing PLG motions, but consider this: Waste Management uses Clay. They’re completely outside our usual world of SaaS and tech buyers. But the use case was rock solid. The flexibility of the platform means GTM Engineering as a discipline can work across different industries and sales models. You’re not locked into one type of motion or one type of buyer.

The reporting structure

Internal GTM Engineering reports to Varun, our co-founder and head of ops. They sit alongside executives running major functions, not buried under a VP of Sales or inside a rev ops org.

This matters for prioritization. When the team that builds your GTM infrastructure has a direct line to founder-level leadership, they can make architectural decisions without getting stuck in departmental politics.

We don’t have a traditional CRO structure at Clay. There’s no single leader with sales, marketing, post-sales, and ops all reporting up through them. Revenue ownership is more distributed. The growth team owns self-serve. The sales team owns sales-led. GTM Engineering facilitates both.

That structure works at our current scale (around $100M in revenue). As we grow into a couple hundred million, we’ll probably need to consolidate under a CRO or adopt something like Stripe’s multiple-CRO model. But the GTM Engineering function will likely stay close to the top of the org chart regardless of how we restructure around it.

RevOps vs GTM Engineering

We still have a RevOps function, but it’s split between GTM Engineering and finance.

Finance handles forecasting, sets pipeline targets, and owns quarter-over-quarter sales planning. They work with GTM Engineering to align on the numbers and set targets across the organization.

Subscribe now

Anything involving systems, data quality, or automation lives with GTM Engineering. Territory carving, sequence deployment, dashboard creation, tool evaluation.

It’s a matrix structure. Pipeline targets are set by finance but delivered through combined efforts from growth, marketing, and GTM Engineering. The internal GTM Engineering team facilitates the execution. This setup works because both teams have clear swim lanes. Finance focuses on what the numbers should be. GTM Engineering focuses on the infrastructure that delivers those numbers.

Tools beyond the core stack

The internal team uses Clay, Snowflake, Salesforce, Gong, and Slack for most of their work. But we’ve layered in some AI tools that have proven valuable:

• Dust acts as an agent layer on top of our company information. Notion, Gong, Salesforce, all of Slack. People use it for Q&A about internal processes, past conversations, and customer context. The feature we use most is Slack search with references to other conversations.
  
  We’ve started migrating some common Dust queries into Clay workflows. Once we see patterns in what people ask, we’ll automate those specific questions. But there’s still a long tail of ad-hoc questions where Dust shines.
  

• Crosby handles our contract redlines. They do the first pass on every legal negotiation. In many cases, deals close without ever escalating to our legal team. We’ve cut redline response time from days to hours.
  
  The Crosby team has done impressive work making LLMs reliable for black-and-white legal language. No hallucinations, no made-up clauses. Getting that level of reliability for legal documents is harder than it looks.
  

• Granola and Gong both run on calls, depending on what team members prefer. Gong is standard across the company (it feeds into all our automation). Some people layer Granola on top for personal note-taking. We’ve given teams flexibility to use what works for them, as long as the data ends up in Clay where the internal GTM Engineering team can transform it.

The sequencing challenge

We’re experimenting with Clay’s native Sequencer for lower-volume, high-touch messaging. It’s not ready for 50,000+ emails per month yet, but for the messages that matter—strategic outreach, expansion plays, partnership development—having everything end-to-end in Clay removes a lot of friction.

For high-volume outbound, we use Gong Engage. Their new API changed how we think about sequences.

The new Gong Engage API lets you customize every message and subject line in a multi-step sequence with a single API call. You can create a fully custom sequence per contact. Not template-with-variables custom. Actually custom.

For GTM engineers, this is a step function improvement. You can pull data from anywhere, generate fully personalized messaging using LLMs, and deploy multi-touch sequences without template constraints. We use this API internally at Clay, and it’s available as an action in Clay for customers building their own workflows.

Where deals actually happen

Here’s something that doesn’t show up in Salesforce: most of our executive-level sales happen over iMessage.

Our sales process is designed to find the executive buyer and get their phone number. Then someone from leadership—myself, our sales lead Becca Lindquist, or our co-founders Kareem and Varun—texts them directly. We schedule calls, negotiate terms, and close deals over text. One of our largest deals this year happened entirely over Slack DMs. Also not synced to Salesforce.

This creates a gap between our automation infrastructure and where work actually happens. The systems are built around email, Salesforce, and Gong. But real conversations happen in iMessage, WhatsApp, Slack DMs.

We haven’t solved this yet. It’s manual. I add contacts to my phone, copy in their number, send texts from iMessage on my laptop. None of it syncs back to our systems.

The same thing happens with Slack. Slack is a Salesforce product, but Slack DM conversations don’t flow into Salesforce records. There’s infrastructure work to be done here, and whoever figures out the DM channel problem will unlock a meaningful advantage.

When to hire a GTM Engineer

If we were starting from scratch today, the first GTM hire would be a GTM Engineer. Before the first AE. Definitely before building out a full rev ops team. (And if you’re curious, we have an entire guide on how to hire a GTM engineer here.)

You’d pair them with a founding AE and either a solutions engineer or a former customer who knows the problem space. Then you’d hire an outbound agency to handle volume. That team could do real damage finding early signal and building the foundation for scale.

The first project for that GTM Engineer: build the golden list.

This is the set of accounts where, if you got a magical intro tomorrow, you’d be thrilled. Each account has the right contacts, with up-to-date information, and clear reasoning for why it made the cut.

Most companies don’t have this. They start selling, build up a messy account list, and then six months later when they need to do territory carving, they realize they don’t actually know how to structure their market. You end up with duplicate accounts, unclear segmentation, and territories that make no sense.

Starting with clean account architecture makes everything easier as you scale. You know your segments. You know your ideal customer profile. You can build territories logically because you understand the shape of your market.

The iterative nature of GTM Engineering is most valuable early. You can try different approaches every day without fighting through tech debt or organizational inertia. Later, the function is still critical, but you’re engineering around constraints instead of building in a green field.

What’s next

We announced several new products at our Sculpt conference. Sculptor, the native Sequencer, Audiences. A lot of that functionality is still rolling out to customers, which means the internal GTM Engineering team is actively building the workflows that take advantage of these new capabilities.

Content generation is the current frontier. The gap between a good follow-up and a great proposal that synthesizes months of conversation is where we’re pushing.

And we’re watching the sales interface space closely. The world of external GTMEs toggling between eight Chrome tabs is ending. What replaces it will probably be some single pane of glass that agents and ops teams can orchestrate behind the scenes. We’re building toward that future, even if we don’t know exactly what the final interface looks like.

The core thesis

GTM Engineering works at Clay because we treat it like engineering. Clear ownership, sprint-based delivery, version control, release notes. The team has space to build real infrastructure instead of fighting fires.

The reporting structure gives them authority to make architectural decisions. The tech stack stays simple enough that they can actually understand the full system. And the work they do—generating decks, automating follow-ups, routing signals—directly impacts revenue in ways everyone can measure.

You don’t need to be a data platform company to run this playbook. You need to believe that GTM infrastructure deserves the same rigor you’d apply to product engineering. And you need to hire people who can build, not just administer.

Start early. Keep the stack tight. Give the team real engineering practices. Let them sit close to the top of the org chart.

That’s how you build GTM infrastructure that scales.

Subscribe now

Field note from Hg1

We believe most AI pilots fail because organizations are trying to run before they walk. They sprint straight into complex automations but their momentum sputters because they haven’t built the right foundations to support their projects. At Hg, we’ve watched this pattern repeat across the industry.

We have a strong thesis that AI is becoming a critical value creation lever in go to market. After rigorous evaluation, Hg decided to partner with Clay with the aim to bring tailored solutions to our portfolio companies to transform their GTM operations. We chose this specific partnership because the technology solved the data foundation and orchestration challenges that cause 95% of AI pilots to fail. Over the past few months, we’ve systematically deployed the platform across several portfolio companies, with another dozen currently in proof-of-concept stages, learning exactly what it takes to turn GTM AI promise into revenue reality.

This collaboration revealed a critical insight from our perspective: success requires more than just deploying technology. The portfolio companies driving successful POCs all paired the platform’s AI orchestration capabilities with deep GTM engineering expertise. Those trying to implement without clear use cases and RevOps knowledge struggled, while those with the right operational talent saw immediate impact. This observation led us to develop this framework together, codifying the patterns that consistently deliver results.

The outcomes validate our thesis. POCs are demonstrating stronger data quality against their existing single-provider approach, in cost per qualified opportunity through intelligent lead enrichment and acceleration in enterprise sales cycles using AI-powered deep account research. These aren’t lucky breaks; they’re the predictable result of following the three-level progression we have built and outlined here.

What follows is the blueprint for AI integration that we have been deploying throughout our portfolio companies. The framework has been refined through each implementation and designed to turn GTM AI investment into sustainable competitive advantage. As AI integration scales across your organisation, individual productivity gains compound into sustainable competitive advantages. But without building a solid foundation first, you’ll waste time and resources on projects that never get fully realized.

The AI pilot problem: Why many fail

Many of you will have read the viral statistic from MIT that 95% of AI pilots in SaaS companies are failing to deliver meaningful business impact. The debate on how definitively to take this rages on (some experts caution that the figure is an estimate based on qualitative data and should not be considered a statistically proven fact), but it does serve as a useful wake-up call about the risks of projects not adding value and being condemned to the long line of experimental R&D projects that don’t drive material business impact.

Some people have taken that to mean that AI integrations are borderline useless. We know that’s not the case because we’ve seen how automation can totally transform how individuals and organizations do business. Rather, the failure of AI programs is due to the approach that many companies take. We see a lot of companies consistently jump straight into complex, black-box automation solutions without building the foundational understanding and processes needed for sustainable AI adoption.

On the other hand, the most successful SaaS companies we’ve studied take a dramatically different approach. They understand that AI transformation requires building organizational capacity before they try to automate things or equip people with AI platforms. The difference between AI tools that deliver real ROI versus expensive “AI theater” comes down to having good data hygiene, low technical debt, and the discipline to define success metrics before they try to embrace AI.

That’s easier said than done. For SaaS companies, the adoption challenge is compounded by fragmented data architecture across the dozen or more tools in typical GTM stacks. One bad data stream can break the entire pilot. Your teams are managing sophisticated MarTech and SalesTech systems with disconnected data, dealing with increasingly complex buyer journeys, and under pressure to demonstrate clear ROI on every technology investment. It can be a mess to untangle, but putting in the work to get clean systems now will have massive payoffs later. That’s a non-negotiable for scaling AI: You need a good handle on your data in order to get the most out of automation.

The following framework has been stress tested across dozens of SaaS organizations, from high-growth startups to enterprise companies. These are companies where AI tools have flourished, that have avoided being another data point in the 95% failure rate. Each level in the framework builds on the previous one, creating a systematic progression from individual experimentation to organizational competitive advantage.

Subscribe now

Before you get started

Before beginning any level of AI implementation, you need to evaluate your organizational readiness across three critical dimensions:

• Data Quality: Can your systems provide clean, accessible data for AI processing? Fragmented data across disconnected tools will limit any AI initiative’s effectiveness. Most of the time, failures at the initial stages come from poor data foundations rather than AI tool limitations.

• Technical Infrastructure: Do you have the engineering resources and platform capabilities to support AI workflows? This includes API management, data pipeline maintenance, and system integration capabilities that become essential at Level 2.

• Organizational Readiness: Does your leadership team understand the investment timeline and change management requirements? Each level requires sustained commitment and often significant process changes.

Organizations that skip this assessment frequently fail at implementation, not due to AI limitations but because of foundational gaps that become apparent only after significant investment.

Level 1: Individual AI access & literacy building

Flooding your organization with AI tools and hoping for the best is exactly how pilots fail. You want to get your teams comfortable with AI tools by putting them directly into the hands of the right individual users and training them on how to use these tools for their specific use cases. Engineers, SDRs, marketers, and project managers are all going to use the same tool in different ways, so they need to be taught how to get the most out of different platforms based on what they need.

This isn’t just about individual efficiency gains either. The insights and workflows discovered in Level 1 become the foundation for a more comprehensive, system-wide deployment in Level 2.

Implementation Strategy

First things first: get ChatGPT, Claude, or another conversational AI tool into the hands of sales reps, SDRs, content marketers, and executives and train them. Almost everyone knows how to talk to an LLM at a basic level now, but there’s a huge amount of value in providing hands-on educational sessions that go beyond basic AI awareness. Understanding the difference between a good prompt and a great prompt—including prompt engineering techniques—provides a benefit to the individual and sets you up for a wider AI legibility across an entire org. The difference between a basic ChatGPT prompt and one that can handle complex inputs and logic also involves context management, error handling, and quality controls, all of which need to be taught to users from Day 1.

Effective prompts at this level include basic syntax, clear output formatting requirements, and validation steps. For example, a deal inspection prompt for a growth marketer needs to specify the exact fields to analyze, the risk categories to evaluate, and the format for recommendations. A lot of times people will just type in “analyze this call transcript,” expect a perfect output, and get frustrated when it doesn’t match expectations. They might even decide AI “doesn’t work” because it’s giving them impractical or ineffective results. A lack of training at this level creates a certain amount of doubt around the value of a tool, which is hard to come back from as you scale AI in an organization. For users new to Clay, we help with this by giving people a “metaprompter” which builds structured prompts from simple instructions.

Create systematic documentation processes that capture both successful workflows and failure modes. This documentation becomes critical input for Level 2 centralization decisions.

Teams are going to progress at different rates and find value in different ways, too, which is why documentation is vital at this first stage. Have individuals note where their successes and failures are happening and then use that to refine your integration. Our data shows that SDRs and content marketers typically see the fastest ROI at this level, often achieving 20-30% time savings on routine tasks within their first month of use. The employment platform Oyster found that sales reps were saving 40 hours every week thanks to Clay’s automation tools, which means their sales teams had an extra week of time every month to work on deal flow. Other teams will see faster or slower gains, but regardless of pace it’s vital to keep track of where things are thriving or foundering.

Here’s where we see a lot of value generated at Level 1:

• Deal Inspections: AI can analyze call transcripts to extract key insights, identify risk factors, and suggest next steps. This is particularly powerful for complex enterprise deals where reps are managing multiple stakeholders and decision criteria.

• Content Personalization: Creating customized outreach messages based on prospect research. AI can synthesize information from LinkedIn profiles, company news, and industry trends to craft relevant, personalized messaging at scale.

• Data Analysis: Processing CRM data to identify patterns and opportunities that might not be obvious from standard reports. This includes spotting trends in deal progression, identifying characteristics of high-value prospects, and uncovering pipeline risks.

• Meeting Preparation: Synthesizing account history, recent interactions, and research into comprehensive briefing documents that help reps show up prepared and credible.

• Email Drafting: Creating first-draft responses that reps can refine and personalize, dramatically reducing the time spent on routine communications while maintaining quality.

Find what’s ready for the next level

As individuals experiment with AI tools, look for workflows that show consistent results across multiple users. Those are the opportunity areas, the processes that can be standardized and scaled without losing effectiveness. The most successful Level 2 implementations emerge from Level 1 use cases that demonstrate clear value, repeatable processes, and scalable impact.

Document not just what works, but why it works: the specific prompt structures, data inputs, and validation steps that produce reliable results. This documentation becomes the blueprint for centralized deployment.

You also need to track user adoption rates across different roles to understand where AI is gaining traction, because that’s where you’ll find exactly where to focus your deployment. Do things like measure time savings on specific tasks for specific teams, and have them report back on where they’re seeing the biggest gains. For context, we’ve seen successful Level 1 implementations showing anywhere from a 15% to a 40% efficiency gain on targeted workflows. Monitor quality improvements in outputs, particularly in areas like email response rates and meeting preparation thoroughness.

You’re going to inevitably run into issues with attribution at this stage. For example,how do you measure the revenue impact of AI-generated insights that influenced a deal that closed six months later? The best way to solve this is by creating leading indicators like engagement rates on AI-enhanced outreach, meeting conversion rates from AI-prepared briefings, and deal progression velocity. These are proxy metrics, but they’ll help build business cases for Level 2 investment.

Where Level 1 can fail

Failures right out of the gate usually result from poor data quality and infrastructure. The golden rule of garbage in, garbage out applies here. There’s also the challenge of insufficient prompt engineering sophistication. Teams get excited about AI possibilities but create workflows that produce inconsistent outputs because the underlying data or prompts aren’t production-ready. It can be easy to get discouraged and go back to manual processes if the tools aren’t getting the job done, and often that’s because there are issues with data and prompt syntax.

Level 2: Centralized deployment & standardization

Equipping individuals with AI and training them to use these tools in ways that work for them is how you get an organization comfortable with automation. But scaling AI is exponentially tougher, both because you’re asking people to take a leap of faith to hand over manual processes and putting business goals in the hands of new technologies. Taking what you learned in Level 1 isn’t going to be enough.

Building on Level 1 Insights

Start by identifying which workflows you built in Level 1 are ready for the next step. There are a couple ways of doing this, but usually the most scalable workflows share common characteristics: they produce consistent results across different users, they can be standardized without losing effectiveness, and they address high-impact, high-frequency tasks.

Organizing and categorizing the best prompts and processes for different platforms—especially the ones that can orchestrate complex workflows—is vital. That’s also where tools like Clay become essential for sophisticated GTM operations. The standardization process involves converting individual prompt experiments into production-ready systems with proper error handling, quality controls, and integration capabilities.

Real, comprehensive organizational change is needed to get the full benefits of this second step in the AI scaling process. You’ll need to hire or designate go-to-market engineering resources, establish AI governance and quality control processes, and create feedback loops between individual users and centralized operations teams.

Based on our observations across SaaS companies, the most effective organizational structure includes a dedicated GTM engineering function that sits between traditional RevOps and the broader engineering organization. This team needs both technical aptitude and deep understanding of go-to-market processes, which are exactly the combination that will be essential as you continue to build AI into your organization.

Key Focus Areas

There are dozens of directions that AI scaling can take in Level 2, but it’s most effective to identify the ones most valuable to your organization. Here are a few to consider:

• Process Acceleration: Converting manual tasks that previously took hours into automated workflows that complete in minutes. The most successful implementations focus on workflows where the time savings are dramatic—typically 10x or greater improvements that justify the centralization investment.

• Quality Standardization: Ensuring consistent output quality across all users and use cases. This requires developing prompt templates, approval workflows, and quality control mechanisms that maintain the effectiveness discovered in Level 1 while enabling organization-wide deployment.

• Knowledge Capture: Systematically documenting and sharing best practices from Level 1 power users. This institutional knowledge becomes a competitive asset that compounds over time and provides the foundation for Level 3 capability development.

• Workflow Integration: Connecting AI processes with existing CRM, marketing automation, and sales enablement tools. The integration work done at Level 2 creates the technical foundation that enables Level 3’s more sophisticated multi-system workflows.

Implementation use cases

Because of how much GTM organizations rely on manual processes, there is an astounding set of potential use cases for AI. Here are a few to consider:

• Automated Deal Scoring: Standardized prompts that analyze deal health across all opportunities in your CRM, providing consistent risk assessment and next-step recommendations that help managers focus their coaching efforts while creating data patterns that inform Level 3 predictive capabilities.

• Lead Enrichment Workflows: Systematic data enhancement for all inbound prospects, combining firmographic data, technographic insights, and intent signals to create comprehensive prospect profiles automatically. The data quality improvements enable Level 3’s advanced targeting and personalization capabilities.

• Competitive Intelligence: Automated monitoring and analysis of competitor mentions, feature releases, and market positioning changes that feed directly into your product marketing and sales enablement processes while building the competitive data foundation for Level 3’s dynamic positioning capabilities.

• Pipeline Reporting: AI-generated insights and summaries for leadership reviews that go beyond standard CRM reports to identify trends, risks, and opportunities requiring executive attention, while establishing the analytical patterns that enable Level 3’s predictive insights.

Where Level 2 fails

We see organizations failing at Level 2 when they underestimate how complex it can be to integrate AI into production-ready systems or not putting enough into their change management efforts. The technical implementation succeeds, sure, but user adoption fails because the workflows don’t integrate smoothly with existing processes or because teams haven’t been properly prepared for the transition from individual control to centralized systems. This is a step that requires both technological investment and a lot of personal nuance to succeed, so pay attention to both sides of the equation.

Level 3: Net new capabilities & GTM alpha

Deploying AI to individuals and your organization is all a way of setting up for entirely new capabilities that can only be achieved with those strong foundations. It’s where the return on your investment in AI comes in and gives you genuine, bankable competitive advantages. We call those edges GTM alpha, where you’re making plays on data that your competitors simply can’t match.

While Levels 1 and 2 focus on making existing processes faster and more efficient, Level 3 creates capabilities that didn’t exist before AI. The key question becomes: “What could we do if we had perfect information and infinite processing power?” The answer depends entirely on the data quality and organizational capabilities built in the previous levels.

Preparing for success at this stage is more about creative problem solving and understanding exactly what AI is capable of. You’ve created the systems, now you get to take advantage of them. The most successful Level 3 implementations we’ve studied are delivering measurable, sustainable, and distinct competitive advantages:

• Predictive Account Intelligence: Companies are using AI to identify expansion opportunities 3-6 months before they become obvious through traditional signals, analyzing usage patterns, support tickets, and stakeholder changes to predict when accounts are ready for upselling. Vanta uses Clay to track external signals that indicate sales opportunities and automates that research process. Now they’re able to do real-time outreach based on funding events, hiring signals, and compliance updates to beat their competitors.

• Dynamic Competitive Positioning: Real-time analysis of competitor mentions, feature releases, and win/loss data automatically adjusts sales messaging and positioning for each opportunity. When a competitor announces a new feature, the system immediately identifies affected deals and suggests updated talk tracks.

• Behavioral Revenue Attribution: Advanced systems track the complete customer journey from first touchpoint through expansion, using AI to identify which specific interactions and touchpoints most strongly correlate with revenue outcomes. Amplitude combined their own first-party data as well as third-party data with Clay to identify customers that were good candidates for cross-selling.

• Contextual Deal Coaching: AI systems that maintain context across multiple interactions provide increasingly sophisticated coaching to sales reps, remembering previous challenges with similar prospects and suggesting personalized approaches based on what’s worked historically with comparable accounts.

These sorts of plays are where AI integrations yield tangible results on your bottom line, and free up time for people to do their best work. Here’s how we categorize those benefits to give you an idea of how to grade your AI integration:

• New Business: Competitive differentiation that helps win more deals versus competitors which means unique plays and leveraging proprietary data combinations or unique process innovations.

• Better Retention: Improved customer experience that results in customers staying around longer and increasing spend with your business. This dramatically improved buyer and customer experiences give new meaning to speed and personalization at scale.

• Process Efficiencies: Automating processes to decouple revenue growth from headcount growth. Think direct contribution to pipeline creation and deal closure through capabilities that identify opportunities and enable approaches at scale without proportional team expansion

Where Level 3 fails

There are a lot of potential pitfalls for this final stage of the framework, but organizations often get tripped up by attempting to build competitive advantages while skipping the foundational work of Levels 1 and 2. Teams create sophisticated capabilities but can’t prove business impact or justify continued investment because they lack the organizational maturity and data infrastructure necessary to support advanced AI applications.

The GTM Engineering Function: Your AI-First Organization

Why GTM Engineering Becomes Essential

As organizations progress through the three levels, the need for dedicated GTM engineering expertise becomes critical. Individual AI tools require minimal technical support, but centralized deployment and competitive advantage creation demand specialized skills that bridge traditional engineering and go-to-market operations.

AI systems require ongoing maintenance, optimization, and improvement that business users cannot handle alone. The integration complexity with existing business systems requires specialized technical knowledge. Organizations need dedicated expertise to stay ahead of the AI capability curve and to build the Level 3 capabilities that create sustainable competitive advantages.

Core Responsibilities and Skills

The most effective GTM engineers combine technical aptitude with AI/ML tools and APIs, deep understanding of go-to-market processes and metrics, and data analysis and workflow optimization expertise. They also need change management and user adoption skills, as they’re often responsible for rolling out new capabilities across resistant or overwhelmed business teams.

Key responsibilities include workflow design and optimization for all three levels, developing and maintaining high-quality prompts for various use cases, managing integrations between AI tools and existing business systems, monitoring AI system performance and identifying improvement opportunities, and training and supporting business users as they adopt new AI-powered capabilities.

Career Paths and Hiring Strategies

The role of GTM engineer is still emerging, but we’re seeing several successful hiring patterns. Some companies promote from within, taking their strongest RevOps professionals and investing in their technical skills development. Others hire from technical backgrounds and train them on GTM processes. The most successful approach often involves creating hybrid roles that combine traditional operations expertise with technical capability, exactly what’s needed to execute this three-level framework successfully.

Implementation Roadmap: Your Path to AI-First GTM

There’s no one-size-fits-all calendar for scaling AI in your organization. Leaner companies can move towards data hygiene and implementation much more quickly than enterprise SaaS orgs that may be digging out of years of data debt. We put together this timeline to provide a general sense of how long each phase should take, but rather than paying attention to the schedule, it’s more important to finish each step before moving on to the next one so you have a strong foundation on which to build.

Level 1: Foundation Building (6 months)

Deploy individual AI tools across your organization, starting with the roles that showed highest engagement in your pilot programs. Conduct comprehensive training sessions that go beyond AI awareness to include sophisticated prompt engineering, result validation, and workflow documentation.

Begin systematically documenting successful use cases and power user behaviors—this documentation becomes the foundation for Level 2 scaling. Establish governance guidelines that balance experimentation with risk management while ensuring data quality standards that will support Level 2 and 3 implementations.

Level 2: Centralization (12 months)

Hire or designate go-to-market engineering resources based on your planned implementations’ scale and complexity. Most enterprises need 12-18 months to reach Level 3 maturity with dedicated resources and strong leadership commitment.

Implement a centralized AI orchestration platform that can handle your most promising Level 1 workflows while building the technical foundation for Level 3 capabilities. Address integration challenges with existing MarTech and SalesTech stacks—budget $50,000-$200,000 annually for platform costs, engineering resources, and training investments.

Create quality control processes and measurement frameworks that can track both leading and lagging indicators of AI impact across all three levels.

Level 3: Innovation (18 months)

Design and implement net new capability workflows that create competitive advantages rather than efficiency gains, building on the infrastructure and organizational capabilities developed in Phases 1 and 2. Establish sophisticated measurement systems that include leading indicators, attribution models, and business case frameworks for continued investment.

Build organizational capabilities for continuous innovation and adaptation as AI technologies evolve, ensuring your competitive advantages remain sustainable.

Measuring impact

Building Attribution Models Across All Levels

Successful AI GTM implementations require measurement frameworks that evolve with each level. Level 1 focuses on efficiency metrics and user adoption. Level 2 adds process standardization and quality consistency measures. Level 3 requires sophisticated attribution models that can track competitive advantage creation and long-term business impact.

Track time savings on specific workflows, weighted by the hourly value of affected roles. Monitor quality improvements through metrics like email response rates, meeting conversion rates, and deal progression velocity. Develop attribution models that account for AI’s influence on long-term outcomes, using leading indicators like engagement rates on AI-enhanced outreach and meeting conversion rates from AI-prepared briefings.

Revenue Impact Measurement

Revenue impact measurement should include both direct pipeline contribution and velocity improvements across existing deals. Customer acquisition cost improvements often result from more efficient targeting and personalization capabilities developed through the three-level progression.

Build business case frameworks that help leadership understand the compound effects of AI investments and justify continued innovation funding even when individual ROI calculations prove challenging. The most sophisticated measurement approaches track how Level 1 efficiencies enable Level 2 standardization, which in turn creates the foundation for Level 3 competitive advantages.

Long-term Value Recognition

One of the most significant long-term impacts of systematic AI GTM adoption is the improvement in customer lifetime value through better targeting, onboarding, and expansion identification. The compound effect of these improvements can be substantial—small improvements in customer selection and onboarding experiences compound over years to create significant competitive advantages in unit economics.

Conclusion: The Future of AI-First GTM

The three-level framework provides a systematic approach to AI adoption that minimizes risk while maximizing long-term competitive advantage. Organizations that implement this approach systematically are creating sustainable competitive advantages that build up organizational capabilities one step at a time.

Rather than asking whether to adopt AI, forward-thinking GTM leaders are asking harder questions: Should we build these capabilities internally or buy them? How do we create competitive advantages that extend beyond the typical 12-18 month window before capabilities become commoditized? What predictions can we make about where this technology evolution leads in 2-3 years?

The companies that start building systematic AI capabilities now—with proper foundations, realistic timelines, and sophisticated measurement—will have significant advantages over those waiting for perfect solutions or clearer ROI calculations.

Your Next Steps

Start with an honest assessment of your current state against this framework. Most organizations discover they’re not ready for Level 2 or 3 implementations due to data architecture or organizational readiness gaps. Address these fundamentals first.

Identify your highest-impact use cases at Level 1 and begin building organizational muscle around prompt engineering, result validation, and workflow documentation. The learning from these early implementations becomes the foundation for everything that follows.

Remember: each level builds on the previous one. Level 1 experiments inform Level 2 standardization, which enables Level 3 innovation. Organizations that try to skip levels or rush the progression typically fail to achieve sustainable competitive advantages.

The future of go-to-market belongs to organizations that can combine human insight with AI capability systematically. This framework provides the roadmap, but success requires commitment to building capabilities rather than just implementing tools.

Learn more about how Clay is ushering in the era of GTM engineering.

Most go-to-market teams are sitting on a goldmine they don’t even know exists.

Every call transcript you have from discovery sessions to customer conversations contain intelligence that should be improving how you build and sell your product.

Yet this context often remains buried in transcripts, lost in Slack threads, or trapped in individual reps’ heads.

At Clay, we’ve built our entire GTM engine around extracting and activating conversational data. That includes…

• Auto-generating handoff docs and slides when deals move from sales → CX

• Analyzing calls for competitive mentions and expansion ideas to start sales or upsell conversations

• Mining conversations for internal feedback on our sales process or product

This approach has fundamentally changed how our GTM teams operate. Our CX team receives deep context before their first customer call and receives feedback that Clay feels like the company that “really understands” their business. Our sales team gets automated competitor intelligence—which our marketing team runs campaigns on. Our product team gets structured feedback from hundreds of deals. All without any manual work.

We’re turning every customer interaction into an actionable workflow to help us increase revenue and find GTM alpha. Read on to learn how to do it too.

Table of Contents

1. Guiding principle: conversations are structured data sources

2. Use your conversations as GTM alpha

   • Building seamless transitions between sales and CX (or between any team for that matter)

   • Finding conversational signals for selling or expanding customers

   • Mining conversations for feedback

3. How to construct the technical architecture to do it yourself

   • Process all your conversation in one place and build reusable intelligence

   • Extracting insights with JSON schemas in Clay

   • Speaker attribution: deeper details for precise targeting

   • Advanced implementation: interactive query capabilities

4. Implementation roadmap and success metrics

5. Conversations as competitive advantage

Subscribe now

Guiding principle: conversations are structured data sources

Most people see conversations as unstructured “soft” data that requires manual interpretation. We see them as structured data sources waiting to be unlocked. Our philosophy centers on three principles:

Auto-extract key points: We automatically extract insights from every conversation using structured flows using formats that align with our team’s note-taking processes.

Process conversations in one central point: We run all conversations through a central pipeline that multiple teams can use.

Trigger automatic workflows based on notes: Our extracted insights immediately trigger workflows like pipeline generation campaigns, handoff automations, product feedback loops, and strategic reporting.

Based on our experience building conversational data workflows, we’ve identified three distinct categories where this approach creates immediate value—for CX, sales, and product feedback.

We’re going to go through each use case and then zoom out to help you figure out how to build the foundation for yourself.

1. Building seamless transitions between sales and CX

An impactful starting point for most teams is automating handoffs between GTM functions. At Clay, this happens when deals transition from sales to CX—but the principles apply to any cross-team transition.

The pre-automation problem: Customers would join their first post-sale call and face the dreaded “So, tell me about your business and why you bought Clay” conversation. Despite having 4-5 detailed discovery calls with sales, they’d need to restart from zero with their CX account manager. From the customer’s perspective, this felt like the company had amnesia. From the team’s perspective, it meant starting relationships from scratch despite weeks of prior context. Requiring people to make slides, docs, or handoff notes manually was too tedious to scale.

Our automated solution: Now, every time a deal closes, our system automatically processes all pre-sale conversations and extracts structured insights using a comprehensive JSON schema. Growth strategists receive auto-generated slide decks with complete customer context before their first call—no manual handoff work required.

Impact: Customers don’t repeat themselves across handoffs—when the growth strategist references specific challenges from the discovery call, customers immediately feel heard and understood. Growth strategists arrive armed with comprehensive context, eliminating catch-up conversation time per handoff. Sales reps avoid manual handoff documentation, and nothing falls through the cracks.

How to do it yourself:

Our system automatically processes all pre-sale conversations and extracts structured insights using a comprehensive JSON schema:

{
  “icp_alignment”: “Strong fit - Series B SaaS company with 50+ person go-to-market team”,

  “org_structure”: “Centralized RevOps team reporting to CRO, 
distributed SDR teams by region”, 

  “primary_challenges”: [

    “Data enrichment taking 40+ hours per week of manual work”,

    “Lead routing delays causing 3-day response times”,

    “Inconsistent data quality across 4 different tools”
  ],

  “red_flags”: [

    “Mentioned budget approval process requires board sign-off”,

    “Previous implementation of similar tool failed due to adoption issues”
  ],

  “expansion_potential”: “Interested in account-based marketing workflows for enterprise segment”,

  “competitors_mentioned”: [
    {
      “name”: “ZoomInfo”, 

      “budget”: “$50K annually”,

      “renewal_date”: “September 2024”,

      “sentiment”: “Frustrated with data accuracy”
    }
  ],

  “key_stakeholders”: [
    {
      “name”: “Sarah Chen”,

      “role”: “VP Revenue Operations”, 

      “influence”: “Primary decision maker”,

      “concerns”: [”Implementation timeline”, “Team adoption”]
    }
  ]
}

Practical implementation detail: Our system automatically generates slide decks for the growth strategist team using these extracted insights. Instead of manually creating customer overview presentations, the workflow pulls from the structured Call Insight records to create comprehensive context decks that include ICP alignment, organizational structure, key challenges, red flags, and stakeholder mapping.

The slide generation workflow operates on a standardized template that adapts based on the extracted data. For enterprise deals, the deck automatically includes sections on decision-making processes, technical requirements, and compliance considerations that emerged from sales conversations. For SMB customers, it emphasizes implementation timeline concerns, budget constraints, and adoption challenges. The system even identifies which growth strategist should handle the account based on industry expertise or previous experience with similar customer profiles mentioned in the conversations.

This eliminates manual prep work per handoff while ensuring nothing gets missed. More importantly, it creates consistency across our customer success team—every growth strategist receives the same quality of customer intelligence regardless of how detailed the handoff notes were from sales.

2. Finding conversational signals for selling or expanding customers

The second category focuses on extracting signals that directly generate new pipeline opportunities. We’ve built several core workflows that consistently drive measurable revenue results.

The pre-automation problem: Sales reps would hear competitors mentioned, budget numbers discussed, and renewal dates referenced during calls—but this intelligence rarely made it into CRM or triggered any systematic follow-up. Reps might remember to log “Uses ZoomInfo” but miss the renewal date, budget amount, or which specific person expressed frustration. Expansion opportunities mentioned in passing during customer calls disappeared into call notes that nobody systematically reviewed. Without structured capture, this revenue intelligence was lost.

Our automated solution: Now, every conversation gets analyzed for competitive mentions, budget discussions, renewal timelines, and expansion signals. When a prospect says “We spend $50K annually on ZoomInfo and it renews in September, but we’re frustrated with data accuracy,” our system automatically creates structured competitive intelligence records and triggers targeted displacement campaigns—without any manual work from the sales team.

Analyze calls for competitive mentions

We analyze every conversation for competitor mentions, budget discussions, and renewal timelines. When a prospect says “We spend $50K annually on ZoomInfo and it renews in September, but we’re frustrated with data accuracy,” our system creates structured records with granular detail like:

• Competitor Intelligence Object: Competitor name, current spend, contract details, renewal timeline, decision-making stakeholders

• Sentiment Analysis: Specific frustration points and satisfaction gaps

• Opportunity Scoring: Displacement probability based on budget size, renewal timing, and pain point severity

• Stakeholder Mapping: Who mentioned the frustration, their role, and influence level

Then, the system immediately creates a “ZoomInfo Displacement” campaign targeting the specific stakeholder who mentioned their frustrations. The campaign includes relevant case studies showing ZoomInfo-to-Clay migrations, ROI calculators based on their mentioned budget, and time-sequenced outreach aligned to their renewal timeline.

Analyze calls for customer expansion signals

Calls are a great way to detect customer expansion use cases. When customers mention interest in specific capabilities during calls, our system captures this and automatically triggers targeted campaigns.

For example, our colleague Spencer built a way to ID the vendors prospects currently use and what new use cases they want to explore. This information feeds directly into marketing email campaigns and product launch targeting. (Every time we launch a new product feature, we can immediately identify and target customers who previously expressed interest in that specific use case).

Here’s how this works in practice:

When we launched our Clay Sequencer product for automated outreach sequences, we queried our conversational database for all mentions of “automation,” “sequences,” “follow-up workflows,” and related terms from the past 12 months. The system identified 340 prospects and customers who had expressed interest in automation capabilities during sales or customer success calls. We automatically segmented these contacts based on company size, current tool stack, and specific automation challenges mentioned in their conversations.

The campaign launched with three different email tracks: enterprise prospects received messaging about replacing complex automation tools, mid-market prospects got content about scaling outreach efficiently, and existing customers saw expansion messaging about adding automation to their current workflows. Because we knew exactly what each person had said about automation needs, we could reference their specific challenges in outreach messages.

Use call data to better target marketing campaigns

When we launch new product features, we query our conversational database to identify all customers who previously mentioned interest in related use cases. This allows us to immediately target the most relevant audience with personalized messaging about capabilities they specifically requested.

We also use conversational intelligence to trigger ongoing nurture campaigns. When someone mentions they’re “evaluating marketing automation tools” or “looking at ABM solutions,” they automatically enter specialized nurture sequences with relevant case studies, comparison guides, and educational content specific to their expressed interests. The campaigns reference not just what they’re interested in, but who mentioned it and in what context, creating highly personalized messaging that feels like a natural continuation of their sales conversations.

The attribution advantage: The critical differentiator is speaker-level attribution. We don’t just capture that “they use ZoomInfo”—we capture that “Sarah from RevOps mentioned frustration with ZoomInfo’s data accuracy during the discovery call.” This granular attribution means our outreach targets the right person with the right message at the right time.

3. Mining conversations for feedback

Conversational data also helps us improve our product and sales motion.

The pre-automation problem: Traditional closed-lost analysis relied on sales reps manually categorizing why deals fell through—often incomplete, inaccurate, or overly simplified. A rep might mark “pricing” when the real issue was the way they mentioned GPDR compliance, or “chose competitor” without capturing which competitor or why. Product teams received anecdotal feedback filtered through multiple layers, losing the nuance of actual customer language. Sales leadership had limited visibility into systematic failure patterns or what differentiated successful reps from struggling ones.

Our automated solution: Now, our system processes actual conversation transcripts from lost deals to identify systematic patterns with unprecedented granularity. Instead of relying on rep recollection, we extract the real reasons—with specific quotes, stakeholder objections, and competitive factors—directly from the calls. This intelligence automatically feeds product roadmaps, sales training programs, and strategic planning discussions.

Automated closed-lost analysis

Our system processes actual conversation transcripts from lost deals to understand systematic failure patterns with unprecedented granularity.

Our closed-lost extraction schema includes:

{

“primary_loss_category”: “missing_integration”,

“detailed_reason”: “Required Marketo integration for European compliance workflows that we don’t currently support”,

“stakeholder_objections”: [

{

“stakeholder”: “GDPR Compliance Manager”,

“objection”: “Data residency requirements”,

“severity”: “deal_killer”

}

],

“competitive_factor”: “Chose Clearbit due to EU data centers”,

“deal_stage_lost”: “technical_evaluation”,

“recovery_possibility”: “low - fundamental capability gap”

}

Sales training and enablement

The closed-lost analysis creates a detailed feedback loop for sales training that goes beyond simple win/loss categorization. Our sales leadership receives structured documentation showing not just what happened, but specific quotes and conversation patterns that led to deal outcomes.

For example, our analysis revealed that newer reps had lower win rates when prospects raised “implementation complexity” concerns during technical evaluation calls. When we analyzed the actual conversation transcripts, we found that experienced reps responded to implementation questions by simplifying technical concepts and providing concrete timelines, while newer reps often went deeper into technical details that increased prospect anxiety.

One experienced rep’s transcript showed this approach: “I understand implementation seems complex. Let me break down what the first 30 days actually look like for customers like you. Week one is just connecting your CRM, which takes about 15 minutes. Week two, we build three simple workflows together. By week three, you’re seeing results.” Meanwhile, a newer rep’s response went: “Implementation involves API configurations, webhook setups, data mapping protocols, and schema validation processes that integrate with your existing tech stack.”

This analysis led to specific coaching programs focused on “technical translation”—helping new reps explain complex capabilities in business-impact terms rather than technical specifications. We built role-playing scenarios based on actual conversation patterns that led to successful outcomes versus losses.

Beyond sales: support ticket integration

We don’t limit conversational data to sales conversations. Our system also processes support tickets and customer success sessions to identify product feedback patterns and user experience insights that feed directly into product development prioritization.

Bruno built workflows that analyze support conversations for recurring themes like feature requests, integration needs, and usability concerns. For instance, when analyzing three months of support tickets, we discovered that a significant portion of integration support requests involved Marketo connections, with customers frequently mentioning “European compliance workflows” and “GDPR automation” as their primary use cases.

This intelligence directly influenced our product team’s decision to prioritize European compliance features in the Marketo integration, rather than focusing on general automation capabilities that seemed more popular in sales conversations but weren’t driving actual support volume. The support conversation analysis revealed the gap between what prospects say they want and what customers actually struggle with post-implementation.

How to construct the technical architecture to do it yourself

You have to solve several engineering and operational challenges to make conversational data actionable.

Process all your conversation in one place and build reusable intelligence

We architected a central pipeline that creates reusable “Call Insight” records in Salesforce. This architectural decision multiplies the value of each conversation by making insights available across multiple workflows.

The processing pipeline: Every conversation flows through our standardized extraction system:

1. Ingestion: Our conversational intelligence platform captures conversations and triggers our processing workflows within minutes of call completion

2. Extraction: Multiple specialized prompts extract different insight categories in parallel

3. Validation: Automated quality checks ensure schema compliance and logical consistency

4. Storage: Validated insights populate custom Salesforce objects with proper field mapping

5. Distribution: Downstream workflows consume pre-processed insights rather than raw transcripts

Call Insight data model: Our core Salesforce object structure includes:

• Call Insight Header: Metadata, participants, timestamp, processing status

• Competitive Intelligence: Competitor mentions, sentiment, budget, timeline details

• Use Case Insights: Current state, expansion interests, tool stack details

• Stakeholder Mapping: Individual participants, roles, influence, specific concerns

• Opportunity Signals: Buying timeline, budget authority, decision process details

Practical architecture benefits: This centralized approach provides two critical advantages. First, individual workflows can focus on their specific value creation rather than handling conversation processing complexity. When our team builds a new campaign automation, they query existing Call Insight records rather than re-processing raw transcripts. Second, insights get leveraged across multiple use cases without duplicate processing costs or delays.

For example, competitor mentions extracted once get used by both the displacement campaign system and the competitive intelligence reporting for sales leadership. Use case insights feed both marketing campaign targeting and customer success expansion workflows. This architectural decision transforms each conversation from a single-use interaction into a multi-purpose intelligence asset.

Extract insights with JSON schemas in Clay

The foundation of usable conversational data is constraining AI outputs to structured, queryable formats. Rather than getting variable free-form responses, you need to define precise JSON schemas that specify exact fields, data types, and acceptable values for every extraction workflow.

Why this matters: Without structured schemas, AI returns inconsistent free-form text that’s impossible to query programmatically. One extraction might return “They’re frustrated with their current vendor” while another returns “High dissatisfaction levels noted.” Structured schemas ensure every extraction follows the same format, making the data immediately usable in downstream workflows.

Step 1: Identify what information you actually need

Don’t design schemas in a vacuum. Start by talking to the people who will use the extracted data.

For customer handoffs, sit down with your customer success team and ask: “What do you wish you knew before every first call with a new customer?” Write down their answers verbatim. You’ll likely hear things like “their main challenges,” “who the decision makers are,” “what they’re hoping to accomplish,” and “any concerns or red flags mentioned during sales.”

For competitive intelligence, interview your sales team: “What competitor details would change how you approach a deal?” You’ll probably hear “which competitor they’re using,” “how much they’re spending,” “when their contract renews,” and “what they’re unhappy about.”

Build your schema around these action-oriented needs. Every field in your schema should answer the question: “What will we do differently based on this information?”

Step 2: Start simple and iterate

Don’t try to capture everything in your first schema version. Start with 5-8 core fields that address your team’s top priorities.

Our handoff schema started with 15 fields because we thought we needed comprehensive data. After three months, we analyzed which fields our growth strategists actually referenced in customer calls. Half weren’t being used at all. We consolidated to 8 high-value fields:

1. ICP alignment (are they a good fit?)

2. Org structure (who reports to whom?)

3. Primary challenges (what problems are they solving?)

4. Red flags (what could derail this relationship?)

5. Expansion potential (what might they buy next?)

6. Competitor mentions (what tools are they replacing or comparing us to?)

7. Key stakeholders (who are the decision makers and what do they care about?)

8. Buying motivations (why did they choose us?)

Each field directly informs how growth strategists approach customer relationships. Nothing in the schema is “nice to have”—everything drives specific actions.

Plan to revisit your schema monthly for the first quarter. Track which fields get used in actual workflows and which get ignored. Remove unused fields and add new ones based on team feedback.

Step 3: Set up your data ingestion

Conversational intelligence platforms provide multiple ways to access the data in your call transcripts. You can use API and webhook capabilities to trigger processing workflows automatically.

Set up a webhook in your favorite platform that fires when calls are completed. This webhook should include the call metadata (participants, duration, timestamp) and provide access to the full transcript. CI platforms capture both calls and other revenue interactions, giving you a comprehensive view of customer conversations across channels.

Your processing system should receive this webhook payload and queue the conversation for extraction. We process conversations within minutes of call completion to ensure insights are available while the conversation is still fresh and relevant.

Step 4: Define your JSON structure

Once you know what fields you need, structure them in JSON format with clear data types and constraints.

Here’s a simplified example for competitive intelligence:

{

“competitor_name”: “string (required)”,

“current_spend”: “string or null (format: ‘$X annually’ or ‘$X/month’)”,

“contract_end_date”: “string or null (format: ‘YYYY-MM-DD’ or ‘Q1-Q4 YYYY’)”,

“renewal_timeline”: “string or null (options: ‘imminent’, ‘within_3_months’, ‘within_6_months’, ‘beyond_6_months’, ‘unknown’)”,

“primary_frustrations”: “array of strings”,

“satisfaction_level”: “string (options: ‘satisfied’, ‘neutral’, ‘frustrated’, ‘actively_looking_to_switch’)”,

“mentioned_by”: {

“name”: “string”,

“role”: “string”,

“influence_level”: “string (options: ‘decision_maker’, ‘influencer’, ‘end_user’)”

}

}

Notice the specific constraints: dates have expected formats, satisfaction levels are limited to predefined options, and numeric fields specify their units. This prevents AI from returning “they’re unhappy” in one extraction and “dissatisfied” in another—both get mapped to “frustrated” based on your prompt instructions.

Step 5: Write detailed prompt instructions

Your extraction prompt needs three components:

1. The JSON schema (what structure you want)

2. Edge case handling (what to do when information is unclear or missing)

3. Output examples (showing properly formatted results)

Here’s how we structure our competitive mention prompt:

Extract competitive intelligence from this conversation transcript.

OUTPUT SCHEMA:

[Include your JSON schema here]

EDGE CASE INSTRUCTIONS:

- If multiple competitors are mentioned, create separate objects for each

- If no budget amount is mentioned, set current_spend to null—do not estimate

- If renewal timeline is vague (”sometime next year”), extract as the full year range “Q1-Q4 2024” rather than guessing specific quarters

- When speakers express frustration, capture their specific language in primary_frustrations—don’t interpret or paraphrase their words

- If the speaker’s role is unclear, set influence_level to “end_user” as the default

- Only mark satisfaction_level as “actively_looking_to_switch” if they explicitly mention evaluating alternatives

EXAMPLE OUTPUT:

[Include 2-3 examples of properly formatted JSON responses]

TRANSCRIPT:

[The actual conversation transcript gets inserted here]

The edge case instructions are critical. They come from reviewing hundreds of extractions and identifying where AI makes inconsistent decisions. Every time you find inconsistent outputs during your quality reviews, add a specific instruction to handle that scenario.

Step 6: Use automated validation

Set up automated checks that run on every extracted record before it enters your CRM or workflow systems. Each check should flag records that fail validation for manual review.

Here are some essential validation checks we use:

1. Schema compliance: Does the JSON structure match your defined schema? Are all required fields present?
   

2. Data type validation: Are dates in the correct format? Are predefined options (like satisfaction_level) using only allowed values? Are numeric fields actually numbers?
   

3. Logical consistency: If a renewal_timeline is specified, is there also a competitor_name? If satisfaction_level is “actively_looking_to_switch,” are there primary_frustrations listed?
   

4. Completeness thresholds: Are text fields substantive (more than 10 characters)? Or did the AI return generic placeholders like “Various concerns mentioned”?
   

5. Required field population: For fields marked as required, is there actual content rather than null values or empty strings?

Build a simple dashboard that shows validation failure rates by type. This helps you spot systematic issues with your prompt or schema design.

Step 7: Create a manual review process

Despite good prompts and validation, some extractions will need human review. Build a weekly process where someone reviews failed validations and identifies patterns.

Here’s our process at Clay:

• Monday morning: Review all validation failures from the previous week (usually 5-10% of total extractions)

• Categorize failures: Group by failure type (date format issues, missing required fields, logical inconsistencies, etc.)

• Identify patterns: If the same type of failure appears 5+ times, it’s a prompt problem, not a data problem

• Update prompts: Add specific instructions to handle the failure pattern

• Reprocess failed records: Run the failed extractions through the updated prompt

For example, we noticed that vague date references like “our contract is up soon” weren’t being handled consistently. Sometimes the AI extracted “within_3_months,” other times “imminent,” other times it left the field null. We added this specific instruction: “For phrases like ‘soon,’ ‘coming up,’ or ‘in the near future’ without specific months, use ‘within_3_months’ as the renewal_timeline.”

After three months of this review process, our validation failure rate dropped from 12% to under 3%, and the failures that remain are genuinely ambiguous cases where human judgment is appropriate.

Find who said what: deeper details of speaker attribution for precise targeting

Advanced conversational intelligence requires capturing not just what was discussed, but who said it. Conversational intelligence platforms provide speaker-attributed transcripts that enable precise stakeholder mapping and targeted follow-up.

Technical implementation: The system processes our call transcripts immediately after each sales conversation. We use Claude with a structured prompt that includes our JSON schema, conversation transcript, and specific extraction instructions. The output populates custom Salesforce objects that our growth strategist team accesses through dashboards and automated slide deck generation:

{

“competitive_mention”: {

“competitor”: “ZoomInfo”,

“budget”: “$50K annually”,

“renewal_date”: “September 2024”,

“speaker”: {

“name”: “Sarah Chen”,

“role”: “VP Revenue Operations”,

“email”: “sarah@prospect.com”,

“sentiment”: “frustrated”,

“specific_quote”: “ZoomInfo’s data accuracy has been really disappointing”

}

}

}

Strategic targeting applications: This speaker-level attribution dramatically improves campaign targeting and account strategy:

• Competitive displacement: Target the specific person who expressed frustration rather than generic account-based outreach

• Use case expansion: Route expansion opportunities to stakeholders who expressed interest in specific capabilities

• Objection handling: Identify which stakeholders raised which concerns for targeted follow-up

• Champion development: Recognize advocates and equip them with relevant supporting materials

Implement interactive query capabilities

We allow GTMEs to query conversational data directly through natural language. Using our integration with Dust, team members can ask questions like “Tell me about what happened on this call with Acme Corp” or “What specific concerns did their compliance team raise?” and get structured responses based on the processed conversational data.

How it works in practice

This creates an interactive intelligence layer where team members can explore conversational context without manually reviewing transcripts.

For example, a growth strategist preparing for a customer expansion conversation can ask: “What use cases did they mention interest in during their last three calls?”

The system responds with structured context, e.g.: “During the Q3 business review, the Marketing Director mentioned wanting to explore ABM workflows for their enterprise segment. In the September check-in, their RevOps lead asked about Slack integration capabilities. Most recently, they expressed interest in expanding to their European team in a GDPR compliant way.”

What makes this valuable

The system can answer specific questions about stakeholder concerns, competitive mentions, technical requirements, or expansion opportunities by querying the structured data we’ve extracted from conversations. This transforms historical conversations from static transcripts into searchable, actionable intelligence that team members can explore conversationally.

Rather than re-reading months of call notes or searching through transcripts manually, team members get immediate, contextual answers to specific questions. The responses include relevant quotes and timestamps, enabling more strategic preparation for customer conversations.

Real-world applications

Our customer success team uses this capability extensively before renewal calls. Instead of spending 30 minutes reviewing call history, they ask targeted questions:

• “What challenges have they mentioned with their current implementation?”

• “Which team members seem most engaged with the product?”

• “Have they mentioned any expansion interests or new use cases?”

• “What concerns did their legal team raise during the sales process?”

The system provides context-rich answers with specific quotes and attribution, enabling CS reps to enter renewal conversations already knowing the key themes, risks, and opportunities. This preparation advantage helps customers feel like we truly understand their business because we reference specific concerns and interests they’ve mentioned over time.

Implementation roadmap and success metrics

Based on our experience scaling conversational intelligence from proof-of-concept to mission-critical GTM infrastructure, here’s how we recommend other teams approach this systematically:

Phase 1: single use case foundation

Start with handoffs: The highest-impact starting point is automating one key handoff in your GTM process. Choose the transition with the greatest context loss and customer friction—typically sales to customer success or SDR to AE.

Technical foundation: Build basic extraction capabilities using a simple JSON schema focused on the specific handoff use case. Start with 5-7 key fields rather than attempting comprehensive extraction.

Success metrics: Measure handoff efficiency (time to first meaningful customer conversation), customer satisfaction scores, and manual documentation reduction.

Phase 2: pipeline intelligence

Add competitive intelligence: Expand extraction to capture competitor mentions, budget discussions, and renewal timelines. Build basic campaign automation triggered by competitive signals.

Schema evolution: Enhance JSON schemas based on Phase 1 learnings. Add speaker attribution and sentiment analysis for more precise targeting.

Success metrics: Track pipeline generated from conversational signals, competitive displacement win rates, and campaign response rates compared to cold outbound.

Phase 3: strategic intelligence

Closed-lost analysis: Implement systematic analysis of lost deals to identify product gaps, process failures, and market positioning opportunities.

Cross-functional integration: Share conversational insights with product, marketing, and strategic planning teams. Build reporting dashboards for leadership visibility.

Success metrics: Measure product feedback cycle time, content performance improvements, and strategic decision-making speed based on conversational intelligence.

Advanced optimization (ongoing)

Predictive enhancement: Integrate conversational signals with existing lead scoring, expansion prediction, and churn prevention models.

Multi-conversation context: Build relationship intelligence by analyzing conversation sequences over time rather than individual interactions.

Compliance and scale: Implement enterprise-grade privacy controls, audit trails, and processing optimization for high-volume conversation analysis.

Conversations as competitive advantage

Every conversation your team has contains intelligence that could drive revenue outcomes. The question is whether you’re systematically capturing and activating that intelligence, or letting it disappear into transcripts that nobody revisits.

Start small. Pick one handoff that frustrates your team and your customers. Build a simple schema. Extract the insights that matter. Then expand from there. The compound value of conversational intelligence grows with every workflow you add.

If you want to see how Clay can help you build conversational intelligence into your GTM workflows, reach out to our team. We’d be happy to show you how we’ve architected these systems and help you think through what would work for your organization.

Most tech companies are overlooking an incredible talent pool of people who are just starting their careers. We knew we didn’t want to make the same mistake, so we decided to build early career hiring into Clay’s talent strategy and create a rotational program that would help those just starting out find their footing. We call it “The Wheel”—and the results have been remarkable.

TL;DR

• Expert generalists beat narrow specialists in an AI-driven world—fresh grads bring technical literacy without over-specialization

• Speed and respect matter in hiring—compressed timelines and responsive communication create massive competitive advantages when most companies ghost candidates

• Early career candidates are an under-appreciated resource—most tech companies avoid early career hiring while qualified graduates struggle to find positions

• Look for cross-functional thinking—focus on candidates who can work across business functions rather than single-skill specialists

• Start small and iterate—test with minimal investment using simple tools (TypeForm + Clay) before building formal processes

The problem: a mismatch in the market

The job market data tells a stark story. Recent graduates are facing one of the toughest job markets in years, with the New York Times highlighting the struggle to find entry-level positions in tech. Meanwhile, companies are hesitant to hire new grads, particularly those with computer science backgrounds who they worry might be displaced by AI.

What that means is that a whole lot of great talent is being left out in the cold, which is a massive opportunity for forward-looking companies to recruit early career professionals. We’ve written a lot about finding GTM alpha; we thought of this as finding talent alpha.

A rotational program that works

The Wheel didn’t start as a grand strategic initiative. It evolved organically from what we were seeing on our support team. We had five to seven people handling customer support, but everyone was also working on side projects across different parts of the business. Support team members were becoming the go-to experts for various initiatives because they understood our product deeply and knew our customers intimately.

We realized we had accidentally created expert generalists: people who could speak multiple business languages while maintaining deep customer knowledge. When we noticed that several high-performing new graduates naturally thrived in this environment, we decided to formalize it into a rotational program.

The scrappy launch: $600 and a TypeForm

Our first run at turning the Wheel into an early career program was beautifully low-tech. We showed up to an NYU career fair with 50 one-pagers, expecting modest interest. Instead, we had a line at our table for the entire four-hour event.

It turned out we were the only tech company there. While other companies were fighting over the same pool of experienced candidates, we had found an untapped market of eager, talented people.

Our entire initial investment was approximately $600 for the career fair booth plus food for our rapid-fire interview day. We bypassed our formal applicant tracking system entirely, running everything through a TypeForm that fed into Clay. If it failed, we’d lose almost nothing. If it succeeded, we’d learn something valuable.

It succeeded. We received over 300 applications and hired our first cohort of seven people.

The Expert Generalist Advantage

Here’s what we’ve learned about why early career hires are particularly valuable in an AI-driven world:

• Fresh perspective without preconceptions. New graduates come in without years of “this is how we’ve always done things” thinking. In a rapidly evolving AI landscape, this flexibility is invaluable.

• Technical literacy without over-specialization. We like to say that the modern computer science graduate knows “enough to be dangerous.” They can speak the language of engineering but don’t need to be pigeonholed as coders. This positions them perfectly for roles that require cross-functional collaboration.

• Energy and adaptability. The enthusiasm level of early career hires operates on a different level entirely. They’re excited to learn, quick to adapt, and eager to contribute across multiple areas.

How The Wheel works in practice

Every “Wheelie” gets a consistent diet of customer-facing support work as well as three-month rotations across different business functions. Participants might spend time with our Chief of Staff, work on marketing initiatives, or dive into the sales process—all while maintaining their support responsibilities.

This creates a dual benefit: Wheelies get exposure to various parts of the business and discover their strengths and interests, while different teams get fresh perspectives and dedicated project support from intelligent, motivated contributors.

As current Wheelie Natalie Ho said, “This position was really special because you get to see other parts of the company while still using your technical brain in support. It’s the best of both worlds.” Here’s a little home movie featuring a recent Wheelie class:

What we’ve learned about early career hiring

Our experiment with the Wheel taught a few things about how to early career hiring the right way. Three big themes stuck out:

• Speed matters, but stay under control. We compressed our hiring timeline not just for efficiency, but to create an exciting candidate experience. Flying people in for an interview day made the process feel special and helped candidates understand our culture firsthand.

• Respect the candidate experience. In a market where ghosting has become normalized, responsive communication and clear next steps create significant competitive advantages. Timely communication and actionable feedback differentiate exceptional hiring processes from the industry standard.

• Look beyond traditional signals. We’ve added a “show and tell” component to our interviews where candidates demonstrate something cool they’ve built—whether it’s a Notion template, an automation, or a side project. This gives people flexibility to showcase their skills in ways that resonate with them.

Going from experiment to hiring engine

After proving the concept, we’re now systematizing what started as a scrappy experiment. We’re moving from TypeForm and Clay to our proper applicant tracking system, bringing in dedicated recruiting resources, and building detailed documentation for rotation leads.

The goal is to create a repeatable cycle with a hiring loop that brings in new cohorts every month and a half, with clear expectations and processes for both participants and rotation leads. (We’re also constantly measuring the effectiveness of these cycles, and seeing if we need to shorten or lengthen them.)

We’re not the only company that could benefit from this approach. The current market dynamics create a perfect storm of opportunity:

• Abundant talent: Qualified new graduates are struggling to find positions

• Overlooked demographic: Most tech companies aren’t actively recruiting this population

• AI-driven skills evolution: The value is shifting from pure technical skills to technical literacy combined with business acumen

If you’re considering early career hiring, here’s what we’d recommend:

• Start small and scrappy. You don’t need a massive budget or perfect processes. Test the waters with a minimal viable approach and iterate based on what you learn.

• Focus on generalists, not specialists. Look for people who can think across functions rather than those who are narrowly focused on a single skill that might be disrupted by AI.

• Create genuine rotation opportunities. Give participants meaningful projects that benefit both their development and your business objectives. Effective rotations involve real work with measurable impact across different functions.

• Invest in the candidate experience. In a market where respect for candidates isn’t a given, exceptional treatment becomes a massive differentiator.

The future belongs to companies that can identify and develop talent that others are overlooking. For us, that means betting big on the combination of fresh perspectives, technical literacy, and expert generalism that early career hires bring to the table. And sometimes, the best strategic decisions start with just $600 and a willingness to try something different.

Interesting in learning more about The Wheel or applying? Learn more about the program here.

Subscribe now

Special thanks to Natalie Ho and George Dilthey for their expert guidance and input for this piece.

While product and engineering teams obsess over performance bottlenecks and data architecture, go-to-market teams are quietly battling a different set of technical constraints. To come together as a GTM Engineering community, we should enumerate the problems we face and think of possible solutions.

There are five unsolved GTME challenges we’re thinking about at Clay:

• Signal aggregation

• Account hierarchies

• Real-time Territories

• Rep Interfaces

• Feedback Loops

Subscribe now

Did we miss any? Let us know in the comments or tell us how you are currently solving one of the above.

TL;DR

1. Signal aggregation is broken: Too noisy, not actionable, not always real signal.

2. Account hierarchies are inaccurate or irrelevant: Legal entities ≠ accounts.

3. Territories are static in a dynamic world: You’re rebalancing accounts once a year. The world changes every day.

4. Rep interfaces are bloated, fragmented, and outdated: No two companies care about the same data for sellers and so all of their UIs should be different.

5. Feedback loops barely work for messaging: Automated systems have trouble adjusting messaging based on success metrics, and manual adjustments take far too long.

1. Signal aggregation: too much noise, not enough action

Everyone knows signals are important, but understanding how signals are interacting with one another is one of the biggest challenges in GTME right now. Revenue teams monitor everything from job changes to page visits to product usage to LinkedIn ad clicks. The result can be chaotic, especially when teams are basing automated actions on faulty signals. When every account is triggering something, nothing feels important.

The core issues are:

• Irrelevant signals: Not every job change matters. Not every page visit indicates intent.

• No prioritization: Signals aren’t weighted, so reps can’t distinguish meaningful activity from background noise.

• Poor delivery: Signals show up as Slack pings, list filters, or spreadsheet rows. There’s no system-level clarity.

Some teams try to solve this by having reps interpret signals manually, but that doesn’t scale. Veteran reps might know what matters, but new reps won’t and learning curves don’t all move at the same speed. Others try to solve it by offloading the thinking behind their signals to vended interfaces. But then every company gets the same interface when the reality of signals is that some deserve to be displayed differently - and the signals every company cares about are different.

This isn’t something you solve in one sprint. But by running controlled experiments, instrumenting for outcomes, and iterating on signal logic, you can gradually move from noisy alerts to intelligent pipeline triggers. At Clay, we combine multiple data sources into one enrichment stream and apply logic and weighting to prioritize high-signal accounts. Our centralized GTM Engineering team adjusts these almost weekly. We’re also experimenting with signal combinations and tracking downstream pipeline results to test different approaches. Here is a look at a recent interaction of our rep signals interface (done in Slack).

2. Account hierarchies: finding a single source of truth

Most CRMs treat companies as single entities, but as anyone on a revenue team knows the truth is typically a lot more complicated. M&A activity, holding companies, subsidiaries, franchises, and LLCs make it nearly impossible to rely on a static database to tell you the whole story. What you’re selling into is often different from what you’re billing, which is different from what your CRM says, which is different from what your data provider reports. And each of those structures changes constantly.

Third-party databases also rarely reflect how your company actually wants to sell. So RevOps teams end up duct-taping hierarchies together manually, which doesn’t work.

Here’s how we think of account hierarchies at Clay:

• Accept that your org’s selling hierarchy is unique to you.

• Normalize multiple third-party data sources into a flexible schema.

• Build interfaces where reps and RevOps can remap or override hierarchy logic.

  

Clay is evolving a unified schema to help with hierarchies, but many teams currently pipe account structures into Snowflake and build around it. But teams that are able to map the real organization that they’re selling into and not just the legal one will be at a huge advantage.

3. Real-time territories: static assignments in a dynamic world

Most sales teams build territories once a year. But the calendar doesn’t care about how efficient and equitable that exercise was. Product launches, economic shifts, elections, layoffs—a lot can affect who should be working on which accounts. If your top reps are stuck with stale books while new signals go to low-performers, it can create even more disequilibrium.

The real challenge is balancing fairness with agility. Account statuses can change wildly over the course of a year: warm ones get cold; dormant ones wake up. Not adjusting to those variables means high-potential accounts sitting untouched because of outdated assignments.

We’ve thought about what a potential set of solutions to real-time territory issues:

• Changes in product-market fit

• New data sources that change account scoring

• Reps’ capacity and strengths

• SLA-based reassignment of untouched opps

  

The tooling here is still early. Most teams rely on spreadsheets or rigid Salesforce logic. Clay is working on account-level rebalancing workflows that plug into CRMs and enforce fairness without sacrificing flexibility. Until then, your best move is to track when territory assignments start diverging from business goals and use GTM engineering to close the gap.

4. Rep interfaces: one size fits no one

Talk to any rep and you’ll hear the same complaint: too many tabs, too much clicking, too little clarity. A single account might require:

• A prospecting tool to source contacts

• A CRM to get history

• An enrichment tool to find titles

• A sales engagement platform to sequence

• A call dialer to reach out

• A Slack thread to see internal context

  

None of these systems talk to each other in a clean way. And reps are expected to stitch together a coherent workflow while hitting quota. Even worse, most of these tools are one-size-fits-all, which doesn’t help when companies and reps are looking for specific signals and functionalities. Every organization wants to run unique motions and use data differently, and static rep interfaces make that more difficult.

GTM engineers are building custom rep interfaces inside Salesforce and Clay or as standalone web apps. But designing, testing, maintaining, and iterating on those interfaces is still early days. Solving this problem is going to require a repeatable process for:

• Pulling data from multiple systems

• Rendering it in a clear, reps-first view

• Updating it as new workflows or data emerge

• Collecting rep feedback and usage telemetry

We believe the future of rep tooling is not buying more SaaS. It’s building composable, flexible UI layers that reflect how your team actually works.

5. Feedback loops for messaging

The temptation is to hand campaign optimization entirely over to AI and let algorithms monitor reply rates, adjust messaging, and retarget based on engagement metrics. This misses the point of what AI actually does well.

AI excels at execution: writing variations of messaging, researching contact details, processing large datasets. But strategic decisions about campaign direction require human judgment informed by market knowledge that AI can't access. When open rates drop or reply sentiment shifts, the response isn't necessarily to change the messaging; it might be to change the target audience, adjust the timing, or reconsider the entire campaign premise.

Campaign data is noisy and context-dependent. A low reply rate might indicate poor messaging, but it could also signal market timing issues, channel saturation, or competitive dynamics. AI can surface these patterns, but interpreting what they mean and deciding how to respond requires human strategic thinking.

The most effective approach treats AI as a research assistant and execution engine, while keeping humans in charge of strategic decisions. Let AI generate messaging variations and identify potential contacts. But have humans evaluate which variations align with your positioning strategy and which contacts fit your ideal customer profile. Use AI to process campaign results, but rely on human judgment to interpret what those results mean and how to adjust your approach.

This division of labor plays to each side's strengths: AI handles scale and pattern recognition, humans handle strategy and contextual interpretation.

Flexible systems create GTM alpha

Most of these problems stem from inflexible systems. Data that can’t be shaped. Interfaces that can’t be changed. Processes that can’t be adapted.

GTM engineers are trying to build their own systems that reflect their unique data, motion, and strategy. The GTM motion that wins in your market probably hasn’t been built yet. But your GTM engineers can create it.

We’re staring down the long Labor Day weekend here at Clay HQ and figured what better time to share some fun projects that our teammates have made using Clay. (Some are GTM engineers and some aren’t, which is part of what makes Clay such a unique tool for creative problem solvers.)

When most people think of Clay, they envision teams enriching lead data and automating outreach sequences. But data enrichment, AI processing, and automated decision-making can help do just about…anything. And that includes figuring out where to get a slice of pizza or how to find furniture dupes for any budget.

Here’s how different Clay employees are building tables for their own needs:

1. Goodreads wrapped: personalized book discovery

2. The ultimate NYC pizza finder

3. A “Severance” inspired employee onboarding experience

4. A salary negotiation assistant

5. Budget bougie furniture sourcer

6. The garment grader: fabric sustainability analyzer

7. A personalized NYC travel concierge

Find out how they built these plays below!

Subscribe now

Goodreads wrapped: personalized book discovery

Claymate: Natalie Ho
Use case: Automating book recommendations and library availability checks
Link to Clay workbook

Natalie is on our CX team and built a “Spotify Wrapped, but for books” experience using Clay. Her project automates the discovery of new books to read based on past preferences, and checks local library availability—all without needing to manually browse Goodreads threads or catalog databases. The system:

• Filters books rated >3 stars from her 2024 reading history

• Uses Claygent to find similar titles via Apify, Goodreads, and Reddit

• Checks local library availability using Navigator

• Flags data mismatches and confidence issues for future improvement

The innovation: Natalie’s project showcases how AI agents and enrichment workflows can make even deeply personal decisions—like what to read next—more streamlined and intelligent. By combining multiple data sources, she built a recommendation engine tailored to both preference and access.

The takeaway: This framework could extend into any content recommendation problem—books, podcasts, learning materials—or power consumer-facing products that tailor experiences based on past behavior and real-world availability.

The ultimate NYC pizza finder

Claymate: Cameron Goldberg
Use case: Curated, AI-scored pizza recommendations across NYC using Clay and community reviews
Claybook

New to New York and on the hunt for the perfect slice, one of our GTM engineers Cameron built an intelligent restaurant filtering system that blends Google Maps data with internet wisdom to discover NYC’s best pizza joints. The workflow:

• Pulled a complete list of NYC pizza restaurants using Clay’s Google Maps integration

• Automatically filtered out all national chains (e.g., Pizza Hut, Domino’s, Papa John’s) using a custom formula

• Used additional filters to exclude large franchise chains with over 50 U.S. locations

• Built a Clay agent to scrape and summarize reviews from Reddit, Instagram, Yelp, TikTok, One Bite Reviews, and articles

• Assigned each restaurant a custom 1–10 score, categorized the type of pizza (e.g., NY slice, Neapolitan), and explained the reasoning behind the rating

• Filtered for only 7+ rated spots and created a color-coded Google Maps overlay for easy mobile access

The innovation: This project is a smart blend of structured and unstructured data—Clay doesn’t just fetch Google results, it synthesizes vibe-rich content from community-driven sources. It’s a great example of how AI-powered enrichment can surface insights traditional search can’t reach.

The takeaway: This could easily scale to restaurant curation platforms, local food newsletters, or niche food tourism tools. Whether you’re searching for the best croissant in Paris or tacos in LA, this project proves Clay can help you taste better with data.

A “Severance” inspired employee onboarding experience

Creator: Ian Cox
Use case: Automated new hire experience for Lumon Industries
Claybook

Clay product designer Ian fully automated the manual process of creating employee welcome materials. His system:

• Pulls new hire data from LinkedIn profiles

• Generates personalized employee ID badges with custom graphics

• Creates AI-written welcome scripts using employee background information

• Produces personalized audio greetings using 11Labs voice synthesis

• Builds interactive welcome pages with embedded media

The Innovation: This is what creative automation at scale looks like. Clay's ability to orchestrate multiple AI services (GPT for scripting, 11Labs for audio, custom image generation APIs) demonstrates how operations teams can build Hollywood-level production workflows without engineering resources.

The takeway: What once required hours of manual design work per employee now happens automatically, creating a premium onboarding experience that can scale with your org’s growth.

A salary negotiation assistant

Creator: Izzy Kim
Use case: Offer Negotiation Assistant powered by market intelligence
Claybook

Izzy is on the Clay customer education team and created a comprehensive salary negotiation platform that rivals enterprise compensation tools. The system:

• Analyzes job offers and identifies comparable companies using Clay's enrichment capabilities

• Scrapes LinkedIn job postings to gather real-time market salary data

• Uses ClayQL to calculate median compensation across similar roles and companies

• Generates personalized negotiation scripts based on market research and offer details

• Integrates with external web applications through webhooks for seamless user experience

The innovation: This demonstrates personal finance automation—using enterprise data tools for individual career advancement. The integration between Clay's data processing and external applications shows how Clay can power consumer-facing products.

Broader applications: This framework could extend to career coaching, job market analysis, or skills gap identification at organizational levels.

Budget bougie furniture sourcer

Creator: Jenny Gu
Use case: Affordable furniture shopping assistant powered by Clay
Claybook

Clay software engineer Jenny combined Clay with creative AI workflows to solve a personal (but very relatable) challenge: finding beautiful furniture without breaking the bank. Her system automates the process of identifying dream furniture and locating high-quality budget alternatives across secondhand marketplaces. The setup:

• Extracts product features and style cues from “dream” furniture listings

• Uses Clay to analyze and compare visual similarity across budget-friendly listings

• Calculates AI-generated similarity scores to match listings with aesthetic goals

• Uses Clay Navigator to check multiple sources (like Facebook Marketplace) for potential matches

• Automates outreach to sellers of high-match items for easy follow-up

The innovation: Jenny’s project is an excellent example of personal automation: applying enterprise-grade enrichment and AI logic to solve everyday consumer problems. It’s both fun and functional, showcasing Clay’s flexibility beyond GTM use cases.

The takeaway: This system could be extended to price tracking, secondhand luxury shopping, sustainable consumption workflows—or even resale arbitrage. It’s a smart mix of data processing, visual intelligence, and personal taste.

The garment grader: fabric sustainability analyzer

Creator: Perrine Brouillet
Use case: Understanding and scoring fabric sustainability using AI and enrichment workflows
Claybook

• Slack AI

  • At Clay, Slack becomes a live interface for internal GTM operations. Engineers use Slack AI to turn historical conversations, shared docs, and team knowledge into a searchable knowledge graph. Common use cases include helping reps query objection responses, surfacing enablement content in real time, or launching workflows (e.g., enriching a lead or checking deal stage) with natural language commands. Engineers configure retrieval systems and define guardrails to ensure precision.

Clay product designer Perrine tackled the complexity of evaluating garment sustainability by building a structured fabric grading system using Clay. Her goal was to make sense of environmental impact across materials, brands, and certifications. The system:

• Generated a fabric database using GPT and Claygent to pull sustainability data on 40+ materials

• Evaluated biodegradability, microplastic shedding, pros/cons, and assigned each fabric a sustainability score

• Scraped product and brand URLs to identify fabric composition and certifications

• Cross-referenced this data with her enriched fabric database to generate a final weighted sustainability score

• Sent user input and scoring results between Slack and Clay via Zapier and webhook integrations

The innovation: Perrine turned a vague and subjective domain into a repeatable data-driven pipeline. By building a scoring engine powered by Claygent and cross-system orchestration, she gave sustainability-minded consumers and designers a powerful evaluation tool.

The takeaway: This model could power sustainable fashion platforms, B2B sourcing tools, or even governmental certifications. It’s a great example of using data automation to drive transparency in complex consumer decisions.

Personalized NYC travel concierge

Claymate: Luca Prando
Use case: Creating custom NYC itineraries using AI, Typeform, and Clay
Claybook

Luca is on our CX team and brought together multiple tools to create a delightful (and efficient) solution to a common traveler pain point—figuring out what to do in a massive city like New York. His Clay-powered travel concierge automates:

• Typeform-based user input capture for preferences and travel context

• GPT-powered generation of personalized activity recommendations, filtered by vibe tags

• Lookup and enrichment of venues (restaurants, bars, museums, etc.) using Claygent and Google Maps

• Email campaign automation using Clay’s sequencer to send custom itineraries

The innovation: Luca’s project is a seamless blend of enrichment, AI-driven content creation, and automated outreach. It shows how Clay can personalize customer experiences at scale with zero engineering help.

The takeaway: This workflow could scale to city tourism boards, concierge services, or even real estate onboarding experiences. It’s a smart example of how to turn static data into delightful, dynamic user experiences.

Workflow orchestration beyond sales

These personal projects are all about intelligent workflow orchestration and show how creative you can get with Clay. If you break each of these into their component parts you start to see some valuable data strategies:

• Data integration at scale: Every project combines multiple data sources (LinkedIn, job boards, company databases, user inputs) into unified workflows.

• AI-native processing: Complex AI operations (content generation, analysis, scoring) are treated as simple building blocks in larger automation chains.

• Real-time decision making: Systems make intelligent decisions based on enriched data, from compatibility scoring to salary benchmarking.

• External system integration: Webhooks, APIs, and custom integrations connect Clay to specialized tools and consumer applications.

• No-code complexity: Operations teams build sophisticated systems that would traditionally require significant engineering resources.

Even if you’re not looking for your next beach read or to find a new sofa, you can use these as inspiration for creative plays. Sometimes you can find GTM alpha in surprising places.

Big thanks to Luca, Jenny, Perrine, Izzy, Ian, Cameron, and Natalie for their creative thinking and sharing their projects.

When Maria Kastani, an MBA student at the International University of Applied Sciences and a member of the Clay Club in Berlin, chose GTM Engineering as her MBA thesis topic, she unexpectedly produced what might be the first comprehensive academic study of the field.

Her 65-page thesis dives deep into GTM Engineering through 17 expert interviews, a real-world implementation at her company Parloa, and enough academic frameworks to make a business school professor smile. While most discussions about GTM Engineering happen in newsletters and LinkedIn posts, Maria did something completely different and brought rigorous, academic research methodology to the table. You can read Maria’s entire thesis below:

Maria Kastani Gtme Master's Thesis

968KB ∙ PDF file

Download

Download

Read to the end for a short interview with Maria about the inspiration for her thesis where asked her about some of the challenges that come with researching an entirely new field and how she combined theoretical and practical analysis to create a first of its kind investigation into the world of GTME.

Subscribe now

TL;DR

• Creative thinking > tech stack: The best GTM Engineers aren't necessarily the most technical—creativity, systems thinking, and experimental mindset matter more than coding ability, especially as AI handles more technical heavy lifting.

• Strategic function, not just tools: GTM Engineering isn't just "RevOps with better tools." GTMEs can “explore” new market approaches while RevOps "exploits" what works at scale.

• Outbound didn't die, it just evolved: Traditional spray-and-pray outbound is dead, but targeted, context-aware outbound still works when matched to market size, company type, and channel saturation levels.

The skills debate: creativity over technical prowess

One of the most interesting findings from Maria's research pushes back on the assumption that GTM Engineers need to be deeply technical. Through her expert interviews, she discovered something exactly the opposite:

"13 out of 17 experts mentioned creativity as a core skill and highlighted the need to think out of the box in order to create innovative plays and improve processes."

What's particularly valuable about Maria's analysis is how she connects this to hiring strategy. She found that companies focusing on background and experience often miss candidates who have the right mindset but haven't followed traditional career paths. Maria identified what she calls the core skill triangle for potential GTMEs: creativity, continuous learning, and computational thinking. One expert told her about successful GTM Engineers "coming from completely different backgrounds, but they wanted to go into this space, they just sat down there, they started learning on mistakes, on successes... and they became successful."

This has real implications beyond just job descriptions. It suggests that the GTME talent pool is much larger than we might think, and includes people who haven't traditionally been in revenue roles but have the curiosity and systems thinking that can make a difference.

Patrick Spychalski from The Kiln put it bluntly in his interview: "the available tools are just catalysts for accelerating creative ideas but don't create creativity themselves."

We see this reflected in our experience. Tools like Clay are becoming more accessible, and AI is handling more of the technical heavy lifting. What separates good GTMEs from great ones isn't their ability to write complex formulas, but rather their ability to see systems, experiment quickly, and understand what actually motivates a potential customer.

Maria also found that traditional hiring approaches might actually be counterproductive for GTME teams. Alex Fine from Understory made that point in his interview that candidates with deep wells of experience can have unconscious biases about what motions they’re interested in exploring:

• "Background can also end up being a hindrance. Because if you have all of these notions and concepts and ideas in your head about how things work and then you go into a role where it's completely experimental and you want to be trying new things, you might go into it with a bias."

This suggests that the best GTM Engineers might not be the ones with the most experience in sales or marketing; they might be the ones who can approach familiar problems with fresh eyes. That’s borne out by the interviews Maria did:

• "Around half of the experts agree that a specific technical, sales or operational background is not necessary... most of our GTM Engineering team are actually not sales people or RevOps people."

Where does this role actually live?

It’s still an open question of where GTMEs should sit within an organization team. Maria's research found that there are several options that work, but there’s no single answer because GTMEs don’t operate in a silo.

"The dominant theme in this question was that the answer depends on the needs, size and structure of the company, and thus no universal solution exists."

Through her interviews, Maria found three main camps:

Most experts (9 out of 17) see GTME as living within RevOps, treating it as a specialized operations function. Others argue for placement in Growth teams, especially when the role is focused on pipeline generation. A smaller group advocates for standalone teams reporting directly to leadership.

Maria also found that the placement decision should actually be driven by where the biggest revenue generation opportunities exist in a company. The GTME Engineer School founder Matteo Tittarelli put it this way in an interview with Maria "Where is the biggest generation of revenue?... [What is] the most time consuming or repetitive task within the biggest opportunity levers?" Only after answering those questions does it make sense on where to place GTMEs within your org—and even then the answers can shift as a company grows and changes.

The nuance here is in understanding that GTMEs are a strategic resource rather than just another role to plug into an org chart. If your biggest growth constraint is top-of-funnel generation, maybe GTM Engineering belongs in Growth. If it's process inefficiency across the entire revenue organization, RevOps makes more sense.

Maria's research connects organizational placement to compensation and success metrics. A GTME generating pipeline probably should have some variable compensation tied to results. One focused on systems optimization? Maybe they earn a higher base salary with efficiency-based bonuses.

The debate around compensation revealed an interesting tension in the field. Some experts argued for commission-based pay because GTM Engineers directly impact revenue. Others pushed back, arguing that since GTM Engineers can't control deal closure, variable compensation based on closed deals would be unfair. As Patrick Spychalski told Maria:

"If I was a GTM Engineer, I'd be pretty upset if, like, the AEs couldn't get the thing across the finish line, and ultimately, if an AE gets a deal and they don't close it, that's like pretty much exclusively on them."

This compensation debate actually reveals something deeper about how the field is maturing. We're moving from "this person uses Clay" to more sophisticated thinking about how GTMEs create value and how that value should be measured and rewarded. As Maria says: "The GTM Engineer does not merely contribute to optimized processes, but is a strategic factor for the growth of an organisation.”

The RevOps vs. GTM Engineering question

The theoretical core of Maria's thesis tackles the question that's been going around the industry: Is GTM Engineering just RevOps with better tools?

Her research found the field split on this, but the arguments on both sides are illuminating. Those who see GTME as distinct from RevOps pointed to fundamental differences in focus and approach. "RevOps may have been involved in orchestrating it, but go-to-market engineering really sits at a strategic data layer," Maria writes.

The key distinction many experts made was speed and external focus. RevOps tends to be internally focused, working with internal stakeholders to optimize existing processes. GTM Engineering, they argued, is externally focused because it actually touches the market and iterates based on external feedback.

As GTME expert Pawel Nical explained it: "go-to-market engineers go directly to markets, so they are closer to that external layer. RevOps is closer to the internal layer."

Subscribe now

Maria found another perspective from some experts who see the roles as naturally complementary rather than competitive. Our own Yash Tekriwal described it as the difference between "keep the plane flying" (RevOps) and "how we are constantly innovating to stay ahead of the market" (GTM Engineering).

This maps to what Maria calls the "explore vs. exploit" framework from organizational theory. RevOps exploits existing capabilities and scales what works. GTM Engineering explores new opportunities and experiments with novel approaches. When something works in exploration, it gets handed off to RevOps for exploitation at scale.

What's smart about this perspective is that it positions both functions as necessary. You need the stability and scale that RevOps provides, and you need the innovation and agility that GTM Engineering offers. It's not about replacement—it's about organizational ambidexterity.

The Clay reality check

Maria’s research found that Clay was a consistent presence in conversations about GTME. "14 out of 17 experts mentioned Clay and its AI agent as their favourite tool," she wrote.

Maria acknowledges this might be a bit skewed as many of her interviewees have Clay partnerships. But she took it upon herself to ask why Clay is so popular.

The experts she interviewed pointed to data democratization (access to expensive data sources without enterprise licenses), workflow consolidation (doing in one tool what used to require many), and AI integration through Claygent as key differentiators. Patrick Spychalski went so far as to say, "I honestly think [Clay] is the reason this role exists... Most people hiring for GTM Engineer roles are just hiring people who are good at Clay."

Maria's research suggests there's probably some truth to Patrick’s statement. Clay has both enabled and furthered GTME as a discipline. What's particularly interesting is how Maria frames this in terms of data democratization. Previously, the kind of sophisticated data operations that GTMEs perform required expensive enterprise licenses for multiple data sources, plus the technical skill to integrate them. Clay made these capabilities accessible to smaller teams and less technical users.

Maria also found that Clay's flexibility—what Pawel Nical compared to "LEGO blocks"—allows for the kind of creative experimentation that defines good GTM Engineering: "From LEGO blocks, you can build a rocket, can build a ship, you can build a plane. It does not predefine what you can do with it," Pawel told Maria.

Maria’s analysis of common workflows bears this out: automated CRM enrichment, LinkedIn engagement tracking, job scraping for market signals, automated commenting systems that improve connection request acceptance rates by 35-40%. These are processes that were either all done manually before tools like Clay existed.

The Clay dominance also reveals something about the maturity of the GTM Engineering field. When one tool is so central to a professional function, it suggests the field is still in its early stages. As the space matures, we'd expect to see more tool diversity and specialization.

Matteo Tittarelli made a point that connects to broader technology adoption cycles: "there's always like a curve of adoption and that leads more to saturation. But then eventually there is always a new innovation that reignites [it]." This suggests that we're in a natural evolution cycle. The current tools and approaches will become saturated, leading to new innovations and approaches. GTMEs, with their experimental mindset, are positioned to identify and capitalize on these cycles.

The outbound evolution: not dead, just different

Maria's thesis digs into a hot debate in GTM about whether traditional outbound is dead. Her research found unanimous agreement among experts that outbound isn't dead, but it has fundamentally changed. "The experts share a unanimous agreement that traditional outbound is not obsolete but has fundamentally changed to a few years ago and that poorly targeted approaches do not work anymore," she writes

GTM strategist and founder of Blueprint Jordan Crawford summed it up well: "What they really mean is you can't do yesterday's playbook today and expect the same results." Maria's research identified the specific factors that determine outbound effectiveness. It's about market context as well as personalization and volume, and merging them can create a huge difference for GTM teams.

Here are three other strategies Maria highlighted in her thesis:

Total Addressable Market size matters. If you have a large enough TAM, mass outbound can still work. If your TAM is small, you need surgical precision.

Company type matters. Generic personalization might work for small businesses but falls flat with Fortune 500 companies that get thousands of similar messages.

Channel saturation is real. The democratization of outbound tools has led to oversaturation, but this creates opportunities for those who can cut through the noise.

Looking forward: strategy over technical skills

Towards the end of her thesis, Maria looks at where GTME is headed. Her research suggests we're shifting toward a world where strategic thinking matters more than technical chops, something we hinted at earlier in this post. "Several experts suggested that as the available technology becomes more widespread and easier to use, the emphasis will shift into critical thinking and strategic skills," she wrote.

This tracks with what we see in other technology adoption cycles. As tools become more powerful and accessible, the competitive advantage shifts from having access to the technology to knowing how to apply it strategically. One expert told Maria: "The ultimate skill that will drive more return or more revenue to your company is not technical skill. It's 100% creative on your know-how."

But Maria's analysis identifies a particularly interesting prediction about the return of relationship-building. "As AI-driven outreach becomes indistinguishable from human outreach, sales is going to transform into a connection-based field, since no one is writing a $100,000 check without having a conversation with a person," she wrote.

This connects to what Maria calls the "High Tech/High Touch" theory, the idea that as technology becomes more prevalent, people increasingly value human experiences and relationships. The implication for GTMEs is significant. The current focus on automation and AI-driven processes might be a transitional phase. As these capabilities become commoditized, the competitive advantage will shift to those who can combine technological leverage with genuine relationship-building.

Maria also identifies an acceleration trend that has implications for how GTM Engineering roles will evolve: "companies that will be late in this will need to pay the price for that, for not being competitive." The speed of innovation and adoption is increasing, meaning GTM Engineers need to be able to experiment, learn, and adapt faster than ever.

Subscribe now

The maturation of a field

As GTME matures from experimental practice to established function, we need more thinking like this. Maria's thesis provides a framework for understanding not just what GTMEs do, but why they matter and where the field is headed. It's rare to see academic rigor applied to an emerging field in business. Maria's work gives us something we didn't have before: a structured way to think about GTM Engineering that goes beyond tool tutorials and growth hacks.

Her research suggests that we're at an inflection point. The early adopters who jumped into GTM Engineering because they were excited about new tools are being joined by more strategic thinkers who see it as a competitive advantage. The field is developing its own body of knowledge, best practices, and experimental frameworks.

This evolution from craft to profession is natural and necessary. Maria's thesis provides a roadmap for that development.

Q&A with Maria Kastani

Clay: You wrote your master's thesis on GTM engineering and Clay specifically. How did that idea come about?

Maria: It started first as curiosity. I work in lead management in the growth team at Parloa, doing lead generation, data enrichment, prospecting, creating campaigns—all these tasks around the area. We were using manual processes that were time consuming, basically eating up resources and time that could be devoted to more important tasks.

Back in January, our VP of RevOps at the time was looking into GTM engineering and Clay. He gave me the idea and I decided to do my thesis on it to combine my university and work focus and provide some actionable value. The idea of looking into a new undiscovered field is much more interesting and rewarding than going over some traditional topic that has been discussed over and over again.

What were the unique challenges of researching such a new field?

You start with no proper academic peer-reviewed literature to reference. This exists for the more long-standing topic of go-to-market strategy and core principles, but not for GTM engineering. So the main source of knowledge has been industry articles, blogs, newsletters, and then the interviews that I did with GTM engineering experts, which was a core method of getting the most up-to-date insights, since those are the people that are shaping the field right now.

There's obviously no proper academic research on GTM engineering so far, which brought some obstacles. But I think this is also what makes the area more suitable for academic exploration, because it provides this opportunity to gain insights at an early stage while the field is growing so fast.

Did anything surprise you during your expert interviews?

From what I had read before, people were praising tech savviness a lot—writing that you have to code, you have to know Python and JavaScript and all these things. So framing the role as super technical and only accessible to people from backgrounds like computer science or data analysis.

But the majority of the experts framed it differently. They said the most important characteristics are systems thinking, creativity, this experimental mindset—and the technical skills you can learn. It's like tools, you can learn them. And coding, right now, is being replaced by all those AI coding tools. So it doesn't seem to be as important as I thought or as I read in the beginning.

What was the reaction to your thesis?

There was a great reaction to it. I got the best grade I could get. That was surprising, but I mean, it was a lot of work, and I really tried to put everything in it.

I had university professors with PhDs thanking me for my contribution, telling me how much they learned from me, how important it is that this field is now explored academically as a first step towards more research and discussion around it.

And then I decided to share it with the industry, and that also blew up. A lot of comments, appreciation, people asking to read it, opportunities opening up.

Were you expecting that level of response?

No, not at this level, but it's great.

Where do you see GTM engineering heading, and what's next for your research?

I identified a lot of areas for further research in the thesis. There could be a broader analysis across more organizations. My research was a mixed method approach, both qualitative and quantitative, but the quantitative practical part was a single case study based on my employer.

Further research could focus across different company sizes or industries and see how GTM engineering provides efficiency in different contexts and organizational structures. It would be super cool to have more long-term studies that track the evolution of the role over time and actually determine the impact over the years.

This is what will show GTM engineering isn't just data enrichment or outbound, but show the strategic value it brings and how Clay enables all the GTM teams to constantly innovate, break boundaries, and explore new possibilities again and again.

Maria’s full thesis includes detailed expert interviews, implementation frameworks, and extensive analysis. Her work represents the kind of structured thinking that will help GTM Engineering evolve from experimental practice to established discipline. We want to thank her for her time and for her incredible work exploring GTM engineering with an academic lens.

While engineering teams have long understood technical debt, go-to-market organizations are dealing with something equally destructive but far less recognized: data debt. Just as technical debt slows software development, data debt quietly sabotages your ability to identify, engage, and convert customers and prospects.

TL;DR

• Data debt compounds as you scale, creating missed revenue opportunities along the way

• Solving data debt requires a unified approach to source, structure, and activate your revenue data

• Clean data transforms from a burden into account intelligence that drives strategic advantage and helps your team find GTM alpha

Data debt costs more than you think

Data debt costs organizations strategic opportunities in ways that compound over time:

Sales teams spend up to 40% of their time on data research that should be automated. A rep making $150K can create a net loss of $60K annually in lost productivity due to data issues.

Marketing teams watch campaign performance tank as deliverability drops. When email bounce rates hit 15-20% due to bad data, your MQL pipeline collapses.

RevOps teams become janitors instead of strategists. They spend time cleaning data rather than optimizing revenue processes. The opportunity cost is massive.

Most teams don't even realize how much data debt is costing them, so they often delay action. By waiting, they put even more revenue growth at risk.

What data debt actually looks like

The signs of data debt are everywhere: you click on a contact to make a call, and they tell you "I left that job two years ago." Marketing campaigns bounce off dead emails. Millions of accounts and contacts sit in CRMs (yes, multiple!) but only a fraction are actually usable. RevOps teams spend 80% of their time on data cleanup instead of building intelligent account systems that drive revenue.

Data debt isn't just "messy data." It's the compound effect of poor-quality, ungoverned, and poorly catalogued data that builds up over time. Every quick fix, every tactical decision, every "let's just import this list" adds to the burden.

Here are the main sources of data debt:

Years of purchased lists: Companies buy lead lists to accelerate growth. These lists contain outdated, duplicate, or irrelevant contacts that never get properly validated. Each purchase adds thousands of unverifiable leads that pile up in your CRM.

Reps importing and exporting without validation: SDRs under quota pressure mass-import contacts from ZoomInfo, export to sequences, then import back to CRM—all without proper validation or deduplication. Sure, ZoomInfo claims high accuracy, but most teams I talk to see actual rates around 70% for accounts and 40-50% for contacts.

Manual data entry at scale: Sales reps create records on the fly, use inconsistent naming conventions, and develop workarounds like Googling "How many employees does [company] have?" to validate basic information. These manual processes fall apart at scale.

Duplicate records everywhere: The same prospect exists across multiple systems with slightly different information, making it impossible to get a single view of your pipeline or customer journey.

The integration multiplication effect: Every new tool—marketing automation, sales engagement, enrichment services—doesn't just add new data. It multiplies existing quality issues across every system. When you add bi-directional syncs between tools, you create doom loops where bad data gets worse as it spreads, and you lose track of where information originally came from.

Subscribe now

How to solve data debt: Source → Structure → Activate

At Clay, we've seen this pattern repeatedly: companies with millions of contacts and accounts in their CRM, but less than 30% actually usable for revenue generation. This is both a data quality problem and a fundamental workflow problem.

The solution goes beyond just cleaning your existing data. You need to build a systematic approach to how data flows through your organization. We think about this in three key phases:

Source: Get the right data from anywhere

The cleanup process starts with sourcing. You need access to comprehensive data that matches your specific business model and requirements. This means connecting to your data warehouse, CRM, marketing automation platforms, and dozens of third-party enrichment providers simultaneously.

But here's the critical piece: your data model matters. For some companies, an "account" is a specific business entity. For others, an account represents a distinct business unit that makes independent buying decisions—you might have separate accounts for Netflix's finance department and marketing department because they buy differently.

Having access to diverse data sources changes how you approach data modeling because you're no longer constrained by what's available in a single system.

Structure: Transform data to fit your business

Once you've sourced the right data, you need to format it for your specific use case. This is where custom taxonomies become powerful. Instead of using broad, standardized industry categories like "healthcare" or "software," you can create your own classification system that actually reflects how your business views the world.

This structuring phase handles several key questions:

• What format does this data need to be in to be useful?

• How do we eliminate duplicates and standardize naming conventions?

• What validation rules ensure data quality over time?

Activate: Put data to work where and when it's needed

The final phase is about getting the right data to the right people at the right time. This depends on who will use the data and how:

• Real-time signals (like job changes or competitor mentions) need immediate alerts in Slack

• Business intelligence and reporting data can be batch-processed since humans aren't looking at individual records

• Sales and marketing data needs to live in your CRM with proper formatting for outreach

Clean, validated data flows back to any system of record—CRM, marketing automation, data warehouse—ensuring consistency across your entire tech stack.

The compound value of clean data

When data debt is eliminated, the benefits compound across three key areas:

Operations become strategic

RevOps teams transform from data janitors to strategic advisors. They can focus on pipeline analysis, conversion optimization, and revenue forecasting instead of constant data cleanup and validation. Implementing new tools becomes easier because you have a clean data model that everything can plug into.

Revenue impact accelerates

SDR teams shift from data sourcing to execution—no more time spent validating accounts or manually researching basic company information. Marketing teams can hyper-target with confidence, knowing their segments are accurate. Speed-to-lead improves dramatically because clean data enables automated lead routing without the risk of sending prospects to the wrong rep.

Customer experience elevates

Teams work with consistent, accurate information across all touchpoints. No more embarrassing emails to people who left the company months ago, or outdated information that kills trust. Every interaction is informed and relevant.

From data debt to account intelligence

Once organizations eliminate data debt, they can move beyond reactive data management to proactive account intelligence. This represents the next evolution of GTM data strategy, where teams go from fixing problems to finding competitive advantage.

This advanced approach focuses on two key capabilities:

Acting on signals faster: Clean data enables immediate responses to opportunities and changes. Whether it's competitor movement, job changes, or funding announcements, you can build automated workflows that alert the right people and trigger the right actions. Companies with clean data foundations achieve speed-to-lead advantages that directly impact conversion rates.

Better prioritization and targeting: With reliable data, you can understand which accounts are truly worthwhile and build systematic approaches to territory planning. This includes mapping account hierarchies to identify companies you can close based on existing relationships, tracking mutual investors for warm introductions, and building sophisticated TAM models that guide expansion efforts.

The result is account intelligence that drives strategic decisions rather than just reactive firefighting.

A special thanks to Clay’s own Dorothy Huynh for inspiring this piece and getting it kicked off.

TL;DR:

• Clay raised a $100M Series C at a $3.1B valuation after more than 2x growth this year. Over 10k customers—including OpenAI, Anthropic, and Cursor—use our GTM development platform to automate GTM research and build revenue systems.

• We’re using the new round of capital to continue to support the GTM engineering ecosystem.

• The fundraise announcement was covered in the New York Times, where the article focused on how Clay is building a new AI-native career category.

• Read our full blog post about it here.
  

Subscribe now

While people debate which jobs AI will automate, we’ve been busy creating a new one that centers human creativity and doesn’t require a CS degree: GTM Engineers.

GTM engineers combine growth acumen with AI and automation to build revenue engines. We call it "engineering" because they work within certain parameters to build scaled systems—but instead of coding software, they're coding revenue.

One GTM engineer can amplify 100 sellers by automating all their research, signal tracking, data entry, and messaging so they can focus on actually selling. They can test hypotheses and scale wins: tasks that required large teams of manual researchers and engineers just two years ago.

400+ GTME jobs were posted in the last 4.5 months at a $160K median salary—20% above traditional sales/marketing operations roles, according to Pave. Multiple Clay customers under the age of 30 have started GTME agencies and scaled to $1M+ ARR in under a year. 60+ Clay clubs worldwide, from Warsaw to Manila, are learning this profession.

GTM engineering makes our own growth possible as well. We're on track to more than triple our revenue this year, and our AI agent has completed > 1.5 billion lifetime tasks.

With $100M in new funding led by Alphabet’s CapitalG, we’re investing in our product and supporting our community of GTM engineers.

Creating global economic opportunity

GTM engineering is creating a new wave of economic opportunity across continents. People are transitioning from traditional roles to GTM engineering—and seeing dramatic career transformations. Some customers are earning promotions; others are launching agencies that scale to millions in revenue within their first year. Seven bootcamps teach GTM engineering, including Clay’s official cohort program with 2,500 alumni.

60+ Clay clubs across more than 30 countries are building economic bridges between markets. At Clay Club Lahore, doctors and software engineers are learning Clay as a path to economic opportunities. In Ukraine, organizers held their first Clay Club meetup despite ongoing war conditions, securing bomb shelter access for 50+ attendees just in case.

This growth also benefits our 150+ data providers—businesses of all sizes. Our integration marketplace connects providers directly with 10k+ qualified customers and is on track to generate over $50M in revenue for partners in 2025. It's a win-win: customers get flexible access to data without procurement delays, while providers reach more qualified buyers.

“Implementing Clay at Hitachi changed my career. What started as a personal project rolled to my entire team, fueled my promotions, and earned me company-wide recognition.This has been the most fulfilling project of my career.” — Umar Farooq Adam, GTM Program Manager at Hitachi

“Before starting my Clay agency, the Kiln, I was $15k in credit card debt and making $3k/month selling clothes. The Kiln now makes >$3M ARR with a 22 person team. My co-founder Mathias paid off his college loans 10x faster than projected.” —Patrick Spychalski, founder of The Kiln

“I was fired as an SDR early in his career before moving to RevOps. I used Clay to revamp Intercom’s TAM sourcing process this year—which earned me a promotion and a spot at President’s Club this year (with my mom).” — Alexander DeMoulin, Director of Revops at Intercom

“I became a millionaire by 27 thanks to my Clay agency, Growth Engine X. I paid for my wedding, house, and cars with that income. My retirement accounts are now fully funded.” — Eric Nowoslawski, Founder of Growth Engine X

“Clay Bootcamp graduates regularly 10x their income. Recent alum Bharat Devana went from charging $18/hour to $100/hour in 5 months, and the agency he started is about to hit $20k MRR. Him and his wife are frankly shocked at his rate of progress.” —Nathan Lippi, founder of Clay Bootcamp

Subscribe now

Tomorrow’s companies are grown by GTM engineers

Our customers are already pushing the boundaries of what's possible with AI-powered GTM.

Anthropic enriches and scores all inbound leads with Clay, generates meeting prep notes for sales calls, and flags fraudulent email domains—tripling their data enrichment coverage and applying AI at scale for GTM research for the first time.

Cursor tracks customer mentions across X, LinkedIn, YouTube, and Reddit to help their CX team respond to users and identify new prospects in real-time.

Vanta monitors four signals simultaneously: SOC2 certification announcements, website changes related to compliance, funding announcements, and CISO job postings—automatically triggering personalized outreach when prospects show intent.

Verkada generates thousands of personalized landing pages for prospects, incorporating company logos and tailored messaging at scale.

Rippling uses Google Maps data to identify prospects' likely corporate addresses, then calculates commuting distances to optimize their global direct mail campaigns.

Beyond tech companies, the applications are getting creative. One customer uses AI to count parking spots in satellite images of warehouses—a surprising predictor of customer fit. Another monitors competitor status pages and launches targeted campaigns during downtime. A third scans financial documents to assess fraud risk for email domains.

Get lit

Our Series C funding expands our ability to support the growth of GTM engineering. We’re going to be making big product updates, in pursuit of building the IDE for GTM—just like Figma for designers or Cursor for developers. This includes:

• Better signals, including website visitors

• The ability to use your own internal data in Clay

• Autonomous agents for research, messaging, and table building

• Scaled performance

More at Sculpt, our GTM engineering conference!

GTM engineering proves that AI can amplify human creativity. Revenue problems are systems problems, and the future belongs to teams that can constantly iterate.

​​If you’re a GTM leader whose team is bogged down by manual research, slow campaigns, or data cleaning, more effort won’t fix things. You need better systems. And GTM engineers are the people who build them.

AI tool fatigue is real. There are thousands of options out there that promise to make you faster and better at everything.

I’ve tried a lot of them in an attempt to figure out which ones work and which ones are full of empty promises. (I’ve been told I have “shiny tool syndrome.”)

In order to save you the hassle and headache of trying dozens of different tools, I put together a list of my favorites and how I use them as well as how we integrate them at Clay. If you want to see exactly how I use all of these tools, you can also check out this video that I made where I run through my entire stack:

TL;DR

• Maximize speed, clarity, and leverage. That means I use a lot of apps that create keyboard shortcuts, AI assistants, and creative tools to work faster and think more clearly without context switching.

• Mix personal productivity tools and organizational AI systems to automate workflows, surface insights, and help the entire GTM team operate at a higher level.

Subscribe now

🧠 Personal productivity

⚡️ Speed

WisprFlow
WisprFlow has completely replaced typing for me in most contexts. I average 190-200 words per minute just by speaking, which is way faster than typing. Beyond speed, speaking my thoughts out loud like this also helps me clarify them—it’s thinking at the speed of speech.

Superkey
Superkey remaps my Caps Lock key into a hyperkey that combines Control, Option, Alt, and Shift—allowing me to stack commands and avoid shortcut collisions. It's the backbone for tons of my navigation workflows. I can trigger shortcuts or tools instantly without reaching for my mouse.

Homerow
Homerow adds vim-style keyboard navigation across my entire computer. Every UI element is tagged with two-letter codes, so I can jump to anything on screen just by typing. If you know where you're going, there's no faster way to get there.

Vimcal
Vimcal is my calendar of choice. It’s entirely built around keyboard shortcuts, so I can toggle views, jump to specific days, and schedule meetings with commands like, “Ted and Yash meeting tomorrow at 12pm for an hour.” I also use it to send clean, custom availability texts instead of calendar links.

🤖 AI assistants

Perplexity Comet Browser
Comet is like having a super-powered AI executive assistant in my browser. I use it to summarize emails, group tabs, write meeting bios, build Amazon carts, and more—all using voice or typed prompts. It has ambient context on everything I'm doing.

Raycast
Raycast is my OS command center. I use it to access clipboard history, trigger snippets, generate Clay images with prompts, manage meeting scheduling, and jump to common tools with quicklinks. It’s where I automate a ton of my routine work.

📹 Video

Google Veo3
I use Veo3 to generate cinematic AI clips for marketing assets and internal videos—like short scenes from Avatar or Avengers intros. It’s become part of my custom workflow when stitching together engaging demos.

ElevenLabs
I use ElevenLabs to create AI voiceovers for demo videos. I feed in scripts, clone voices, and use them to narrate Veo3-generated clips. It makes our content feel more polished without needing voice actors.

Yarn.so
Yarn is how we produce GTM education videos internally. I record in-studio, then use Yarn to edit, style, and caption everything. It’s powerful enough for real production but simple enough to use async without a video editor.

💬 Communication

Superhuman
Still my go-to email client. The speed, shortcut design, and AI features make it easy to triage, respond, and search with minimal friction. It’s a staple in my daily stack.

CleanShot X
CleanShot X is how I give contextual product feedback. I use it to highlight, annotate, blur, and narrate screenshots with just a few clicks. It also integrates with Raycast so I can OCR and analyze screenshots using AI.

Loom
Loom is still the best way to record long-form async explanations or walkthroughs. I use it for tutorials, bug reports, and when writing things out would take too long.

🌀Vibe coding

Lovable
Lovable is how I build internal tools without needing engineering time. I spin up pricing calculators, partner forms, or microsites end-to-end, then export them to Git for final edits. It’s my starting point for vibe-driven builds.

Cursor
Cursor is my Claude-powered coding IDE. Once I have a prototype from Lovable, I bring it into Cursor to refine the code, add logic, or make small tweaks. It’s perfect for fast iteration.

Vercel
Vercel is how I ship side projects or GTM tools to the rest of the team. Once it’s ready, I deploy it on Vercel and share a live link. Super easy.

Claude Code
Claude is my go-to for creative and agentic coding tasks. It’s great for writing AppScripts, debugging Clay integrations, or generating clean, readable prototypes. I rely on it a lot more than GitHub Copilot.

✍️ Research & Writing

Claude
Claude is my main partner for creative thinking, writing, and code. The outputs are easy to read, scan, and reuse—especially when I need to create prompts, build workflows, or generate docs at scale.

ChatGPT
I use ChatGPT when I need structured, research-heavy outputs. For parsing documents, doing competitor analysis, or summarizing long notes, it’s still the best model. I usually pair it with Claude to cover both ends of a project.

📢 Social Media

Assembly.marketing
Assembly keeps our team aligned on content cadence. It helps us schedule and engage with posts across LinkedIn so we can show up consistently without daily coordination.

Scripe.io
Scripe is how I break my writer’s block. I voice memo ideas, then Scripe suggests headlines, formats, and even carousels based on my past content. I still write the final posts, but it’s the best starting point I’ve found.

🏢 Organizational productivity

🧠 Enterprise search

Dust AI
Dust is our custom-trained copilot that pulls from our docs, sales playbooks, enablement content, and more. It gives accurate, contextual answers and can be tailored by prompt to match different teams or needs.

Slack AI
I use Slack AI to query past conversations, pull old decisions, and get context from shared channels. It’s surprisingly good at surfacing relevant data if you frame the question right.

Notion AI
Notion AI is my fallback when Dust or Slack AI don’t hit. It searches across Notion, Slack, Linear, and Gong. I also use it to scaffold new docs and databases, like project trackers or SOPs.

🤖 GTM automation

Clay
Clay is our go-to automation engine. We use it for enrichment, routing, territory planning, and lead scoring—plus all sorts of partner discovery and workflows. It replaces a ton of spreadsheets and manual ops with structured data flows.

Attention
Attention is my favorite AI native call recorder. I use it to summarize calls, pull questions I asked, and create action items. It also powers some of our smartest Slack helpers by indexing key call moments with the Smart AI Assistant.

Zapier / Make / n8n
These are the glue for last-mile automations. I use them to sync recruiting pipelines, push updates between tools, and trigger custom workflows. If Clay doesn’t support something yet, these tools close the gap.

Many GTM leaders we talk to are drowning in manual processes at the same time they’re trying to build their first revenue engine. They know they need help with automation — but they’re still struggling to find the right candidates for the job.

Most teams approach GTM engineering hiring backwards: by posting generic job descriptions without understanding what they're actually solving for. But hiring a successful GTME requires knowing exactly when you need this role and how to identify the right person.

Here's how we think about hiring GTMEs effectively, based on real examples from Clay and the dozens of GTM teams we've helped scale.

TL;DR

• Timing matters: Hire a GTME when you're ready to build repeatable revenue systems, not when you're still figuring out product-market fit or positioning.

• Look for hybrids: The best candidates combine commercial thinking with technical building.

• Focus on adaptability over expertise: Prioritize candidates who love learning new tools and think like detectives about GTM problems.

• Design practical interviews: Use behavioral questions, systems thinking challenges, and real take-home assignments. We have examples of those at the bottom.

• Recruit from communities: The best GTMEs hang out in Clay communities, RevOps groups, and LinkedIn sharing automation workflows

When to hire a GTME

Bring on your first GTME once you're ready to build out your revenue org: when you’re launching a real outbound or inbound motion and need someone to help design, implement, and operationalize it.

If you're still in the early stages of validating your positioning or finding product-market fit, it's probably too early to hire a GTME. For early stage companies, founders often wear the GTME hat when they’re getting their hands dirty with Clay. But once you're ready to stand up a sales engine, run email campaigns, or score inbound and outbound leads, a GTME can quickly become one of your most strategic hires.

Regardless of company size or funding status, you need a GTME when you have repeatable processes to systematize, not when you're still figuring out what to build.

What makes a strong GTME candidate

GTM Engineer is still a new title, so it can be difficult to find someone with direct experience. Look for candidates with transferable skills and the ability to ramp quickly. The best GTMEs are hybrids: part commercial thinker, part builder. Strong archetypes often come from GTM ops backgrounds: sales ops, rev ops, marketing ops, and similar roles. This is what Robert Jones at Canva has to say about GTME candidates:

The best GTM Engineers think like product designers—they approach revenue generation as a design challenge, mapping out customer journeys and building systems that scale rather than simply connecting tools. What I look for is someone who genuinely understands sales teams as their users, grasping not just what's broken but why it matters to the people using these systems daily.

You want someone who gets excited about diagramming complex processes, can communicate effectively with both executives and SDRs, and instinctively asks 'how can we leverage AI to make this significantly better?' They need some sales exposure—not necessarily hitting quotas, but enough to understand why timing matters in outreach and where automation might damage relationship building. The key indicator is finding someone who's already a technology enthusiast, actively using tools like ChatGPT or Claude and quickly mastering new platforms without extensive training. This industry evolves rapidly, so you need someone who finds that constant change energizing rather than overwhelming. Get these qualities right and you'll have a strategic thought partner, not just someone waiting for direction.

Here are the specific areas that actually predict success:

• Technical fluency: They may not be classically trained, but they like learning new tools and vibecoding. Familiarity with Clay, n8n, Zapier, Lovable, Bolt, TypeScript, Python, or SQL is nice to have. The real signal is a willingness to learn by tinkering. Our GTME Spencer started as a product designer and learned SQL on the job with Claude.

• Commercial bias: They think about the ROI of their work, constantly asking questions like "Does this workflow actually help someone close a deal?" They understand that automation should drive revenue outcomes, not just efficiency.

• Curiosity: They approach every go-to-market puzzle like detectives, breaking down complex problems systematically and investigating when things don't work as expected.

• Experimental mindset: They know how to test ideas, validate signals, and turn feedback loops into better systems. They're comfortable with iterative improvement rather than perfect solutions.

• Hacker mentality: They're resourceful and creative in how they solve problems. The question shouldn't be "Can I do this?" but "How do I do this?" They find ways to make things work with available tools and constraints.

• Comfort with ambiguity: They need to be able to take a big problem and figure out how to tackle it. They should not only handle ambiguity but actually enjoy it—turning unclear requirements into structured approaches.

  

There are some motion-specific needs that will depend on your revenue operation:

• Product-led growth: Look for someone strong in product data and SQL—they'll need to understand conversion paths, usage patterns, and how product signals translate to sales readiness.

• Sales-led: The focus shifts to funnel conversion, handoff processes, and outbound effectiveness. They should understand pipeline velocity and what drives deal progression.

Before hiring externally, see if anyone on your current team could uplevel. If not, look externally. (More on that later.)

This is what Alexander DeMoulin, director of RevOps at Intercom, has to say about assessing GTME candidates:

The right person absolutely needs to think way outside the box. I want to understand real examples of times when they've thrown wacky stuff at the wall and discovered what actually worked. They also need a sales background. I want someone who has sat in the sales seat before as this is a role, at least at larger companies like Intercom, is primarily making sales more efficient and helping them spend as much of their time actually selling.

As far as red flags go, someone who has no experience with traditional ops whether its marketing or sales ops at a company isn’t a great fit for us. We're still early in figuring out GTME and any success will heavily depend on the ability to bridge between what's "always been done" vs. what's possible now.

Crafting the interview process

We recommend a behavioral interview, multiple interviews to evaluate their hacker mentality and ability to handle ambiguity, and a take-home assignment.

Example interview questions

Here are specific questions we've used successfully, organized by skill area:

• Systems Thinking:

  • Tell me about the last process you built from scratch.

  • Walk me through how you'd diagnose why our email reply rates dropped 30% last month.

• Handling Ambiguity

  • If I asked you to run an experiment with no clear playbook, how would you get started?

  • If I gave you a database with product usage, CRM, and marketing data, what questions would you ask first?

• Prioritization

  • Tell me about a time you had to ship fast and iterate later. How did you manage tradeoffs?

  • We need to double our pipeline in six months without adding headcount. How would you approach this?

• Creativity

  • What's the coolest automation you've built or seen? What problem did it solve?

  • If we had to double our pipeline in 6 months without doubling headcount, what would you do?

• Curiosity

  • What's something technical you taught yourself recently? Why, and how did you approach learning it?

Take-home assignments that work

The best assignments are practical and realistic. Tailor the assignments based on which skills or tools (e.g. Salesforce or SQL) you care most about so that you can see how a candidate works with platforms you use in practice.

Here are example prompts:

• Outbound Reply Rate Analysis: You've been provided with a dataset containing information about outbound emails sent to prospects as part of Clay's go-to-market motion. Your task is to analyze this data and provide insights that can help improve reply rates and downstream funnel performance. The goal is to identify which variables—such as job function, company stage, industry, team composition, or timing—most strongly influence reply likelihood, and to surface opportunities to better target, prioritize, or personalize outreach.

• Outbound Campaign Creation: Your task is to build an outbound campaign using the complete GTM data provided. You have 60 minutes to read this document, analyze the data, design and build your solution.

• Hypothesis Creation and Testing: Form a hypothesis about what companies they should target and then execute on that to find those companies through enrichment, AI, data scraping, etc.

• Inbound Lead Analysis: You've been provided with a dataset containing information about inbound leads who have submitted a form, signed up, or otherwise engaged directly with Clay. Your task is to analyze this data and identify opportunities to improve inbound qualification, response, and conversion rates. The goal is to spot patterns in who converts and who doesn't, and to recommend improvements to how inbound leads are prioritized, worked, and messaged.

Strong candidates will break the problem down, explain their assumptions and fallback logic, and identify both external levers (like new data sources) and internal ones (like SDR-to-AE routing delays).

Red flags

Even candidates who sail through interviews can fall short on the job. As you hire your first GTME, keep an eye out for these common warning signs:

• Tunnel vision: Suggesting only one channel or approach without considering alternatives or trade-offs.

• Shiny Object Syndrome: Good candidates will be on the cutting edge of technology but they should know the difference between a useful tool and a trendy one.

• Ignoring obvious risks: Not thinking through challenges like deliverability issues, targeting fatigue, or data quality problems.

• Over-engineering: Jumping straight to complex solutions without considering simpler approaches first.

• Lack of commercial awareness: Focusing purely on technical implementation without connecting to business outcomes.

Where to find the right GTME candidates

Your next GTME might be hanging out in Clay communities, RevOps groups, or posting on LinkedIn about automations they've built. At Clay, some of our best hires came directly from our ICP — people who were already using our platform to solve similar problems.

Here are some specific recommendations for sourcing:

• Submit your job listing to Clay's GTME job board

• Post in Slack communities like Clay and The GTM Engineer Lab.

• Email noah@thegtmengineer.ai to get your job featured in the GTM Engineer newsletter

  Look for people sharing automation workflows on LinkedIn

  Engage with practitioners in RevOps communities who are solving real problems

The best GTMEs are often already employed and engaged in the community—they're not actively job searching but are curious about new challenges and opportunities to build interesting systems. Here’s Rippling’s Noah Adelstein on what he looks for in a GTME:

What I look for in a strong GTM Engineer candidate is someone who's deeply curious about technology and can give you specific examples of going down interesting rabbit holes with their curiosity. They should be able to walk you through building a complicated workflow in detail—bonus points if they mention tools like n8n or Clay. I want candidates who have clear spikes in analytical skills, customer empathy, or creativity, depending on what the role specifically needs, and ideally they teach you something new during the conversation in their area of strength. The red flags are pretty clear: if they don't know any modern software tools like Clay, only talk about experience with traditional marketing channels, or have no GTM experience whatsoever, that's concerning. Someone without a GTM background can likely become a GTM engineer, but they'll need significant ramp time to get there.

Building for the long-term

We're excited about the rise of GTMEs and how fast the ecosystem is growing. GTM Engineers are becoming the foundation behind organizations finding their GTM alpha—the systematic advantages that compound over time.

The goal isn't just to hire someone who can implement tools today, but to find someone who can build the systems that will scale your revenue engine as both your business and the technology landscape evolve. When you find that person, they'll quickly become one of your most strategic hires. Take the time to build the foundation properly rather than rushing to fill the role with the first person who knows how to use automation tools. Your team will thank you.

Other Resources

Matthias Powell, co-founder of The Kiln, a Clay that specializes in creating custom workflows for inbound, outbound, and RevOps use cases, has a great LinkedIn post that lays out what he’s learned about GTME interviews. The PDF is below.

The Kiln GTME Interview Guide

2.47MB ∙ PDF file

Download

Download

Sample take home assignments

Inbound Lead Analysis Take Home Example

71.5KB ∙ PDF file

Download

Download

Outbound Reply Rate Analysis Take Home Example

79KB ∙ PDF file

Download

Download

Outbound Campaign Creation Take Home Example

95.1KB ∙ PDF file

Download

Download

Sample job descriptions

Clay GTME Job Description

32.7KB ∙ PDF file

Download

Download

OpenAI GTME Job Description

34.8KB ∙ PDF file

Download

Download

Webflow GTME Job Description

53.8KB ∙ PDF file

Download

Download

Thanks to Alexander DeMoulin, Robert Jones, Noah Adelstein, and the GTME team at Clay for helping shape the ideas in this article.

We built Clay for GTM engineers: one place to access 130+ premium data sources and GTM's most beloved AI research agent—then automate growth workflows to turn insights into revenue.

Two weeks ago, our first newsletter broke down what GTM engineers do and why they’re ripe for the moment. This week, we're opening up Clay's GTM engineering lab to show how we use state changes to trigger revenue plays—and how every problem we solve internally becomes a feature our customers rely on.

From internal solutions to customer success

Clay is the default tool for GTM engineers, and what we pilot internally often turns into powerful customer use cases. We simultaneously learn from what our customers want and what we need to build.

We often go from internal problem → solution → beloved customer feature:

• Our sales team wanted automated pre-meeting notes → Notion integration

• We needed personalized landing pages → Webflow integration

• We needed to convert more trial users → automated trial conversion emails

• Inbound response time was killing conversions → automated routing and messaging

This approach—turning our own needs into customer solutions—runs on four core principles.

The four principles of GTM engineering

Four tenets guide GTM engineering at Clay.

1. The user journey is a state machine. Customers move through stages or “states” as a deal progresses. A GTME’s job is to understand what triggers those state changes and how to activate them. Approximating a customer’s state tells us how to develop our relationship.

2. Go-to-market is a learning exercise. The market is a moving target, with a stream of new entrants and constant changes. No tactic lasts forever: experimentation is necessary.

3. Deliberate design unlocks freedom. Well designed systems let you iterate fast. We build modularly to avoid vendor lock-in and mix-and-match capabilities.

4. Good GTME teams are a force multiplier. We help GTM teams scale their work and ideas effectively. One seller’s great idea should always become an entire team’s superpower.

These principles ladder up into the foundational belief that any GTM function needs to be an adaptable, experimental process: strong enough to run smoothly and nimble enough to shift gears. That’s reflected both in how we built Clay as a product and how we use Clay as a GTM engineering team.

The first principle—treating the user journey as a state machine—is where everything starts. Because if you can identify when users change states, you can build systems to respond automatically.

All problems are data problems

These principles come to life through how we approach every GTME challenge at Clay. Each GTME problem starts with data. The user journey is a state machine, and we use Clay to identify the right signals to know when and how a user is transitioning between states. We've built our entire GTM motion around identifying these state changes and automating our response.

Let's dive into four example plays built around state changes:

• Play #1: Job listings as market intelligence. We'll show you how to turn job postings into qualified pipeline by identifying companies ready for GTM transformation.

• Play #2: Converting trial users at scale. Here's how we transform free users into enterprise accounts with automated, personalized outreach.

• Play #3: Seamless sales-to-success handoffs. We'll walk through automating the context transfer between sales and growth teams to prevent churn.

• Play #4: Mining support conversations for expansion. Learn how support tickets become enterprise opportunities with AI-powered routing.

Play #1: Job listings → sales conversations

During an internal hackathon, we spotted Vanta hiring for a GTM Innovation role—a clear signal they were rethinking their go-to-market approach. We reached out and it became one of our most successful partnerships.

But one win isn't a strategy. To scale this approach, we designed LLM agents to identify true GTM roles across job sites. With the right prompts and agent profiles, the data went from noisy to actionable. We generated lists of companies for sales outreach, understood their GTM plans and hiring needs, then helped them use Clay once roles were filled.

Play #2: Trial users → paid users

Trial users are untapped sales leads that benefit from personalized, automated outreach. When users sign up for Clay, we enrich them in a table using 50+ data providers, web scraping, and AI. We collect:

• Company information (description, employee count, revenue, social media)

• Individual details (job title, start date, professional profile)

• Sales and growth team headcounts

We categorize companies as high-growth tech, enterprise, or agency and score each lead to identify high-priority executives in growth, marketing, and sales. We monitor trial users for upgrade signals, launching campaigns when users meet criteria like:

• Companies with 2+ trial sign-ups (team-wide engagement)

• High-grade contacts (A or B level) who are decision-makers

• Marketing, growth, and sales leaders with purchasing authority

When triggered, the highest-graded contact enters our outreach flow. We pull company details from Gong for personalized email copy. (E.g. if multiple users at a company sign up for Clay, we mention this, ask why, and suggest a call while referencing similar companies Clay has helped.)

Play #3: Sales → CX handoffs

The handoff of a signed customer from sales to CX isn't always smooth. Growth strategists need deep customer context that isn't always available. We automated this with Clay and Gong to auto-generate handoffs in Salesforce, giving our growth team crucial context. We also run deal close and qualification criteria through Clay to generate summary notes, easing transitions.

Play #4: Support conversations → enterprise deals

Support conversations are an underappreciated source of enterprise deals. We use AI to flag accounts interested in enterprise features and trigger scheduling links to GTMEs. Accounts automatically route to appropriate team members. By reducing friction from support to sales, we amplify the support channel's output.

The GTM Engineering mindset: always be iterating

These four plays demonstrate how GTM engineering transforms every touchpoint into a growth opportunity. But here's the key: none of these solutions are static.

As we wrote in our GTM Alpha piece, this is the reality of modern growth: there is no permanent competitive advantage, only the continuous pursuit of temporary advantages. The market evolves, competitors copy successful tactics, and buyers become numb to approaches they've seen before. The best teams aren't attached to their current methods: they're energized to discover what works next.

We know our GTM workflows are never perfect. Iteration, experimentation, and the flexibility of Clay are core to finding our GTM alpha—and yours.

Move fast. Stay creative. Automate where you can. It's how we run GTM engineering at Clay and ship tools that change how our partners do business.

Thanks to Ted Brown, Mishti Sharma, Spencer Chemtob, Manny Adelstein, Scott Tousley, and Bruno Estrella for their thoughtful contributions to this article.

If you’re a GTM leader whose team is bogged down by manual research, slow campaigns, or data cleaning, more effort won’t fix things. You need better systems. And GTM engineers are the ones who build them.

GTM engineers build revenue engines using AI and automation. Since we coined this role in 2023, it has emerged at companies like Cursor, Lovable, and Webflow. Today, about 100 GTME job listings go live every month.

GTM engineers (GTMEs) primarily live within ops and can solve problems across any revenue-critical function. That includes:

• RevOps: Automate manual seller work (e.g. replace manual account research, update CRMs based on call transcripts, send follow-up emails, etc.)

• Growth: Automate demand gen and ABM (e.g. Monitor complaints against competitors on social platforms and launch personalized campaigns within hours).

• Customer success: Automate retention and expansion plays (e.g. analyze support tickets to predict churn and send targeted retentive emails).

Ops teams have always been the backbone of revenue teams. Now, with AI, they're stepping into their most strategic era yet. Their job is changing from data plumber to growth architect: someone who tests hypotheses and scales what works, without waiting for developers or manual research. When ops teams turn into GTM engineers, they stop reacting to tickets and start proactively growing revenue.

In this guide, we share how GTM engineering is evolving at Clay, describe live GTME workflows, and offer advice for how to structure and hire GTMEs in your organization based on our top customers’ setups.

Subscribe now

Why GTM engineering now?

Two shifts made traditional GTM roles and processes obsolete:

First, GTM tactics became commoditized. The sales tactics that worked in 2010 fall flat today. Prospects get hundreds of generic cold emails, and spam filters ignore "quick question" subject lines. Winning companies continuously find a competitive edge, or GTM alpha, with unique data and differentiated plays.

Second, AI eliminated the need for custom manual research and engineering. AI can research thousands of companies at once. APIs can pull data from anywhere. What required either manual research or engineering talent two years ago is now easy no-code automation. This unlocked the ability to test highly targeted, creative approaches at scale.

These shifts created both the need and the opportunity for GTM engineering. The commoditization of tactics demanded creativity. AI made that creativity executable, collapsing the gap between idea and execution from months to hours.

GTM engineers find and fix revenue bottlenecks. They can discover that you should spend resources targeting NYC cafes with $10-20 entrees who just joined DoorDash—and help you reach them tomorrow, not next quarter.

GTM engineering at Clay

At Clay, our GTM engineers act like an internal product team that serves our GTM organization. They identify problems, write specs, ship prototypes, and scale what works, measuring success by metrics like meetings booked and hours saved.

Their work impacts sales enablement, growth marketing, customer success, and more. They both invent new workflows and scale promising tactics from individual experiments. For example, a seller recently built a custom Clay table to track buying signals and draft outreach for top prospects. The GTME team templated the build and rolled it out org-wide within days.

More unique to Clay: our GTMEs also act as consultative sellers. Just as Harvey uses lawyers to sell legal software and Prompt Health uses therapists to sell and support their product, Clay uses GTMEs to sell Clay. These sellers have deep empathy for our customers and speak their language.

How GTM engineering can solve different domains’ problems

Our GTMEs tackle RevOps, Growth, and CX challenges by first nailing the basics: a clean, trustworthy CRM. Without that data foundation, nothing scales.

Like data scientists, GTM Engineers offer a portable toolkit that only works when the stack beneath it is solid. Their work progresses through three rungs, each building upon the last:

1. Data foundation: Keep CRM and warehouse records clean, deduped, and trustworthy. (Automated enrichment jobs, schema audits, “merge-and-purge” routines, and ownership rules.)

2. Data modeling: Collect unique data points that predict purchase, expansion, or churn. (Building propensity scores, defining ICP attributes, and adding AI-data points.)

3. Data activation: Deploy unique data points in revenue-generating workflows. (Automated outreach, meeting notes, churn-risk or expansion nudges, sales enablement, etc).

Most companies stumble on the first rung. They either try fancy campaigns on incomplete, dirty, or duplicate-riddled data, or waste 80% of their time on data hygiene (updating records, validating info, fixing duplicates) and leave only 20% for strategic work.

GTM Engineers flip this ratio: they automate the hygiene work so teams can spend their hours experimenting and fine-tuning ICP. Below are real builds from Clay to show what that means.

Revenue operations & seller enablement

RevOps often focuses on increasing sales efficiency. That could include scoring and replying to inbound interest, auto‑updating your CRM based on call recordings, and more.

• Intelligent inbound routing: Manny and Osman’s model scores new sign-ups for $25k-plus potential, auto-assigns the best leads, and even drafts meeting notes and follow-up messages that mention similar customer use cases and custom signals.

• Signal digests in Slack: Osman pipes signal digests to individual sellers for account awareness and call prep.

• VIP event invites: Spencer cross-references event data with geolocation data to surface perfect event invitees, and automatically follows up on behalf of sellers.

• One-click call rescheduling: A reschedule link fires whenever a prospect misses a call to suggest a new time to meet.

• Transcript‑powered data entry: Blake’s script listens to calls, extracts firmographics, and backfills Salesforce, so reps don’t waste time in the CRM.

Growth marketing

Growth focuses on demand generation: finding the right prospects, personalizing outreach, and rapid‑testing new channels.

• Activation plays: Osman and Manny automated a playbook that lifted trial conversion rates. They also run plays for activated workspaces and new promising customers. Each of these have centralized lead scoring and routing.

• Programmatic partner sourcing: Tommy scraped social media and website profiles, scored fit, and launched our influencer marketing program.

• Dynamic visitor campaigns: Pranav’s workflow watches reverse‑IP data and triggers personalized emails while interest is hottest.

Customer success & expansion

CX focuses on retaining revenue by spotting risk early and acting on upsell moments.

• Ticket‑spike alarms with docs: Bruno’s workflow flags surges in support tickets and drafts the help center articles that prevent the next wave.

• CX idea generator: Spencer merged Salesforce and Claygent data to recommend bespoke plays for CSMs to suggest to their accounts.

  

• Smart support routing: When someone contacts support asking for a sales meeting, our system qualifies them instantly and sends a meeting link if they're a good fit—no manual handoff needed.

• Expansion radar: Osman scans support threads for enterprise‑only feature requests (RBAC, faster refreshes) and feeds those signals to the account manager before renewal.

Examples of GTME organization structures

Our customers implement GTM engineering in different ways (and by different names), though the common goal is to build automated revenue engines. Here are some emerging models:

Model 1: GTME inside RevOps (the dominant pattern)

At most mid-to-large companies, GTM Engineers report into RevOps or GTM ops. The function sometimes splits into prototypers and implementers, where generalists close to sales hack together proofs-of-concept, then engineers harden the winning ideas to touch millions of CRM rows without breaking.

• Intercom: Alexander DeMoulin’s GTM Ops team pilots new plays (e.g., TAM enrichment), while GTM Systems, embedded in R&D, scales methods to production.

• Canva: Robert Jones’s GTM AI team automates workflows such as transcript summarization, while a separate enrichment team pipes novel data into those plays. Longer-term, Canva may embed GTMEs directly inside sales, marketing, and CX tribes

• Notion: Three teams work together to drive RevOps and GTM AI. Evan Peters owns RevOps and Strategy with a GTM innovation pod to build workflows, experiment, and get hands-on commercially (reporting to the CRO). Jalal Iftikhar and Shelley Lee's BizTech and automation engineering teams build foundational GTM systems and scale workflows (reporting to the CFO). Theo Bleier is an embedded AI engineer building and scaling applications (reporting through the CTO).

• Anthropic: Everything lives in one GTM Infrastructure & Incentives pod led by Adam Wall. A “Productivity Engineering” sub-squad wields Claude + Clay to automate sales and marketing work.

Why it works: RevOps already owns data pipelines and quality, so lodging GTMEs here draws a straight line from “We spotted a friction point” to “We shipped the fix.”

Model 2: GTME within Growth

A second archetype puts GTM Engineers inside the Growth org.

• Ramp houses a Growth Platform squad, led by PMs like Keyan Sarrafzadeh, who partner with Growth Engineering. They run two-week sprints, shipping internal prospecting tools, data aggregators, and AI outreach flows. A separate Business Systems group looks after core Salesforce plumbing.

• Verkada keeps its GTMEs in Davide Grieco’s Growth team under the CMO. Their charter is to generate demand and create systems that help the broader GTM organization. That ranges from generating personalized landing pages for ABM campaigns to automating 80% of SDR workflows so they can book 4x the number of meetings per month (80-100 per rep).

• Rippling runs GTM engineering within Noah Adelstein's international growth team as well as the US growth team. These teams run frequent growth experiments, including automating outbound and direct mail campaigns.

Why it works: Embedding technical talent beside demand gen unlocks ideas—programmatic landing pages, real-time intent harvesting—that traditional marketers might never attempt.

Cross-model lessons

1. Start in ops, federate later. Most companies incubate GTM Engineering under RevOps, then push talent outward once foundations are solid.

2. Balance rapid prototyping with stable implementation. Data engineering skills are often useful when you’re ready to scale experiments that work.

3. Data hygiene is non-negotiable. Every win traces back to clean, enriched, well-modeled data.

How to hire a GTME

When teams first hear about GTM engineering, the next questions are always, Who do I hire? and Where do I find them?

Great GTM Engineers are often hybrids: half commercial thinker, half builder. (Think “marketers who are bad engineers” or engineers who care more about moving revenue than writing perfect code.)

Where to find them: These folks might be hanging out in Clay communities, RevOps groups, or posting on LinkedIn about automations. At Clay, some of our best hires came directly from our ICP.

What to look for:

• Technical fluency: They may not be classically trained, but they like learning new tools and vibe coding. Familiarity with Clay, n8n, Zapier, Lovable, Bolt, TypeScript, Python, or SQL is nice; the real signal is a willingness to learn by tinkering. (E.g., Our GTME Spencer started as a product designer and learned SQL on the job with Claude.)

• Commercial bias: They think about the ROI of their work, asking questions like “Does this workflow actually help someone close a deal?”

• Curiosity: They approach every go-to-market puzzle like detectives.

• Experimental mindset: They know how to test ideas, validate signals, and turn feedback loops into better systems.

How to assess them:

1. Business problem investigation

Hand them a fuzzy problem, e.g. “Our trial-to-paid rate won’t budge.” Strong candidates start by asking:

• Who is our ICP?

• What are we missing in their journey?

• Which signals tell us someone is ready to buy or churn?

Good answers explore both market levers (new intent data) and internal levers (slow SDR-to-AE routing). Candidates should be specific, e.g. asking questions about your most successful customer calls to work backwards from there.

2. Systems sketch

Next, have them outline how they’d turn those insights into a working flow. Can they pick good/unique data points to track, keep them clean, and plug them into a Clay workflow? Watch for the mindset of someone who tests, measures results, and iterates.

3. Mini build challenge

Give a take-home based on the above, e.g. design and validate a specific set of data points that predict churn. Any tool is fair game. A good submission:

• Explains assumptions and fallback logic

• Mentions suppression or multi-channel sequencing (no blast-all emails)

• Shows how they’ll measure success and iterate

Red flags include tunnel vision, like if they only suggest one channel or ignore obvious risks like deliverability or targeting fatigue.

GTMEs can come from a variety of backgrounds—the diagram below is roughly representative of our team.

A systems-oriented future

GTM alpha belongs to teams that can build revenue engines with AI. As tools and tactics become commoditized, the edge shifts to how well you can design experiments and scale them fast. Hiring 10 more reps for every 10% pipeline lift won't cut it anymore.

Ops was never meant to live in the back office. Today, the teams closest to your data are also closest to new revenue. GTM Engineers turn ops from support function to growth engine—the connective tissue between product, sales, and marketing. While marketing drives awareness and brand, GTMEs build the infrastructure that turns it into repeatable revenue.

Your revenue problems aren’t people problems. They’re systems problems. And GTM engineers are the ones who fix them.

Thanks to Evan Peters, Alexander Demoulin, Robert Jones, Adam Wall, Davide Grieco, Keyan Sarrafzadeh, Noah Adelstein, Keith Jones, Rachel Hepworth, and most of all, every GTME at Clay for helping shape the ideas in this article.

We built Clay for GTM engineers: one place to access 130+ premium data sources and GTM's most beloved AI research agent—then automate growth workflows to turn insights into revenue.

Try Clay free