
👋 Hi, it’s Rick Koleta. Welcome to GTM Vault - a breakdown of how high-growth companies design, test, and scale revenue architecture. Join 27,000+ operators building GTM systems that compound.
This episode in the Library: the written playbook, the stack and the full transcript, free and open. Open it at pro.gtmvault.co.
This episode is now a free Claude skill: Review intelligence signal layer, built from the system Vinayak Mishra walks through here. See Vinayak’s full stack on the Stack Index.
Show Me Your Stack, Episode 1: Review-Led GTM for Slang AI
This episode: Vinayak Mishra walks through a restaurant review intelligence system built for Slang AI. Five tools. Five layers. Stage 2 orchestrated workflow. The breakdown below maps the build back to the Revenue Architecture.
The Targeting Problem Behind Review-Led GTM
Slang AI sells a voice AI reservation system for restaurants. The product solves a specific operational problem: restaurants that lose bookings because no one answers the phone during peak hours. The company recently closed a Series B round.
The GTM bottleneck is targeting. Slang AI needs to find restaurants that are actively struggling with phone and reservation communication. Not restaurants in general. Restaurants where the problem is already visible in the customer record. The question is where that signal lives and how to extract it at scale.
The answer is reviews. Customers leave complaints on Google Maps, Yelp, and TripAdvisor when they cannot reach a restaurant by phone, when reservations are lost, when special requests made during booking are ignored. These are not abstract intent signals. They are documented failures described in the customer’s own language, timestamped and geolocated. Every negative review mentioning phones or reservations is a qualified signal that the restaurant has the exact problem Slang AI solves.
This is not a lead list problem. It is a signal extraction problem. The system Vinayak built treats reviews as structured GTM data, not marketing noise.
Five Tools, Five Layers, One Direction

Five tools. Each one exists for a specific architectural reason.
Serper.dev serves as the discovery layer. It hits the Google Maps API to scrape restaurant listings by locality and state across the US. The query structure is simple: “restaurants in [locality], [state].” Each query returns 20 results per page. The tool exists because it provides fast, cheap access to Google Maps data at scale without building a custom scraper.
Clay operates as the master data layer. Three tables, each with a distinct function. Table one holds the raw locality and state inputs that generate Serper queries. Table two stores the scraped restaurant data (names, websites, place IDs, phone numbers, ratings). Table three receives qualified reviews pushed back from the orchestration layer. Clay is not a CRM in this architecture. It is the system of record.
Apify provides the review aggregation layer. A pre-built actor called “restaurant review aggregator” takes search keywords and location as input and returns reviews across Google Maps, Yelp, TripAdvisor, Facebook, UberEats, and DoorDash. The tool exists because building custom scrapers for six review platforms is not a productive use of engineering time when a managed actor already handles it.
n8n is the orchestration and filtering layer. It receives review data from Apify via webhook, applies a star rating filter (three stars or below), passes filtered reviews to the Claude analyzer, and routes qualified results back to Clay. n8n exists because this workflow requires conditional branching (star filter, relevance check, true/false routing) that Clay alone cannot handle cleanly.
Claude performs the relevance analysis. A structured prompt instructs the model to act as a review analyst for Slang AI, evaluating each negative review against specific signals: restaurant unreachable by phone during busy periods, multiple unanswered calls, lost reservations, ignored booking requests. The prompt includes relevant signals, non-relevant signals, and edge cases. Claude exists in this stack because keyword matching would miss the semantic complexity of review language. “Called three times, no one picked up” and “tried to book for my daughter’s birthday but they completely forgot” both indicate the same structural problem, but no regex catches both.
The Pipeline from Query to Qualified Signal
The system runs as a five-layer pipeline. Each layer feeds the next. Data flows in one direction.
Query construction. Clay builds Serper queries from locality and state columns using a JavaScript formula. Each row generates a query like “restaurants in LA, California.”
Restaurant discovery. Serper HTTP requests execute against each query. Twenty results per page, across multiple pages. Raw restaurant data (name, website, place ID, phone, rating) populates the second Clay table.
Review aggregation. For each restaurant in Clay table two, an Apify actor run pulls reviews from Google Maps and Yelp. Each run returns the review text, the author, the date posted, and the star rating.
Filtering and analysis. Review data enters n8n via webhook. First filter: star rating less than or equal to three. In Vinayak’s test run, 20 reviews entered, 16 were discarded, four passed. Second filter: Claude analyzes each surviving review for Slang AI relevance. The model returns a structured response with reasoning and a true/false classification.

Qualified output. Reviews classified as relevant are structured and pushed back to Clay table three via webhook. Each row contains the restaurant name, the review text, the relevance reasoning, and the original metadata.
Humans intervene at two points: prompt design (the Claude analyzer instructions) and quality review of the third Clay table before any outreach begins. The system does not send emails. It produces a qualified signal list. Everything from signal to outreach copy would require additional layers that Vinayak scoped as a separate build.
I classified this as a Stage 2 orchestrated workflow during the episode. Not yet Stage 3 autonomous. The system executes a static path with human-designed logic. It does not read its own pipeline state, it does not adapt to decay, and it does not spawn sub-agents. The orchestration is well-built, but the decision architecture is still human.
The Review Volume Density Problem
The architecture has specific structural vulnerabilities that any operator replicating this build should understand before scaling.
Some restaurants have hundreds of reviews. Others have twelve. The system treats both equally, but the signal density is radically different. A restaurant with three hundred reviews and two phone complaints is a weaker signal than one with twenty reviews and four phone complaints. The current build does not weight by density. At scale, this means the qualified list will contain restaurants where the signal is statistically weak alongside restaurants where it is overwhelming. The fix is straightforward (divide relevant reviews by total reviews to produce a signal density ratio) but it does not exist in this version of the build.
Serper returns 20 results per page. Vinayak ran three localities in the test. Scaling to every US locality means thousands of Serper calls and thousands of Apify actor runs. The system works at test scale. The economics at full scale depend on Serper and Apify pricing tiers that Vinayak did not model in the episode. An operator copying this build should calculate cost per qualified signal before scaling past ten localities.
The Claude relevance analyzer works on the current prompt. But review language shifts by region, cuisine type, and platform. A Yelp review reads differently than a Google Maps review. A fine dining restaurant’s complaints about reservations sound different from a pizza shop’s. The prompt was tested on a small sample. At scale, edge cases multiply. Vinayak acknowledged this, noting his background in AI evaluations and the need for rigorous testing before scaling.
There is no feedback loop. Qualified reviews go to Clay table three. But there is no mechanism to track whether the outreach team actually converts those signals into meetings. Without that loop, the system cannot learn which review signals predict conversion and which are noise. The architecture identifies signal. It does not yet validate it.
What to Measure and What to Ignore
The signals that matter in this architecture are structural, not volumetric.
Review relevance rate. Out of 20 reviews in the test run, 4 passed the star filter and a subset passed the Claude relevance check. The ratio of total reviews to qualified signals is the core efficiency metric. If it drops below 5%, the Serper queries are targeting the wrong localities or the Apify actor is pulling from the wrong platforms.
Cost per qualified signal. Every Serper call, Apify run, and Claude API call has a dollar cost. The system is only viable if the cost per qualified review is lower than the cost of an SDR manually finding the same signal. Vinayak did not share exact numbers, but stated one GTM engineer can replace a manual analyst team running this process.
Signal specificity. The Claude prompt distinguishes between “bad food” complaints and “phone/reservation” complaints. The specificity of that filter determines whether the output list is full of qualified leads or contaminated with irrelevant restaurants. This is the metric that degrades first at scale if the prompt is not maintained.
Ignore total restaurant count scraped, total reviews processed, and star rating distribution. These are activity metrics. They describe throughput, not signal quality. An operator running this system who reports “we processed 50,000 reviews this month” without reporting the relevance rate and cost per signal is measuring the wrong layer.
What to Copy and What Depends on Context
The three-table Clay architecture is the most transferable pattern in this build. Separating query inputs, scraped results, and qualified outputs into distinct tables prevents data contamination and makes each layer independently testable. This works for any scrape-filter-qualify pipeline. Swap restaurants for agencies, reviews for job postings, Slang AI for any product with a documentable pain point. The table structure holds.
The mechanical pre-filter before AI analysis is a cost control pattern worth copying everywhere. Running every review through Claude would be expensive and unnecessary. The star rating filter (three stars or below) eliminates 80% of reviews before the AI layer touches them. Any workflow where AI is doing classification on a large dataset should have a cheap, deterministic filter upstream that reduces the volume before the expensive model runs.
Vinayak’s Claude prompt structure is the most underrated piece of the build. He did not write “analyze these reviews.” He defined the decision boundary: here are the relevant signals, here are the non-relevant signals, here are the edge cases. That prompt architecture is replicable for any use case where AI is classifying unstructured text against a specific ICP problem.
Testing on 10 to 15 rows before scaling is not cautious advice. It is an economic argument. Run the full pipeline on a small sample. Check where it breaks. Calculate the success rate. Then decide whether to scale. Credits spent on a broken pipeline at scale are unrecoverable.
What depends on context is the signal source itself. Review-led prospecting works because Slang AI sells to restaurants, and restaurants have a public, structured review ecosystem across multiple platforms. A company selling to mid-market SaaS would not find the same signal density in reviews. The transferable principle is this: find where your ICP’s pain is publicly documented, then build a scraping and classification pipeline against that source. The specific data source changes with every ICP.
The five-tool stack is also contextual. Serper, Clay, Apify, n8n, and Claude were chosen for this use case. A different build might swap Apify for a custom scraper, n8n for Make, or Claude for GPT-4. The orchestration logic matters more than the vendor selection. If you can draw the five-layer pipeline on a whiteboard and each layer has a clear input and output, the specific tools are interchangeable.
Where This Build Sits in the Revenue Architecture

This build operates primarily at the Signal and Distribution layers.
At the Signal layer, the system solves a specific problem: how to detect buying intent when the buyer does not know they are expressing it. A restaurant owner who receives a one-star review complaining about unreturned phone calls is not in-market for a voice AI product. But they have a documented, timestamped problem that maps directly to the product’s value proposition. The system converts latent signal into structured pipeline input.
At the Distribution layer, the architecture creates a new distribution channel that did not previously exist. Before this build, finding restaurants with phone and reservation problems required manual research, cold call discovery, or waiting for inbound. The review intelligence system creates a signal-led outbound channel where every contact in the output table has a documented reason to take the meeting.
The constraint is at the Execution layer. The build stops at the qualified list. There is no outreach automation, no sequencing logic, no response handling. Vinayak acknowledged this explicitly, noting that enrichment, personalization, and send logic would be separate builds layered on top of the third Clay table. The architecture is sound but incomplete. It solves signal extraction. It does not yet solve signal activation.
Full transcript, searchable to the timestamp: pro.gtmvault.co/episodes/smys-01.
On the record from this episode: Apify, Claude, Clay, n8n and Serper.dev. Each links to the operators who run it on The Stack Index.


