Twenty CRM: What It Actually Does and When It Fits Your Revenue System

Twenty CRM is an open source customer relationship management platform built as a lighter alternative to Salesforce and HubSpot. It gives you custom objects, GraphQL and REST APIs, and the option to self-host on your own Postgres database. It fits engineering-led B2B SaaS teams that want data ownership and API control, and it ships without native sales engagement or marketing automation.

Key takeaways

• Twenty is a modern, developer-friendly CRM: TypeScript codebase, Postgres storage, GraphQL and REST APIs, and a metadata API that lets you create objects and fields programmatically.
• Its real advantage is control. You own the database, the schema, and the deployment, which matters if your product data and CRM data need to live close together.
• Its real gap is the surrounding ecosystem. Sequencing, dialing, marketing automation, forecasting, and the long tail of native integrations are things you assemble yourself.
• Self-hosting is not free. At 25 seats, the engineering time to run it usually costs more than the license fee you avoided.
• Twenty makes sense for teams with in-house engineering capacity and an unusual data model. Teams that need a working revenue system in 30 days should buy something with a mature ecosystem.

What is Twenty CRM, and who is it built for?

Twenty is an open source CRM project that began as a public GitHub repository and grew into a product with both a hosted cloud offering and a self-hosted deployment path. The core is licensed under AGPL, which is worth flagging to your CTO early: AGPL carries copyleft obligations if you modify the code and expose it as a network service. For internal use, this is usually a non-issue. For anything you plan to embed in a customer-facing product, get a real answer from counsel before you build on it.

Architecturally, Twenty behaves like a workspace database with CRM defaults on top. You get standard objects (companies, people, opportunities, notes, tasks) and you can define your own objects and fields through the UI or the metadata API. Views come as tables and kanban boards, filtered and sorted per user. Gmail and Google Calendar sync pull message and meeting activity into records automatically.

The honest audience for Twenty is a technical team. If your founding engineers are comfortable running a container and a Postgres instance, and your GTM motion has a data shape that standard CRMs fight you on, Twenty is a serious option. If your revenue team’s first instinct on any change is to file a ticket with a vendor, it is the wrong tool.

What does Twenty CRM actually do well?

Three things stand out.

The data model bends to you. Most CRMs force B2B SaaS companies into a contact-account-opportunity shape that ignores how their business actually works. Product-led companies track workspaces, not accounts. Marketplaces track supply and demand sides. Usage-based businesses track consumption events that drive expansion. In Twenty, those become first-class objects with their own fields and relationships, defined in code and version controlled alongside the rest of your stack. This is the same design philosophy behind relationship-first tools like Affinity, applied with more flexibility and less opinion.

The API is a real API. Every custom object you create automatically gets GraphQL and REST endpoints. Webhooks fire on record changes. That means enrichment, scoring, and routing logic can live in n8n, Clay, or your own service, writing back to the CRM without a middleware tax. For teams doing serious CRM enrichment work, the difference between an API that exposes your custom schema cleanly and one that hides it behind rate limits and object permissions is weeks of engineering time.

You own the data. Your CRM sits in your Postgres instance, in your VPC, under your backup policy. You can join it directly against product usage tables in your warehouse without an ETL hop. Security reviews get shorter. Data residency questions from European buyers get simpler answers.

Where does Twenty CRM break down?

The gaps are predictable for a young open source project, and they are the gaps that cost revenue teams the most.

There is no native sales engagement layer. No multichannel sequences, no dialer, no built-in A/B testing on cold email. If your SDR motion depends on those, you are buying Outreach, Salesloft, Smartlead, or Instantly alongside Twenty and syncing them yourself. That sync is real engineering work, and it is the layer where most homegrown stacks quietly rot. Our breakdown of Outreach vs Salesloft covers what that layer needs to do.

There is no marketing automation. Lifecycle email, form handling, landing pages, and lead scoring all live elsewhere. Reporting is functional rather than deep: you will not get the pipeline waterfall, cohort, or attribution analysis a CRO expects without pushing data to a BI tool.

The integration ecosystem is thin compared to the incumbents. Salesforce’s AppExchange and HubSpot’s marketplace each carry over a thousand listings. Twenty covers the important connections through Zapier, n8n, and its API, which works well when you have someone to build and maintain those connections, and works badly when you do not.

Finally, adoption risk does not disappear because the software is free. Gartner’s research on sales technology has consistently found that a large share of the tools sales organizations buy go underused by the reps they were bought for. A CRM your team ignores costs you the same forecast accuracy whether it cost $0 or $165 per seat.

How does Twenty CRM compare to HubSpot, Salesforce, and Attio?

Dimension	Twenty	Attio	HubSpot	Salesforce
Hosting	Self-host or cloud	Cloud only	Cloud only	Cloud only
Source access	Open (AGPL core)	Closed	Closed	Closed
Custom data model	Strong, API-defined	Strong, UI-defined	Moderate	Strong, admin-heavy
Sales engagement	None native	Limited	Built in (Sales Hub)	Built in (Sales Engagement)
Marketing automation	None native	None native	Best in class	Via Marketing Cloud
Reporting depth	Basic, pair with BI	Moderate	Strong	Deepest
Ecosystem	Thin, API-first	Growing	Very large	Largest
Best fit	Engineering-led teams with unusual data models	Fast-moving Seed to Series A teams	Marketing-led SMB and mid-market	Complex enterprise sales orgs

What does Twenty CRM really cost once you self-host it?

Run the math for a 25-seat Series A team.

Salesforce Sales Cloud Enterprise lists around $165 per user per month, so roughly $49,500 a year before implementation. HubSpot Sales Hub Professional lists around $100 per seat per month, roughly $30,000 a year. Twenty self-hosted costs you infrastructure, call it $150 a month for a managed Postgres instance and a container host, so about $1,800 a year.

Then add the part teams forget. Someone has to build the initial schema, wire up email and calendar sync, connect enrichment and outbound tooling, handle version upgrades, own backups, and answer the pager when the instance goes down mid-quarter. Budget 3 to 6 weeks of engineering for the initial build and 10 to 20 percent of one engineer thereafter. At a fully loaded engineering cost of $180,000, that ongoing slice alone runs $18,000 to $36,000 a year.

So Twenty self-hosted lands in roughly the same total cost band as HubSpot at 25 seats. It gets meaningfully cheaper at 100 seats, because the engineering cost stays flat while per-seat license fees do not. The decision at Seed to Series B is about control and data architecture, and the savings argument only becomes real at scale.

What does Twenty need around it to produce pipeline?

A CRM records what happened. Pipeline comes from the system built around it. McKinsey’s B2B Pulse research has found that buyers now move across a large number of channels in a single purchase journey and expect consistency across all of them, which means your CRM has to receive signal from many places and route it fast.

In practice, a working stack around Twenty looks like this: a data layer that sources and verifies contacts (see our guide to B2B email list providers for how to buy that well), an enrichment and scoring layer that writes firmographic and intent data back through the API, a sequencing tool for execution, and a BI layer for reporting. Twenty sits in the middle as the system of record.

The weakest link is almost always data quality. Research published in Harvard Business Review by Tadhg Nagle and Thomas Redman found that only a very small percentage of the data records they tested met basic quality standards. A flexible schema makes that worse if nobody owns field definitions, because every rep invents their own. Define your objects, required fields, and stage exit criteria before you migrate a single record, the same discipline that makes an outbound funnel measurable.

Should your team adopt Twenty CRM?

Work through this before you commit:

• We have an engineer who will own the deployment, upgrades, and backups by name, not by hope
• Our data model genuinely does not fit a standard contact-account-opportunity structure
• Data residency, source access, or warehouse proximity is a real requirement, not a preference
• We already run sequencing and marketing automation in dedicated tools, or we do not need them yet
• Legal has reviewed the AGPL implications for how we intend to use and modify it
• We can absorb 3 to 6 weeks of build time before the revenue team gets a usable system

Five or six checks means Twenty is worth a pilot. Two or three means you should buy a mature platform and spend your engineering time on the layers that actually differentiate your revenue motion. That judgment call sits with whoever owns your GTM function, and it is the same tradeoff analysis we run when scoping any GTM engineering build.

Frequently Asked Questions

Is Twenty CRM free?

The self-hosted version is free to download and run under its open source license, so you pay only for infrastructure. Twenty also offers a hosted cloud plan priced per user, which removes the operational burden. The self-hosted option carries real ongoing engineering cost, so treat “free” as license-free rather than cost-free.

Can Twenty CRM replace Salesforce for a Series B company?

For most Series B companies with a complex sales process, no. Salesforce’s advantage at that stage is forecasting depth, territory and permission granularity, and an integration ecosystem your CS, finance, and support teams already depend on. Twenty replaces Salesforce well when the sales process is simple and the data model is unusual.

Does Twenty CRM have an API for enrichment and automation?

Yes. Twenty exposes GraphQL and REST endpoints, including for custom objects you define, plus webhooks for record events and a metadata API for creating schema programmatically. This is one of its strongest features and makes it straightforward to connect Clay, n8n, or your own services for enrichment and routing.

How does Twenty compare to Attio for early-stage B2B SaaS?

Attio is faster to stand up and requires no infrastructure work, which suits most Seed to Series A teams. Twenty gives you source access and self-hosting, which matters when data ownership is a requirement or when CRM data needs to sit next to product data. Pick Attio for speed, Twenty for control.

What is the biggest risk in adopting Twenty CRM?

Orphaned ownership. Open source CRMs tend to get deployed by a founding engineer who then moves on to product work, leaving upgrades, integrations, and data hygiene unowned. Six months later the schema has drifted and the pipeline data is unreliable. Assign a named owner with allocated time before you migrate.