# What tools do GTM engineers use to build automations?

> The typical GTM engineering stack: a CRM, Clay for enrichment, a sending tool, an orchestrator like n8n, Make or Zapier, and AI coding agents for custom code.

- Published: 2026-10-27
- URL: https://teton.so/guides/tools-gtm-engineers-use-to-build-automations

Most GTM engineers build automations on four layers. They use a CRM as the system of record and Clay for sourcing and enrichment. A sending tool such as Instantly or Smartlead handles outbound, and a workflow builder such as n8n, Make or Zapier connects everything. A growing share also write custom code with AI coding agents like Claude Code, for jobs the no-code tools handle badly. In one practitioner survey of 228 GTM engineers, [92% use a CRM, 84% use Clay, 71% use AI coding tools and 54% use n8n](https://gtmepulse.com/tools/).

Below is what each layer does, when each tool fits, and where these stacks tend to break.

## The stack, layer by layer

| Layer | Common tools | What it does |
| --- | --- | --- |
| System of record | HubSpot, Salesforce | Holds accounts, contacts, deals and activity |
| Data and enrichment | Clay, Apollo, ZoomInfo, FullEnrich, Lusha, Cognism | Finds and fills in people and company data |
| Sending | Instantly, Smartlead | Runs outbound email sequences |
| Orchestration | n8n, Make, Zapier, MCP servers, Claude Code, custom scripts | Moves data between tools on triggers and schedules |
| Internal apps | Retool, Streamlit, custom Next.js | Front ends for reps and ops |

The orchestration and internal app rows follow [Cleanlist's layer model](https://www.cleanlist.ai/blog/2026-05-22-what-is-gtm-engineering). A word of caution on sources: Clay, Cleanlist and several of the agencies writing about this stack sell tools or services in it. The GTME Pulse survey is the main independent data, and its method isn't published in detail. Treat the percentages as a rough picture.

## Clay for data and enrichment

Clay is the tool most associated with the job. It appears in [69% of GTM engineer job postings](https://gtmepulse.com/tools/tech-stack-benchmark/), more than any other tool. Clay's own description of the stack puts [Clay at the center for sourcing, enrichment and AI messaging](https://www.clay.com/blog/gtm-engineering), with a CRM, a sending platform and connections to warehouses and signal providers around it.

The core idea is a table. Each row is a person or company and each column is a piece of data from a provider. The [waterfall logic is built into the column type](https://gtmepulse.com/insights/clay-vs-n8n-for-gtm-engineering/): if the first provider returns nothing, try the second, then the third. Clay also has an AI research agent, Claygent, for [company research and personalized messaging](https://www.understoryagency.com/blog/ai-automation-tools-gtm-teams-clay-make-n8n-pipeline-guide). That's why Apollo and ZoomInfo are mostly used as [data sources piped into Clay rather than standalone platforms](https://gtmepulse.com/tools/tech-stack-benchmark/).

The cost is complexity. To run Clay well you need to understand [providers, credits, workflow logic, enrichment costs and data quality](https://www.anfloy.com/blog/gtm-engineering-tools). Clay is also the [most complained-about tool](https://gtmepulse.com/tools/) in the survey, which mostly says how hard it is to leave.

**Fits:** enrichment-heavy work, such as list building, waterfall lookups, ICP scoring and pushing clean records to the CRM, without writing code.

## n8n, Make and Zapier for connecting tools

The workflow builders move data between systems: a form comes in, a CRM record changes, a reply lands, and something happens elsewhere. The usual pattern is [Clay for enrichment, with Make or n8n for orchestration](https://www.understoryagency.com/blog/ai-automation-tools-gtm-teams-clay-make-n8n-pipeline-guide).

n8n is popular with GTM engineers because it is [open source and can be self-hosted](https://www.fullfunnel.co/blog/building-automated-gtm-engine-clay-n8n). Self-hosted n8n makes workflow automation [the cheapest tool category for agencies](https://gtmepulse.com/tools/) in the survey. To try it locally, n8n publishes a Docker image:

```bash
docker volume create n8n_data
docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n
```

The editor is then at `http://localhost:5678`. Running it in production means a server, backups, updates and a public URL for webhooks, which is the price of the lower per-run cost.

Zapier and Make are hosted, need no server and are quicker to start with. They suit teams with modest volume and no one who wants to maintain infrastructure.

One comparison rule: compare [total cost including vendor API spend, not just the platform price](https://gtmepulse.com/insights/clay-vs-n8n-for-gtm-engineering/). An orchestrator that is cheap per operation can still be expensive if every run calls paid enrichment APIs.

**Fits:** integration-heavy work across many SaaS apps, where steps are fixed and the logic is "when X, do Y."

## AI coding agents and custom code

The newest layer is code written with an AI agent. A survey respondent put it as: [someone who couldn't write Python six months ago can now build API integrations with Claude Code](https://gtmepulse.com/tools/tech-stack-benchmark/). Clay itself lists [n8n, Zapier, TypeScript, Python and SQL](https://www.clay.com/blog/gtm-engineering) among the skills it looks for, and says the stronger signal is a willingness to learn by tinkering.

Custom code is the better choice when:

- A job needs judgment, like summarizing a call, deciding whether a deal has gone quiet or drafting a follow-up.
- An API isn't covered well by the no-code connectors, or you need fields like custom objects that sync tools map poorly.
- You want logic you can read, diff and version instead of a canvas of nodes.

The catch is that a script on your laptop isn't an automation. It needs a schedule or webhook, credentials stored somewhere safe, a record of each run and somewhere to keep state between runs.

## Where these stacks break

A typical outbound operation means [configuring 4-6 tools, building integrations between them and troubleshooting when data gets lost between systems](https://gtmepulse.com/tools/tool-wishlist/). All-in-one platforms try to fix this, but they [haven't yet matched the specialized tools in any single category](https://gtmepulse.com/tools/tool-wishlist/). The integrations practitioners most want fixed are telling:

- Clay to CRM sync that handles custom objects and picklist fields without manual mapping.
- Instantly to HubSpot reply tracking without Zapier in the middle.
- n8n and Clay webhooks that fire consistently without dropped events.

You can't stop every dropped or repeated event, but you can make each job safe to run twice. Record an ID for every event you process, and skip any you have seen. In Postgres:

```sql
create table processed_events (
  event_id text primary key,
  source text not null,
  received_at timestamptz not null default now()
);
```

```python
import psycopg

def first_time_seen(conn, event_id, source):
    row = conn.execute(
        """insert into processed_events (event_id, source)
           values (%s, %s)
           on conflict (event_id) do nothing
           returning event_id""",
        (event_id, source)).fetchone()
    conn.commit()
    return row is not None
```

Call `first_time_seen` before writing to the CRM or sending anything. If it returns `False`, the event is a retry or duplicate and the job stops. Pair this with a scheduled job that re-checks recent records, so a dropped webhook is caught on the next pass.

## Running Claude Code workflows in the cloud

If the AI coding layer is where you do most of your building, [Teton](https://teton.so) is one place to run it. Teton is the cloud for Claude Code, built for RevOps and GTM engineering teams. You do the job once with Claude in plain language until the output is right. Then type `/teton` and Claude writes it up as one workflow file with the trigger, the steps and the credentials it needs. One deploy makes it live, and it runs whether your computer is on or not.

The parts that matter for GTM work:

- Triggers are a schedule (cron with a timezone), a webhook or by hand.
- The steps Claude worked out run the same way each time. Claude is called inside a step only where judgment is needed.
- Each workspace has its own Postgres database for state between runs, like the `processed_events` table above or yesterday's pipeline snapshot.
- Shared context files hold team definitions such as ICP, scoring rules and what a qualified lead is. Every workflow reads them on each run.
- When a workflow writes to your CRM, each run lists exactly which records it changed.
- Credentials are entered once in the dashboard and only sent to the API hosts a workflow declares.

Teams use it for jobs like posting what moved in the HubSpot pipeline to Slack each morning, flagging deals that have gone quiet, and drafting the follow-up email after every sales call. It doesn't replace Clay's enrichment tables or a sending tool. It replaces the server, scheduler and database you would otherwise set up to run code Claude wrote.

## How to choose

| Need | Good fit | Why |
| --- | --- | --- |
| Enrichment and list building without code | Clay | Waterfall columns, many providers, CRM sync |
| Many app-to-app integrations, lowest run cost | Self-hosted n8n | Open source, you run the server |
| Simple integrations, no infrastructure | Zapier or Make | Hosted, quick to set up |
| Jobs that need judgment or custom API work | Claude Code plus a place to run it | Code you can read and version |
| Running Claude Code jobs without a server | Teton | Schedules, webhooks, Postgres and run history included |

A small team can often start lean, with [CRM, enrichment, automation and AI](https://www.anfloy.com/blog/gtm-engineering-tools), and add tools only when a job outgrows them.

## FAQ

### Do I need Clay to be a GTM engineer?

No, but most job postings ask for it, and it is the default for enrichment. If your work is mostly connecting systems rather than enriching data, n8n or code may cover it.

### Is n8n or Zapier better for GTM automations?

n8n fits when volume is high and someone can run a server. Zapier fits when you want something hosted and running today. Compare total cost, including the paid APIs each run calls.

### How much do GTM engineers spend on tools?

In the GTME Pulse survey, [55% of agency GTM engineers spend $5,000 to $25,000 a year](https://gtmepulse.com/tools/), mostly on Clay credits, Apollo and sending tools. In-house teams will vary.

### Should I learn Python or JavaScript?

Either helps. Clay code steps and n8n nodes accept JavaScript, and Python is common for scripts and data work. With an AI coding agent, reading code well matters more than writing it from scratch.

---

- [All guides](https://teton.so/guides)
- [Teton](https://teton.so): the cloud for Claude Code. Build a workflow with Claude once and Teton runs it on a schedule or a webhook.