A founder asked me last month to help him hire a Head of GTM.

He sent me the job description. Five years of HubSpot administration. Salesforce certification preferred. Experience managing a Marketo instance. Proficiency in Outreach, Salesloft, the usual stack.

I read it twice.

Then I told him the person who fit that description perfectly was probably the wrong hire.

He thought I was joking.

Here is the thing nobody wants to say out loud about go-to-market hiring in 2026.

The skills that made someone a great RevOps or GTM leader between 2015 and 2023 are now, in many cases, a liability. Not neutral. A liability.

Because those skills were built inside a specific world. A world where the CRM was a rigid database, where every workflow had to be wrestled into Salesforce’s schema, where “good at GTM ops” meant “good at making legacy tools do things they were never designed to do.”

That world is ending. And the people who mastered it are the ones least equipped to see it.

I run a consultancy. We have done over a hundred B2B implementations. So I am not theorizing here. I am describing a pattern we see on almost every engagement.

Over half the companies we work with were running on stacks that structurally could not leverage AI. Not because the tools lacked AI buttons. Everyone has AI buttons now. The buttons are not the problem.

The problem is the architecture underneath. And the bigger problem is the person defending it.

There is a specific moment in a lot of our projects. We propose rebuilding the GTM stack on a modern, composable foundation. And the loudest objection in the room comes from the most experienced person on the team.

The Head of RevOps. The one who spent five years becoming the company’s Salesforce expert.

They are not wrong to object. From inside their mental model, the objection is rational. They are protecting an investment. Their own expertise is the sunk cost.

But here is what I have learned watching this play out a hundred times.

The companies that make the transition successfully are almost never the ones with the most experienced GTM ops person.

They are the ones with a different kind of person entirely.

I have started calling this person the Modern GTM Leader. Not because the title sounds good on LinkedIn. Because there is no existing word for what they actually are.

The Modern GTM Leader is not defined by which tools they know.

They are defined by their willingness to unlearn.

They look at the way GTM has always been done, and instead of asking “how do I optimize this,” they ask “why is it done this way at all.” They think from first principles about what a go-to-market motion should be when AI can do most of the rote execution. They are not attached to the funnel they inherited.

Sometimes they are the GTM Lead. Sometimes the RevOps Lead. Sometimes the Growth Lead. Sometimes a founder who never had a GTM team and therefore never learned the bad habits.

The title varies. The trait does not.

The trait is this. They are comfortable being a beginner again.

That sounds small. It is not. Most senior people are not comfortable being beginners. Their seniority is built on knowing things. Asking them to unlearn is asking them to give up the thing that makes them senior.

The Modern GTM Leader does it anyway. They treat their five years of Salesforce expertise the way you treat a language you no longer need. Useful once. Not the future.

Let me make this concrete, because “unlearn and rebuild” sounds like a slogan until you watch someone actually do it.

We do a lot of our rebuilds on Attio. Not because it is the only modern CRM, but because its underlying model rewards exactly the kind of thinking the Modern GTM Leader brings.

Here is what the difference looks like in practice.

A legacy-trained ops person opens a new CRM and immediately tries to recreate what they had. They rebuild their Salesforce schema field by field. They port over the same fourteen-stage pipeline. They recreate the same workflows, just in a nicer interface. Six weeks later they have a prettier version of the system they were trying to escape. The architecture changed. The thinking did not.

A Modern GTM Leader opens the same tool and asks a different question. Not “how do I rebuild what I had,” but “what should this actually be.”

In Attio that question has real consequences, because the data model is relational and flexible rather than rigid. So instead of forcing every relationship into a “lead” or a “contact,” they model the business as it actually works. Founders and LPs as their own objects, if they run an investment motion. Partners and referrals as first-class entities, not notes stuck on a contact record. Customer success, hiring, and partnerships running on the same connected foundation as sales, because all of it is relationship data and there is no reason to scatter it across five tools.

Then they layer AI on top of that clean foundation, and it works, because the underlying structure was designed to be queried and operated on, not just stored.

The legacy expert produces a migration. The Modern GTM Leader produces an operating system.

Same tool. Completely different outcome. The variable was never the software. It was the person configuring it.

I have watched a few of them work up close. People who took teams from legacy chaos to something genuinely ready for what is coming next. They do not get faster by automating more. They get sharper by removing the layers that do not deserve human attention in the first place.

That is the move. Not “automate the work.” Question whether the work should exist.

There is an uncomfortable implication here, and I am going to say it plainly.

If you are a GTM ops person whose entire identity is built on knowing the legacy stack cold, the next three years are going to be hard. The tools you mastered are becoming the tools companies are trying to leave. The expertise that got you hired is depreciating.

The way out is not to defend what you know. It is to become the person who helps the company leave it.

The best RevOps people I know are doing exactly this right now. They are not protecting their Salesforce knowledge. They are leading the migration away from it. They saw the shift early and decided to be the one driving it rather than the one being driven.

That is a choice available to anyone in these roles. Most will not take it. The ones who do will be the most valuable GTM hires of the next decade.

So back to the founder with the job description.

I told him to throw it out. Stop hiring for tool proficiency. The tools will change twice before this person’s second anniversary.

Hire for the trait instead. Find someone who has done the unlearning, or who is clearly capable of it. Someone who thinks about what GTM should be, not what it has always been. Someone comfortable being a beginner in a category that is being rewritten in real time.

He asked me how you screen for that in an interview.

I told him the easiest tell. Ask a candidate about the tool they know best. Then ask them what is wrong with it.

The legacy expert defends it. The Modern GTM Leader has a list.

The first time I opened Salesforce, I gave up in under three minutes.

Buttons everywhere. Tabs I couldn’t read. Objects I didn’t ask for. Pre-built reports for use cases that weren’t mine. The product assumed I already knew what I wanted to do with it.

I didn’t.

Most B2B products do this. They ship every feature on day one and call it power. The user opens the app and gets handed the entire toolkit at once: every object, every integration, every workflow, every setting. Day one is the most overwhelming day of the relationship, and it’s also the day the product asks you to commit.

This isn’t power. It’s a setup for churn.

The Mario Kart principle

Open Mario Kart for the first time. You get three cups. Three or four characters. A handful of karts. No 200cc. No mirror mode. No Rainbow Road.

You play. You unlock. You get better. The game gets harder as you do. By the time you’re racing in 200cc mirror mode with the entire roster, you’re a different player than the one who started.

That isn’t a gimmick. It’s how learning works. You start with constraints, master them, then the constraints lift. Each new feature lands on a foundation strong enough to hold it.

Now compare that to Salesforce. Day one, you get every feature, every object, every report, every automation surface. The product gives you no path. It hands you a fully unlocked save file and expects you to play like a speedrunner.

This is why CRM implementation is a market. The complexity isn’t a feature. It’s a tax on adoption that the ecosystem has monetized.

I learned Attio because Attio was simple

I started using Attio in 2022, when it was a central database for people and companies and almost nothing else. No Ask Attio. No call intelligence. No MCP. No SDK. Barely any native integrations. You imported your data, you built objects, you connected your inbox, and that was the product.

That constraint made me good at it. Not at Attio specifically. At CRM architecture. With nothing to hide behind, I had to think about the data model, the object relationships, the attribute logic, the flow between records. The fundamentals.

Three years later, Attio is a different product. Workflows. Call intelligence. Ask Attio. An MCP server. An SDK. Lists that behave like apps. None of that overwhelmed me, because each layer landed on a foundation I’d already built. I “unlocked” features as they shipped, in the order I was ready to use them.

If I started today on the current product, I’d be drowning. The gap between zero and the full surface area is too wide to cross in one jump. I’d skip the fundamentals, copy a template, and end up with the kind of CRM that looks fine for six months and then quietly rots.

This is what nobody admits about CRM expertise: a lot of it is just the privilege of having joined early.

The panel question

Last week I was at a panel at Attio’s London office. Filip Mark moderating, with Nicolas Sharp (Attio’s founder and CEO), Nad Chishtie from Lovable, and Saaras Mehan from Jack & Jill.

The question that stuck with me: in a world where you can interact with any product through Claude or ChatGPT via MCP, why keep building UI at all?

Nicolas’s answer was that UI isn’t decoration. It’s mental cache. A well-designed interface you use every day is restful for the brain. You don’t restart from zero each session. You don’t burn cognitive load reconstructing context. The UI is the shortcut. Strip it away and replace it with a chat box and every interaction becomes an exam.

I agree with him. And I’d add a layer.

The malleable product

If UI is mental cache, then the UI should evolve with the user.

The day one UI and the year two UI should not be the same product. Not in a “we have advanced mode in settings” way. In a structural way. Features unlock as users demonstrate they’re ready to handle them. The product gets denser as the user gets better. The complexity ladder is built into the product itself, not bolted on as documentation.

This was hard to do in the pre-AI world. You shipped one product to everyone because personalizing the surface per user was expensive engineering. Now it isn’t. The infrastructure to render a per-user product surface, gated by behavior and context, is sitting on the shelf. Most B2B SaaS just hasn’t picked it up.

What I’d want to see:

• Day one ships the minimum viable surface. A CRM ships records and pipelines. Not workflows, not reports, not integrations, not AI agents. You earn those.

• Features unlock through use, not through pricing tiers. The trigger for unlocking the workflows engine is “the user has built a clean data model and used the pipeline for two weeks,” not “the user upgraded to Business plan.”

• The UI explicitly tells you what’s locked and why. Same way a video game tells you “complete the Mushroom Cup to unlock the Flower Cup.” Not hidden. Earned and visible.

• Power users can opt out. There’s always a “show me everything” mode for the consultants, the ops people, the early users who already know the product. The default isn’t the ceiling.

This is the inverse of how most SaaS thinks about onboarding. Today, onboarding is the bridge between “user signed up” and “user gets the full product.” The full product is the destination. In the model I’m describing, the user is never given the full product. The full product reveals itself as they earn it.

Why this matters for retention

The retention math on B2B SaaS is brutal. Most products lose 60 to 80% of new signups inside the first 30 days. The standard playbook is more onboarding, more checklists, more in-app tours, more customer success calls. All of which assume the problem is that users don’t understand the product.

The problem is the opposite. Users understand exactly what’s in front of them. They see too much. They can’t tell what to do first. The cognitive load of choosing is what breaks them.

A gamified product doesn’t ask the user to choose. It tells them: here’s what you can do right now, here’s what’s next, here’s what you’ll unlock when you get there. The path is the product. Mastery is built in.

This is also why Mario Kart players keep playing for twenty years and Salesforce users hire consultants to keep playing at all.

The fastest way to get good is to play with someone who’s already great

Here’s what every gamer figures out eventually: the fastest path to mastery isn’t grinding alone. It’s playing with someone who’s been at it for ten years and shows you the shortcuts, the lines, the matchups, the cheat codes you wouldn’t have found in a hundred hours of solo play.

You don’t skip the learning. You compress it. You see what good looks like before you’d have figured it out on your own, and the next thousand hours of play are faster, sharper, more deliberate.

That’s the role Novlini plays for teams adopting Attio.

We’ve been inside the product since it was a database with three objects. We’ve built CRMs for companies going from zero to Series B and from Series B to Series D. We’ve seen the data models that scale and the ones that quietly break at 50,000 records. We know which features to turn on at month one and which ones to leave alone until month six.

When a team brings us in, we’re not absorbing complexity they couldn’t handle. We’re handing them the cheat codes. We design the data model, build the workspace, plug in the integrations that matter, and run the team through how it all fits together. The teams that want to go all the way become operators themselves, and we step back. The teams that want to focus on selling keep us on retainer to evolve the system as the company grows.

Either path works, because in both cases the team starts at a level it would have taken them eighteen months to reach alone. That’s the compression.

The other reason teams keep us around: at a certain point, expertise should be externalized. You don’t want your head of revenue spending Thursday nights tuning Attio workflows. You want them selling. The CRM gets handled by people who do nothing else, which is also how every serious operation runs its stack. Specialists for the specialist tools. Operators for the operating.

This is why the Attio ecosystem exists, and why it’ll keep growing as the product does. The better the product gets, the higher the ceiling. The higher the ceiling, the more value in having someone next to you who already knows where it is.

The next layer

Most B2B SaaS still ships with cheat codes enabled. Every feature, day one, no progression. And then it wonders why nobody finishes the game.

The AI layer doesn’t change this thesis. It enables it. The same infrastructure that lets you render a custom email per prospect lets you render a custom product per user. The same models that can answer “which deals are stale” can decide “this user is ready for advanced pipeline reports.”

Nicolas is right that UI is mental cache. The next step is UI that grows with the user. Not features hidden behind toggles, but a product that genuinely starts simple and ends complex, the way every good game does.

When that future arrives, the role of experts doesn’t disappear. It gets sharper. The product handles the progression. The experts handle the ceiling.

Earlier this week, Attio (the AI-native CRM company that’s been quietly building one of the more interesting positions in B2B software) published something called the GTM Atlas.

It’s a free, ungated, web-based resource. Nine chapters by nine operators, covering the full customer journey from lead capture to retention. The contributors are a who’s who of operators in companies most B2B builders are watching right now: Vercel, Framer, Lovable, Owner.com, Intercom, MKT1, plus respected solo voices like Maja Voje and Josh Epstein.

The framing is unusual. It isn’t a course. It isn’t gated. It doesn’t read like vendor content. The intro by Nicolas Sharp (Attio’s founder) explicitly calls it a “map for modern go-to-market” rather than a playbook, and tells you to skip to whatever section is relevant to where you are.

It’s worth reading the whole thing if you have an hour. What follows is my best attempt at telling you what’s in it, what stood out, and what I think it actually means for anyone building or thinking about a GTM motion in 2026.

The nine chapters, in one paragraph each

Sharp opens with an intro called “GTM is a creative act.” His thesis: AI has collapsed the gap between hypothesis and working system. The era of “buy Salesforce, copy the playbook, hire a RevOps lead” is dead. What replaces it is each company building its own system around its own thesis about its own customer. Less template, more judgment.

Elena Verna (Lovable) writes on lead capture under the title “Your product is the pitch.” Her argument is product-led: in 2026, the website and the product are the demo, the marketing, and the qualification all at once.

Emily Kramer (MKT1) covers qualification with “Gen marketers do less, better.” Her core point: stop doing random acts of marketing. Most early teams say yes to every founder request and copy what other teams do. The teams that win pick a few big-bet campaigns, integrate content (fuel) and distribution (engine), and let a single generalist orchestrate end-to-end.

Maja Voje (The GTM Strategist) writes a second qualification chapter, “Build your GTM brain.” It’s the most strategic of the chapters: how to build a layered understanding of your market that holds up as the product evolves.

Kyle Norton (CRO at Owner.com, where he scaled GTM from $2.5M to nearly $100M ARR in under four years) covers outbound in “Start with the data.” His thesis is uncompromising: outbound has one point of failure, the data. Bad lead lists make every other intervention worthless. AI’s job is to remove wasted motion, not to send more emails.

Roniesha Copeland (VP Strategic Sales at Vercel) writes the second outbound chapter, “Build the system before the message.” Process before craft.

James Pastan (Head of Growth at Framer) covers activation: “Activation is more than activity.” Pushing back against the idea that engagement metrics equal real value.

Rati Zvirawa (Senior Director of Product at Intercom) covers conversion with “Let AI own, not assist.” The argument: in customer-facing AI, the line between “AI assists a human” and “AI owns the workflow” is the line between toy and product.

Josh Epstein (CRO at Coder) closes with retention: “Retention is a culture problem.” Most retention failures aren’t dashboard problems, they’re org problems.

That’s the Atlas in one breath. Each chapter is short, focused, and written by someone who’s actually shipped the thing they’re writing about. The site itself is a beautiful interactive map, worth seeing for the design alone.

The thing nobody is saying about this Atlas

When you read all nine chapters in one sitting, a pattern emerges that I haven’t seen mentioned in any of the relays I’ve read.

Every chapter describes the same role under a different name.

Kramer calls it the “gen marketer.” Norton calls it the “GTM engineer.” Voje calls it the “GTM brain.” Sharp calls them “operators with a clear point of view.” Strip away the vocabulary and you get the same job description across all nine: one human who owns the data layer, owns the system layer, owns the message layer, and translates a founder’s belief about the customer into a working machine.

This convergence is the news. The Atlas isn’t really nine essays on nine topics. It’s nine arguments for the same role, dressed in nine different hats.

That role doesn’t have a settled name yet. Three years ago it didn’t really exist as a discipline. People doing this work were scattered across titles like Head of Growth, Marketing Ops Manager, Head of Demand Gen, RevOps Lead, sometimes a founder doing it themselves on the side. The work was happening, but the category wasn’t.

The Atlas crystallizes the category.

Why a CRM company published a guide that isn’t about CRM

Here’s the strategic move underneath, and I think it’s worth naming.

When a software company publishes a 9-chapter resource featuring nine respected operators, the default assumption is that it’s lead gen. SEO. Top of funnel.

The Atlas is something else. It’s a category-defining document. Sharp’s intro lays out a thesis (AI has collapsed the gap between hypothesis and system, the playbook era is over, GTM is now a creative act) and the rest of the Atlas reinforces it through nine independent voices.

Why does that matter? Because if you accept the thesis, you also accept its corollary: the monolithic CRM (the kind designed for one playbook, one process, one set of standardized handoffs) doesn’t fit anymore. What fits is a composable stack. Tools that let each company build its own system around its own thesis.

The Atlas’s Stack page lists the tools featured: Attio, Clay, Customer.io, Claude, Notion, Framer, Granola, Fin, Wispr Flow. There’s no Salesforce. No HubSpot. No Outreach. No Marketo. The implicit message is that the legacy stack belongs to the era the Atlas is declaring over.

This is how categories get redrawn. You don’t compete on features. You publish the manifesto, you let nine respected operators give it social proof, and you let the worldview do the work.

What to take from this if you’re building a GTM motion right now

Three things.

One: don’t hire a BDR before you have a system. This is Norton’s argument and I think it’s the most important practical insight in the whole Atlas. Reps fail not because they’re bad. They fail because the data they’re working with is unusable. Most early-stage teams hire bodies before they hire (or build) the layer that makes those bodies productive. That order is wrong.

Two: stop looking for the playbook. Sharp’s framing is correct: there isn’t one. The teams that win in 2026 won’t be the ones who copied the right template. They’ll be the ones who built the system that fits their specific belief about their specific customer. Borrowing tactics is fine. Borrowing entire models is now a competitive disadvantage.

Three: name the role you’re actually trying to fill. If you’re hiring “Head of Marketing” but what you actually need is someone who can wire your CRM to your enrichment to your lifecycle automation and run end-to-end experiments with AI-generated assets, write that JD. The Atlas just gave you the vocabulary. Use it.

A closing note

Disclosure: I run Novlini, a GTM and RevOps consultancy that operates inside the ecosystem the Atlas describes. Attio, Clay and Customer.io are the three core tools of our stack, and we are official partners with all three. We picked them by conviction first, the partnerships followed.

I’m not a neutral observer of this document.

But for two years I’ve been having the same conversation with founders, explaining why a composable stack beats a monolithic CRM, why one operator with a strong point of view outperforms five specialists with handoffs, why the playbook era is over and what replaces it.

The Atlas is the first time I’ve seen that conversation written down by people other than me, with social proof attached.

That’s why I think it matters. Not because it teaches anything radically new, but because it names what was already happening. And in this industry, naming things is half the battle.

Worth the hour.

I have had the same conversation probably fifteen times in the past year.

A founder or ops lead reaches out. They are frustrated with their CRM. HubSpot has become a mess. Salesforce costs too much and nobody uses it correctly. They have heard good things about Attio. They want to migrate.

We get on a call. I ask them to walk me through how their data is structured today.

And within ten minutes, the real problem is visible.

It is not HubSpot. It is never HubSpot.

The migration trap

When teams switch CRMs, they do one of two things.

The first option: they export everything from the old tool and import it as-is into the new one. Same fields. Same structure. Same logic that stopped making sense eighteen months ago. The new CRM looks different. The underlying architecture is identical. Six months later, they are frustrated again, for the same reasons, and they are blaming the new tool.

The second option: they start from scratch, but they use the default schema as a template. People, Companies, Deals. Maybe a few custom fields. They get up and running quickly, which feels like progress. But the data model was designed for a generic B2B sales motion that may have nothing to do with how their business actually works.

In both cases, the tool is not the problem. The problem is that nobody stopped to ask: what does our data actually look like, and how should it be connected?

What a broken data model costs you

It is not dramatic. That is the thing. A poorly modeled CRM does not explode. It just quietly degrades everything it touches.

Reporting becomes unreliable. You pull a number, you are not sure you trust it, you go validate it manually. Every time.

Automations misbehave. They fire on the wrong records, skip edge cases, require constant human override. The workflow you built to save time creates more exceptions than it handles.

Onboarding takes longer than it should. A new hire opens the CRM and cannot figure out what anything means. The structure does not reflect the business. It reflects whatever someone decided three years ago when they were in a hurry.

And when you start layering AI on top - agents, automations, enrichment - the noise gets amplified. An agent acting on a badly modeled pipeline does not fix your errors. It scales them.

What a good data model actually looks like

The core question is: what are the entities in your business, and how do they relate to each other?

For a straightforward B2B sales motion, the defaults work fine. A Contact belongs to a Company, a Deal tracks the opportunity. Done.

But most businesses are not that simple. A consulting firm has clients, projects, workstreams, and deliverables - four distinct entities, each with their own attributes and lifecycle. A VC has portfolio companies, investment rounds, and co-investors that all need to be tracked separately and linked correctly. A SaaS company has companies, users, and subscriptions, and the relationship between them is not always one-to-one.

When those entities get forced into a schema that was not built for them, the data model starts lying. A “Deal” field stores project status. A “Note” stands in for what should be a linked record. Custom fields multiply until nobody can remember what they were created for.

The answer is not more fields. It is the right objects, with the right relationships, defined before you start importing data.

Why this matters right now

I wrote a few weeks ago about push vs. pull in the GTM stack. The short version: most AI tools today are impressive but passive. The next generation acts before you think to ask. Background agents that scan your pipeline, surface what matters, draft the follow-up before you open your laptop.

That shift is coming faster than most teams expect.

And it has a hard prerequisite: the data underneath has to be trustworthy. An agent working from clean, well-structured CRM data is a multiplier. An agent working from a tangled mess of imported fields and workaround logic is a liability.

The teams getting ready for that are not spending their time evaluating new AI tools. They are fixing their foundations first. Cleaning their schema. Defining their objects. Mapping their relationships properly.

It is unglamorous work. It rarely makes it into a conference talk.

But it is the difference between a CRM that earns intelligence layered on top of it, and one that does not.

If you are in the middle of a CRM migration, or you have been living with a data model that no longer reflects how your business works, I wrote a detailed guide this week on how to approach this in Attio specifically - custom objects, relationship types, and how to structure a real business inside a modern CRM.

Read it here.

Your CRM can now talk back

I wrote this post from inside a Claude conversation that had my Attio workspace open in the background.

Not a screenshot. Not a demo environment. A live CRM, queryable through natural language, while I was writing something else entirely.

That’s what Attio MCP enables. And it’s worth slowing down on, because the implications go further than most of the “AI + CRM” content you’ve been seeing.

The tab-switching problem was always a data problem in disguise

The reason salespeople don’t update their CRM isn’t laziness. It’s friction cost. Every switch to a new tab is a context interruption. Every manual field update is a micro-decision about whether the information is worth preserving.

The result: CRMs with thin, stale data. Which makes the CRM less useful. Which creates more resistance to using it. Classic negative loop.

The promise of MCP - Model Context Protocol, the standard that lets AI tools read from and write to external systems - is that it collapses that friction to near zero. You’re already in Claude drafting a follow-up. You ask it to pull the last interaction on that account. It does. You tell it to log the call notes and update the deal stage. Done.

No tab. No form. No context switch.

What the workflow actually looks like

Here’s a concrete sequence we’ve been running with clients:

Research a target company in Claude. Ask it to create the company record in Attio, add it to the prospecting list, and draft a personalized first message. All in one conversation.

Get off a discovery call. Your notetaking tool already has the transcript. Your AI agent reads it, identifies the key outcomes, and updates the deal record in Attio: stage, next steps, notes. By the time you close the laptop, the CRM is current.

Ask ChatGPT which deals haven’t had activity in two weeks. Get a clean list. No filter-building, no report setup. Just an answer.

These aren’t hypotheticals. They’re available today, natively, in Claude, ChatGPT, and Notion.

The part nobody talks about

Here’s where I have to be honest, because this is where implementations go wrong.

MCP makes your CRM accessible. It doesn’t make it good.

If your Attio workspace has inconsistent data, unmapped fields, deals sitting in the wrong stage, contacts without company associations - the AI will faithfully surface all of that confusion. Garbage in, garbage out. The protocol doesn’t fix the underlying data model.

What we see with clients who get real value out of this stack: they invested in CRM architecture before layering in AI. Clean objects, meaningful attributes, a deal flow that reflects how they actually sell. The MCP connection is the last mile, not the foundation.

If your CRM is a graveyard of half-entered records, this is a good moment to fix that. Not because MCP requires it - but because the gap becomes impossible to ignore once an AI is reading it back to you.

The broader shift

The more interesting unlock isn’t Attio + Claude in isolation. It’s what happens when your entire toolstack is MCP-connected.

Meeting notes update an Attio record. A deal note triggers a ticket in Linear. Your CRM context travels with you across every tool, automatically, without manual handoffs.

The CRM stops being a destination you visit. It becomes infrastructure that runs underneath everything else.

That’s a different way of thinking about what a CRM is for. Less a system of record you fill in after the fact. More a live data layer that every tool in your stack can read and write to in real time.

We’re early. But the primitives are there now.

If you’re on Attio and want to actually build this

At novlini we’ve been implementing this stack for clients - CRM architecture first, then the AI layer on top. If you want to understand what’s possible in your specific setup, reply to this post and I’ll reach out directly.

The brief seemed routine.

A Series A B2B startup, around twenty people, wanted to move off HubSpot. Too heavy, too expensive, too many features sitting untouched. They’d heard about Attio. A friend had recommended it. They wanted to move fast - ideally within a month.

We started where we always start: an audit of what they had.

That’s when things got interesting.

Eleven deal stages

Their HubSpot pipeline had eleven stages.

Eleven - for a three-person sales team, a three-week average cycle, and a single customer segment. I asked the Head of Sales to walk me through stage seven. He paused. Looked at his screen. Said: “I think that was added by an old intern.”

No one used it. No one knew what it meant. No one had deleted it either.

This happens more often than it should. CRMs accumulate decisions the way email inboxes accumulate newsletters - passively, incrementally, until the weight of all those small choices makes the whole thing impossible to navigate. Nobody adds eleven pipeline stages in one go. They add one. Then another. Then a consultant recommends a different structure. Then someone reads a blog post about “deal velocity” and adds two more stages to track it.

And nobody removes anything, because removing feels risky when you don’t fully understand what’s there.

The wrong move would have been easy

We could have migrated all eleven stages into Attio. It would have taken two hours. The client would have been satisfied - at least for a few weeks. And then, slowly, the same problems would have resurfaced: low adoption, messy data, a pipeline that doesn’t reflect how deals actually move.

This is the trap with CRM migrations. The technical work is straightforward. Map fields, move records, reconnect integrations, set up automations. That part is a solved problem. The harder part - and the part that determines whether a migration actually succeeds - is everything that happens before you touch the tool.

Instead of migrating, we stopped. And we asked three questions.

1. When does a deal actually change status in your cycle - not on paper, in reality?

2. Who needs to know what, at which point, and why?

3. What do you want to be able to measure in three months that you can’t measure today?

Half a day of structured conversation. We went from eleven stages to four. The pipeline became readable. The forecast became usable. Adoption on the new system was immediate, because the structure matched how the team actually worked instead of reflecting someone else’s playbook.

The migration itself took a few days. Clean, fast, without drama.

A CRM is a mirror

After dozens of these projects, one thing is consistently true: a CRM doesn’t create problems. It reveals them.

A team with a fuzzy sales process will have a fuzzy CRM. A team with unclear ownership between AEs and CSMs will have a CRM that nobody fully owns. A team that hasn’t defined what a “qualified lead” means will have a pipeline full of noise that never closes.

The tool is almost never the issue. It’s a symptom. HubSpot wasn’t failing this client. It was faithfully reflecting years of accumulated decisions, never revisited. That’s actually what a good CRM does - it surfaces the state of your process with uncomfortable precision.

This is also why Attio works so well for the teams we build with: it’s flexible enough to match your actual process instead of forcing you into a predefined structure. But that flexibility only becomes an asset if you know what structure you’re building toward. In the wrong hands, it’s just a faster way to create a cleaner mess.

The mirror only helps if you’re willing to look into it.

Five signals that tell me a migration is going to be painful

These aren’t theoretical. Every one of them has delayed a project or forced a rebuild.

1. “We just want to move the data over”

The belief that the problem is technical. It never is. When a client frames the migration as purely a data transfer exercise, it means the process conversation hasn’t happened yet - and we will eventually have it, either before the migration (easy) or after a failed one (expensive).

2. No clear owner of the CRM post-migration

Someone has to own data quality, field definitions, and workflow logic once we hand over the keys. If the client can’t name that person, the system will degrade within sixty days. Not because Attio is hard to maintain - it isn’t - but because no tool maintains itself.

3. Existing data hasn’t been touched in months

Stale data is a red flag - not about the data itself, but about whether the team is actually using the CRM to run the business. If the records haven’t been updated, it’s because nobody is reading them. Migrating abandoned data into a new tool doesn’t revive the habit. You need a process change, not a platform change.

4. Multiple people define the pipeline differently

Ask three salespeople what “Proposal Sent” means in their pipeline. If you get three answers, you don’t have a pipeline - you have three individual tracking systems living inside the same tool. This surfaces fast in migration scoping calls. When it does, we stop and do a pipeline alignment workshop before anything else. The cost of skipping this is rebuilding the entire structure three months later.

5. The decision to switch was made without the sales team

CRM decisions made top-down, without involving the people who will use the tool daily, fail at adoption. Not because of the tool. Because of the process. If the sales team didn’t ask for this change, they will default to old habits - Notion, spreadsheets, their own notes - within weeks. Adoption has to be designed in, not assumed.

What this means in practice

When a prospect tells me they “just want to migrate,” I know the migration is the easy part.

Every project we run at Novlini starts with a process audit before we write a single line of configuration. Not because we want to add scope - because the questions we ask in that audit determine everything downstream: the data model, the pipeline structure, the automations, the reporting.

A CRM built on a clear process takes days to configure and months to outgrow. A CRM built on top of a broken process takes days to configure and weeks to abandon.

The tool is almost never the constraint. The real question is always: what does your sales process actually look like - not on the wiki, not in the onboarding doc, but in the real conversations your team has every day?

Answer that honestly, and the rest is execution.

I had a monthly review with Johan, CEO of Spiich Labs, yesterday. 24 hours later, I’m still thinking about it.

Not because of what we discussed. Because of what happened after the call ended.

I pressed “process meeting” in Spiich. Ten seconds later, my Attio records were updated, the follow-up email was drafted, and the next step was already mapped. I did not write a prompt. I did not open a doc. I did not spend fifteen minutes reconstructing the context of a conversation I had just lived.

It just happened.

And sitting with that for the rest of the day, I realized the thing that bothered me was not about Spiich specifically. It was about everything else.

The stack we built is a system of responses

Look at how almost every GTM tool works. You log in. You search. You ask. You get an answer.

Even the AI features that have shipped over the past two years follow this pattern. HubSpot Breeze, Salesforce Einstein, Attio’s AI blocks, Clay’s enrichment logic - these are all powerful. I use several of them daily. But they all share the same underlying model: the human initiates, the tool responds.

You have to know what to ask. You have to remember to ask. You have to open the right tab, frame the right question, and then interpret the output well enough to decide what to do next.

That is a lot of cognitive overhead normalized into a routine so familiar we stopped noticing it.

Every morning, sales reps open their CRM and spend twenty to thirty minutes just getting oriented. Where are we on this deal? What happened after that call last week? Who was I supposed to follow up with? This is not selling. It is reconstruction. And we have built an entire generation of tools that make reconstruction slightly faster without questioning whether it should exist at all.

There is a difference between pull and push

The mental model I keep coming back to is simple.

Pull tools respond when you ask. Push tools act before you think to ask.

Most AI in GTM today is pull. Impressive pull, increasingly capable pull, but pull. You open Claude or ChatGPT, you get a beautiful answer, and then you stare at it thinking: now what. The output is great. The initiation still came from you.

Push is different. It means background agents that run while you are in a meeting, or sleeping, or thinking about something else. They scan your pipeline. They check your email threads. They look at what changed since yesterday. And by the time you open your laptop, you are not starting from scratch. You are starting from a situation already assessed, with actions already recommended, sometimes already taken.

The value is not a better answer. The value is the elimination of the question itself.

That is a meaningful distinction, not a marketing one.

What this looks like in practice

I invest in Spiich Labs. I want to be upfront about that, because what I am describing is not a detached observation. I put money in because when I tested it, I saw something I almost never see in this space: a product that does the boring things well, reliably, without demanding that you change how you work to accommodate it.

The thing that got me was not the AI quality. It was the proactivity.

There are background agents running constantly. They monitor your pipeline, your threads, your calendar. They surface what matters before you open a dashboard. They suggest the next step with enough context that the suggestion is actually useful, not generic.

And when you combine that with a properly architected CRM - in my case, Attio - the loop closes in a way that feels almost unfair. Meeting ends. Press one button. CRM updates. Email drafted. Done in ten seconds. The cognitive tax is gone.

I didn’t build this. I just turned it on.

The prerequisite nobody mentions

Here is the part that matters if you are thinking about integrating anything like this into your stack.

Background agents are only as good as the foundation they sit on.

An agent that scans a poorly modeled pipeline does not catch your errors. It amplifies them. It acts on stale data, drafts follow-ups based on the wrong deal stage, and automates your confusion at scale. That is not a reason to avoid agents. It is a reason to take the architecture seriously first.

This is something I have seen play out enough times that it has become a rule at Novlini: you do not layer intelligence onto a system that has not earned it. Clean data model, properly defined objects, relationships that actually mirror how your business works. Automations that serve reality, not a sanitized version of it.

Only then does a push system make sense. Because at that point, what the agent is acting on is true. And acting on truth, proactively, at the right moment, without waiting to be asked -- that is where the real leverage is.

Where I think this goes

Spiich is early. Small. Barely known outside a handful of people paying close attention to the GTM tooling space.

But the pattern it represents is not going away.

In the next eighteen to twenty-four months, I think the GTM stack will split into two camps. Tools that wait for you to initiate, and tools that monitor, decide, and act. The first camp will still be valuable. But the second camp will quietly absorb the highest-leverage parts of the workflow: the morning orientation, the post-meeting update, the follow-up timing, the pipeline health check.

The teams that get there first will not get there because they picked the right product. They will get there because they built the right foundation underneath it.

That is still the work. It is still unglamorous. It is still mostly about schema design, data quality, and workflow logic that nobody wants to talk about at a conference.

But it is what separates a GTM stack that is ready for agents from one that will be broken by them.

Vibecoding a Custom CRM vs Attio: the 80/20 reality

The current “vibecoding your CRM” wave (using tools like Claude Code or Lovable) is real, and the demos are legitimately impressive. In a few hours, you can produce an app that looks and feels like a CRM, often good enough to replace spreadsheets and reduce seat-based SaaS spend for small teams. That is not hypothetical: Lovable published a recent customer story about Atonom replacing a Salesforce contract with a Lovable-built CRM, claiming a major cost reduction, with the first version built in ~3 hours.

But the pattern the sources keep reinforcing is the same: the easy part is the “first 80%” (CRUD, views, dashboards). The hard part is the last 20% that makes a CRM operationally safe and durable: permissions, security, data integrity, auditability, edge cases, integrations, scale, and long-term maintainability. Even platforms with strong compliance posture explicitly frame security as a shared responsibility.

Attio’s core advantage is that it is already designed around that last 20% while still being unusually flexible: a configurable data model (objects, lists, attributes), enterprise-grade controls (permissions, SSO), and an AI-native layer (Ask Attio, Attio MCP) that is explicitly permission-aware and built around OAuth-scoped access.

After reviewing the most widely circulated “replaced Salesforce with a vibecoded CRM” claim, I can verify one concrete, named example (Atonom). I did not find a well-documented, independently audited example of a vibecoded CRM that is both widely scaled (large headcount, complex permissions, heavy integrations) and publicly evidenced as secure (clear threat model, app-level controls, testing) in the way enterprise buyers typically require.

What the evidence says about vibecoded CRMs right now

The most verifiable Salesforce replacement story circulating from the Lovable ecosystem is Atonom. Lovable’s customer story claims: Salesforce cost ~$40,000/year for ~25–30 users; a finance/legal leader built a working CRM prototype in ~3 hours; the company moved usage away from Salesforce; and the new system runs on Lovable at roughly ~$1,200/year including hosting.

There is also direct first-person corroboration from Atonom leadership on social, with some numerical inconsistency that’s worth calling out. Gabe Larsen describes “ripping out” a ~$30k Salesforce contract and building a CRM in ~3 hours on Lovable, costing ~$100/month. The direction matches the case study, but the exact numbers vary ($30k vs $40k; $1k vs $1,200).

Lovable also positions the broader “buy to build” narrative as viable at very large scale, citing eXp Realty (83,000+ agents) replacing or reducing multiple per-seat SaaS costs via internal software built with Lovable, including claims of eliminating ~$1M/year in per-seat licensing for an internal “Hub” product and saving ~$1M/year by replacing ChatGPT Enterprise custom chatbots with custom workflows using the OpenAI API. This is not a Salesforce CRM replacement story, but it is evidence that Lovable is used for mission-critical internal software in at least one large org.

On the “why the last 20% matters” question, the most useful sources are the ones that are unusually explicit about operational boundaries:

Claude Code’s own documentation emphasizes that agentic coding tools are powerful precisely because they can read code, modify files, and run commands, and therefore need a strict permission and approval model (read-only by default; explicit approval required for edits and shell commands; configuration of allow/ask/deny rules; warning against bypassing permissions outside isolated environments).

That caution is not abstract: recent reporting described a real incident where a developer’s production resources were deleted after delegating infrastructure changes to Claude Code with inadequate supervision and guardrails. The details are specific to that case, but the meta-lesson is transferable to “vibecoded CRM as a system of record”: agentic tools plus elevated permissions can create fast failure modes.

Lovable’s security posture is strong at the platform level (SOC 2 Type 2, ISO 27001:2022; enterprise security positioning; DPA language on maintaining certifications), but its docs also explicitly state that built-in security tools do not replace a thorough security review and that the builder remains responsible for app-level security decisions, especially for sensitive data or critical functions.

Attio’s engineering perspective is the closest thing to a “primary-source” articulation of why CRMs become hard at scale: it’s not just the data model, it is executing user-defined workflows reliably and at scale (Attio references thousands of workflows initiated every minute). This maps directly to the “last 20%” bucket: reliability, orchestration, and safe automation.

Draft Substack article in my voice

I keep getting the same question lately:

Should we just vibecode our own CRM with Claude Code or Lovable?

I understand the temptation. The demos are insane. You go from “I hate Salesforce” to a clean pipeline UI in a few hours. It feels like teleportation.

There’s a reason this trend is spreading. For a long time, “build vs buy” was a fake choice. Building internal business software was slow, expensive, and brittle. Now AI collapses the first part of the curve. A solid CRUD app is basically a prompt away.

But here’s my contrarian take:

Most teams are vibecoding the wrong thing.

They’re vibecoding the part that’s easy to demo, and underestimating the part that makes a CRM real.

The seduction of the demo

Let’s anchor this in a real example, not vibes.

Lovable published a customer story about Atonom, a startup that claims it replaced a ~$40,000/year Salesforce contract with a Lovable-built CRM for roughly ~$1,200/year including hosting, with the first prototype built in ~3 hours.

Atonom’s CRO (Gabe Larsen) posted publicly about ripping out a ~$30k Salesforce contract and building a CRM in ~3 hours on Lovable for ~$100/month. The exact numbers differ, but the narrative is consistent: rapid build, fast adoption, and a meaningful reduction in per-seat SaaS spend.

That’s the wow-effect.

And honestly, it’s legit. If your “CRM” today is a spreadsheet plus a weekly pipeline meeting, AI-assisted building can bring you to a working internal tool fast.

This is the part many people stop at. They look at the app, they look at the old CRM bill, and the conclusion seems obvious: we can just build it.

The 80/20 trap: the last 20% is the whole job

A CRM is not a UI. It’s an operational truth machine.

It becomes the system of record for revenue. It’s where you answer questions like: who can see which customer, which deals are real, what forecast is trusted, what happened, and who did what.

And that last 20% you don’t see in demos is where CRM complexity lives:

Security and permissions. The moment you have multiple teams, regions, contractors, or sensitive accounts, permissions stop being a checklist and become foundational product design. One misconfigured rule turns “internal tool” into “data leak.” The best agentic tools are explicit about this: Claude Code defaults to read-only, requires explicit approvals for actions, and warns against bypassing permission systems outside isolated environments. That is not paranoia. It’s product reality.

Data integrity and auditability. CRMs survive by being boringly correct. You need reliable workflows, consistent data modeling, history, and the ability to answer “what changed, when, and by whom.” That’s also why CRM platforms talk about running automation at scale and keeping it reliable. Attio’s engineering writing is unusually direct: once users can create workflows, the platform has to execute them reliably at scale, with thousands initiated every minute. That is the opposite of a demo.

Integrations. A CRM is never standalone. Email, calendar, enrichment, billing, product data, warehouse, support, outbound, attribution. The glue is the system. Claude Code can connect to external tools via MCP, but it also warns: third-party MCP servers are not all verified, and you should treat them as a trust boundary.

Maintainability. This is the silent killer. Even if you “own the code,” you also own the on-call. Lovable’s documentation is candid about the operational surface area you inherit if you stop using the platform for hosting and management: CI/CD, infrastructure, scaling, databases, backups, access controls, OAuth, secrets, monitoring, compliance posture. The cost doesn’t disappear. It moves.

And if you want a visceral example of how quickly it can go wrong, look at the recent incident reporting about a developer delegating infrastructure work to Claude Code and accidentally deleting production resources. Different context, same lesson: when AI has write access, guardrails are not optional.

So where do I land: build around the CRM, not instead of it

At Novlini, we’ve been testing these tools closely. My takeaway so far: vibecoding is amazing at producing focused tools and workflow-specific interfaces quickly. It’s less proven as a complete CRM replacement once you hit real-world complexity.

This is why I’m bullish on Attio as the baseline.

Attio’s core design is closer to “programmable CRM” than “legacy CRM.” The data model is flexible by default: you can define custom objects and lists, with a wide range of attribute types, and you start from the canonical primitives (people, companies, deals).

Then it adds something legacy CRMs are still awkward about: an AI layer that is permission-aware.

Ask Attio explicitly positions itself as enforcing existing permissions, so people only see what they’re supposed to see, and the human remains in control of suggested actions.

And Attio MCP matters because it’s the cleanest “AI meets system of record” bridge I’ve seen so far. It is a hosted MCP server, OAuth-authenticated, designed to give AI tools access to your workspace with confirmation on writes, and it is built for AI assistants to read and act on CRM data without turning your CRM into a DIY integration science project.

This is also where the “build vs buy” argument gets more interesting.

For most teams, the right move is not:

Build a CRM vs buy a CRM.

It’s:

Buy a system of record, then build the missing surfaces around it.

Retool has been making this point for years in the internal-tools world: keep Salesforce or HubSpot as the system of record, and build focused apps (deal review dashboards, commission calculators, renewals control centers) on top of CRM data via APIs.

With Attio, that “build around it” story gets even cleaner because the platform is already oriented around flexibility, strong permissions, and modern integrations. Attio has been shipping directly on these themes recently (MCP server, upgraded permissions, Ask Attio).

What about true counterexamples

Do I think vibecoded CRM replacements will exist? Yes.

Do I see a clearly evidenced, production-grade, secure-and-scaled example today? Not really.

I can verify that Atonom claims to be running a Lovable-built CRM in place of Salesforce for a relatively small team, and that claim is documented both by Lovable and by Atonom leadership.

What I can’t verify from public sources is the “enterprise-grade” part: the app-level threat model, permission architecture, audit logging, penetration testing, and how it behaves after the tenth integration and the hundredth edge case. And Lovable’s own docs explicitly remind you why that gap exists: platform security does not replace your responsibility for application security.

So my position is simple:

If your goal is to replace spreadsheets and move faster this quarter, vibecode away.

If your goal is to build a CRM that can survive the next two years of complexity, start from a platform that already solved the last 20%, and use AI to extend it.

That’s the bet behind building on Attio, then vibecoding the pieces around it.

This morning I saw a post from Alex Vale, VP Marketing at Attio. It said, with the exact level of restrained triumph B2B software deserves, that Attio is now more widely adopted than Pipedrive.

Naturally, I clicked.

First the screenshot. Then the Ramp page. Then the little “Explore with AI” button, which is a very 2026 sentence to write unironically. And somewhere between the chart and the AI summary, I realized the interesting part was not the headline itself.

The interesting part was what the data says about the CRM market underneath it.

Because yes, “Attio is now ahead of Pipedrive” is a nice symbolic milestone. But the more useful question is this: what kind of market produces that result, and what does it tell us about how companies are choosing CRM in 2026?

As the founder of Novlini, I spend a lot of time inside CRM systems, mostly when companies realize their old setup is either too rigid, too shallow, or somehow both at once. So I am not approaching this as a detached industry analyst in a grey blazer. I am approaching it as someone who has watched the same pattern repeat across startups, scale-ups, funds, and service businesses: teams do not actually want “a CRM.” They want a system that matches how their go-to-market motion really works.

That is why this Ramp data is interesting.

Not because it gives us some final, absolute truth about market share. It does not. Ramp is very clear that this is based on anonymized, aggregated procurement and renewal activity from businesses on its platform, measured over a trailing 12-month window. In other words, this is spend data, not product telemetry, not active seat count, and not the entire software market. But it is still very useful because it captures something closer to buying behavior than brand perception. It tells us what companies are actually paying for.

And what companies are paying for, at least in Ramp’s view of the world, looks like this: Salesforce still dominates CRM with 76% adoption, HubSpot is second at 35%, Zoho is third at 13%, and Attio now appears in fourth place at 4%, ahead of Pipedrive, which also shows 4% on the rounded public chart. On the growth side, Attio is the fastest-growing CRM vendor in the dataset at +0.14 percentage points, ahead of Salesforce at +0.07, while Pipedrive and HubSpot are both declining on this measure.

That combination matters more than the ranking itself.

Because the CRM market is not a normal software market. It is a market with absurd inertia. People do not switch CRMs for fun. They switch because pain has finally become more expensive than migration. And since migration is one of those projects everyone says will “only take a few weeks,” right before it quietly colonizes an entire quarter, most teams delay it for as long as possible.

So when a vendor moves in CRM, even a little, it is usually telling you something real.

The first thing Ramp’s data tells us is that the incumbents are still very, very incumbent. Salesforce remains the gravitational center of the category. HubSpot remains the default second answer for a huge part of the market. If you wanted a neat challenger narrative where the new generation has already overthrown the old one, this is not that. The market is still concentrated, still sticky, and still dominated by tools that have spent years becoming procurement-safe choices for companies that would rather preserve continuity than pursue elegance.

The second thing it tells us is that the edges are moving.

Attio’s public Ramp profile says it reached 4% adoption in March 2026, up 2 percentage points year over year. That sounds small until you look at the historical table: Ramp shows Attio at 1% in March 2024, 2% in March 2025, and now 4% in March 2026. In a category as sticky as CRM, that is not just growth. That is a sign that a different product philosophy is finding repeatable demand.

And this is where the “Attio passed Pipedrive” story becomes more interesting than a leaderboard screenshot.

Pipedrive is not some random app. It represents a whole generation of CRM thinking: pipeline-first, sales-led, operationally lightweight, good for teams that mainly need to move deals from stage to stage without building a data architecture degree on the side. Ramp’s data still shows Pipedrive as stable enough on adoption to round to 4%, but with negative growth, a 4% competitor switch rate, and stronger relative adoption in mid-market and enterprise than Attio. In other words, Pipedrive still has a real installed base, and not just among tiny teams.

So if Attio is now surfacing above it in the category ranking, even while both round to the same adoption number, the signal is not “Pipedrive is dead.” The signal is that the center of gravity for new CRM energy has shifted.

From pipeline-first to system-first.

From “where do I track deals?” to “how do I model relationships, automate context, and connect GTM work across the business?”

From a CRM as a sales tool to a CRM as an operating layer.

That shift has been visible in practice for a while. Ramp’s numbers simply make it harder to pretend it is niche.

The interesting nuance, though, is where Attio is winning.

Ramp’s Attio page shows the vendor is heavily skewed toward smaller companies. SMBs represent the largest share of its customer base at 56%, and its adoption is much higher in SMB than in mid-market or enterprise, where it sits at just 1%. That tells you Attio’s growth is not coming from broad enterprise standardization yet. It is being pulled upward by smaller, more modern teams. The kind of teams that care less about whether a CRM looks familiar and more about whether it can actually match the way they work.

This is exactly how most meaningful CRM shifts start.

Not with giant enterprises heroically abandoning their legacy stack in the name of software design. That fantasy mostly exists on LinkedIn.

They start with companies that are still early enough, or sharp enough, to ask the better question before the worse system hardens into process. Startups. Lean revenue teams. Founder-led sales motions. Funds building relationship intelligence. Agencies running hybrid outbound and partnership workflows. Businesses that do not fit neatly into the old “leads, contacts, accounts, opportunities, now good luck” worldview.

In that sense, Attio’s 4% is doing more work than it seems.

Because this is not a “we won the whole market” number. It is a “we became the obvious answer for a specific kind of high-agency buyer” number.

And in software, that is often how the real category shift begins.

There is another data point that makes this story even better, or worse, depending on whether you enjoy nuance ruining a clean narrative: Attio is not yet dominating first-time CRM adoption or competitor displacement. Ramp’s category data shows Salesforce captures 65% of first-time adopters in CRM, HubSpot 21%, Zoho 11%, with both Pipedrive and Attio at 3%. On switching, Salesforce also leads at 42%, HubSpot follows at 37%, Zoho sits at 10%, Attio at 5%, and Pipedrive at 4%.

This matters because it suggests Attio’s momentum is not simply “everyone is ripping out their old CRM and moving.” At least not yet. The numbers imply something more subtle.

Attio is growing fast, but it is still a challenger operating from the edge rather than the center. It is not yet the default procurement answer. It is not yet the mass-market first choice for every new buyer. And it is not yet the main recipient of large-scale competitive switching in the way Salesforce still is.

Paradoxically, that makes the growth more interesting.

Because it suggests the product is not winning through inertia. It is winning through fit.

People are not buying it because their board told them to.
They are buying it because the thing actually makes sense for the motion they are building.

And if you have spent enough time around CRM decisions, you know how rare that is.

Most CRM purchases are not moments of clarity. They are moments of compromise.

Someone wants flexibility.
Someone wants reporting.
Someone wants familiarity.
Someone wants speed.
Someone wants “something the sales team will actually use.”
And somehow the final answer ends up being a compromise between procurement defensibility and organizational habit.

This is why I keep coming back to the same idea: CRM adoption data is not really about CRM. It is about organizational self-awareness.

Salesforce’s dominance tells you that scale, continuity, ecosystem, and institutional trust still matter enormously.
HubSpot’s size tells you the all-in-one promise still works for a huge slice of the market.
Zoho’s durability tells you value and breadth remain underrated.
Attio’s acceleration tells you a growing segment of companies now wants a CRM designed more like modern software and less like a digitized filing cabinet with a quota attached.

And Pipedrive’s position tells you something else, something slightly uncomfortable if you have built your GTM around a classic sales pipeline: there is a difference between a CRM that helps a sales team operate and a CRM that helps a business think.

That does not mean every company should move to Attio tomorrow morning, ideally after a dramatic internal memo and one inspirational FigJam.

It does mean the old segmentation logic is weakening.

For years, the CRM conversation was framed too simply:
Salesforce for enterprise.
HubSpot for growth teams.
Pipedrive for lean sales teams.
Spreadsheets for the brave, the chaotic, and the seed-stage.

That map is getting outdated.

Now the better segmentation is something like this:
Do you want a CRM that mainly tracks a process, or one that can model your business?
Do you want a tool that works out of the box, or a system that becomes a real advantage once shaped properly?
Do you need familiarity, or leverage?

These are much better questions. They are also the questions modern teams are finally starting to ask before they have 17 workarounds, 4 duplicated databases, and a RevOps lead muttering “we should really clean this up” every Monday.

From where I sit, that is the deeper meaning of the Ramp chart.

Attio being ranked ahead of Pipedrive is not the end of anything. It is the visible tip of a broader shift in buyer preference. A small but meaningful signal that a more flexible, model-driven, automation-friendly kind of CRM is moving from “interesting” to “adopted.”

Not dominant. Not universal. Not inevitable.

Just increasingly hard to ignore.

Which, honestly, is how most real market shifts look before everyone starts pretending they saw them coming.

And yes, I know how this sounds coming from me, Giacomo, founder of an Attio-centric GTM consultancy. Convenient, I agree.

But this is also precisely why I pay attention to data like this. Not because it confirms a bias, but because it helps explain why certain client conversations now happen much earlier, much more often, and with much less resistance than they did even twelve months ago.

The market is telling us something.

Quietly, with procurement data, rounded percentages, and one smug little screenshot.

That is usually how the good shifts begin.

Executive summary

CRMs have historically been sticky for boring reasons: once you centralize customer data, rebuild integrations, train a team, and embed workflows into daily habits, switching becomes painful. Economists call that “switching costs,” and it’s a classic source of durable power in software markets.

Model Context Protocol (MCP) changes the interface economics. MCP standardizes how AI systems connect to external tools and data sources via a consistent protocol (hosts, clients, servers) and turns “talking to software” into structured tool calls.

Once a CRM is agent-operable, your primary user is no longer just a human rep clicking through UI. It is also an agent that can read, write, search, and orchestrate work across systems. That shifts the competitive lens from “best UI + most features” to “best controlled action surface + best data model + best ecosystem routing.”

The catch: agent-operability erodes some switching costs (faster querying, automation, even parts of migration), but it can also create a new type of lock-in: your company’s operating logic becomes encoded in schema design, permissions, audit trails, and agent tool semantics.

In that world, the economic moat of a CRM becomes less about a monolithic suite and more about being the highest-trust “system of relationship record” that agents can safely operate. The center of gravity moves toward modular architectures and marketplaces for “skills,” actions, and integrations.

Thesis

Agent-operable CRMs do not kill moats. They rewrite them.

The CRM moat used to be: UI adoption + data gravity + workflows + ecosystem.

The CRM moat in an MCP world becomes: agent-safe permissions and auditability + schema flexibility + tool surface quality + ecosystem reach across modules and agent skills.

The strategic implication is provocative but practical:

If your CRM cannot be operated safely by agents, it becomes a UI wrapper around your real operating system.

And if your CRM is agent-operable, your real competition shifts. It is not just “Sales vs Marketing suite wars.” It is “who owns the action layer for customer data across the whole stack.”

Where CRM moats came from

Most CRM lock-in is not mystical. It is structural.

Switching costs and knowledge lock-in. Once you’ve trained a team, built role-specific processes, and shaped behavior around “how the CRM works,” you pay switching costs in retraining and operational disruption. Classic work on switching costs shows how these costs soften price competition and strengthen incumbents.

Data lock-in. Customer data is not just rows in a table. It is history: activity timelines, attribution, pipeline stage logic, custom fields, and the “meaning” of your objects. This maps directly to the information economics view of lock-in: data and training are durable sources of switching friction.

Ecosystem and network effects. At scale, CRM behaves like a multi-sided platform: customers on one side, app builders and services partners on the other. Network effects theory explains why: more complementors increase platform value, and more customers attract more complementors.

This is not theoretical. It’s how the category leaders won.

• Salesforce was founded in 1999 and introduced AppExchange in 2005, explicitly creating a third-party marketplace to extend the platform.

• Salesforce positions AppExchange as a core growth engine: a marketplace with “over 9,000 partners,” “13 million installs,” and “over 91% of Salesforce customers using AppExchange.”

• HubSpot was founded in 2006 on inbound marketing, then expanded into a “crafted, not cobbled suite of products” built on an AI-powered Smart CRM, explicitly selling the bundle.

• HubSpot’s Marketplace claims “2,000+ apps” and “2.5M+ active installs,” which is the same ecosystem play, scaled to their customer base.

Pull quote: The old CRM moat was not “a database.” It was an ecosystem wrapped around a process.

So where does MCP fit?

It attacks the interface layer through which ecosystems and switching costs are experienced.

What MCP changes: agent-operability in practice

MCP is not “AI integration” in the vague marketing sense.

MCP is a protocol that standardizes how an LLM application (host) connects through clients to servers that expose resources, prompts, and tools, using JSON-RPC 2.0 over stateful connections with capability negotiation.

It explicitly foregrounds “Security and Trust & Safety” principles like user consent, data privacy, and tool safety.

That’s the protocol layer.

Agent-operability is the product layer: what happens when a CRM decides to become a first-class MCP server, not just a REST API with a chat widget taped on top.

On February 19, 2026, Attio shipped a hosted MCP server (“search, query, and act on your Attio data, from any MCP client”). This is a clean focal case because Attio’s own documentation is unusually explicit about the design goals and trust model:

• OAuth authentication tied to the user account (no API keys), with sessions revocable.

• Read operations auto-approved; write operations require user confirmation.

• Operations logged and auditable, constrained to workspace permissions.

• A tool surface that includes search across records and semantic search across notes and call recordings, plus creation and updates of tasks and records.

Attio’s engineering write-up adds a key technical-economic insight:

An MCP server cannot be designed like a public API, because context windows and token costs force different primitives. They argue “fewer, richer tools” outperform many atomic ones, and they optimized output formats to reduce token overhead.

That matters economically because agent throughput is a cost function: more tool calls means more latency, more token burn, and more failure points.

Here’s the simplest mental model:

This flow is consistent with MCP’s host-client-server architecture and the protocol’s intent to expose tools and build composable workflows.

Pull quote: In an MCP world, “the UI” is a host. The moat is the tool surface behind it.

Important nuance: agent-operability is converging across incumbents.

• Anthropic introduced MCP as an open standard in November 2024.

• MCP was donated to the Linux Foundation’s Agentic AI Foundation in December 2025 to keep it neutral and community-driven, with founding participation from OpenAI and Block.

• Salesforce’s Agentforce 3 explicitly shipped “built-in support for open standards like Model Context Protocol (MCP)” and framed it as interoperability for agents.

• HubSpot opened a remote MCP server in public beta on May 6, 2025 and describes MCP as an abstraction layer over APIs for AI clients.

So the question is not “will MCP exist?” It already does.

The question is “what becomes scarce, valuable, and defensible once MCP makes tool connectivity cheap?”

The economics: moats, switching costs, network effects, modular stacks

If you strip the hype, agent-operable CRM economics comes down to four moving parts: switching costs, network effects, modular architectures, and governance.

Switching costs shift from UI friction to schema friction. You used to pay switching costs in clicks and human time. MCP reduces that. Agents can fetch context, draft updates, and execute routine tasks. Attio explicitly sells “natural language CRM management” and “full workspace access” via MCP.

But switching costs don’t disappear. They relocate:

• From “how to use the UI” to “how your data model encodes your business.”

• From “workflow building” to “tool semantics, permissions, and auditability.”

• From “manual reporting” to “agent reliability and governance.”

That aligns with switching cost theory: durable customer retention often comes from accumulated, firm-specific investments. Under MCP, those investments increasingly live in schema and governance rather than UI muscle memory.

Network effects evolve from app marketplaces to action marketplaces. Platform economics research shows multi-sided marketplaces win by aligning incentives across sides. Enterprise software marketplaces are a known pattern, including CRM ecosystems like AppExchange.

The agent twist is that the “complement” is no longer just an app. It is also:

• a tool bundle,

• a skill template,

• an agent action,

• a governance-approved connector,

• a reusable workflow that can operate across the stack.

Salesforce’s AgentExchange is the clearest incumbent signal: a marketplace for agents built to work with its “digital labor platform,” explicitly extending the old AppExchange logic into agentic AI.

HubSpot is making a parallel move from the other direction: it built a remote MCP server to power a Deep Research Connector for ChatGPT, aiming to democratize agent access across “250,000+ businesses,” and built an auth-app layer to manage OAuth credentials for remote MCP connections.

Modular architectures become more viable because orchestration is cheaper. In platform terms, making integrations composable lowers coordination cost across components and accelerates best-of-breed architectures. MCP explicitly frames “composable integrations and workflows” as a core goal.

This is where Attio’s positioning is interesting: it describes core primitives like objects, records, attributes, and lists in database terms (tables, rows, columns), and emphasizes custom objects and relational modeling. That is structurally compatible with modular stacks because the CRM becomes a flexible graph of relationships that other tools can read and write via APIs and MCP.

Governance becomes the new product surface. MCP’s own spec warns that tool invocation creates “arbitrary data access and code execution paths” and requires explicit user consent and control. Security research and enterprise commentary points to risks like the “confused deputy” problem, supply chain risks, and prompt injection, with mitigations like strong auth, least privilege, version pinning, and confirmation for sensitive actions.

That makes “permissioning quality” and “auditability” real economic value: if agents can act, safety is not optional. Attio’s MCP design explicitly builds confirmation gates for writes and a logged, auditable model.

Comparative feature and economics table

The platform-specific claims above are grounded in each vendor’s own MCP/agent announcements and ecosystem disclosures.

Evidence: migrations and market comparisons

Economics without examples is just vibes. The best public evidence here is migration velocity and the degree to which MCP changes the “labor content” of CRM change.

Migration examples with documented sources

Flatfile: moved from Salesforce to Attio within a month. Attio’s customer story claims Flatfile moved their entire CRM “within a month,” motivated by rigidity in legacy structure and enabled by a flexible data model, automation, and custom objects. Treat this as vendor-published, but it’s still a real, named migration with an explicit timeline.

Snackpass: switched off Salesforce, built custom objects and automated workflows. Attio’s Snackpass story emphasizes “custom objects” plus automated workflows to unify GTM operations and reduce silos, including syncing revenue/volume data and integrating marketing data into lists.

Jellysmack: end-to-end migration in four weeks (Novlini case study). A Novlini case study (non-independent, but documented) describes a four-week migration from Salesforce to Attio including pipelines, fields, workflows, and access controls, with a modular stack design.

Pull quote: The point is not that migrations are “easy.” The point is that time-to-switch is becoming a strategic variable.

What migration friction still looks like in the real world

Attio’s migration documentation is refreshingly candid about limitations, and those details matter economically because they translate directly into labor hours.

• Import2 supports migrating Contacts, Accounts, Leads, Opportunities from Salesforce, but not Cases.

• CSV imports do not support importing notes (with a workaround: migrate records via CSV and notes via Import2).

• Import2 “will create new records” but “will not update attribute values” on records already created in Attio, requiring operational sequencing (including disabling mailbox sync and deleting records) if you want a clean overwrite.

That is exactly what switching-cost theory predicts: it’s not just exporting data, it’s reconstructing meaning, sequencing dependencies, and protecting continuity.

Migration cost model table

Assumptions: public, comparable migration cost datasets are scarce; the model below is an explicit decomposition, not a claim about any single vendor’s bill. Where vendor-provided “reduced cost” mechanisms exist (like Import2 being free for Attio users, or MCP-enabled automation), they affect specific components rather than eliminating the whole.

This decomposition aligns with how MCP is described (tool calls, trust principles) and with real migration constraints disclosed in platform documentation.

A timeline view: why this is happening now

The “now” matters. MCP moved from announcement to governance to vendor adoption fast.

This timeline is based on vendor histories and official changelogs/announcements.

The common pattern: ecosystems first (apps), then standardization of agent connectivity (MCP), then a race to own the action layer safely.

Risks, counterarguments, and practical recommendations

Agent-operable CRMs are not automatically better. They are higher-leverage, which means higher risk if misused.

Risks and counterarguments

Security risk is real, not theoretical. MCP’s spec explicitly warns that data access and tool invocation create powerful (and dangerous) execution paths, requiring explicit user consent, control, and tool safety practices.

Enterprise security perspectives highlight risks including confused deputy (authorization mistakes that let users access more than intended), supply chain risk (MCP servers are executable code), prompt injection, and tool injection, with mitigations like least privilege, version pinning, and user confirmation for actions.

Attio’s own MCP design choices (auto-approved reads, confirmation for writes, auditable operations) are a direct response to these risk classes.

Agents can become a new lock-in. If your GTM operating logic becomes encoded in agent prompts, tool flows, and schema-specific semantics, migration can become harder, not easier. This is still switching cost, just in a new form.

Incumbents aren’t asleep. Salesforce and HubSpot have already moved: Salesforce bakes MCP into Agentforce interoperability; HubSpot ships both remote MCP for CRM data and local MCP for developer workflows, plus a connector management layer.

So “MCP support” will not be a moat by itself. It’s table stakes.

The real question becomes control and economics. Who can offer agent throughput without chaos? Who can offer openness without breaking governance? MCP makes the transport standard; it doesn’t make your data clean or your org disciplined.

Practical recommendations for founders

Treat the CRM as infrastructure, not a tool.

1. Design your schema like a product API. Favor explicit objects, stable identifiers, and relationship modeling that reflects your domain. Attio’s own conceptual model (objects/records/attributes/lists) is a good mental template for “CRM as system of record.”

2. Invest early in permissioning and audit. If you want agents to act, you need least privilege, approvals, and logs. MCP guidance and vendor implementations point the same way.

3. Prefer modular stacks where the CRM is the memory layer and specialized tools do specialized work. MCP explicitly targets composable integrations; enterprise software marketplaces show why ecosystems win.

Practical recommendations for RevOps

Pull quote: Your job title is trending toward “GTM systems architect.”

1. Define “agent-grade data quality” metrics. If agents will act, you need stronger standards for required fields, stage definitions, and identity resolution. This is the real operational moat.

2. Don’t automate what you can’t audit. Start with read-only use cases (research, summarization, health checks), then gated writes (tasks, notes), then higher-risk actions. This mirrors MCP safety principles and the read/write approval patterns vendors use.

3. Make migration a capability, not a project. Document mappings, keep a canonical schema dictionary, and maintain integration diagrams. Migration becomes easier when meaning is explicit. Attio’s migration docs illustrate why sequencing and constraints matter in practice.

Practical recommendations for VCs

Underwrite agent-operability like you underwrite developer experience.

1. Ask: “Can this CRM be safely operated by agents?” Not “does it have AI features.” Look for concrete mechanisms: OAuth, granular scopes, approval flows, auditing, and tool semantics.

2. Watch for marketplace power shifting. App marketplaces were the old network effect. Agent marketplaces and connector registries are the next one. Salesforce’s AgentExchange and HubSpot’s connector strategy are explicit signals.

3. Be skeptical of “suite bundling” as the only moat. MCP lowers integration friction, which makes best-of-breed more plausible, especially for technical startups. The economic value shifts toward the cleanest system of record and the safest action surface.

Three-year outlook

By early 2029, “agent-operable” will be as expected as “has an API.”

MCP’s governance path supports this: it moved to a neutral foundation under the Linux Foundation’s AAIF (December 2025), with major AI labs supporting open, interoperable infrastructure.

Vendors are already racing to productize the action layer:

• Salesforce positions MCP support as interoperability for scaling agents at enterprise governance levels.

• HubSpot is building both remote and local MCP servers and investing in connector lifecycle tooling for broader adoption.

• Attio is explicitly shipping a hosted MCP server and describing agent-driven workflows as a first-class developer platform surface.

So what’s the real bet?

The winners will be CRMs that become high-trust, composable operating memory. Not because they have more features, but because they let agents act with the right constraints, in the right data model, with the lowest marginal cost of orchestration.

Three predictions, stated cleanly:

First, “workflow” will split into two layers. Deterministic automations remain for compliance-critical operations. Agentic execution dominates messy, high-context tasks (research, routing, follow-ups, CRM hygiene), because MCP makes tool access cheap and standardized.

Second, marketplaces will re-price. The scarce asset will be not just an app listing, but a trusted action bundle that can be invoked by agents inside governance boundaries. AgentExchange is an early form factor.

Third, migration velocity becomes strategic. If agents can reduce the labor content of switching (mapping, reconciliation, reporting rebuild), the CRM competitive landscape opens, at least for startups and mid-market. But schema lock-in becomes the new gravity, so the cost of getting your data model wrong rises.

The CRM war is shifting from “who has the best UI?” to “who owns the safest action layer over customer reality?”

For most of its existence, the CRM category has been solving the same underlying problem while describing it in different language. Vendors spoke about pipeline visibility, forecasting accuracy, and productivity gains, yet the real objective was always more fundamental: organizations needed a shared memory, and humans were unreliable storage devices.

So software was built to discipline recollection.

Stages existed because narratives drift over time. Required fields existed because context disappears under pressure. Forecasting existed because leadership could not rely on individual interpretation. The CRM was therefore not primarily a system for selling, but a system for forcing the organization to describe itself in a structured way.

Every improvement in the last twenty years made this discipline less painful but never changed its nature. Interfaces became cleaner, workflows became configurable, automation reduced manual effort, and analytics attempted to reconstruct meaning after the fact. Yet the contract remained intact: the company only knew what employees remembered to record, and the software merely preserved those fragments.

Humans maintained the organizational brain.

The release of Attio MCP marks a departure from that contract, not because it inserts artificial intelligence into the CRM interface, but because it allows intelligence to operate the CRM directly. The distinction appears subtle, but it changes the nature of the system itself.

The interface was never the real product

Most software categories evolve by improving interaction first. The early CRM stored records. The next generation automated workflows. Then came analytics dashboards, and eventually AI assistants capable of summarizing conversations or recommending next steps. Each iteration reduced friction while preserving the assumption that a user remained the primary operator of the system.

This assumption explains why many recent “AI CRM” features felt impressive during demonstrations yet inconclusive in practice. The model could observe data and interpret patterns, but it still relied on humans to maintain the underlying reality. Intelligence commented on the system rather than participating in it.

Observation does not remove responsibility.

The limitation, therefore, was not model capability but architectural placement. Intelligence embedded inside the interface remains downstream of human action. Intelligence connected to the system state becomes part of the action itself.

What Model Context Protocol actually introduces

The Model Context Protocol represents a standardized way for reasoning systems to securely access and modify structured software environments. Rather than interacting through screens designed for humans, an agent interacts with the data model directly through permissioned operations.

Historically, the flow of work looked like this:

Human → interface → database

With agent-operable systems, the direction changes:

Human intent → agent reasoning → system state

The CRM ceases to be a location where activities are documented after completion. It becomes an environment where activities are executed as they unfold. An agent can search accounts, update relationships, create follow-ups, and maintain continuity of context without waiting for manual intervention. The system transitions from retrospective record to operational memory.

From record keeping to operational memory

Traditional CRM data describes events that have already happened. An agent-operable CRM maintains a continuously evolving model of reality.

Every interaction contributes to that model. Meetings alter deal confidence. Emails reshape relationship strength. Behavioral signals modify expansion probability. The pipeline stops functioning as a reporting artifact and instead becomes a probabilistic representation of the company’s commercial state.

The organization no longer narrates reality to the software. The software maintains a representation that the organization can reason over.

At that point, the CRM resembles infrastructure more than application software, because other processes begin to depend on its state rather than merely referencing it.

Why earlier AI approaches plateaued

Most AI implementations inside CRM products attempted to compensate for weak structure. They summarized ambiguous notes, predicted outcomes from inconsistent fields, and recommended actions without stable semantic grounding. The results appeared intelligent but rarely decisive because the model was inferring clarity rather than relying on it.

Humans routinely compensate for imperfect systems through tacit knowledge and informal conventions. Machine reasoning cannot rely on those mechanisms. It requires explicit relationships and consistent meaning across time.

This is why many organizations improved models instead of improving systems. MCP reverses that effort. The objective becomes making the system intelligible to intelligence, not making intelligence tolerant of ambiguity.

The CRM therefore moves from “AI-powered interface” to “AI-operable environment.”

The emergence of the operational graph

Businesses do not actually operate through pipelines; they operate through evolving relationships between entities. Champions change roles, accounts fragment, influence accumulates across multiple channels, and risk emerges gradually rather than discretely.

Human-operated systems compress this complexity into stages for cognitive simplicity. Agents do not require such simplification. When reasoning systems continuously interact with structured relationships, the fidelity of the underlying model becomes the competitive layer.

The question shifts from usability to coherence.

Which system most accurately preserves the relationships that define the business over time?

That system becomes the substrate for decision-making.

The economic inversion

Once agents operate the CRM directly, data entry ceases to be labor and becomes exhaust. Information is generated as a consequence of activity rather than as a prerequisite for reporting. Forecasting evolves from manual estimation into continuous inference because the system’s state already reflects accumulated evidence.

Operational processes begin to depend on the CRM’s representation of reality. This dependency creates defensibility not through user preference but through structural reliance. Organizations cannot easily reason outside the environment that maintains their operational memory.

This mirrors the transformation payment processors underwent when other financial systems began to rely on their ledgers. The value moved from interface convenience to infrastructural authority.

Organizational implications

Three practical consequences follow from this shift.

First, revenue operations transitions from workflow configuration to systems design. The challenge becomes modeling the business precisely enough that automated reasoning produces reliable outcomes.

Second, playbooks evolve into datasets. Rather than prescribing human behavior, companies curate the signals agents use to interpret context.

Third, tool categories converge toward memory ownership. Sales, support, and marketing systems increasingly orbit the platform that maintains the most coherent representation of the company’s relationships.

Agents act where context is stable.

After the interface

Every major software transition removes a layer once considered essential. Cloud computing removed server management. APIs removed manual integration. Agent-operable systems begin removing interaction itself.

People will still open CRMs, just as engineers still open terminals, but they will no longer be the primary operators. The CRM used to be the place work was recorded after completion. It is becoming the place where work unfolds because the system maintains enough understanding to act.

When that happens, the defining property of the product changes. Ease of navigation matters less than clarity of representation. The interface stops determining value; the structure does.

When software becomes thinkable by machines, it ceases to be merely a tool.

It becomes infrastructure.

The Context: From CRM Clutter to Instant Clarity

Every GTM leader and RevOps pro knows the struggle: important context is scattered across emails, call notes, and records. Before a big meeting, you’re frantically clicking through tabs, digging for that one critical detail. Sales reps waste hours hunting for context, customer success rebuilds account history from scratch, and executives end up making decisions with incomplete data . It’s not for lack of data – it’s that our tools haven’t made sense of it for us.

Attio’s latest release Ask Attio aims to change that. Launched this week, Ask Attio is an AI-powered conversational interface that lets you search, update, and create across your entire CRM just by asking . In plain English: you talk to your CRM, and it understands your business. This isn’t another gimmicky chatbot bolted onto a legacy system – it’s built on Attio’s core Universal Context engine. That means every customer email, call transcript, note, and even product usage signal in Attio is semantically indexed as one connected whole . The upshot for RevOps and GTM teams is immediate, unified answers instead of manual data sleuthing.

We’ve seen plenty of AI assistants hyped by the big CRM players, but those often amount to flashy demos that fizzle out when faced with real-world CRM messiness. (Salesforce’s “Einstein” or HubSpot’s chat helpers might answer simple questions, but ask them to navigate your custom fields and tangled timeline, and they hit a wall.) Attio’s approach is different because it tackled the data unification problem first. With Universal Context knitting every interaction together, Ask Attio can truly grasp the story in your CRM, not just keywords. It deeply understands your entire business context, giving you what you need the moment you ask . This feels like a meaningful shift: instead of you adapting to the CRM, the CRM adapts to you.

Why Ask Attio Is a Big Deal for RevOps

In practical terms, Ask Attio turns your CRM into a proactive partner. You’re no longer confined to dashboards and forms; you have a conversational AI that can retrieve insight or perform actions on command. Here’s why this release matters:

• Universal Context = No More Siloed Info. Ask Attio is powered by Universal Context, Attio’s unified intelligence layer that treats all your data as one interconnected knowledge graph . It preserves links between signals – so that an email thread about pricing, a dip in product usage, and a new stakeholder joining all connect. This is huge for GTM teams. Seeing those connections instantly is what separates good teams from great ones. Now you can simply ask, “What’s the story with Account X?” and get the full picture in seconds – including that the VP raised a budget concern last month, their usage dropped two weeks ago, and a new CFO came onboard last quarter . That kind of holistic insight used to require painstaking manual research (or more often, never happened at all).

• Truly Conversational Updates and Queries. Unlike basic chatbots that only spit out answers, Ask Attio can take action. Because it understands context, you can describe an update or task in natural language and it will execute it (with your approval). Need to log a meeting outcome? Just tell Attio what happened, and it will update the deal stage, set the next step, add the meeting notes, and even assign follow-up tasks for you . Want to add a new contact you met? Say the word, and their details are created in the CRM. This turns data entry and CRM upkeep – traditionally RevOps pain points – into something that happens in the flow of conversation. Your CRM starts to maintain itself, so your team can focus on selling and strategizing.

• “Always-on” GTM Intelligence. Because Ask Attio can pull from all your connected data, it’s like having an analyst on call 24/7. GTM leaders can ask high-level questions that would’ve taken an ops team days to answer. “Which deals are at risk this quarter and why?” “What do our win rates look like for deals over $50k?” “Which customers mentioned Feature X in the last month?” – instead of running reports, you get answers on demand, grounded in real data. One Attio customer, Plain, uses Ask Attio to quickly answer questions about win rates, pipeline health, and the overall state of play in their business . Another team, Wordsmith, reports that their leadership can now get immediate answers about competitive deals and pipeline trends, accelerating strategic decisions . In short, data-driven decision making becomes a natural part of the day-to-day, not a special project.

• Built for the Real World (Trust and Control). A critical point for RevOps: Ask Attio was designed with enterprise guardrails. Every answer it gives is backed by actual records and notes – real information, not AI invention . The AI won’t hallucinate some non-existent deal; it’s constrained to your truth. It also respects user permissions by design, so a sales rep will only get insights from data they have access to . That alleviates the risk of sensitive info inadvertently surfacing. And when it comes to taking action, Attio’s philosophy is “AI suggestions, human decisions.” The AI might propose updates or draft an email, but you always get the final say – nothing is changed unless you click “Accept” . This transparent, controlled approach is exactly what RevOps teams need to trust an AI agent in their workflow (and it’s something many other AI-for-CRM tools have overlooked).

Ask Attio in Action: Everyday Use Cases

So what does Ask Attio actually do for your team on a daily basis? Here are some real examples of how GTM teams are using it to streamline work:

• Lightning-Fast Meeting Prep: Instead of combing through CRM records and past emails before a call, reps can just ask Attio to “Prep for my next meeting.” Within moments, they get a comprehensive brief: who the participants are (with roles and recent interactions), the full account history (notes from previous calls, emails, support tickets), product usage trends, even any open deals or support issues – all summarized in plain language. Sales teams have literally cut pre-meeting research down to seconds. One user, Ian Ahuja (Head of Sales at Lightdash), says “Before every meeting, Ask Attio centralizes, summarizes and surfaces everything I need to know to give a great first impression or close the deal.” His team reports that what used to take 30 minutes of prep now takes 30 seconds. In fact, Lightdash is prepping for meetings 10× faster by letting Ask Attio gather context across product usage data, customer history, and even browser research – instead of reps doing it all manually .

• Hands-Free Post-Meeting Follow-Up: After a sales call or customer meeting, the real work often begins – updating the CRM and sending follow-ups. Ask Attio takes on much of this grunt work. Simply prompt “Recap last call”, and it will generate a structured call recap and log it in the record (leveraging call transcripts if available). It can then update the opportunity status, next steps, and any fields that changed (for example, if the prospect mentioned a new timeline or a role change, those details get captured) . Finally, it can draft a personalized follow-up email to the client, summarizing key points and proposing next actions – ready for the AE to review and send . All of this happens in one conversational flow. No more forgetting to log notes or letting tasks slip through: Ask Attio ensures nothing falls through the cracks. Early users love this. The team at Marketer, for instance, now uses Ask Attio to draft context-rich follow-up emails right after calls, instead of bouncing between call recordings, an AI writing tool (like Claude), and their email client . It’s one stop and done. Reps stay in the zone, and data gets updated as a byproduct of talking to the assistant.

• Contextual Record Updates on Command: Perhaps one of the most game-changing aspects for RevOps is how updating CRM data becomes as easy as asking. Let’s say you just learned on a call that your deal’s champion got promoted to Head of IT, and the client company also raised a new funding round. Normally, you’d have to navigate to the contact, update their title, find the account, update a funding field, etc. With Ask Attio, you can literally say: “Update this deal – change the champion’s role to Head of IT and note that the account raised $120M.” The AI understands and will propose those exact field updates right in the chat: e.g. “Update Drew Houston’s role to Head of IT?” (Accept) and “Update Greenleaf’s funding to $100M–$250M range?” (Accept) . You confirm, and it’s done. This level of context-aware editing is something we’ve hoped for in CRM for years. It means your data actually keeps up with reality without heavy lifting. For RevOps, that translates to dramatically higher data hygiene and timeliness – the bane of every ops person’s existence. As one beta user put it, Ask Attio turns a two-hour CRM admin slog into a two-minute chat.

• On-Demand Insight and Analysis: Ask Attio isn’t just automating workflow – it’s also augmenting your decision-making. GTM executives and RevOps leads can use it like an analytical advisor. You might ask, “Which customers have mentioned pricing pain in the last month?”, or “Show me all deals in Q1 where no next step is set,” or even “What should I know today?” and get meaningful answers. Because it draws on all your customer signals, the answers are often things you wouldn’t catch in a standard report. For example, Ask Attio can identify a pattern where users who raised a certain feature request also have low adoption, flagging a churn risk cluster. Or it can instantly pull up a list of accounts that fit a certain profile (say, who would benefit from a new feature launch) by understanding context from notes and usage, not just checking a box in a field . Teams are already leveraging this for proactive moves: Listen Labs, as an early adopter, uses Ask Attio to turn their trove of customer call transcripts into messaging insights – essentially asking the AI what resonates across different segments and getting a distilled answer . Similarly, Plain’s team can get quick reads on pipeline health or win rates without waiting for a weekly report . This kind of accessibility to insight means faster, better decisions at every level, from front-line managers adjusting strategy mid-quarter to CEOs prepping for board meetings with real-time metrics.

(Even Customer Success and onboarding teams are benefiting – using Ask Attio to generate instant account onboarding briefs or transition notes. A CSM taking over an account can ask, “What’s the history here?” and get a concise narrative of all interactions to date, plus product usage trends and any open issues. That kind of head start is invaluable for driving customer growth from day one . In founder-led sales scenarios, founders love Ask Attio because it connects what prospects say with how they use the product and where they get stuck – revealing not just what customers want, but why . In short, every go-to-market function finds something to love here.)

Early Results: Real Teams, Real Impact

Attio’s beta users have already reported impressive gains from Ask Attio. Some highlights from the launch:

• Wispr Flow – Responds to customers faster and more confidently, now that all relevant notes and action items are surfaced together when they need them .

• Lightdash – Preps for sales meetings 10× faster by letting Ask Attio pull product usage stats, past conversations, and key context in one go (no more digging through dashboards and Gmail threads separately).

• Marketer – Writes better follow-up emails in a fraction of the time. Their team uses Ask Attio to draft contextual emails directly from CRM data, instead of juggling call recordings, a writing AI, and an email client .

• Listen Labs – Turns aggregated customer call data into actionable messaging insights. By asking Attio to find what resonates across features, accounts, and deal stages, they extract themes that inform marketing and product messaging .

• Plain – Stays super agile in an evolving go-to-market motion by querying Attio for on-the-fly answers about win rates, pipeline health, and other vital stats . They no longer wait for a data analyst to run a report – the answers are immediate, so they can adjust tactics quickly.

• Wordsmith – Gives its leadership team instant visibility into the business. Ask Attio provides immediate answers to questions on competitive deals or pipeline status, accelerating their strategic decision-making . Essentially, meetings that used to require “I’ll get back to you on that” now get answers in the room.

It’s early days, but these examples show the potential: major time savings, smoother handoffs, and smarter decisions. When a Head of Sales says this tool surfaces “everything I need to know to close the deal,” you pay attention. When a team claims 10× faster prep or stops using three different apps to piece together an email, it’s not hype – it’s actual workflow change.

Strategic Perspective: How GTM Teams Should Leverage Ask Attio

From a RevOps leader’s standpoint, Ask Attio’s release signals a new expectation for CRM software. Your CRM shouldn’t just be a database of record; it should be a partner in action. Here’s how this shift changes workflows and what you should consider:

1. Embrace the “AI Co-pilot” Mindset: Your team can now interact with CRM data more naturally, which means processes can be redesigned around conversation rather than clicks. For example, instead of a sales playbook that says “research the account via XYZ sources,” you might institutionalize “ask Attio for an account brief” as the first step. Reps stay in flow, and nothing important is missed . Leaders should encourage their teams to use these features habitually – the more you ask, the more value you get. It’s a bit of a culture shift: moving from “Did you update the CRM and check the notes?” to “Did you ask Attio to catch you up?”.

2. Prioritize Data Foundations (Garbage In, Garbage Out): While Ask Attio can work wonders, it’s not a magic wand for bad data. In fact, it will shine a bright light on gaps or inconsistencies in your CRM. If your pipeline stages are a mess or half your calls aren’t logged, the AI can only do so much. In my experience, an AI agent will not save a broken GTM – it will make it fail faster . Use this launch as an impetus to audit your CRM schema and data hygiene. Clean up your fields, ensure your email and call syncs are working, and define clear ownership of data. Attio’s architecture gives you a solid flexible base (custom objects, fast API, etc.), but you need to have that base organized. The good news is, once you do, Ask Attio will help maintain it – it’s far more enticing for reps to simply chat and let the AI log the call and next steps than to painstakingly fill out forms. But you must lock in those minimal processes first.

3. Start Tactical, Then Scale: Don’t try to “boil the ocean” on day one with AI. A tactical rollout will yield the best results. Pick one or two high-impact workflows to start – say, meeting prep and post-meeting follow-up. Enable Ask Attio for a small team and set clear guidelines: for example, “The AI can auto-create tasks and update fields X, Y, Z, but reps should review all changes.” Monitor adoption and impact. Track metrics like the percentage of opportunities with next steps logged, or the average time between a meeting and when the CRM is updated . If you see improvement (which I suspect you will), then expand to more teams and use cases. If not, gather feedback, adjust prompts or data mappings, and iterate. Essentially, treat Ask Attio like a new team member – onboard it with a focused role and measure its performance.

4. Leverage the Prompt Library and Best Practices: One clever feature of Ask Attio is the Prompt Library – a collection of pre-built prompts and workflows for common tasks (e.g. “Daily brief”, “Objection handling”, “QBR prep”) . RevOps leaders should take advantage of this. Curate a set of prompts that match your go-to-market motions and share them with the team. You can even customize prompts to your jargon or process (for instance, a prompt for “Prep for renewal call” that not only pulls past notes but also usage and support tickets specific to your SaaS metrics). This turns best practices into standard practice across the org. The idea is that your top performer’s habits (say, always researching a prospect’s recent funding before a call) can be templatized so everyone gets that benefit automatically. It’s a new kind of enablement – less training slides, more AI-assisted workflows baked right into the tool.

5. Maintain Human Oversight and Continuous Improvement: Even as Ask Attio automates work, keep a human in the loop for quality control. Encourage reps and managers to treat the AI’s output critically – verify important answers, double-check suggested updates – especially early on. Build trust in the system by instituting something like a weekly audit: e.g. every Friday, review a handful of AI-generated notes or changes with the team (we do this at Novlini in our “Friday AI review”) . This practice not only catches any issues (maybe a prompt needs tweaking or a field isn’t being captured right), but it also increases everyone’s confidence in the AI. Over time, as the accuracy proves out, you can dial up automation (perhaps allow certain low-risk updates to auto-apply, etc.). The key is to treat Ask Attio as a junior analyst with superpowers – amazing at speed and aggregation, but guided by your expertise and business judgment.

The Bottom Line: CRM Enters a New Era

Attio’s Ask Attio launch represents more than just a cool new feature – I believe it’s indicative of a broader shift in CRM and RevOps tooling. We’re moving into an era where real-time context and intelligent assistance are table stakes. The CRM is no longer a passive system of record; it’s becoming an active participant in your revenue engine. For GTM executives, this means higher team productivity and better decision-making with less guesswork. For RevOps, it means finally cracking the age-old problems of CRM adoption and data quality, by offloading the drudgery to an AI that actually does what it promises.

Crucially, Ask Attio achieves this without the fluff. It’s not about AI for AI’s sake. It’s about solving the tactical pains – prepping for calls, logging notes, updating fields, finding insights – in a way that keeps your team in flow and your data truthful . When you can ask “What should I know today?” and actually get a useful answer , you realize the CRM can be so much more than a glorified spreadsheet.

From my perspective, this is the kind of advancement that will become standard in the next 1–2 years. We’ll look back on manually trawling through CRM records as antiquated. As with any shift, those who adapt early will have an edge. Teams using Ask Attio (and tools like it) will have more informed reps, tighter execution, and a clearer view of their business. Those that stick to business-as-usual may find themselves outpaced by competitors who are literally getting answers and work done faster.

In sum, Ask Attio is a breath of fresh air in a space that’s long overdue for innovation. It combines the strategic big-picture promise of AI in CRM (universal context, automated intelligence) with very concrete, tactical benefits (shaving hours of busywork every week, keeping pipeline data fresh, delighting customers with timely follow-ups). It’s early, but the results are promising and the vision is sound. As an Attio Expert Partner and someone who has spent countless hours wrestling with CRMs, I’m excited – and admittedly a bit relieved – to see a solution that hits the mark in practice.

No hype needed: if your CRM can tell you exactly what you need to do today and handles the busywork, that is a game-changer. Ask Attio points to a future where our systems actually work for us. And that future has just arrived, starting with the teams savvy enough to ask more from their CRM .

The limits of “AI-powered CRM” as a category

Over the past few years, CRM vendors have converged on a shared belief: adding artificial intelligence to the product would finally unlock the productivity gains the category has promised for decades. The idea was simple. If sales reps forget to update fields, AI will summarize calls. If managers struggle to forecast, AI will predict outcomes. If pipelines are messy, AI will recommend next steps.

From the outside, this looked like progress. From inside GTM systems, the picture is far less convincing.

At novlini, we design and rebuild CRM architectures for startups and scale-ups right after fundraising, when complexity accelerates faster than headcount. Across dozens of environments, the pattern is remarkably consistent. AI features inside CRMs rarely fail loudly. They fail quietly. They produce outputs that are plausible but not decisive, helpful but not trusted, impressive in demos and irrelevant in boardrooms.

This is not because large language models are insufficiently capable. On the contrary, their capabilities are advancing at a pace few expected. The issue lies elsewhere. Most CRMs were never designed to be systems that intelligence could operate on. They were designed as human-facing databases, tolerant of ambiguity, inconsistency, and manual correction.

Embedding AI into such systems treats intelligence as an overlay, when in reality intelligence is only as good as the structure it reasons over. This is why most “AI CRM” initiatives plateau quickly. They try to fix downstream symptoms while leaving upstream architecture untouched.

Why AI struggles inside legacy CRM architectures

Traditional CRMs evolved in an era where the primary challenge was data capture, not data reasoning. Their internal models reflect this. Objects are often overloaded. Fields drift in meaning over time. State changes are enforced socially rather than structurally. Critical context lives outside the system in emails, Slack threads, or unstructured notes.

Humans compensate for this constantly. Sales reps remember what a half-filled field really means. RevOps teams maintain parallel spreadsheets to correct reporting. Leadership teams add verbal disclaimers to every dashboard review.

AI cannot do this.

Large language models require explicit semantics, stable relationships, and clear ownership of truth. When asked to reason over ambiguous systems, they do exactly what they are designed to do: infer. The result is output that sounds confident but lacks grounding. This is why AI summaries, risk scores, or recommendations inside many CRMs feel generic or misaligned. The model is not wrong; the system it observes is incoherent.

This mirrors a broader pattern identified in analytics and decision systems. McKinsey has repeatedly highlighted decision latency as one of the biggest hidden costs in modern organizations, particularly in growth-stage companies, where fragmented systems slow alignment and execution (McKinsey – The Decision-Driven Organization). AI layered on top of fragmented data does not reduce this latency. It often increases it by adding another interpretive layer teams must second-guess.

The architectural inversion introduced by Attio MCP

Attio MCP — Quick Fact Sheet

Attio MCP (Model Context Protocol) is Attio’s official MCP server that lets AI assistants securely interact with an Attio CRM workspace using natural language.

Instead of calling raw APIs, the AI uses structured tools with clear schemas, permissions, and confirmations. Attio becomes a reliable, AI-operated system of record.

Attio operates the MCP server.

---

Why it matters

• OAuth authentication. No API keys.

• AI acts as the authenticated Attio user.

• Read actions are auto-approved.

• Write actions require explicit confirmation.

• No hallucinated fields. Fully auditable.

---

What you can do

• Search and update companies, people, deals

• Create and search notes

• Manage tasks

• Search meetings, calls, emails, transcripts

• Query the workspace and user identity

---

How to use it

MCP endpoint

https://mcp.attio.com/mcp

Connect it as a custom MCP connector in ChatGPT, Claude, Cursor, or any MCP-compatible client, then authenticate via Attio OAuth.

---

Example prompts

• “Who am I in Attio?”

• “Find all contacts at Stripe”

• “What was our last interaction with Linear?”

• “Create a follow-up task for next Friday”

---

One-liner

Attio MCP turns Attio into a secure, AI-native CRM backend that can be safely operated by AI agents.

Attio’s Model Context Protocol (MCP) marks a structural break because it does not attempt to make the CRM intelligent. Instead, it makes the CRM intelligible to intelligence.

This distinction is subtle but decisive.

With MCP, Attio exposes its data model and actions through a standardized interface that external LLMs can read from and write to, under strict permissioning. Intelligence lives outside the CRM. You choose the model. You choose the orchestration layer. You decide what agents can do, observe, or modify.

Attio’s role becomes that of a system of record designed for reasoning, not a UI trying to simulate it.

This aligns the CRM with how modern software systems are built. We no longer embed databases into applications; we expose them through APIs. We no longer hardcode logic into monoliths; we orchestrate services. MCP applies the same logic to intelligence. The CRM becomes infrastructure, not interface.

Anthropic, which introduced MCP as an open standard, has described it as a way to make tools and data “legible” to AI systems, rather than forcing bespoke integrations for every model and platform (Anthropic – Introducing the Model Context Protocol). Attio’s adoption of this standard places it in a fundamentally different category from CRMs that treat AI as a feature set rather than an architectural concern.

Why this matters specifically after fundraising

Post-raise, organizations experience a predictable shift. Processes that were previously informal become bottlenecks. Tribal knowledge stops scaling. The CRM is suddenly expected to answer questions it was never designed to support: which accounts actually matter, where risk is accumulating, which motions are working, and where execution is leaking.

This is the moment when many teams discover that their CRM is not a source of truth but a partial reflection of reality. The real system lives across tools, people, and undocumented workflows.

Andrew Chen has written extensively about why systems outperform tools as organizations scale, because they reduce coordination costs rather than optimizing individual actions (Andrew Chen – Why Systems Beat Tools). CRMs designed as configurable tools struggle here. CRMs designed as adaptable systems begin to matter.

By exposing Attio as an operable backend for intelligence, MCP allows post-raise teams to build reasoning capabilities around the CRM rather than inside it. This creates optionality. You can experiment with agents without committing your architecture to a vendor’s AI roadmap. You can evolve intelligence as your GTM motion evolves.

Agent-readiness is a data modeling problem, not an AI problem

There is, however, an uncomfortable truth that MCP makes impossible to ignore. An AI agent is only as effective as the structure it observes. If your Attio setup is inconsistent, ambiguous, or historically polluted, agents will not fix it. They will surface it.

From the field, this is where most AI ambitions break down.

Agent-ready CRM setups require explicit answers to questions many teams have never formalized: what object truly owns revenue, what constitutes a lifecycle transition versus an activity, which signals are authoritative, and which are derived. If those answers live in people’s heads instead of the schema, no amount of prompting will compensate.

Humans forgive poor modeling because they contextualize. AI does not. It assumes the system means what it says.

This is why AI-first CRM narratives often disappoint. They underestimate how much structure intelligence demands. Tools do not create clarity. Architecture does.

Why most AI–CRM projects will fail

The market is entering a phase where “AI agents” will be announced everywhere in GTM. Most will stall, not because agents are incapable, but because they are deployed on top of systems never designed to be reasoned over.

This is a familiar pattern. In the early days of business intelligence, companies bought dashboards before fixing data pipelines. Trust eroded. Adoption stalled. Spreadsheets returned. AI will follow the same curve unless architecture comes first.

Marc Andreessen has argued that software transitions are driven less by features than by new primitives that unlock different system designs. AI is such a primitive. It does not reward patched systems. It rewards legible ones.

CRMs that evolved as workflow trackers will struggle. CRMs designed as flexible data systems will compound.

What actually changes in AI-operable Attio setups

At novlini, designing Attio systems for AI does not start with agents. It starts with discipline.

We focus on object taxonomy, relationship clarity, lifecycle modeling, ownership semantics, and the separation between raw signals and derived insights. We reduce clever shortcuts and remove ambiguous fields. We optimize for legibility over convenience.

The objective is straightforward: make the CRM understandable to a non-human operator.

Once that foundation exists, agents become genuinely useful. They can reason across accounts, detect anomalies, orchestrate workflows, and surface insights that are grounded in reality rather than inference. Without it, they hallucinate politely and waste time.

This is where expertise matters. MCP lowers the technical barrier, but it raises the architectural bar. Teams that treat CRM design as a strategic capability, rather than an implementation task, will extract disproportionate value.

The CRM as infrastructure, not interface

We are entering a phase where CRMs are no longer products teams “use.” They are systems intelligence operates on.

Attio MCP makes this explicit. It aligns the CRM with modern software architecture and with the operational realities of LLM-driven systems. It shifts value away from embedded features and toward structural soundness.

For founders in post-raise mode, the implication is clear. The question is no longer which CRM has the best AI demo. It is which CRM architecture allows intelligence to compound over time.

This is why Attio matters, and why expertise around its design matters just as much. Architecture, not automation, will determine which GTM systems scale with intelligence and which quietly resist it.

As with every major platform shift, the advantage will accrue to teams that recognize the change early and design accordingly. In this cycle, CRM architecture is not a tooling decision. It is a strategic one.

And in an AI-driven GTM world, structure is destiny.

The most expensive part of your CRM is not the license.

It’s the friction it creates every day.

The work your team does around the system to make it usable.

The context it fails to carry.

The decisions it slows down.

At novlini, we sit inside GTM systems for a living.

We design, audit, and rebuild go-to-market setups for startups, scale-ups, and investment teams across Europe and the US. Today, we’re actively involved in more than 60 GTM systems, with Attio at the core as the CRM.

Different companies. Different stages. Different stacks.

The same pattern keeps coming back.

The CRM looks fine. The business reality lives elsewhere.

Most teams don’t realize their CRM is failing because failure is quiet.

Deals don’t explode.

Reports don’t crash.

Nothing “breaks” outright.

Instead, reality slowly leaks out of the system.

The real conversation is in Slack.

The real objections are in call recordings.

The real deal context lives in Notion docs, inboxes, and people’s heads.

So the CRM becomes a thin projection of reality. A system of record that records too little, too late.

This isn’t anecdotal. Salesforce itself has published that sales reps still spend less than 30% of their time actually selling, with the rest consumed by admin work, internal coordination, and tooling overhead

(Source: Salesforce, State of Sales reports).

When context is fragmented, reps don’t “forget” to update the CRM.

They opt out.

As one RevOps operator put it bluntly:

“Sales teams don’t revolt against bad CRMs.

They just stop using them.”

— paraphrased from multiple RevOps leaders on LinkedIn

The real cost is cognitive, not financial

Most CRM cost discussions focus on price per seat.

That’s the wrong unit.

The real cost is cognitive load.

When answering a simple question like “What’s the status of this account?” requires opening:

• the CRM,

• Slack,

• a doc,

• an email thread,

• maybe a call transcript,

you’re taxing your best people with unnecessary mental work.

This aligns closely with what Andrew Chen describes when he talks about systems vs tools: tools don’t create leverage on their own, systems do. Fragmented tools without a clear system architecture increase coordination costs instead of reducing them

(Andrew Chen, Why systems beat tools).

We see this constantly during CRM audits.

Pipeline reviews turn into debates about data quality.

Forecasts require manual clean-up.

Leadership meetings start with “Can we trust these numbers?”

At that point, the CRM is no longer accelerating decisions.

It’s slowing them down.

McKinsey has repeatedly shown that decision latency is one of the biggest hidden drags on organizational performance, especially in growth-stage companies

(McKinsey, The decision-driven organization).

Manual discipline does not scale

Most CRM failures are blamed on “adoption”.

That’s convenient. And wrong.

If your CRM requires:

• constant reminders,

• manual policing,

• weekly clean-up rituals,

• “please update the CRM” messages,

you’re relying on human discipline to compensate for system design.

That model breaks as soon as you scale.

Ted Gioia often writes about invisible systems that only become noticeable when they fail. CRMs fall squarely into that category. When a system works, nobody notices it. When it doesn’t, everyone feels it

(Ted Gioia, The State of the Culture essays).

In GTM, every missed follow-up, every stale deal stage, every forgotten signal is revenue quietly leaking out.

SalesTech research consistently shows that missed follow-ups and slow response times materially reduce close rates, yet these failures rarely show up in dashboards because they’re process failures, not metric failures

(Source: SalesTechStar, Why sales automation still fails teams).

Why we keep seeing teams move to Attio

This is the point where Attio enters the picture, not as a shiny alternative CRM, but as a fundamentally different approach.

Teams don’t come to Attio because they want another tool.

They come because:

• their existing CRM cannot model reality without heavy customization,

• context lives outside the system,

• automation feels bolted on rather than native,

• the CRM dictates process instead of adapting to it.

Attio’s core design philosophy is closer to a flexible data system than a traditional CRM. Its object model, relationships, and API-first approach allow teams to model how their business actually works, not how a vendor thinks it should work

(Attio product philosophy).

In practice, this means:

• fewer forced fields,

• fewer “fake updates” just to keep the system happy,

• more automation driven by real states instead of manual rules,

• better alignment between how deals move and how data updates.

This matches what modern RevOps thinking advocates: structure first, automation second, AI last. Not the other way around.

The compounding effect of getting it right

When a CRM is designed properly:

• context accumulates instead of scattering,

• workflows reinforce behavior instead of relying on reminders,

• reporting becomes a byproduct of execution, not a separate project.

This is what Lenny often highlights when he writes about systems that “disappear into the workflow” instead of demanding attention

(Lenny Rachitsky, Good systems feel boring).

The payoff isn’t just cleaner data.

It’s:

• faster decisions,

• less internal friction,

• more trust in numbers,

• more time spent actually selling, building, and closing.

A simple test

If you want to know whether your CRM is costing you more than the license, ask yourself:

• Where does the truth live today?

• How much effort does it take to answer basic GTM questions?

• How often do humans compensate for the system?

If the answer involves Slack archaeology, spreadsheet backups, or heroic individual effort, the cost is already there. You’ve just normalized it.

The most expensive part of your CRM is not what you pay for it.

It’s the cost of running your GTM motion around a system that was never designed to carry reality.

Notes from our Novlini × Attio workshop

Earlier this week, and I hosted a workshop with Attio on a deceptively simple topic: how agencies should set up their CRM.

Not which tool to choose.

Not which outbound stack performs best this year.

But how to design a system that still makes sense once sales is no longer the main problem.

What follows is not a recap of slides. It’s the reasoning behind the setup we presented, and the mental model we apply every time we design a GTM system for a service business.

Because most agency CRMs don’t fail because they lack features.

They fail because they encode the wrong idea of how an agency actually works.

Why agency CRMs break so quickly

Most agencies start by copying a SaaS sales setup.

They build a pipeline, define stages, and push their team to keep deals clean. For a while, everything looks fine. Forecasts exist. Dashboards get filled. Management feels in control.

Then delivery starts.

Projects overlap. Scope evolves. Renewals, amendments, and staffing constraints appear. And suddenly the CRM becomes a reporting artifact instead of a system the business actually relies on.

The reason is structural.

Agencies don’t sell deals. They sell relationships over time, constrained by people, contracts, and operations. Revenue is not a single event. It’s a sequence of commitments.

A CRM designed only to answer “what’s in the pipeline?” is structurally incapable of answering the questions that matter once the business is running.

Designing the system before touching the CRM

The first thing we showed during the workshop was not a CRM screen.

It was the GTM stack as a whole.

A CRM never works in isolation. An agency GTM system is an ecosystem: sourcing tools, enrichment tools, sequencing tools, contract tools, delivery tools.

The mistake is not using too many tools. The mistake is letting each tool become its own source of truth.

Our rule is simple and non-negotiable: one system must sit at the center.

In our case, that system is Attio.

Not because it tries to do everything, but because it holds structure, relationships, and decisions. Other tools either feed it or execute from it. None replace it.

The moment this rule breaks, the system fragments.

Encoding the agency business model in the data model

Once the system is clear, we move to structure.

Most agencies assume they need a complex, highly customized CRM schema. In practice, this usually creates fragility, not clarity.

For most agencies, the default data model is enough.

The shift is conceptual, not technical.

People and companies capture relationships and history. They are long-lived. Deals are short-lived. They are moments in a relationship, not the relationship itself.

When deals are treated as the center of the CRM, context disappears the moment they are closed. When companies become the center, deals fall back into their proper role.

This single change fundamentally alters how an agency experiences its CRM.

Processes matter more than features

Only after structure comes process.

Every agency GTM motion, regardless of size or positioning, follows the same arc: someone enters the system, a deal process happens, and then the real work begins.

Most CRMs obsess over the middle part and ignore the rest.

That makes sense in theory. The middle part is visible. It’s where forecasts live. It’s where pressure concentrates.

But in an agency, the most expensive mistakes happen after the deal is won. That’s where information gets lost, expectations drift, and delivery teams inherit half-formed promises.

A CRM that stops caring at “Closed Won” is not neutral. It’s actively harmful.

Outbound without destroying the database

Outbound is often where agency CRMs quietly degrade.

Leads are scraped, enriched, sequenced, replied to, recycled. Very quickly, the People object becomes an unmanageable mix of prospects, clients, partners, and noise.

The fix is not better enrichment or more automation.

It’s separation.

In the setup we showed, outbound leads are deliberately isolated at first. They enter the system through dedicated lists, go through a qualification step, and only then are pushed into sequencing tools.

Outbound tools execute.

The CRM decides.

That distinction keeps the database usable over time.

Rethinking deal stages for services

Deal pipelines are where confusion usually becomes visible.

People ask what the “right” stages are. In reality, stages matter far less than what they do.

A deal stage is only useful if moving a deal into it changes something in the real world. A task is created. A document is prepared. A handoff is triggered. Someone becomes accountable.

If a stage exists only to make reporting look cleaner, it will eventually be ignored.

“Deal won” should not be a label. It should be an operational event.

Contracts belong inside the CRM

Contracts are one of the most painful parts of agency operations because they usually live outside the system.

Information is copied manually. Context leaks. Speed is lost at the exact moment when momentum matters.

In the setup we presented, contracts are generated directly from the CRM. Not as a convenience feature, but as a design decision.

The CRM remains the place where reality is reflected, even when signatures are involved.

From signed to operated: where margin is protected

The most important part of the system is what happens next.

Once a deal is signed, the center of gravity shifts from sales to delivery. And yet, most CRMs disappear at that moment.

In our setups, deal data flows automatically into the project management layer. The tool matters less than the principle.

Sales should not brief delivery manually.

Delivery should not chase sales for context.

The system should handle the handoff, every time.

Attio remains the source of truth for meetings, history, and decisions. Operations pick up execution with full visibility.

That’s where margin is protected.

Calls as data, not memories

One smaller detail we covered during the workshop compounds over time.

Calls are usually treated as ephemeral. Once they’re over, they live in someone’s memory, or nowhere at all.

When calls are recorded, transcribed, and structured inside the CRM, they become shared context. Institutional memory. A way to reduce dependency on individuals without losing nuance.

For agencies, that kind of memory is leverage.

What agencies keep getting wrong

After working with many service businesses, a few patterns repeat.

Heavy pipelines often hide unclear processes.

Weekly pipeline meetings compensate for systems that don’t answer questions on their own.

“AI-first” promises collapse when the underlying model is messy.

Tools don’t fix confusion. Structure does.

Closing thoughts

That was the point of this workshop.

Agencies don’t need more software. They need systems that reflect how services actually work, before, during, and after the sale.

A CRM is not a pipeline. It’s an operating system. And operating systems deserve to be designed, not improvised.

Most scale-ups hit the same wall shortly after a big fundraising round. Revenue grows. Headcount grows. Complexity explodes. Suddenly, the CRM that once sufficed becomes a bottleneck . In this phase of hypergrowth, what these companies need isn’t just “a CRM” - they need a system that connects to everything in their go-to-market (GTM) engine and stays flexible as the organization evolves . This is where a new approach to CRM architecture changes the game.

Modular, API-native CRMs like Attio are emerging as the foundation for such systems. Instead of a monolithic traditional CRM struggling to keep up, Attio enables a modular GTM architecture that integrates with best-of-breed tools (from lead enrichment to billing) via APIs. The result is a CRM-centric system more adaptive than the org itself - one that can scale faster than the team and remove friction from growth . In this article, we’ll examine why legacy CRMs (Salesforce, HubSpot, etc.) often fail in post-raise scale-ups, and how Attio’s modern approach unlocks speed, visibility, and configurability across the GTM stack. We’ll also dive into real-world case studies of companies that rebuilt their GTM systems on Attio, integrating tools like Clay, lemlist, Allo, OpenAI, Oneflow, Notion, BigQuery, Stripe, and Customer.io into a cohesive engine. Finally, we’ll compare Attio’s architecture with traditional CRMs in a post-raise environment and discuss the urgency of making the right architectural decisions after a funding round.

I lead Novlini, where we design Attio-based GTM systems for scale-ups right after their fundraising. Across dozens of implementations, the same failure pattern appears every time.

The “Complexity Wall” After Fundraising

In the early scrappy days, many startups get by with duct-tape solutions: leads in a Google Sheet or Typeform, sales tracking in a free HubSpot, meeting notes in Notion, and some reporting in Excel . This patchwork works until the team or customer base grows and GTM motions diversify - then someone asks, “Where is the truth?” . The “truth” (i.e. the source of reliable, up-to-date customer and revenue data) is hard to pin down when data and workflows are fragmented. This fragmentation is a form of architectural debt : an early trade-off of speed over structure that starts to drag on execution as scale increases.

A substantial fundraise (say a Series A/B) usually heralds an inflection point. With new capital, startups rapidly hire reps, launch new regions or products, and face orders-of-magnitude more data - more leads, more deals, more customer touchpoints. The operational load on the commercial team soars. At this moment, what used to work breaks down. Sales reps find themselves copying data between tools, deals slip through cracks, and managers lose visibility into the funnel. In many cases, the CRM itself becomes the choke point . A CRM that was fine for a 5-person team can feel like a rigid, underpowered spreadsheet for a 50-person go-to-market team. It’s common to hear frustrations like “our CRM feels blocked” or “it doesn’t integrate with our tools” - as one fast-scaling company, Vocca, put it bluntly .

Why does the CRM turn into a blocker? Legacy CRM platforms often force your business into their structure (standard objects, fields, and processes) rather than adapting to how your business actually works. As one industry expert observes, in traditional setups “the CRM should bend to your team, not the other way around” - yet the opposite often happens with legacy systems. When you’re growing fast, being locked into rigid data models and workflows is dangerous: you need to tweak pipeline stages, capture new metrics, or support a new sales motion now, not in six months. But heavy CRM platforms (think Salesforce) can require lengthy reconfiguration or custom coding for even modest changes, and lighter-weight CRMs (like early HubSpot plans) might not support the complexity at all.

Moreover, as teams scale, integration gaps become glaring. A high-growth startup might be using specialized tools for outreach, data enrichment, customer success, billing, etc. - but if the CRM isn’t deeply integrated with each, data ends up siloed. Traditional CRMs often sync slowly or not at all with external apps, leading to partial views of the business. For example, a sales engagement tool might not log email replies back to the CRM in real-time, causing reps to unwittingly chase leads that have already responded. Indeed, keeping a legacy CRM and an email sequencing tool in sync is notoriously difficult: manual CSV exports are slow and error-prone, and standard automation tools often have a data lag (e.g. a reply in the outbound tool might not show up in the CRM for minutes), leading to embarrassing duplicate follow-ups . In short, a fast-growing business can outpace the CRM’s ability to ingest and surface data quickly.

Finally, user experience and admin burden play a role. As processes get more complex, a CRM can either streamline work or pile on extra work. Too often it’s the latter - sales teams complain of spending hours on data entry and admin rather than selling. (One analysis noted that most CRMs create more work than they eliminate, with reps bogged down logging calls, updating statuses, and stitching together reports.) The net effect: the CRM becomes a source of friction, an ever-growing “to-do” list, rather than the single source of truth that propels the team forward.

Why Traditional CRMs Become Bottlenecks

Let’s drill down into the limitations of legacy CRMs (like Salesforce, HubSpot, etc.) in a post-raise, scaling context. There are several recurring issues:

• Monolithic & Rigid Architecture: Traditional CRMs were built as all-in-one systems, which often makes them inflexible. They come with predefined data schemas and processes that assume your business will conform to them. Customizing these systems to fit your evolving strategy can be arduous. For instance, adding a new object or workflow in Salesforce might require significant configuration and even custom code. HubSpot, while easier to use, offers limited custom objects on lower tiers and can’t easily handle, say, a complex many-to-many relationship between companies and deals without workarounds. In a hypergrowth scenario, this rigidity means your CRM workflows lag behind your business needs - exactly when you need maximum agility.

• Integration Gaps and Siloed Data: A legacy CRM on its own is rarely sufficient to run a modern GTM motion - you’ll have a constellation of other tools (marketing automation, outbound sequencing, data enrichment, contracting, support desk, etc.). Traditional CRMs do have integration ecosystems, but they often rely on third-party plug-ins or scheduled syncs that aren’t real-time. As noted, a reply or interaction in one tool might not register in the CRM until hours later (or at all) . Many scale-ups experience that “our tools don’t talk to each other” feeling - data lives in disconnected places. In the Vocca example, their Attio CRM wasn’t natively talking to their outbound email tool (lemlist), resulting in a manual, unsustainable sales process . When your CRM isn’t the integrated hub, reps waste time swiveling between apps, and leadership loses the 360° visibility needed for decision-making.

• Slow to Evolve (Operational Drag): Implementing or overhauling an enterprise CRM can be a months-long project. Post-fundraise, startups don’t have that luxury - they need systems now, not next year. However, many teams that “upgrade” to a big CRM find themselves mired in implementation: importing data, setting up pipelines, training users, building reports. It’s not uncommon for a Salesforce deployment to take 6+ months for a scaling company’s needs (often requiring external consultants and a dedicated admin). By the time it’s fully operational, the company’s strategy may have shifted again! This slow cycle means your CRM is always playing catch-up with your go-to-market. In contrast, as we’ll see, some teams have stood up complete, tailored Attio workspaces in under a week . The speed gap is huge.

• Lack of Configurability for End Users: In high-growth situations, front-line teams need to be able to modify how they use the CRM on the fly - creating a new list, a new view, adjusting a field, etc. Legacy systems either lock this down (to prevent “mistakes”) or become the Wild West if unlocked (leading to chaos with inconsistent fields and processes - the “chaotic CRM” problem). Neither is good. What you want is guided flexibility: the ability to design new workflows intentionally and quickly, without breaking the system. Legacy CRM UX often isn’t geared for this; it’s geared for consistency and control in a steady state, not rapid reconfiguration. So teams either operate with suboptimal setups or they try to bend the CRM in ways that create mess (think: dozens of custom fields added ad-hoc, reports that no one trusts, automations that conflict). This is where the architectural debt creeps in and slows everyone down.

• Hidden Data and Poor Visibility: A CRM is only as good as the data in it. If important interactions (emails, calls, product usage, support tickets, billing events) don’t make it into the CRM, you get blind spots. Traditional CRMs often fall short here because they weren’t built to easily ingest real-time events from everywhere. You might end up with “hidden data” - for example, product usage metrics sitting in a database that salespeople can’t see during renewal conversations, or campaign responses sitting in a marketing tool that aren’t linked to pipeline deals. A legacy approach might require a complex business intelligence pipeline or periodic CSV uploads to unify this data, which is hardly agile. The outcome is that teams operate with incomplete information. As one founder put it after upgrading their CRM architecture, “No more rigid processes. No more hidden data. No more friction.” - that’s the ideal we’re striving for, and legacy all-in-one CRMs often can’t get you there.

Given these issues, it’s no surprise that many scale-ups decide to rip out or significantly augment their CRM in the post-raise period. Some attempt to switch from a simpler CRM to a powerhouse like Salesforce - only to encounter the above challenges. Others stick with an incumbent but bolt on numerous tools and hacks, ending up with a Frankenstack. Increasingly, however, a third path is gaining traction: Adopting a modular, API-first CRM as the core of a new GTM architecture.

The Modular CRM Stack: Attio as a GTM Engine, Not Just a Database

Imagine a CRM that is not a static database but the real-time command center of your revenue operations. That’s the vision behind Attio and the modular CRM stack. Attio is a modern CRM built with flexibility and integration at its core - essentially an API-native, developer-friendly platform that you can shape to fit your business, rather than shaping your business to fit it . It provides the foundational data layers (contacts, companies, deals, interactions - all fully customizable) and a clean UI, and crucially, it’s designed to connect with everything else in your stack seamlessly. At novlini®, where we specialize in designing modern GTM stacks, we never deploy Attio as a standalone silo. We always connect it to the full stack a team relies on .

Attio sits at the center of a modern, modular GTM stack - integrating with specialized tools for every function (from lead enrichment and outbound sequencing to contract management and customer success) via APIs. In this architecture, data flows in real time between Attio and the surrounding tools, creating a system that moves faster than the team itself and eliminating rigid processes and data silos .

Concretely, what does a modular Attio-based stack look like? It means pairing Attio with best-in-class tools for each GTM function and having them talk to each other as one system. For example, an Attio deployment might integrate: Clay for data enrichment (to source and enrich lead info), lemlist (or another outreach tool like Smartlead) for email sequences, Allo for call recordings, OpenAI (or partners like Spiich Labs) for AI-driven workflows, Oneflow for digital contracts and e-signatures, Notion for operational playbooks or customer notes, BigQuery (or a data warehouse) for advanced analytics, Stripe for billing events, and Customer.io for lifecycle marketing automation . Each of these tools is excellent in its domain; Attio serves as the central brain that they feed into and draw from. The philosophy is modularity: use the right tool for the job, but ensure the CRM is the unified interface and database where everything converges.

This approach yields a GTM system that’s actually more adaptive than the organization running on it. As new needs arise - say, you decide to implement a usage-based pricing model - you can integrate a product analytics event stream into Attio or plug in a new billing integration with minimal friction. Attio’s developer platform was built for this kind of extensibility: it offers a robust REST/GraphQL API and even an App SDK for building custom add-ons . In effect, Attio treats CRM not as a fixed SaaS product, but as a platform or infrastructure that you build upon. It’s akin to how modern product teams treat cloud platforms: configurable, scriptable, and part of your core tech stack. Attio themselves describe it as bringing a “truly modern, cohesive developer experience” to CRM, comparable to what Stripe did for payments . The upshot: if you need Attio to do something new, you can likely build it or connect it quickly - whereas with a legacy CRM, you’d be waiting on a plugin vendor or wrestling with outdated SOAP APIs.

Integration as a First-Class Feature

The biggest practical benefit of the modular approach is integration. Because Attio is API-first, anything in your GTM stack can be tethered to it in real time. Compare this to the typical experience with a traditional CRM + tools: often you’re stuck with nightly syncs or clunky third-party connectors. With Attio, if we need a two-way sync with a tool like lemlist, we don’t settle for a 15-minute delayed Zapier zap - we build a direct bridge. In one integration project, for example, we created a bi-directional, real-time link between Attio and lemlist so that whenever a contact replied to a campaign, that interaction was logged in Attio instantly, preventing reps from sending any redundant follow-ups . Likewise, when a rep added a contact in Attio to an “Active Leads” list, that person would auto-enroll into the correct lemlist campaign without anyone exporting CSVs . Every email open, click, reply, or bounce would flow back into Attio, attaching to the contact’s activity history . And because we scripted smart field mappings and error handling, the data stayed clean - no duplicate contacts or mismatched fields . This kind of tight integration transforms the CRM from a passive database into the active command center of your revenue engine . There’s no manual busywork; the CRM orchestrates and records the entire process.

Attio’s openness also means you can maintain a single source of truth even as you diversify tools. For instance, one Attio customer uses Segment (a customer data platform) to funnel product usage events into Attio as part of a “product-qualified lead” system . Others have built custom apps - one popular Attio add-on called Granola automatically syncs meeting notes, and another (Polytomic) enables two-way sync between Attio and data warehouses . The difference here is that instead of relying on the CRM vendor’s limited feature set, you have the freedom to enhance the CRM with whatever data or workflow you need. If tomorrow a new “must-have” GTM tool appears, a modular system can incorporate it; a legacy CRM would treat it as a foreign object.

Speed, Visibility, and Flexibility: Benefits at Scale

A modular Attio-based architecture isn’t just a tech novelty - it directly addresses the pain points we outlined with legacy CRMs. Here’s how it translates into tangible benefits for a scaling company:

• Speed of Implementation and Iteration: Perhaps the most eye-opening benefit is how fast you can get a sophisticated system up and running. Instead of a drawn-out months-long CRM project, many Attio implementations are measured in days or weeks. For example, Wonder Studios (an AI-native film studio) migrated from tracking deals in Notion to a structured Attio CRM in just 2 days, complete with automated multi-currency revenue reporting . Vocca (the healthtech company mentioned earlier) had a complete outbound sales engine built on Attio (integrated with Clay and lemlist) in only 5 days, mapping their entire French market of 80,000 leads and automating the outreach workflow . And in another case, a startup in the creator economy replaced a mess of spreadsheets with a custom Attio CRM - including complex contract and revenue management - in 4 days . These timeframes are unheard of with traditional CRM projects. The reason it’s possible is twofold: Attio’s ease of configuration (you can rapidly design custom collections/fields, import data, and set up pipelines), and its ability to piggyback on existing tools via integration (so you’re not reinventing every wheel from scratch). Speed isn’t just a one-time benefit either; it means faster iteration. If next month you decide to tweak your lead scoring model or add a partner referral pipeline, you can do it in a modular system with minimal disruption. The architecture is designed for evolution.

• Visibility and a Unified Source of Truth: By integrating every part of the GTM stack into Attio, you eliminate the data silos and “hidden data” that plague growing teams. All interactions - marketing emails, sales calls, product usage signals, support tickets, contract statuses, billing events - can be linked to the relevant contact or company record in Attio. This gives leadership a true 360º view of an account and gives front-line reps complete context at their fingertips. For example, if a customer replies to a campaign in lemlist, that reply (and its content) is visible on the contact in Attio immediately . If a deal moves to “Proposal Sent”, an integration with Oneflow might fetch the contract link and status so the rep sees if the customer has viewed the proposal. If a Stripe payment fails for a customer, that could log an alert on the account in Attio, prompting the success team to intervene. Compare this to a traditional setup where a lot of this info lives in separate dashboards or not at all. The one central hub approach was a game-changer for Vocca: all their campaign activity and lead enrichment flowed back into Attio, automatically creating deals and tasks for the sales team - turning what was a “blocked” CRM into a proactive system driving the next actions . In short, everyone sees the same truth, and nothing falls through the cracks due to missing data.

• Flexibility & Configurability: A modular Attio system is highly configurable by design. Need a custom field to track something unique to your business? It takes seconds to add, and you can backfill or compute values easily (Attio even supports calculated fields, e.g. “Last Interaction Date” or tagging key roles like Decision Maker) . Want a custom object like “Partners” or “Investors” beyond the usual CRM entities? Attio lets you create new collections and define relationships between them. This means your CRM data model can mirror the reality of your business, not just the generic lead-account-opportunity of yesterday’s CRM. Additionally, you can set up views and pipelines that make sense for each team’s workflow. For instance, SDRs might have a view of “leads contacted in the last 7 days” while Customer Success managers see “at-risk accounts with no recent interaction” - all drawing from the same data but sliced for their needs . Legacy CRMs have some of this capability, but Attio’s clean UI and flexible filtering make it far easier to build these custom views without an admin’s help. The benefit is operational clarity: each role sees a tailored perspective, but all based on one underlying system, so reporting stays consistent.

• No-Code and Low-Code Automation: Flexibility isn’t only for those with engineering skills. While Attio shines with its API for developers, it also works with no-code automation tools like Zapier, n8n, Pipedream, etc., for more straightforward tasks . Non-technical team members can set up a zap to, say, push form submissions from the website into Attio as new leads, or trigger a Slack alert when a big deal is marked “Closed Won.” The combination of Attio’s built-in automation (like triggering workflows on stage changes) and external automation tools means teams can automate repetitive tasks on their own. Compare that to a traditional CRM where adding an automation might require digging into a complex workflow builder or apex code (in Salesforce’s case). In the modular stack, if something doesn’t have a native integration, you build a quick one or use a general automation service. The GTM team becomes a bit more self-sufficient and can experiment with processes - without waiting in the engineering queue.

• Adaptability to Process Changes: Perhaps the most strategic benefit is that your GTM system can change as fast as your strategy does. Post-raise startups often pivot segments, adopt new sales methodologies, or rework their customer journey as they find product-market fit in new areas. A modular CRM architecture handles this in stride. Need to support a usage-based sales-assisted funnel? Pipe product events into Attio and create a new “Product Qualified Lead” scoring model. Spinning up a partner referral program? Add a Partners collection in Attio and link it to deals, maybe integrate with an affiliate tool via API. Because Attio is essentially part of your tech stack, your engineers or ops team can treat it like any other product component - versioning changes, rolling out updates, and governing it like infrastructure . This is a markedly different mindset from treating the CRM as a purchased tool that you grudgingly live with. As one guide put it, “Great CRM systems are not bought. They’re designed.” With Attio, you are designing your system in a way that simply isn’t possible with off-the-shelf legacy solutions.

To illustrate these advantages, let’s look at a few companies that embraced the modular approach with Attio, and what they achieved:

Real-World Case Studies: Attio in Action at Scale-ups

Vocca (Health Tech SaaS): Vocca, a French healthcare tech company, provides AI receptionists for medical practices. After raising funds and preparing to scale, they hit the classic problem: their sales process was largely manual and their key tools - Attio (as CRM) and lemlist (for outbound email) - were not connected . Their CRM felt like a “blocker” because it wasn’t fueling their sales outreach. In just 5 days, our team at novlini helped Vocca build a fully automated outbound engine by integrating Attio, Clay, and lemlist . Clay was used to identify and enrich all potential leads (we’re talking 80,000+ leads, essentially mapping their total addressable market in France) . Those enriched leads flowed into Attio and were automatically passed into lemlist campaigns. Every reply or interested response in lemlist synced back to Attio in real time, automatically creating deals and follow-up tasks for the sales team . Vocca’s result was a night-and-day transformation: their CRM went from a static repository to a dynamic system that continuously fed their pipeline and alerted reps to engage at the right time. In the words of Vocca’s team, it turned the CRM from a “blocker” into a powerful sales system, enabling their new sales hires to be productive from day one .

Jellysmack (Digital Media, 500+ employees): Even larger organizations feel this pain. Jellysmack, a global creator company with over 500 employees, found that their Salesforce CRM was becoming unwieldy and limiting for their growth needs. They made the bold move to migrate from Salesforce to Attio for their sales CRM, and in the process, built new custom lead generation pipelines integrated with lemlist . This case is significant - it’s proof that an enterprise-scale team can replace the long-standing “industry standard” CRM with a modern alternative and come out better for it. By shedding Salesforce’s complexity and adopting Attio, Jellysmack could configure a system tailored to their workflows and integrate it tightly with their outreach. It’s telling that a company of this size valued flexibility and custom workflows enough to make the switch. The outcome was a more efficient top-of-funnel process and a CRM that their team actually likes to use (as opposed to the Salesforce instance that felt like a burden).

Tandem Health (Healthcare): Tandem’s sales organization was struggling with what they described as a “chaotic HubSpot CRM.” As they grew, their HubSpot instance had devolved into an inconsistent jumble of fields and manual work, and it wasn’t keeping up with their needs. They opted to move to Attio and simultaneously reinvent their outbound process. Using Attio as the foundation and Clay for lead sourcing, we helped them create a fully automated outbound motion, replacing chaos with structure . In Attio, Tandem now has clean pipelines and automated triggers (e.g. when a lead is moved to Contacted, Clay enriches it and lemlist sends an email, and any reply comes back into Attio). The key lesson from Tandem is that migrating off a legacy CRM is an opportunity to clean house and instill best practices. By starting fresh with Attio, they implemented proper data governance (naming conventions, defined lifecycle stages, etc.) and ended up with a CRM that provides clarity instead of confusion.

Other Examples: Many other high-growth teams have taken this path. A few highlights: A consulting firm, Northlane Partners, built a scalable outbound engine with Attio + lemlist to move beyond their reliance on manual referrals . A fintech startup, Arcola, constructed a dedicated private equity CRM on Attio that even uses AI (OpenAI GPT models) to auto-summarize 50-page investment memos into 1-page briefs - dramatically accelerating their deal qualification process . A crypto company, Plume, overhauled their Attio setup with advanced dashboards and a custom Slack integration to keep their team in sync in real-time (alerting channels when big deals closed, etc.). And a fashion-tech platform, Future Fashion Assembly, left behind a tangle of spreadsheets for an Attio system that automated their sales steps and follow-ups. The pattern is clear across these cases: once teams experience a tailored, integrated CRM system built on Attio, going back to a one-size-fits-all CRM is unthinkable.

Attio vs. Traditional CRM: A Side-by-Side Comparison

To crystallize the differences, let’s compare Attio’s modular CRM architecture with a traditional CRM (like Salesforce or HubSpot) in the context of a post-raise scale-up:

Table: Comparing a modular Attio-based CRM architecture vs. a traditional CRM in a post-raise growth scenario.

As the table shows, an Attio-driven approach aligns technology with the need for speed and flexibility in a scale-up. A legacy CRM, by contrast, can become an anchor that drags behind your speedboat.

Post-Raise Urgency: Laying the Right Foundation

There’s a saying in startup operations: don’t let your systems be the rate-limiter of your growth. After a fundraising event, companies often have a brief window to build momentum - new sales targets to hit, pressure from investors to show results, perhaps a hiring spree to absorb. In this climate, making smart architectural decisions is critical. Choosing how you manage customer and revenue data is as important as choosing your product architecture or your key hires. A misstep - like sticking too long with a CRM that can’t scale, or embarking on a long implementation of an overly complex tool - can cost precious time and focus.

Adopting a modular CRM stack early in this journey can pay dividends. It gives you a foundation that won’t need to be ripped out a year later when you triple your customer count, because it’s built to scale and adapt. In fact, many companies are proactively making the switch right after raising, precisely to avoid hitting the wall we described. They are essentially saying: let’s invest a couple weeks now to design our GTM system properly, rather than slog through six months of pain and then do it anyway. It’s akin to building a solid foundation before adding more floors to a building.

One might wonder, is there a risk in moving to a newer CRM like Attio versus the “devil you know” in Salesforce/HubSpot? It’s a fair question - Salesforce in particular is a proven platform at massive enterprise scale. But the needs of a scale-up in 2025-2026 are different from those of a Fortune 500 in 2010. Modern high-growth teams prize agility and developer-friendliness; they operate in a world of APIs and microservices, and they often have in-house ops or engineering talent that can extend a platform like Attio. In that context, the risk of an older, inflexible system causing execution issues is actually greater than the risk of adopting a modern tool that might still be evolving. Moreover, Attio has matured rapidly (with a recent Series B raise of its own fueling development ), and it’s backed by examples of deployment in teams of all sizes - from startups to multi-hundred user companies like the ones we discussed.

It’s also worth noting the cost of delay. If your CRM is a bottleneck, every day could mean lost deals or inefficient use of your new hires. On the flip side, a streamlined system can quickly show ROI - for instance, automating follow-ups or lead enrichment can immediately boost pipeline generation (Vocca’s automated engine started reaching thousands of prospects within days, something impossible in their old setup). One of our clients saw their sales velocity increase by 40% after removing the administrative friction in their process - much of which was tied to their old CRM usage. These are meaningful gains that affect the trajectory of the company.

Conclusion: Designing Your GTM System for Hypergrowth

Andrew Chen often talks about the importance of foundations and loops in growth. Think of your CRM and GTM stack as part of that foundational loop: it’s how leads become customers, how customer actions lead to follow-ups, how revenue is tracked and grown. If that loop is clunky or broken, no amount of individual hustle will fully compensate. As we’ve explored, many scale-ups face a moment of truth post-fundraise where they realize their internal systems are not ready for the next stage of growth. The savvy ones are responding by rearchitecting - treating their CRM not as a static off-the-shelf tool, but as a key piece of infrastructure to be crafted for their needs.

Modular CRM architecture, exemplified by Attio, represents a new mindset. It says that flexibility beats rigidity, that a network of specialized tools can outperform an all-in-one behemoth if you connect them intelligently, and that speed and visibility are paramount in a world where go-to-market moves fast. It’s an approach born out of practical necessity, but now proven in the field by numerous success stories. The CRM no longer needs to be a bottleneck or a blocker. With the right architecture, it becomes a growth enabler - an engine that accelerates go-to-market activities by automating data flow and surfacing insights proactively.

For founders and operators, the takeaway is clear: if you’re gearing up for rapid growth, don’t wait for complexity to cripple you before upgrading your systems. Be proactive. Whether you stick with your current CRM and supercharge it with new integrations, or switch to a modern platform like Attio and redesign your workflows, approach your GTM tech stack as you would your product tech stack - with intention, modularity, and an eye toward scale. As we often remind our clients, CRMs don’t drive growth by themselves; but the right CRM architecture can remove obstacles to growth. By eliminating rigid processes, data silos, and friction , you create the conditions for your team to execute at their best. In a post-raise sprint, that can make all the difference.

Ultimately, the companies that master this - that build GTM systems more adaptable than the organizations they support - gain a competitive edge. They can iterate on sales and marketing strategy faster, respond to customer signals in real time, and glean insights from a unified data set that others simply can’t. Their operational agility becomes a moat. So if you find yourself hitting that CRM wall, take it as an opportunity to rethink and retool. The tools and approaches are now out there to turn your CRM from a necessary evil into a strategic asset. In the new world of modular GTM architecture, your systems evolve as quickly as your strategy - and your startup can sprint ahead confidently, backed by an engine that’s built to scale right along with you.

This is the architecture we build every week at Novlini for teams preparing their next stage of growth. If your CRM is becoming the bottleneck, you can reach out - I’m happy to share what this system would look like for your company.

Sources:

1. Giacomo Caranese (novlini) on LinkedIn – “Most scale-ups hit the same wall right after fundraising… the CRM becomes the bottleneck.”

2. novlini® Case Study – Vocca GTM Engine (Attio + Clay + lemlist)

3. novlini® – “Lemlist – Attio Integration” (real-time two-way sync solution)

4. novlini® Blog – “Designing a Modular CRM Stack” (on architectural debt and CRM as infrastructure)

5. Attio Developer Blog – “Meet the Attio Developer Platform” (API-first philosophy)

6. novlini® Case Studies – Various success stories (Wonder Studios, Trendly, etc.)

7. novlini® Case Studies – Jellysmack (Salesforce to Attio migration) & Tandem Health (HubSpot to Attio)

8. novlini® LinkedIn post – “Our CRM feels ‘blocked’ and doesn’t integrate…” (Vocca quote and outcome)

I spend my days inside GTM stacks. At Novlini we design systems for startups and scale-ups, usually replacing legacy CRMs with Attio and connecting everything else around it. It is not glamorous work. Most of it happens under the hood: data cleaning, object modeling, wiring APIs, defining workflows. But this invisible layer is what makes the difference between a sales team stuck in spreadsheets and a team that scales.

That is also why I’ve been watching the “AI agent” wave with both excitement and suspicion. Everyone has an “agent” right now. Most of them are assistants with better marketing.

I even put my money where my mouth is. I invested in Spiich Labs, a Swedish startup building an AI sales agent that plugs into Attio. Because when I tested it, I saw something I rarely see in this space: a product that does the boring things well. Talk or type, it writes to the CRM, prepares a brief, and gets out of the way. No fireworks. Just fewer stale deals and cleaner next steps.

The hype vs. the work

We’re living peak agent-washing. Salesforce announces Agentforce. HubSpot ships Breeze. Zoho keeps pushing Zia. Pipedrive talks about “agentic experiences.” These are serious companies with good intentions. But here is what I see on the ground when we implement for clients: their agents rarely survive first contact with the mess of a real CRM. Custom fields, multi-threaded deals, partial data.

At Novlini, we do not have the luxury to buy into the hype. If the pipeline is wrong, my clients cannot forecast. If the data is dirty, their outbound tanks. That is why we start with architecture: a programmable CRM like Attio, fast APIs, and a schema that mirrors reality. Only then does it make sense to add an agent. Otherwise, you are just paying to automate bad habits.

One simple test

Here is my personal test. After a meeting, can the agent:

• create the contact,

• log the note,

• set the next step,

• update the opportunity,

• assign the right owner.

If yes, the pipeline stays true and the rep keeps selling. If no, you have just added another inbox with opinions.

Spiich passes this test. Not perfectly — ambiguity and exceptions still need humans — but enough that adoption is natural. Reps actually use it, because it is faster than typing and it does not fight the schema we set up in Attio.

Where agents fail (and why we call them out)

I’ve seen the failures too:

• Ambiguity: free-form voice mixes up objects.

• Exceptions: complex renewals and bespoke pricing break the flow.

• Latency: if the third rep after a team call waits 20 seconds for a summary, they’ll never try again.

• Opacity: if we cannot see exactly what the agent wrote and why, we switch it off.

This is not a reason to avoid agents. It is a reason to treat them like adults: scoped permissions, full logs, weekly audits. At Novlini, we even have a “Friday review” where we check ten agent writes with the team. If it is wrong, we adjust schema, prompts, or guardrails. That is how you build trust.

Two axes that matter

Every GTM leader I talk to eventually faces two choices:

• Assistant-led vs agent-anchored: Do you want a chat window that gives you advice, or an agent that actually changes the state of your business.

• Monolith vs programmable base: Do you accept the CRM as-is and wait for vendor roadmaps, or do you model your business in a system that can flex.

The top-right box is the only one that pays: agent-anchored, programmable base. That is why we bet on Attio. And why I invest in tools like Spiich that respect the system of record.

How we roll it out

When we deploy for clients, we never start with “let’s AI everything.” We start small:

• Lock the minimal schema in Attio.

• Decide what the agent can write without approval.

• Pilot with one team, two workflows, four weeks.

• Track two numbers: percent of opportunities with next steps, and median time to update after a call.

If both improve, we expand. If not, we cut. No romance.

My opinionated take

Agents will not save a broken GTM. They will make it fail faster. The real work is boring: model your business, clean your data, build your workflows. Then, and only then, add agents that keep the pipeline true.

I am bullish on this space. That is why we architect modern stacks at Novlini, why I back Spiich, and why I call out hype when I see it. The winners will not be the loudest demos. They will be the ones that keep truth in the CRM while humans do the human work.

More at novlini.io.

Hello again, everyone.

In my last post, I wrote about how I built my first real automation with Make.com to pipe our most valuable leads from a Gmail inbox directly into Attio. It was a huge win. The machine worked, my days of manual copy-pasting were over, and I felt like I had solved a real problem.

But that just meant a new manual task was waiting for me. Now that the leads were neatly in our CRM, my next job was to support the sales team as they moved through the pipeline. My new mission: prepare a detailed briefing note before every single sales call.

This is a breakdown of how that one tedious, manual task led me to a powerful new tool, a great mentor, and a professional certification that has completely changed my career path. It’s a playbook for anyone who has a painful part of their job they wish a robot would do, and it’s proof that the best way to become an expert is to solve a problem that you truly feel.

My Life Before - A Mess of 15 Browser Tabs and Hope

For every meeting, my process was exactly the same: a ritual of organized chaos.

I’d start by opening a dozen or so tabs, searching for company news, funding announcements, and anything that could give our sales team an edge. The process was messy, and my notes were a chaotic mix of copied-and-pasted links and hastily typed summaries. I knew the notes I was delivering were just “okay.” They were a collection of facts, not a cohesive analysis.

I did this every single day. It was my job, but I knew it was inefficient.

A New Direction

One afternoon, Victor, a consultant on our team, saw my screen, a dizzying mosaic of open windows. Victor is known around Novlini as our resident expert on Clay, with years of experience building complex automation for our clients.

He watched for a moment, and then a smile broke across his face.

“You know, this can all be automated, right?” he asked. “In fact, I built a very similar research system for one of our clients Northlane, just recently”

I was stunned.My entire day was spent doing this manually. I explained my process, and he just nodded. “You’re thinking about this like a researcher,” he said. “You need to think about it like an architect. Let me show you Clay.”

My “Aha!” Moment with Clay

I had heard of Clay, but I thought it was just another tool for finding emails. I was completely wrong.

Victor pulled up a Clay table and started mapping out my entire manual process on a whiteboard. Every tab I opened, every search I made, every piece of information I looked for he drew a box for it.

“Clay isn’t a database; it’s an engine,” he explained.

“It’s like a set of digital LEGOs. It connects to dozens of different data sources, runs AI prompts, and finds information at a scale and speed you never could as a human. We can build your entire workflow in here.”

This was my lightbulb moment. Instead of me preparing for meetings, I could build a system that prepared the meetings for me. Victor gave me my first project: automate myself.

My Life After - Building the Pre-Meeting Note Machine

I got to work immediately. My goal was to build a hands-free system where moving a deal to the “Meeting” stage in Attio would automatically generate a perfect briefing note.

Here’s how the machine I built works:

1. The Trigger in Attio: Everything starts in our CRM. I built a simple workflow in Attio. As you can see here, the trigger is “When a deal’s stage is updated to ‘Meeting’,” and the only action is to send the company info to a Clay webhook.

2. The Signal to Clay: The Attio workflow’s only action is to send that webhook to Clay. This is just a simple, instant message that carries the name of the company for the meeting.

3. The Clay Research Engine: The company name lands in a Clay table, and a series of powerful automations run instantly. You can see a few of the rows here, each one representing a company being enriched in real-time.

This is the part that replaced my 15 browser tabs:

• Clay finds recent news: It searches the web for news about the company from the last 30 days and uses AI to summarize the key points.

• Clay finds customer look-alikes: Clay searches our own Attio CRM to find existing customers in the same industry perfect for social proof.

• Clay generates talking points: I wrote an AI prompt that says: “You are a world-class GTM consultant. Based on this company’s website and recent news, provide three smart recommendations their CEO would love to hear.”

4. The Briefing Note in Attio: After Clay does its research, it sends all the structured, perfectly formatted information back to Attio. A final Attio workflow assembles it into a new, beautiful note that it attaches directly to the deal record. An example -

From Project to Profession - The Path to Certification

Building that first machine was exhilarating. It worked. The notes were better than mine, and they were instant. But I knew I had only scratched the surface.

Victor saw my progress and gave me my next challenge. “You’ve solved one problem,” he said. “Now, get certified and prove you can solve any problem.”

This is how I truly deepened my expertise. My learning shifted from a single project to a systematic understanding of the platform. I dove into Clay’s official certification program. In which It was about proving my skills by building a real-world project.

The challenge was to build a complete CRM enrichment workflow from scratch. It involved using APIs to pipe data out of a CRM, enriching it in Clay with multiple data sources, and then sending the clean, valuable data back into the CRM. It was the exact kind of high-value, technical work Victor does for our clients every day.

Submitting that project and earning my Clay CRM Enrichment Certification was more than just a credential. It was proof of a complete transformation.

The Result - From Intern to Automation Expert

My entire workload shifted. I stopped being a manual researcher who was always behind. I started building and improving our automated systems. Not only did I save hours of my own time, but the notes the system produces are better, deeper, and more insightful than anything I could have found by hand.

I became a Clay expert not because I planned to, but because I had a real, painful problem to solve, a clear goal, and a great mentor. It turns out that automating my own job was the most valuable project I could have possibly worked on.

And now, I’m ready for the next one.

Check out my certification here.

Ready to Empower Your GTM Team?

My journey from manual researcher to automation expert highlights a core truth at Novlini: your team’s real value lies in strategy and human connection, not repetitive tasks. We empower Go-To-Market teams by eliminating operational friction, allowing them to focus on what truly drives growth.

If outdated processes are slowing down your sales cycle, impacting your client experience, or draining your team’s energy, we specialize in building the intelligent, automated systems that transform these bottlenecks into competitive advantages.

Don’t let manual work hold you back. Discover how a tailored automation strategy can elevate your GTM operations.

Let’s build something powerful together. Visit novlini.io →

Hello readers! My name is Premdeep, and I’m an intern here at Novlini. When I first joined, one of the main jobs was to support the sales team. My biggest task was processing our most important leads, and it was completely manual. This is the story of how a technical dead-end led to a creative solution and my first real automation project.

The Daily Routine - Manually Processing Our Best Leads

At Novlini, we’re an Attio expert partner. That means we get listed on Attio’s “Hire an expert” page as a top option. When a potential client finds us there and fills out the contact form, it’s a huge buying signal. These are our best leads.

And every single one of them landed in my lap.

The process was this: a notification email from PartnerPage would hit our inbox. I would then have to stop everything, open up Attio, and manually copy and paste every single detail: first name, last name, company, email, and the comments etc from their message.

It was slow, and I was always terrified of making a typo. A single mistake could mean a bad first impression with our most important prospects. The process worked, but it felt clunky and fragile. It relied entirely on me.

A Roadblock and a New Direction

We knew this manual process was time taking and we would like to reach out to them asap. One day, Giacomo, and I first looked into the most obvious solution: using the PartnerPage API to get the data directly. We figured we could just build a simple integration.

But we hit a wall. The PartnerPage API documentation wasn't very good. It was confusing, and we couldn't find a clear or reliable way to get the data we needed. It felt like a dead end.

I was a bit discouraged, but Giacomo saw it as a puzzle.

He said, "Okay, the direct API is a no-go. But the data still comes in as an email, right? The information is all there. Why don't you look at the Gmail API side of things, or find another workaround? See if you can grab the data from the email itself."

That was the spark I needed. My task was no longer just about data entry. My new mission was to find a clever workaround and build a machine to do it for me.

Building the First Version, Step-by-Step

With Giacomo’s advice as my guide, I dove in. My plan was to use Make.com to connect Gmail to Attio. I spent a few days learning the tools, and after a lot of trial and error, I started building.

Here’s how I put the first version together:

Step 1: I started in Gmail. The first puzzle was isolating the right emails. I created a filter that looked for the specific subject line from our PartnerPage notifications. Then, I told the filter to automatically apply a new label to these emails, which I called “incoming/partnerpage”. This puts all the important leads in one neat folder, ready for the automation to find them.

Step 2: I moved to Make.com. This was going to be the engine. I created a new scenario and set up a Gmail module to act as the trigger. I configured it to watch the incoming/partnerpage label. Now, the machine had a starting point.

Step 3: I figured out how to parse the data. The next challenge was getting the information out of the email body (HTML to text). I added a "Text Parser" module in Make.com. Using its "Match Pattern" tool, I told it to find the text after "First Name:", then do the same for "Last Name:", "Email:", and so on. This was the most tedious part, but once it was done, I had clean, separate pieces of data.

Step 4: I sent the data to Attio. This was the most exciting part. I went into Attio and created a new workflow with a "Webhook is received" trigger, which gave me a unique URL. Back in Make.com, I added an "HTTP" module and configured it to POST a JSON package of my clean data to that Attio URL.

Step 5: I put it all together in Attio. The final piece was telling Attio what to do with the data it received. In my Attio workflow, the first step after the webhook was to "Parse" the JSON. Then, I added steps to "Create or update" a Company record and a Person record. I mapped all the data from the webhook and set key attributes like the "Lead Stage" to "New" and the "Source" to "Attio - Partnerpage." etc.

It worked! I ran a test, and a few seconds later, a new lead popped up in Attio, perfectly formatted. I was proud. I had taken Giacomo's idea and built a real, working automation.

Getting an Expert’s Advice: Making It Better

My machine worked, but I had a feeling it could be more robust. To get an expert opinion, I reached out to Benoit, one of our technical consultants. I showed him what I had built.

Benoit looked at the workflow and smiled. "This is great. Really smart," he said. "But what happens if the Attio API is down for a minute and the call fails? How do you handle errors?"

He was right. My machine worked when things went perfectly, but it wasn't prepared for the real world.

He gave me a suggestion that took it to the next level. "After you send the data to Attio," he explained, "add a Router. This will create two paths: one for success and one for failure. On the success path, you can re-label the email so you know it's done. On the failure path, you can give it an error label so you can fix it manually."

That was the expert touch I was missing. It was a small change that made the whole system resilient and professional. I immediately went back and updated the final step.

On the success route, I added a Gmail module to remove the incoming/partnerpage label and add a processed/partnerpage label. This was the deduplication step that ensured the same lead would never be processed twice.

On the failure route, I added another Gmail module. This one removed the incoming/partnerpage label but added an error/attio label. This quarantined any problematic emails, so I could review them without breaking the whole system.

The Final Machine - Fast, Accurate, and Clean

With Benoit's advice, the final machine was complete. The whole thing takes about 30 seconds and has transformed my daily work. I no longer spend my time copying and pasting; I spend it looking for the next process to improve.

Human Buffer, or Automated System?

The old way of working relied on a human buffer, in this case, me manually connecting two systems by copying and pasting. It worked, but it was fragile, slow, and would never have scaled as we grew.

That’s not just a bad process. It’s a liability.

The better way is to build a machine. My project to automate our most valuable leads is a perfect example of this. We connected our tools intelligently. We empowered our team by automating a repetitive task, which allows us to act faster and more accurately. This is how the best operations teams build.

And they’re moving faster than you.

Let’s catch up.

Want to Rethink Your GTM Operations?

At Novlini, the project I just described isn't a one-off. It’s a perfect example of our core philosophy in action. We believe that your team’s time is your most valuable asset, and it shouldn't be wasted on tasks a machine can do better.

We look for operational bottlenecks like manually processing leads, cleaning messy data, or preparing for sales calls and build smart, automated systems to solve them.

If you’re ready to stop being the buffer and start building the machine, we should talk.

Start here: Visit novlini.io →

When a software company announces a big funding round, most people glance at the number, nod, and move on.
$52 million. Google Ventures. Another startup with big ambitions.

But here’s the thing: not all funding rounds are created equal.
Some are just fuel to keep the lights on.
Others are genuine turning points - moments when a company moves from “interesting” to “credible,” from “niche” to “mainstream contender.”

Attio’s $52M Series B is one of those moments.

Why CRM still matters

It’s worth taking a step back.

CRM isn’t just another SaaS category. It is the operating system of go-to-market teams.
Every lead captured, every deal tracked, every renewal flagged, every forecast debated - it all runs through CRM.

That’s why Salesforce built a $300B company. That’s why HubSpot became the default for startups.
CRM is sticky, central, and strategic.

But it’s also broken.

Most teams today see their CRM as a necessary evil:

• A database nobody trusts.

• A system reps hate to update.

• A tool that feels out of sync with how go-to-market actually works in 2025: fast, automated, AI-powered.

In short: the old guard has become a bottleneck.

The Attio difference

Attio was born in reaction to this bottleneck.

Instead of a static database, Attio is a programmable CRM:

• AI-native - not AI bolted on top, but AI woven into the foundations: ingestion, workflow automation, permissions, predictive intelligence.

• Flexible by design - teams adapt CRM objects and workflows to their business, not the other way around.

• Programmable - companies build on Attio, spinning up custom apps, automations, and workflows in days, not months.

The result: a CRM that feels alive, closer to a product platform than a rigid database.

What $52M unlocks

A Series B of this size - led by Google Ventures, with Redpoint, Balderton, Point Nine, and 01A following on - changes the game in three concrete ways.

1. Product at another scale

Startups often win because they move fast, but they lose credibility with larger buyers because they lack robustness.
With this funding, Attio can scale its engineering team and ship enterprise-grade features at pace:

• granular permissions,

• advanced compliance,

• hardened security,

• deeper integrations with the rest of the stack.

This is the difference between being loved by startups and being trusted by mid-market and enterprise.

2. Credibility with larger customers

A CRM is a 5–10 year decision. No CMO or CRO wants to bet on a vendor that might not be around in 24 months.

By raising $116M to date and adding GV’s Michael McBride (ex-CRO of GitLab) to the board, Attio is now sending the right signal: we’re here for the long run.

That’s not just a line for investors. It’s what reassures a scale-up CFO signing a multi-year contract, or an enterprise RevOps leader considering a migration project.

3. Bigger opportunities for partners

At novlini, we’ve worked with Attio since the early days. We’ve already migrated fast-growing scale-ups like Jellysmack, Morning, Tandem Health, and Plume onto Attio.

Until now, we mostly recommended Attio for startups and younger scale-ups. But this raise means we can bring it confidently into RFPs against Salesforce and HubSpot.

That’s a massive shift: from “promising alternative” to serious competitor in big projects.

What this looks like in the real world

Funding stories mean little unless you connect them to actual customers. Here’s what we’ve seen at novlini.

Jellysmack

A global content company with complex GTM operations across multiple geographies.
Their challenge: consolidating customer data across teams while automating repetitive workflows.
With Attio, they could design their own data model and automations. The CRM finally fit their business - instead of forcing them to fit the CRM.

Morning

A fast-growing French scale-up.
They needed a CRM that could evolve as quickly as their go-to-market.
Attio let them define custom objects and workflows, and then adapt them as the business shifted. No waiting on vendor roadmaps. No multi-month SI projects.

Tandem Health

A Swedish health-tech company where compliance and security were critical.
Attio’s permissions and data controls gave them the trust they needed, while still letting their RevOps team build automations that eliminated manual work.

Plume

A wellness scale-up aiming to capture customer context end-to-end.
Attio’s ingestion and programmable surfaces allowed them to unify signals from marketing, product, and billing into one system - without relying on endless spreadsheets and middleware.

The pattern across all four is the same:

• Teams spend less time on manual updates.

• Processes adapt faster to market changes.

• CRM becomes a system of action, not just a system of record.

Why this is a turning point for the CRM market

Let’s talk about the market structure.

For years, there were really only two serious options: Salesforce and HubSpot.

• Salesforce dominates at the enterprise level. It’s powerful, but incredibly heavy. Customization means armies of consultants, six-figure budgets, and slow iteration.

• HubSpot became the default for startups. It’s easy to get started, but its flexibility and scalability hit a ceiling once you grow beyond standard marketing-sales funnels.

This duopoly created a trap: startups had to start with HubSpot, then “graduate” painfully to Salesforce. Everyone accepted the cost and complexity as inevitable.

Attio breaks that cycle.

It offers the flexibility startups need and the robustness enterprises demand. It’s programmable, AI-native, and designed for iteration. That’s why this raise matters: it gives Attio the resources to compete credibly in the middle and upper market, where Salesforce and HubSpot once had no challengers.

How Attio compares

Here’s a clear look at the differences.

Salesforce

• Strengths: ecosystem, integrations, global brand, enterprise credibility.

• Weaknesses: slow, expensive, requires heavy consulting, not AI-native, painful UX.

• Fit: enterprises with huge budgets and tolerance for complexity.

HubSpot

• Strengths: easy to adopt, strong marketing automation, polished UX.

• Weaknesses: rigid data model, limited customization, becomes fragile at scale.

• Fit: startups and SMBs who need to move quickly but don’t require complex processes.

Attio

• Strengths: AI-native architecture, fully programmable, flexible data model, fast iteration.

• Weaknesses: younger ecosystem, still maturing enterprise features (permissions, compliance).

• Fit: scale-ups and mid-market companies that want agility now, and larger enterprises looking for modern alternatives in pilots or new divisions.

This is why the Series B is so important: it allows Attio to close the gap on enterprise readiness, while keeping its DNA of speed and programmability.

What this means for GTM leaders

If you’re leading sales, marketing, or RevOps today, here’s the takeaway:

1. You finally have a third option. For years, it was Salesforce or HubSpot. Attio is now credible enough to join the shortlist.

2. You can design GTM like a product. With programmable CRM, your processes become policies and automations, not just spreadsheets and meetings.

3. You can scale without rebuilding. Attio adapts as your company grows, instead of forcing painful migrations.

4. You can future-proof your stack. With AI at the core, you’re not bolting features on an old foundation - you’re building on a system designed for the next decade.

The bigger picture

Attio’s raise is more than a funding headline. It’s a signal that the CRM category - one of the most entrenched in SaaS - is finally being reinvented.

For customers, it means more choice, less lock-in, and CRMs that actually accelerate go-to-market instead of slowing it down.
For partners like novlini, it means we can bring Attio into larger and larger deals, helping clients escape the HubSpot-to-Salesforce treadmill.
For the market, it means competition, innovation, and the beginning of a new era where CRM is programmable, AI-native, and truly adaptable.

The future of CRM is being built now.
And with this $52M round, Attio just proved it intends to lead that future.

Looking ahead: what CRM could look like in 5 years

This $52M round isn’t just about scaling the current product. It’s about laying the foundation for where CRM is heading. And if Attio executes, the category could look very different five years from now.

1. Natural language workflows

Instead of configuring a CRM through forms and checkboxes, teams will describe what they want in plain English.
“When a customer hits 3 product milestones in 14 days, create an expansion opportunity, assign it to the right AE, and draft the outreach email.”
Attio’s engine will translate that into live workflows instantly - no consultants, no six-month implementation.

2. AI agents running pipeline

Today, sales managers chase reps for pipeline hygiene. Tomorrow, agents will do it for them.

• Agents will check for missing contacts, stalled opportunities, or late follow-ups.

• They’ll draft updates, reminders, and even forecast adjustments.

• Humans will supervise and approve, but the manual pipeline policing will disappear.

Instead of CRM being a chore, it will feel like a co-pilot actively keeping your GTM on track.

3. GTM as code

In the same way developers moved from manual server setups to infrastructure-as-code, GTM leaders will move to go-to-market-as-code.
Your routing policies, SLAs, playbooks, and success plans will live as versioned, auditable configurations.

• Need to adapt your ICP? Update the policy file, not a dozen spreadsheets.

• Need to test a new territory motion? Spin it up as a branch, measure outcomes, and merge if it works.

This means GTM becomes iterative, testable, and transparent - more like product development, less like corporate folklore.

4. The end of the HubSpot → Salesforce treadmill

For the last decade, the narrative was simple: start with HubSpot, then “graduate” to Salesforce once you grew.
Five years from now, that won’t be the default.
With programmable, AI-native CRM like Attio, companies will start earlier and stay longer. The system will adapt as they scale, instead of forcing painful migrations.

Why this matters

The CRM market hasn’t seen a true paradigm shift in 20 years. Most so-called “innovations” have been features bolted onto legacy systems.

Attio’s raise is different. It signals a company building for the next paradigm:

• AI-native from the start.

• Fully programmable.

• Designed for scale, but flexible enough for small teams.

For GTM leaders, this means the way you build, run, and scale revenue systems is about to change as fundamentally as software engineering changed with the cloud.

Closing

Attio’s $52M Series B isn’t just another funding story. It’s the signal that CRM is entering its most exciting era since Salesforce invented the category.

For companies, it means more choice and more innovation.
For partners like novlini, it means we can finally put Attio head-to-head with Salesforce and HubSpot in major projects.
And for the future of GTM, it means CRM will stop being a database of record and become a programmable, AI-driven system of action.

The future of CRM is natural language workflows, AI agents running pipeline, and GTM as code.
Attio just put itself in position to build that future.

About me

I’ve had the privilege of being Attio’s first partner, and over the past years I’ve helped migrate scale-ups like Jellysmack, Morning, Tandem Health, and Plume onto the platform. Writing this analysis is not abstract for me - it’s the reflection of what I see every day: companies rethinking their GTM from the ground up once they have a CRM that finally adapts to them. With novlini, I continue to work with teams that want to move faster, scale smarter, and build GTM systems that are ready for the next decade.