The 30-Day Revenue Architecture Build

What a founder should stand up in the first thirty days, in layer order, with the operators who ran each piece

The short version

A GTM engineering function for a $2M to $20M ARR B2B company installs in thirty days when it is built in layer order: Identity in week one (one signed ICP, 500 ranked accounts), Signal in week two (verified emails, two signals scored, a daily list of fifteen), Motion in week three (a two-step campaign on inboxes warmed from day one), and the reply loop in week four (replies classified, routed to Slack, written back to the CRM). Most thirty-day plans are organized by tool category instead: data, signals, prospecting, orchestration, sending. That is a shopping list, not an architecture. Every tool named here was described on the record by an operator who runs it, and every one of them sits in The Stack Index. Evidence read live on October 21, 2026.

A Tool Category Is Not a Layer

The thirty-day GTM engineer plan is now a genre. Pick a data vendor, pick a signal vendor, pick a sender, pick an orchestrator, build one thing a week, call the four builds a portfolio. The format works for someone learning the role. It fails the person who has to pay for it.

A founder at $2M to $20M ARR does not need to learn GTM engineering. They need to know what gets installed first, what it has to produce before the next piece goes in, and what to look at when a week stalls. Those are sequencing questions. A category list cannot answer them, because categories describe what a vendor sells, not what the revenue system needs next. Two operators on this show run Clay for completely different jobs: one as a master data layer across three tables (Umar Farooq Adam, SMYS 5), one as the thing he replaced with a terminal (Tim Scheuer, SMYS 6). Same category, different layer, opposite decisions.

So this build is organized by layer. Four weeks, four layers of revenue architecture, four systems that have to be running before the next week starts. Identity first, because every downstream signal is scored against it. Signal second, because a signal with no ICP to rank against is noise with a timestamp. Motion third, because sends go out only once the list is ranked and verified. The feedback loop last, because an agent routing replies into a CRM that has no definition of a good account will route garbage at speed.

The tools are not the point, but they are named, because an architecture with no instrumentation is a whiteboard. Every tool in this essay was described on the record by an operator who runs it in a working system, with the episode cited. Nothing here is a recommendation from a vendor list.

Figure 1. The four-week build laid across the layers of revenue architecture, with the system each week ships. The structural point is that every week produces an input the next week depends on; skip one and the week after it has nothing to run against.

Week One: Identity, or Who the System Is Allowed to Talk To

Ship by day seven: one written ICP definition that sales, marketing and RevOps have signed, and a ranked universe of five hundred accounts built against it.

The ICP is not a slide. It is the scoring function every later layer reads from. Angelo Quiambao will not build an agent until account tiering definitions, ICP definitions, product information and buying teams are mapped and uniform across RevOps, marketing and sales (SMYS 7). Christian Kletzl refuses to start a new customer on workflows and starts on ICP definition instead, because a signal firing on an account the company should never have touched burns that account for six months (GTM 53). Both run the same rule from different companies: definition before instrumentation.

The five hundred accounts are a ranking, not a list. Kletzl's version compares the companies that bought against everyone who never did, across twenty million accounts and six hundred attributes, and collapses that into one ICP score. At $2M to $20M ARR you will not have twenty million accounts. You will have your closed-won list, your closed-lost list and a CRM export. Jai Toor started from exactly that, pulled the win and loss lists out of HubSpot, found the differential signal between them, and had a scored universe and a verified-lead campaign exported in thirty minutes for under ten dollars of enrichment spend (SMYS 4). The point is the differential. An ICP built from wins alone describes your market. An ICP built from wins against losses describes your buyer.

Instrumentation for the week sits in two layers of The Stack Index. Source, where raw records enter: Apollo is the most-cited source on the record, run by six operators including Alexander Shartsis, Garrett Wolfe and Charles Cormier. Enrichment and Resolution, where records are deduplicated and matched: Clay, run by seven operators, is the master data layer in Umar Farooq Adam's build (SMYS 5). If the account universe cannot be exported from one table with one owner, Identity has not been installed, whatever the tooling.

The failure mode for week one is a definition that exists in three versions. Marketing's ICP, sales' ICP and the one in the enrichment table disagree on employee count or vertical, and every week after this one inherits the disagreement.

Week Two: Signal, or What Changed and When

Ship by day fourteen: the five hundred accounts carrying verified emails, two signals stacked on top of fit, and a daily ranked list short enough for one person to work.

The category plan says "two signals." The operators on the record say the signal is worthless until it is scored against the Identity layer from week one. Kletzl's number is the one to hold in your head: a job change alone tops out at around 12% of the pipeline it could produce, and the compounding sits in how many signals land on the same account and how they are scored together. His output is not an alert feed. It is a daily ranked list of fifteen (GTM 53). Michael Bartimer's signal agent at Clarify goes further: the first thing it does is throw signal away, and an account only crosses into sales-ready when its PQL score reaches sixty or above (SMYS 9). Garrett Wolfe scores hiring, revenue, engineering headcount and infrastructure into a single number from one down to zero and sifts accounts into tiers off it (SMYS 3).

Three builds, one rule. A signal is an input to a score, never an output to a rep.

The email waterfall belongs here, and there is a live disagreement on the record about it. Umar Farooq Adam waterfalls company enrichment across three vendors to fill employee count and revenue, then layers intent on top of fit (SMYS 5). Tim Scheuer runs Lead Magic, Prospeo and BetterContact in sequence for emails (SMYS 6). Kletzl argues against waterfall enrichment entirely: it buys quantity at the cost of knowing whether any single record is current, and at a 10% error rate reps stop trusting the motion whatever its coverage (GTM 53). Both positions are right for their stage. Under $20M ARR with no pipeline, coverage is the constraint and the waterfall wins. Past that, trust is the constraint and freshness wins. Decide which constraint you have before you buy credits.

Instrumentation sits in the Signal layer of The Stack Index: Vector for website de-anonymization and PostHog for product usage in Bartimer's build (about half the inputs to his PQL score), Trigify for LinkedIn monitoring in Shartsis's (SMYS 2). Review sites are a signal too. Vinayak Mishra pulls reviews through Apify, gates them by star rating in n8n, and has Claude return a true or false relevance verdict with reasoning before anything reaches a human (SMYS 1).

The failure mode for week two is a dashboard. Signals land, nobody scores them, and the week ends with more data and no shorter list.

Week Three: Motion, or Where the Sends Go Out

Ship by day twenty-one: a live two-step campaign to the top two hundred ranked accounts, on inboxes that were warming while weeks one and two ran.

That last clause is the sequencing decision most plans miss. Inbox warm-up takes weeks, not days. If the domains are bought on day fifteen the campaign cannot send on day twenty-one. Buy them on day one. Tim Scheuer's send layer at Oxygen is Instantly across 220 inboxes, with Zapmail provisioning the mailboxes (SMYS 6). Charles Cormier runs cold email as an engine rather than a volume play, with GPT agents on the post-call workflow and follow-ups, and the same lean sending surface (GTM 19). Instantly is the most-cited sender on the record, run by four operators. Lemlist is where Jai Toor's verified-lead campaign lands from a single terminal (SMYS 4).

The constraint has moved. Scheuer's argument is that sending capacity is no longer the bottleneck in outbound; campaign creation speed is. His build went from three to five hours in Clay to forty minutes in a terminal because he prompts Claude Code to assemble the list, the waterfall and the split test instead of building tables by hand (SMYS 6). Read that as a layer decision, not a tool decision. When the Identity and Signal layers are clean, the Motion layer is mostly assembly, and assembly is what agents are good at.

Set expectations on the reply rate before the first send. Scheuer's campaigns average between 1% and 5% replies and he says so on the record: it is not magic, but scaled up it performs. Toor's win-loss scored list roughly doubled reply rates against the signals the company had been using (SMYS 4). Those two numbers together are the lesson. The sender does not move the reply rate. The ranking from week two does.

Two steps, not seven. The second step is a bump, not a second pitch. A seven-step sequence to two hundred accounts is a burn, and Kletzl's six-month rule from week one applies to every account you spray.

The failure mode for week three is sending to the whole universe. The ranked list of fifteen a day exists so the campaign goes to accounts the Signal layer has already qualified. Sending to all five hundred is a return to the category plan.

Week Four: The Loop, or What Runs Without You

Ship by day thirty: every reply classified by an agent, routed to Slack, and written to the system of record with the account's score updated. No human reads the inbox first.

This is the week the category plan calls "AI and automation," and it is the week most likely to be built wrong, because an agent is only as good as the definitions underneath it. Quiambao's rule is the governing one: your reps should never meet your agents. The multi-agent system runs in Relevance AI behind a single rep-facing checkbox, and the reps see a decision, not a model (SMYS 7). Amos Bar-Joseph runs the whole RevOps agent as a Slack app, where researching an account or changing the ICP definition goes from thirty minutes of work to ten seconds (GTM 16). Slack is the most-cited action surface on the record, run by five operators, because it is where the rep already is.

The loop has three parts and they install in order. First, classification: a reply is interested, not now, wrong person, or bounce, and the verdict carries its reasoning. Mishra's true or false relevance check with reasoning in Claude is the pattern (SMYS 1). Second, routing: the verdict goes to the owner in Slack the day it lands, which is Umar Farooq Adam's account monitoring rule, any change on a monitored account routed to its owner the same day (SMYS 5). Third, the write-back: the reply and its classification land in the system of record and the account's score moves. Bartimer's PQL agent does exactly this, nurturing an account until the score crosses sixty and then enrolling it in a campaign with one click after a ten to twenty second human look (SMYS 9).

The system of record matters more here than anywhere else in the build. HubSpot is where Toor pulls his win and loss lists and where Adam's monitoring universe lives, which makes it the ledger the week one ICP was built from and the ledger week four writes back to. If the CRM is not the same system at both ends, the loop is open, and an open loop is a workflow, not an architecture.

For why the record is the one layer a lean stack cannot cut, read The Lean GTM Stack Is Missing Its Record Layer.

One caution from the record. Alex Bilmes's argument is that context is GTM infrastructure, not a tool connector: pull CRM, call recordings, email and Slack into one place, run agent loops upstream that compress each account into a dense one-pager, and serve that through a single MCP (GTM 46). That is the right end state and the wrong week-four scope. Build the reply loop first. Build the context layer in month two, on top of a loop that already runs.

The failure mode for week four is an agent that drafts replies. Drafting is the visible part and the least valuable. Classification and write-back are what compound, because they are what make week one's ICP smarter every day the system runs.

Figure 2. The reply loop: classify, route, write back. Coral marks the open loop, where the reply is drafted but never scored, which is the point at which most week-four builds stop.

The Example Stack, in Install Order

This is the stack for a $2M to $20M ARR SaaS, sales-led into SMB and mid-market, whose binding constraint is no pipeline, read from Build Your Stack on October 21, 2026. Operator counts are the number of operators who described running the tool on the record. The order is the install order, not a ranking of vendors.

Figure 3. The example stack laid across the seven instrumentation layers in install order, with the week each layer goes in. The structural point is that the system of record is touched twice, first as the source of the ICP and last as the target of the write-back, which is what makes it a loop.

1. Source (Identity, week one): Apollo, six operators. LinkedIn Sales Navigator for research. Apify where review sites are a source, two operators.

2. Enrichment and Resolution (Identity, week one): Clay as the master data layer, seven operators. For the email waterfall, Lead Magic first call, then Prospeo and BetterContact, the sequence Tim Scheuer runs.

3. Signal (Motion, week two): Vector for website de-anonymization and PostHog for product usage, both feeding Bartimer's PQL score. Trigify for LinkedIn monitoring.

4. Action Surface (Motion, week three): Instantly for sending, four operators. Lemlist, two operators. Slack as the surface the rep works in, five operators.

5. Orchestration (Functional Coherence, week four): n8n for the deterministic gate before the reasoning step.

6. Reasoning (AI Layer, weeks three and four): Claude Code, seven operators, the most-cited tool in the AI Layer. Claude for classification verdicts with reasoning, three operators.

7. System of Record (Functional Coherence, weeks one and four): HubSpot, two operators on the record. Attio is essay-recommended only; no operator has described running it yet, so it does not carry the same grade.

What is deliberately missing: no ads layer, no content engine, no attribution tool. Those are Distribution and Measurement installs for month two, once the loop above has run long enough to produce a baseline worth attributing against.

When a Week Stalls, Name the Layer

The category plan's fix list is tactical: narrow the ICP, run the waterfall, lead with a signal, add a fallback. Each of those is a correct action and a wrong diagnosis, because it treats the symptom in the week it appeared. A stalled week is almost always a layer failure one week upstream.

Figure 4. Five ways a week stalls, each traced to the layer that failed and the week it was installed. Coral marks the symptom, gold the layer. The last row has no tool on the right because sequencing is not instrumented.

1. Bad-fit replies in week three are an Identity failure. The ranking is wrong, or the three versions of the ICP never got reconciled. Go back to the win-loss differential, not to the copy.

2. Bounces in week three are a Resolution failure. The waterfall is either missing a vendor or returning stale records. Kletzl's 10% error threshold is the line: above it, reps stop trusting the list and the motion dies regardless of coverage.

3. No replies on a verified, ranked list is a Signal failure. The accounts are a fit and reachable, but nothing changed at them recently, so the message has no reason to land now. Lead with the signal that put the account on the list, which only works if week two scored it.

4. A loop that breaks in week four is an Orchestration failure, and the fix is a fallback that routes to a human, not a retry. Mishra's star-rating gate in n8n is the model: a cheap deterministic check before the expensive reasoning step. Tim Scheuer's qualify layer, as he described it publicly this week, writes the fallbacks into the build itself: no fit, hold the account; wrong persona, try the next role; no email, LinkedIn steps only. A fallback decided at build time is architecture. One improvised at 11pm on day twenty-six is a patch.

5. A build that runs but produces no pipeline after thirty days is a Sequencing failure, which no tool addresses. Something was installed before the layer it depends on.

The eight-question revenue system audit at pro.gtmvault.co/stack/audit asks one question per layer and returns the weakest ones with the episodes that address them. Run it on day thirty before deciding what month two installs.

Who Is on the Record

Every operator cited above has a page in The Stack Index showing their full stack by layer, built from what they described on the show.

1. Christian Kletzl, UserGems, GTM 53: stacked signals, the daily list of fifteen, the case against waterfall enrichment.

2. Angelo Quiambao, Intellistack, SMYS 7: definitions before agents, reps never meet the agents.

3. Jai Toor, DeepLine, SMYS 4: win-loss differential scoring to a verified campaign in thirty minutes.

4. Umar Farooq Adam, Hitachi Vantara, SMYS 5: Clay as the master data layer, account monitoring routed same day.

5. Michael Bartimer, Clarify, SMYS 9: the signal agent that throws signal away, PQL threshold of sixty.

6. Garrett Wolfe, 1GTM, SMYS 3: scoring accounts from one to zero into tiers.

7. Tim Scheuer, Oxygen, SMYS 6: outbound run by Claude Code, 220 inboxes, 1% to 5% replies stated plainly.

8. Charles Cormier, TopLeads, GTM 19: cold email as an engine, not a volume play.

9. Vinayak Mishra, Slang AI, SMYS 1: review intelligence gated in n8n, relevance verdicts from Claude.

10. Alexander Shartsis, Skyp, SMYS 2: MCPs against APIs in a production enrichment pipeline.

11. Amos Bar-Joseph, Swan AI, GTM 16: the RevOps agent as a Slack app.

12. Alex Bilmes, Endgame, GTM 46: context as GTM infrastructure, served through one MCP.

Four Builds Is Not a Portfolio, It Is a System

The category plan ends with four builds and calls them a portfolio. A portfolio is what a candidate shows a hiring manager. A founder does not need a portfolio. They need the four builds to be the same system, each one reading from the one before it and writing to the one after.

That is the difference between thirty days of GTM engineering and thirty days of revenue architecture. The first produces four artifacts. The second produces one loop: an ICP that ranks the universe, signals scored against that ranking, sends that go only to what the score qualified, and replies that move the score. Day thirty-one is not a new build. It is the first day the loop runs on its own and the question changes from what to install to what to retire.

The tools above are the ones operators on this show run. Your stage, motion and binding constraint decide which of them install first, and Build Your Stack returns that order for a $2M to $20M company with no pipeline, buying at the mid-market tier, with the operators behind every tool. Install it with me: Pro from $99 a month.

Common questions

What does a modern B2B sales stack look like?

A modern B2B sales stack is organized by layer, not by vendor category. On the record in The Stack Index the shape is: a source layer (Apollo, Sales Navigator), an enrichment and resolution layer (Clay, with a waterfall of Lead Magic, Prospeo and BetterContact for emails), a signal layer scored against the ICP (Vector, PostHog, Trigify), an action surface (Instantly or Lemlist for sends, Slack for the rep), a reasoning layer (Claude Code, Claude) and a system of record (HubSpot). The defining feature is the loop: replies move the account score, which re-ranks the universe.

What is an example GTM stack for a $5M ARR SaaS?

For a $5M ARR SaaS selling into SMB and mid-market with no pipeline, Build Your Stack returns this install order: Apollo and Clay first (Identity), then Instantly and Slack (Motion), then the email waterfall (Lead Magic, Prospeo, BetterContact), then Vector and PostHog as signals, n8n for orchestration, Claude Code at the reasoning layer and HubSpot as the system of record. Ads, content and attribution tools are deliberately not in the first thirty days. The full build, with the operator behind each tool, is at pro.gtmvault.co/stack/build.

What tools do GTM engineers use?

The tools GTM engineers describe running on Show Me Your Stack, by operator count: Clay (seven operators), Claude Code (seven), Apollo (six), Slack (five), Instantly (four), Claude (three), with Lead Magic, Apify, Lemlist and HubSpot at two each. Counts are read from The Stack Index, which records only tools a named operator described running in a working system. The pattern across all of them is one agent runtime (Claude Code) assembling what used to be built by hand in Clay tables.

What are the best enrichment waterfall tools, and is a waterfall worth it?

The waterfall on the record is Lead Magic as the first call, then Prospeo and BetterContact, run inside Clay or assembled by Claude Code (Tim Scheuer, SMYS 6). Umar Farooq Adam waterfalls company enrichment across three vendors for employee count and revenue (SMYS 5). Whether it is worth it depends on the binding constraint. Under $20M ARR with no pipeline, coverage is the constraint and the waterfall wins. Past that, freshness is the constraint: Christian Kletzl's threshold is that at a 10% error rate reps stop trusting the list regardless of coverage (GTM 53).

How do operators use Claude Code for outbound?

Seven operators on the record run Claude Code in their GTM stack. Tim Scheuer prompts it to assemble the account list, the email waterfall and the split test, then pushes the campaign to Instantly across 220 inboxes, cutting campaign creation from three to five hours in Clay to forty minutes in a terminal (SMYS 6). Jai Toor uses it to pull win and loss lists from HubSpot, find the differential signal, and export a verified campaign to Lemlist in thirty minutes for under ten dollars of enrichment (SMYS 4). Alexander Shartsis runs it in plan mode as the orchestration environment over MCPs (SMYS 2). The common thread is assembly, not writing: the agent builds the list and the pipeline, humans still set the ICP.

What CRM do AI-native GTM teams use?

On the record, HubSpot is the system of record two operators describe reading from and writing back to (Jai Toor, SMYS 4; Umar Farooq Adam, SMYS 5). Attio is essay-recommended in The Stack Index but no operator has yet described running it, so it carries a lower evidence grade. Michael Bartimer's own company, Clarify, is an AI-native CRM with a built-in agent handling briefs, data entry and pipeline updates (SMYS 9). The architectural rule matters more than the vendor: the CRM has to be the same system the ICP was built from and the one the reply loop writes back to, or the loop is open.

What tools run alongside Clay?

Across the seven operators who run Clay on the record, the tools that sit beside it are Apollo as a source (Garrett Wolfe, Tim Scheuer, Charles Cormier), Lead Magic in the waterfall (Wolfe, Scheuer), Instantly for sends (Scheuer, Cormier), Apify for review scraping (Vinayak Mishra, Cormier), n8n for orchestration (Mishra), Claude Code as the agent runtime (Wolfe, Scheuer), Clay MCP for agent access to tables (Elliot O'Connor) and HubSpot plus Slack (Umar Farooq Adam). Each tool page in The Stack Index lists its "runs alongside" set from the same data.

What is a GTM engineer?

A GTM engineer builds and runs the revenue system: the account universe, the enrichment and signal pipelines, the sending infrastructure and the agents that classify and route what comes back. The role sits between RevOps and sales engineering and is defined by what it ships, not what it reports. Revenue architecture is the discipline above it: deciding what gets built, in what order, and what each system has to produce before the next one goes in. A GTM engineer without that sequencing produces four builds. With it, one loop.

What reply rate should cold outbound expect in 2026?

Between 1% and 5% on a well-run campaign, which is the range Tim Scheuer states on the record for Oxygen across 220 inboxes (SMYS 6). The sender does not move that number. The ranking does: Jai Toor's win-loss scored list roughly doubled reply rates against the signals his company had been using (SMYS 4).

Related reading

1. A Tool List Cannot Tell You What to Build First: why The Stack Index sits under the Eight Layers rather than beside them, and why tool categories are not architecture layers.

2. The Premature Scaling Doctrine: the sequencing failure this build is designed to prevent, installed one layer at a time.

3. Show Me Your Stack: the show every operator stack in this essay was recorded on.

4. Stacked Signals Generate 19x the Pipeline: the full Kletzl episode behind week two.