← Guides

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

  1. 1Signals

    In: Any signal, from any source.

  2. 2The router

    The router

    One, not one per source

  3. 3The layer that decides

  4. 4The layer that remembers

    Your database is the truth. The CRM gets views of it.

  5. 5Record and 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

  1. 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.
  2. 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.
  3. 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.

  4. 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.
  5. Score in two numbers. Store both on the account: fit, and timing with its decay.
  6. 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.

  7. 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.
  8. 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

  1. Signal: a comment on a post
  2. matched to a 90-person company on the map, tier 1
  3. timing score up, top of today's list
  4. a rep calls with the comment as the reason
  5. 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 cost

The 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.