Forward-Deployed CRM Architect

RevOps is changing fast, and so is the way GTM processes get built and maintained inside the CRM. This role puts you on the front edge of it: forward-deployed in our clients' RevOps teams, building and running their GTM systems in a genuinely AI-first environment.
GTMBase is an AI-first GTM engineering and RevOps agency. We help post-PMF B2B companies (€8M to €50M ARR, 5+ reps) whose go-to-market is over-performing their systems. Reps do manually what should be automated, sales and marketing data doesn't connect, and leadership can't trust the reporting.
We combine strategic GTM thinking with hands-on technical build, and we fix the foundation before running campaigns.
We deliver across Four Pillars:
1. Data Foundation: list building and enrichment so reps win with better data (Clay, Apollo, custom scrapers, AI research)
2. RevOps & CRM: building the right GTM process inside the client's CRM, including architecture, lifecycle, pipelines, routing, and reporting (HubSpot, Salesforce)
3. Agentic Workflows: building agentic GTM workflows with Anthropic Managed Agents and Hermes, getting the org ready for Agentic GTM
4. GTM Strategy & Plays: recommending and executing the highest-impact campaigns
We've done this for clients including Groupon, Blinkist, Booksy, and Sendify. We work in small pods, with a Strategist, a CRM Architect, and a GTM Engineer.
How We Operate
--------------
We run the company on Claude Code. It's our operating system: client context, playbooks, automations, and delivery all live in it, and AI is the default way we work rather than a bolt-on. You'll work this way too, and get very good at it.
Why This Role Matters
---------------------
You're the person who turns our GTM strategy into a CRM that actually works. Most clients run their entire revenue motion on HubSpot or Salesforce, and the quality of that system runs through this role: how clean the data is, how well leads route, whether leadership can trust the reporting.
Here, "Architect" means architecting inside the CRM: the object model, pipelines, workflows, and automations. The GTM and revenue strategy is set with you in your pod, not by you alone, and you build it with real craft.
You're forward-deployed: you embed with clients' RevOps and sales teams and build inside their live CRM.
The Role
--------
You'll build and maintain GTM process and automation inside our clients' CRMs, mostly HubSpot. Working from the direction set in your pod, you turn requirements into a clean, well-built system the sales team can rely on.
One week you're building a client's lead lifecycle and routing. The next you're debugging a broken automation, untangling duplicate deals, or shipping a dashboard a CRO asked for. You move across several client instances at once without dropping threads.
You're a builder with an admin's discipline. You know the object model, not just the UI. You sweat the details others miss, you test before you ship, and you document what you build so the rest of the pod can run it. When something breaks, you find the root cause and fix it properly.
How This Differs From a GTM Engineer
------------------------------------
Your pod is you (CRM Architect), a Strategist who sets direction and hands you requirements, and a GTM Engineer. You and the GTM Engineer are both builders, but you own different layers:
* You (CRM Architect, Pillar 2): the GTM process inside the CRM. HubSpot/Salesforce architecture, lifecycle, routing, deal logic, automation, reporting, data integrity. You live in HubSpot, Salesforce, Operations Hub, and n8n.
* GTM Engineer (Pillar 1): the data layer. Enrichment, scraping, signal detection, list building, custom research agents. They live in Clay, Apify, custom scrapers, and data APIs.
Think of it as the data into the CRM (GTM Engineer) versus the system it lands in and the process the sales team runs on (you). You don't need to be a Clay or Apify expert. You just need a solid working understanding of what a GTM Engineer does, enough to spec what you need, integrate their output cleanly, and know what's possible.
What You'll Do
--------------
* Architect and build in client HubSpot instances: information architecture (objects, associations, lifecycle stages, pipeline structure), workflows, deal logic, lead scoring, routing, properties, and permissions
* Build and debug automations across the GTM stack: HubSpot workflows, n8n, APIs, and webhooks. When an automation breaks, you find the root cause rather than just toggling features
* Guard data integrity: deduplication, field validation, association hygiene, and import discipline so reporting and forecasting can be trusted
* Build the reporting leadership relies on: pipeline coverage and velocity, stage-by-stage conversion, and full-funnel dashboards. You know where HubSpot's platform and paywall limits force a different approach
* Design integrations and data flows between HubSpot and the rest of the stack (Clay, Aircall, telephony, billing, enrichment pipelines)
* Turn requirements into working builds: take a brief like a 15-minute lead-response SLA and ship the routing system that delivers it
* Keep multiple client instances healthy at once, with fast turnaround and nothing falling through the cracks
* Work client-facing: you can talk through a data question with a technical lead and walk a frustrated AE through a new flow in the same afternoon
* Codify what works into our library of reusable plays and patterns, so every client build sharpens the whole team
What We're Looking For
----------------------
Must-have
* Deep HubSpot expertise: hands-on across Sales, Marketing, Service, and Operations Hubs. You know HubSpot well enough to know what is and isn't possible at the platform level, and to choose native functionality over a workaround when it's the right call.
* Strong CRM and RevOps fundamentals: lead lifecycle and qualification, routing and assignment, pipeline and deal-stage setup, the data model, and the governance that keeps it clean.
* An admin's discipline: precise, reliable, and detail-obsessed. You test before you ship, you keep data clean, and you don't let things fall through the cracks.
* A builder's instinct: you build workflows and integrations, debug them when they break, and aren't intimidated by APIs, webhooks, or a tool you haven't used yet.
* AI-first, and we mean it literally: AI is your default operating mode, not a novelty. Your first move on a problem is to reach for an agent, a prompt, or a workflow before a manual process. If you're not already using AI tools daily, this isn't the right fit. (If your CRM fundamentals are deep but your GTM-tooling experience like Clay or Claude Code is light, that part is learnable and we'll back you on it. The fundamentals and the AI-first instinct are not.)
* Forward-deployed temperament: comfortable building across multiple clients in parallel, client-facing, proactive, and able to move fast without waiting for perfect requirements.
* Full-time availability with reliable overlap to CET hours.
Nice-to-have
* Salesforce: admin or build experience, especially HubSpot to Salesforce sync and migrations (relevant to Groupon and enterprise work)
* A working understanding of the GTM Engineer's toolkit: Clay, Apify, enrichment providers (ZoomInfo, Apollo, Clearbit), scraping. Enough to collaborate, spec, and integrate. Your pod's GTM Engineer owns the deep builds.
* n8n orchestration and custom API integrations
* Scripting (Python, SQL, or JavaScript) for data manipulation and custom connectors
* German: a good chunk of our client base is DACH
* HubSpot certifications: a plus, never a gate. Demonstrated depth matters more.
What You'll Get
---------------
* Real client build work from day one, with no busy work and no hand-holding
* A front-row seat in a genuinely AI-first environment: Claude Code as the operating system, Clay, and the full modern GTM stack
* Direct collaboration with one of the most experienced RevOps leaders in Europe
* Exposure to a wide range of B2B companies, stacks, and GTM problems
* A seat at the table in a growing practice, not a cog in a machine