How it all fits
The four-layer GTM stack
One layer decides. One remembers. One records. One touches.
By Mike Hurley, founder of WarmUp. This is the layout our own pipeline runs on.
Version 1.0. Last updated . About 6 minutes.
- Motion
- Systems
- Steps
- 8
- Tools
- Freckle, Clay, Postgres
The four-layer GTM stack: the layers
Follow the numbers: where signals start, the router, the layer that decides, the layer that remembers, and the two layers a person sees (the record and the touch). Each layer is drawn in full, in the same order, beside the step that builds it under "How to build it": what each part reads, what it writes, and the one thing it never does. Go to the layers in detail
1Signals
Every signal, one way in
In: Any signal, from any source.
2The router
One, not one per source
3The layer that decides
4The layer that remembers
Your database is the truth. The CRM gets views of it.
5Record and touch
- The rep's daily list
- The layer that records: the CRM
- The layer that touches: one tool a channel
- One blocklist, one writer
- Nothing starts itself
Out: A short list for a person, and a record of every touch.
- Flow, left to right
- Each layer has one job and a short list of things it never does.
Replies come back in at the left.
Download the boardOpen it full sizeOne sheet, free to keep and share.
Why it helps
Most teams I talk to own the tools: a CRM, a data tool, a sender or three. What they do not have is an answer to a plain question: when two of those tools disagree about a company, which one is right? Without an answer, every new tool adds another copy of the truth, and the rep ends up checking three places before a call.
This layout answers it by giving each layer one job. One layer decides what a signal means. One remembers everything, in a database you own. One records what happened, where the team already works. One touches the buyer. The map, the hiring feed and the social play are all parts of the first two layers.
The tools in the last column are the ones we use today, and they are not the ones on the first drawing of this board. We changed senders in September 2026. That is the kind of change the layout is meant to absorb, and it is why the tools are named as examples and the layers are not.
Why we built it this way
- One router, not one workflow per source. Every signal, warm or cold or dug out of old CRM history, is matched to a company and a person and put in one shape before anything acts on it. A new source is a new input to the router and nothing else.
- Fit and timing are two numbers. Fit belongs to the account and changes when a fact does. Timing belongs to the signal and fades. A signal moves an account up inside its tier and never changes the tier.
- Your database is the truth. The CRM gets views of it. We ruled this in August 2026. The CRM is where people work, so it shows the ranked list with reasons. It is never the only copy.
- One queue. Everything upstream exists to produce one ordered list a rep can finish in a morning, with the reason to call beside each name.
- One sender per channel, one blocklist writer. Email, LinkedIn and calling each have one tool. One sync tool keeps do-not-contact identical in all of them and writes their activity back to the CRM.
- Automation prepares, people send. Nothing creates a deal and nothing starts a campaign on its own. Every write leaves a record of what was checked and what it cost.
- Replies come back in at the left. A reply, a question on a call or new engagement is a fresh signal. The loop is the same router, so nothing is rebuilt to close it.
How to build it
- Name your four layers before you name a tool. Write one line each: what decides, what remembers, what records, what touches. If one tool is doing two of these, write down which copy wins.
- Stand up the memory first. One database you own, with three tables to start: companies keyed on domain, people keyed on profile address or work email, and signals you only ever add to.
- Build one router. Every source posts to it. It looks the company and the person up, fills in what is missing, and writes one event in one shape.
1Signals
Where a signal starts
Three kinds of thing can put a company in front of a rep. All three enter the same way.
Every signal, one way in
Warm signals
Post engagement, site visits, sign-ins, replies, form fills, things said on calls.
Cold accounts
The companies on your map, each with where it came from, when, and why it qualified.
Old CRM history
Closed-lost deals, no-shows and leads nobody worked. Run through the same router as everything new.
In: Any signal, from any source. 2The router
The router
One, not one per source
Matches every signal to a company and a person, looks both up in the CRM, and puts the signal in one shape before anything acts on it.
- Put the rules in files. Segments, triggers, title lists and weights live under version control. The workflow builder reads them. This is what lets you change builders later.
3The layer that decides
The event router
Who is this, what do we already know, and what should happen next?
Example tools · A workflow builder such as Freckle or Clay
- Reads
- Any signal, and the CRM for an existing company or contact.
- Writes
- One event in one shape, with the match it found.
- Never
- Runs a separate workflow for each source.
The fit and timing scorer
How well does the company fit, and how fresh is the signal?
Rules · Segments and triggers kept in one file the scorer reads
- Reads
- The account's facts and every signal on it.
- Writes
- A fit score that changes when a fact does, and a timing score that fades.
- Never
- Lets a signal change the tier. Fit and timing are two numbers.
The call reader
What did buyers say in their own words?
Source · Recorded sales calls
- Reads
- Each external call once.
- Writes
- The pains named, the questions asked, the tools mentioned.
- Never
- Keeps a transcript where it does not belong.
- Score in two numbers. Store both on the account: fit, and timing with its decay.
- Build the queue as a view of the database. Then show it in the CRM as a list with the score and the reason. Keep it short enough to finish.
4The layer that remembers
The map
Every company you have ever looked at, keyed on its domain.
Example tools · Your own database, such as Postgres
- Reads
- Every source, with a rule for which one wins.
- Writes
- A status, a segment, a tier and a reason.
- Never
- Deletes a row. A status changes when a fact does.
People and what they did
Who each person is, and every touch in both directions.
Keys · Profile address or work email
- Reads
- Engagement, replies, calls held.
- Writes
- Identity, intent and how recent it is.
- Never
- Matches a person by name.
The priority queue
One ordered list: the score, the reason, and who to reach.
Built from · The map, the scores and the people
- Reads
- Fit, timing and the do-not-contact list.
- Writes
- Today's list, short enough to finish in a morning.
- Never
- Becomes a second list kept somewhere else.
Your database is the truth. The CRM gets views of it.
Scores, memory and where each company came from live in a store you own. That is what lets you change a tool without losing what you know.
- Give each channel one sender and the blocklist one writer. Before you add a second writer to any field, decide which one is being retired.
5Record and touch
The rep's daily list
Who to call first and why, the same day the signal arrives. The rep brings the judgment on every touch.
The layer that records: the CRM
Guarded writes only: contact and company updates and the queue score with its reason. Automation prepares; it never invents a deal.
The layer that touches: one tool a channel
Email, LinkedIn and calling each have one sender (for us Smartlead, HeyReach and Salesfinity). The tier decides how much is automated; the top tier is led by a person.
One blocklist, one writer
A sync tool (for us OutboundSync) keeps do-not-contact the same in every sender and writes each tool's activity back to the CRM.
Nothing starts itself
Every campaign is created as a draft. A person reads the first batch and presses start.
Out: A short list for a person, and a record of every touch. - Send every reply and outcome back to the router. As a signal. And give the whole thing a reader: one ledger of what ran, what it decided and what it spent.
One row
- Signal: a comment on a post
- matched to a 90-person company on the map, tier 1
- timing score up, top of today's list
- a rep calls with the comment as the reason
- the call is recorded on the contact
The rules that make it last
Tools change every year. These four rules are what stay, and they are why replies, call questions and new engagement can return to the left side as fresh signals without anything being rebuilt.
- AOwn the memory
- The map, the scores and the history live in your database. A vendor tool can read them. None of them is the only copy. (Design rule.)
- BPortable by design
- The rules live in files under version control. The builder is where they run, so the system can move from one tool to another. (Design rule.)
- CAutomation prepares, people send
- Nothing invents pipeline and nothing sends on its own. Every write leaves a record of what was checked and what it cost. (Design rule.)
- DOne writer per destination
- One router, one queue, one blocklist writer. Two things writing the same field is how a system starts to disagree with itself. (Design rule.)
Copy this
The contract between layers
What each layer reads, what it writes, and what it never does. The tools in the comments are examples. The contract is the part to keep.
# layers.yaml
decide: # a workflow builder, e.g. Freckle or Clay
reads: [any signal, the CRM for an existing match, the rules files]
writes: [one event in one shape, a fit score, a timing score that fades]
never: [a separate workflow per source, a tier changed by a signal]
remember: # a database you own, e.g. Postgres
reads: [every source, with a rule for which one wins]
writes: [the map (status, segment, tier, reason), people and every touch, today's queue]
never: [a deleted row, a person matched by name, a second queue kept elsewhere]
record: # the CRM
reads: [views of the database, activity from the senders]
writes: [contact and company updates, the queue score with its reason]
never: [a deal created by automation, the only copy of a score]
touch: # people, plus one sender per channel
reads: [today's queue, the do-not-contact list]
writes: [replies and outcomes, back to the router as new signals]
never: [a campaign started by code, a second blocklist]
rules:
- one writer per destination
- rules live in files under version control
- every write leaves a record of what was checked and what it costThe same guide as plain Markdown, for an agent or a notes app: /library/four-layer-gtm-stack.md
Words we use
- Layer:
- One of four jobs in the stack: decide, remember, record, touch.
- Router:
- The one step every signal passes through. It matches the signal to a company and a person and puts it in one shape before anything acts on it.
- Fit and timing:
- Two separate numbers. Fit is how well a company matches who we sell to, and it belongs to the account. Timing is how fresh the signal is, and it fades.
- Queue:
- The one ordered list a rep works from, with a score and a reason to call beside each name.
- Sender:
- A tool that delivers messages or calls on one channel: email, LinkedIn or the phone.
- Blocklist:
- The companies and people we must never contact. One tool writes it, and every sender reads the same copy.
Want your tools arranged this way?
We build it in your tools and run it with your team.
30 minutes to scope it. Engagements are contracted through WarmUp, Inc.