Most founders think GTM engineering is just cold outbound done better. Clay's Head of GTM Engineering Osman Sheikhnureldin reveals why that mindset will cost you months of wasted effort.

In this episode, Osman walks us through exactly how to identify your ideal customers at the perfect moment, then demonstrates his framework live with two early-stage founders - showing you can't just wing GTM engineering, but when done right, the results compound.

Osman Sheikhnureldin is the Head of GTM Engineering at Clay, the company that invented GTM Engineering. He's helped hundreds of startups transform how they use data and technology to remove growth constraints. Joining him are Nilo Rahmani, Co-founder and CEO of Thoras AI (AI-driven cloud reliability and cost optimization), and Panos Papageorgiou, Co-founder of Keragon (HIPAA-compliant automation platform for healthcare).

In Today's Episode We Discuss:
01:51 - GTM engineering defined: Solving growth constraints with technology, not headcount
02:57 - Why your target list matters more than your message will ever matter
04:45 - Ditch static ICPs: The jobs-to-be-done framework that actually works
06:53 - The "magic wand" question every founder must answer before building workflows
08:49 - The account scoring workflow no human should ever do manually again
13:46 - How Clay built an ML model to predict contract value from enrichment data
19:18 - Vanta's genius GTM hack using AI screenshots to analyze brand consistency
21:30 - European food startup's signal stack: First US hire + ad spend + new landing pages
23:06 - Early-stage messaging must be hyper-specific—big company tactics won't work for you
26:54 - Founders who lived the pain have an unfair advantage in outbound messaging
28:59 - Counterintuitive truth: AI SDRs have failed—human taste matters more than ever
31:48 - Why hybrid LLM + human skeleton emails crush pure AI-generated copy
34:42 - Voice AI skepticism: Great for extraction, not ready for cold calls
37:18 - Three brutal truths: GTM engineering takes months, hard work, and real creativity
38:20 - "Earn the right to message someone"—the philosophy behind effective outbound
39:24 - Live teardown: Keragon's healthcare GTM using EHR migration as the trigger signal
47:08 - Finding EHR signals through PR announcements, patient portals, and RSS feeds
55:38 - Live teardown: Thoras AI's challenge—spotting cost-cutting triggers that signal growth
01:00:58 - Why "cutting costs" often means a company is scaling, not struggling
01:07:32 - Novel signal: Second product launch as the perfect moment to reach infrastructure teams
01:13:06 - The biggest misconception: GTM engineering goes far beyond cold outbound

Clay pioneered GTM engineering and went from $1M to $100M in ARR in 2 years.

I talked to the person who invented the role of GTM Engineer at Clay.

Yash Tekriwal, Clay's first GTM engineer - back when the $3B company was still figuring out what that even meant.

What started as one person drowning in too many jobs (RevOps + Sales + BDR + data analyst) has since become a new category that's now reshaping how startups think about go-to-market.

You’ll learn:

• Why RevOps is "maintenance" but GTM engineering is a growth lever
• The skills that define a great GTM engineer today (hint: it involves vibe coding)
• What "treating go-to-market like a product" actually looks like in practice
• Two org models for GTM engineering teams - and which to start with
• "Automate the manual, but don't automate the important"

In Today's Episode We Discuss:
01:23 - The origin story of GTM engineering at Clay and why the term is polarizing
05:02 - GTM engineer vs RevOps: maintenance function versus growth lever
07:31 - Treating go-to-market like a product team, not an individual sport
10:42 - Three experiments every GTM team should run on inbound and outbound
15:24 - The essential GTM tech stack: CRM, enrichment, sequencing, and what actually matters
19:08 - Tools founders should consider when getting started—and the automation trap to avoid
22:12 - Zero to $1M: be thrifty on tools and process information manually
25:38 - What to look for in your first GTM engineering hire (hint: it's not technical skills)
28:43 - Signals that you need to hire a GTM engineer for outbound vs inbound motions
31:45 - Scaling past $10M: specialize fast and the hyperscaler dilemma
36:01 - Two org models for GTM engineering: centralized hit team vs embedded engineers
40:22 - The ideal GTM engineer profile: tinkerers, not traditional engineers
43:33 - Why engineers are not the ideal candidates for GTM engineering roles
45:19 - Can salespeople become great GTM engineers? The sales hacker archetype
47:26 - Resources to learn GTM engineering: Clay University, substacks, YouTube channels, and agencies
51:00 - Top three things founders must know about GTM engineering at any stage
52:16 - The most creative GTM engineering builds: satellite imagery, hospital capacity, and custom memes
56:24 - Personal lessons from scaling at Clay: ego death, pivoting, and balancing maintenance with big bets
59:42 - The one thing Yash would change: stop oscillating and let problems become obvious

The Horizontal vs Vertical AI Debate: Why This Ex-Meta AI Researcher Is Betting Big on Horizontal Web Agents

Should you build narrow (vertical) or go broad (horizontal) in AI? This episode unpacks why one PhD researcher abandoned his working vertical product to chase a much riskier horizontal bet - and why VCs leaning heavily into vertical AI might be missing something.

Abhishek Das is the co-founder and co-CEO of Yutori, which has raised over $15 million from Radical Ventures, Felicis, and prominent angels including Ali Gil, Sarah Guo, Scott Belsky, and Guillermo Rauch. Previously a research scientist at Meta's FAIR lab, Abhishek holds a PhD from Georgia Tech where he pioneered work on AI agents that can see, talk, and act starting in 2016.

In Today's Episode We Discuss:
00:53 - Why how we interact with the web hasn't changed in three decades and what will break that
02:27 - The coming shift from manual browsing to AI assistants performing tasks in the background
05:57 - What "agents" actually meant in ML research before the term became overloaded
06:14 - Why 90% accuracy per step creates catastrophic failure rates over multi-step workflows
08:46 - The behavior pattern humans nail intuitively that machines struggle with: backtracking from errors
10:11 - The DoorDash experiment: building an end-to-end food ordering agent that never shipped
12:58 - Why training on sinle websites leads to memorization instead of generalization
13:03 - The dopamine problem: some tasks users don't want automated
15:08 - Why capability-scoped beats website-scoped: the pivot to read-only horizontal agents
18:05 - Three criteria that drove the horizontal decision: research, user value, and data strategy
24:18 - Scouts API launch: why different channels have different risk appetites for web agents
26:30 - Flying close to the sun: how Yutori competes with hyperscalers on horizontal AI
30:32 - What VCs should actually test for in horizontal AI teams beyond founder horsepower
32:10 - Why three-month roadmaps are the only reasonable planning horizon in AI today
33:05 - The dogfooding ritual: every team member rotates through user feedback weekly
34:50 - Why research and product can't be siloed and how ideas flow both directions
36:03 - The uncomfortable truth: end users don't care about your research breakthroughs
37:32 - The Nintendo Switch 2 problem: aggregating individual feedback into systemic fixes
39:35 - Reframing web agents as "buyer's agents" that filter the internet on your behalf
40:59 - The simulation bet: training agents on cloned websites for high-stakes irreversible actions
43:05 - Why initial team skepticism about Scouts' value proposition was completely wrong
45:01 - How scout reports contextualize results with reasoning and ingest feedback over time
47:52 - The core insight test: where does your instinct lie across research, market, and domain?
49:36 - The hiring trap: why preemptively hiring sales leadership to impress VCs backfires
51:18 - The 12-year-old advice that still guides him: "Be a sponge when entering a new space"
53:05 - Non-negotiables: walking the dog with podcasts and personally reading every user email
54:49 - What founders actually need from VCs: direct and timely feedback, not just capital

Stop launching into the void and start creating campaigns that actually get attention.

Sumeru Chatterjee reveals the exact 10-week playbook he's used to generate millions of impressions at four unicorns, including why most B2B launches fail and how to weaponize your investor network for maximum impact. You'll discover why emotion beats logic in B2B marketing and why treating existing features as "new launches" is the growth hack nobody talks about.

Sumeru Chatterjee is Head of Growth at CoWorker AI, the first AI agent for complex work. Previously an early employee at four unicorns and founder of LaunchMob agency, Sumeru orchestrated CoWorker's launch that generated over 1 million impressions in a single day with 75 investors coordinated like a military operation.

In Today's Episode We Discuss:
03:45 - Mine 20 customer calls for launch gold using AI
07:29 - Stop hiring humans: Why fear sells better than features
10:23 - The 200 dream customers exercise founders skip
14:50 - Find 50 influencers who already own your audience
18:05 - Three distribution channels max or you'll fail everywhere
20:40 - Everyone claims differentiation but nobody actually commits
29:48 - The $20 book that made Hormozi $60 million
35:36 - Competitive positioning vs contextual positioning changes everything
38:28 - 46 creative concepts: From white papers to doormats
44:16 - Product Hunt is dead for B2B launches
54:05 - Coworker's investor spreadsheet that drove 1M impressions
01:08:44 - Launch every two weeks or become irrelevant
01:11:03 - OpenAI launches Slack integration like it's revolutionary
01:14:37 - Your 10 employees are connected to 500,000 people
01:15:37 - Different is better than better always wins
01:18:04 - Master one funnel before attempting anything else

The forward deployed engineer model took Happy Robot from zero to millions in revenue in under 2 years.

In this episode, Pablo Palafox reveals exactly how to implement Palantir's FDE motion at a startup - including when to use it, who to hire, and the costly mistakes to avoid. Learn why embedding engineers directly with customers beats traditional sales approaches for complex AI products.

Pablo Palafox is the co-founder and CEO of Happy Robot, the AI-native operating system for supply chain and logistics. Prior to Happy Robot, Pablo completed his PhD in computer science and deep learning. Happy Robot has raised over $60M from investors including a16z, YC, and Base10, and serves enterprise customers like DHL.

In Today's Episode We Discuss:
02:01 - When the CEO realizes they're actually the company's first FDE
05:13 - Why embedding with customers beats having a sales pitch
09:01 - Stop trying to copy Palantir - build your own FDE playbook
13:25 - The critical difference between FDEs and deployment strategists
17:19 - How Discord servers led to billion-dollar freight broker clients
21:33 - FDEs must become industry insiders, not just tech experts
25:46 - When NOT to use the forward deployed engineer model
30:55 - The FDE hiring secret: Look for "nerds who can sell"
36:35 - Why FDEs need 1-2% equity vs 0.1-0.5% for regular engineers
41:49 - An FDE's day: 80% building, 20% with customers onsite
47:00 - The $30K to $3M expansion playbook for FDE accounts
52:10 - Building FDE "pods" for vertical specialization
56:27 - Why waiting to verticalize FDEs was their biggest mistake
59:19 - The 10X deployment accelerator most startups forget
62:00 - Why FDEs will soon build entire vertical products autonomously
64:58 - When to transition from "things that don't scale" to scale
67:11 - The one place every vertical AI founder must go immediately

Why saying "no" is the secret to growing faster as a startup founder

Most founders think raising $100M means spending aggressively. Adit Abraham raised $108M and spent only $1M - while landing Fortune 10 contracts very early on and having experienced zero enterprise churn to date.

In this episode, he reveals the counterintuitive focus strategies that helped Reducto turn documents into data better than anyone else, including why they fired a $5K contract, limited engineers to one priority per week, and spent months recruiting a single PhD instead of scaling the team quickly.

Adit Abraham is the co-founder and CEO of Reducto, an AI company that transforms documents into structured data for language models. He previously worked at Google and attempted other startups before Reducto, where he learned the hard lessons about focus that now drive his company's success. Reducto has raised over $100M from A16Z, Benchmark, First Round Capital, and Y Combinator.

In Today's Episode We Discuss:
02:04 - Pivoting from a viral product before Y Combinator even began
05:48 - How free computer vision consulting revealed real product-market fit
07:29 - The exact moment founders know they've found product-market fit
08:03 - Why going one layer deep on ideas is the most dangerous founder trap
11:10 - Choosing two PDF features over 35 file types competitors supported
14:54 - Turning down construction document contracts worth millions in revenue
17:10 - Past startup failures that became the blueprint for saying no successfully
22:25 - Cutting engineer to-do lists from 10 items to 1 weekly priority
27:45 - The doctor-patient framework that makes rejecting customers feel collaborative
31:35 - Maintaining velocity while scaling from 4 to 20 high-agency employees
36:08 - Prioritization without spreadsheets: qualitative judgment over point systems
38:50 - Spending $1 million after raising $108 million from top-tier VCs
40:52 - Why their first research hire is one of 10 best in world for document AI
46:35 - The fitness trainer analogy every founder misunderstands about company building
49:14 - When "stay lean" advice becomes the wrong strategy for your stage
50:16 - Why full-time commitment creates space for different experiments than side projects
52:04 - The VC conversation that made sharing bad news feel safe instead of scary

Every bottom-up PLG company faces this tension:

PLG gets you in. Enterprise funds the future. They need vastly different products - how do you prioritize?

If you try to please both motions at once, you starve both.

How to balance PLG with enterprise is what I discuss with Feross Aboukhadijeh, the CEO and co-founder of Socket ($65M raised from a16z, Abstract, Dylan Field, Aaron Levie, and other).

Socket, a developer-first security platform protecting code from vulnerable and malicious dependencies. Before Socket, Feross was an open source maintainer and developer who built widely-used libraries.

In Today's Episode We Discuss:

01:43 - How developer background dictated Socket's PLG-first strategy over enterprise

04:50 - Building a GitHub app in 48 hours to avoid launching with zero user capture

07:56 - The counterintuitive rule: launch with intentionally missing enterprise features

10:53 - Why Socket deliberately ignored vulnerabilities despite every competitor offering it

11:20 - The dirty secret of startup pricing pages most founders won't admit

15:37 - How Socket mistakenly modeled pricing after GitHub's public/private repository strategy

16:08 - Why cryptocurrency companies exposed a fatal flaw in Socket's pricing model

18:19 - Going straight to enterprise sales to defend against fast-following competitors

19:37 - Why product quality loses to inferior products with superior go-to-market

21:36 - Socket's first enterprise deal was $500 and they kept doubling until pushback

24:27 - When PLG and enterprise roadmaps become zero-sum resource battles

26:27 - The strategic mistake of abandoning PLG motion after enterprise traction

28:54 - How developer awareness creates unfair advantages in security tool evaluations

29:23 - Enterprise handholding versus self-serve product design create opposing company muscles

33:01 - Figma's playbook: how connecting free-to-enterprise destroys customer acquisition costs

36:12 - The biggest regret: not building the PLG funnel before enterprise distraction hit

40:57 - Getting SOC 2 on day one would have parallelized six months of enterprise delays

41:00 - The monstrosity trap: second-time founders who hire VPs before product-market fit

40:13 - Why the popular advice to limit cap table size is fundamentally wrong

41:05 - Why Feross regrets turning away a $10K angel investment over ego

43:24 - The technical founder's fatal mistake: choosing to code over customer conversations

45:04 - Why selling before building feels wrong but saves months of wasted development

45:13 - The Mom Test: the book that teaches founders how to extract honest customer feedback

Most startup founders discover they have a culture problem when things are already breaking

Today, we discuss how to build the right culture before the wrong one costs you millions.

Every founder thinks about culture, but almost none do it right.

Abhi Sharma, a second-time founder / now the founder and CEO of Relyance AI, learned this the hard way after reaching several million in ARR.

Things were breaking and he couldn’t pinpoint exactly why.

Now he shares the exact framework he uses to build culture that actually scales - from defining your company's "invariant" to implementing tactical excellence across every department.

Abhi Sharma is the co-founder and CEO of Relyance AI, a company building super intelligence for data security. To date, Relyance has raised over $60 million from top-tier investors including Menlo Ventures, Unusual Ventures, and Microsoft's M12 Venture Fund.

In Today's Episode We Discuss:
00:01:41 - Why culture always feels like an afterthought until systems break and you can't explain why
00:03:35 - The exponential dissipation problem: how founder control over culture disappears faster than you think
00:05:09 - Three catastrophic ways poor culture manifested at Relyance: hiring mistakes, product strategy disconnects, and enablement failures
00:09:59 - Why shouting culture values from the rooftops fails: the unreasonable hospitality pivot that actually worked
00:12:14 - The $X million ARR wake-up call: when Abhi realized he was getting hires wrong and had to define operating principles
00:15:25 - From weekend reflection to company DNA: the exact process of distilling culture down to actionable principles
00:17:11 - The one piece most founders iterate on after writing culture docs (and why examples matter more than principles)
00:20:21 - Your company's invariant: why every startup is ultimately about one core idea that never changes
00:23:56 - Stripe's GDP example: how the best companies anchor to fundamental human behaviors, not features
00:25:14 - The Hedgehog Concept decoded: three components that create your competitive moat (straight from Jim Collins)
00:28:06 - Data journeys as superpower: why Relyance's unique differentiator became their core product feature
00:30:08 - Economic driver vs. pricing: why most founders confuse the two and how it kills scalability
00:32:54 - Dominance friction: how misalignment between business model and customer value creates disruption vulnerability
00:33:28 - Costco's profit-per-square-foot model: the counterintuitive pricing strategy that drives more volume
00:37:30 - Why it took three years to figure out Relyance's economic driver (and why that's perfectly okay)
00:38:50 - Culture is actions, not words: why cultural values without operating blueprints are worthless
00:40:57 - The trust operating principle: Stockdale Paradox, job vs. responsibility, and good news fast vs. bad news faster
00:45:20 - How job versus responsibility transforms employees into owners (and why most companies fail at this)
00:47:23 - Why "you don't get credit for 80% to the moon" is the ultimate accountability framework
00:49:16 - Making escalation a good word: rewiring team psychology around bad news and urgency
00:51:41 - The belief system cherry on top: three statements that tie everything together and fit on a sticker
00:55:19 - Tactical excellence: why Control-C, Control-V matters more than inspiration (and how to operationalize culture daily)
00:58:20 - The monthly new hire ritual Abhi still does himself: why culture onboarding can never be delegated
00:59:49 - Founder mode vs. micromanagement: Brian Chesky was right, but where's the line?
01:01:22 - The X vs. X+Y million ARR question: why every growth gap traces back to cultural problems
01:03:26 - Popular bad advice: why "hire executives and step away" is wrong and when founder instinct trumps expertise
01:05:06 - The brutal honesty test: if you're not all-in, don't start a company (and why vanity startups fail 100% of the time)
01:06:16 - Reflection time as competitive advantage: how America's polymaths and founding fathers made progress through going inward
01:06:48 - The first five deals rule: why Abhi banned VC introductions for Relyance's initial customers (and why it was magical advice)
01:09:36 - Product-market fit vs. AI hype: are you hacking your way to ARR or truly iterating toward customer pain?