Self-Host Twenty: The Open-Source CRM You Actually Own
The moment that makes you hate your CRM is always the same. You add one more person to the team, the per-seat bill jumps again, and you realize you are paying a monthly rent that only ever goes up, for software that holds the single most valuable asset your business owns: your customer relationships. You do not own that data. You rent access to it, and the landlord sets the price.
Twenty is the open-source CRM built for people who are tired of that arrangement. It looks and feels like a modern tool (think clean, fast, Notion-style), it runs on your own server, and the bill is a flat infrastructure cost instead of a number that scales with your headcount. Here is what it actually is and why it is worth a weekend of your time.
What Twenty actually is
Twenty is a community-built alternative to Salesforce and HubSpot. You get the things you expect from a CRM: contacts and companies, deal pipelines you can drag cards through, notes and tasks, and email sync so conversations land next to the record they belong to. Nothing about it feels like a compromise you make to save money.
The part that makes it interesting under the hood is the data model. Most CRMs lock you into their idea of what a "contact" or a "deal" is. Twenty lets you define your own objects and fields right in the UI, and the backend rebuilds its API around them at runtime. Add a custom object called "Contracts" and, seconds later, it has a working API with no migration to run and no developer ticket to file.
You own the data, and the API that comes with it
Every Twenty workspace auto-generates both a REST and a GraphQL API from your data model. There is a Core API for your records (People, Companies, Opportunities, Notes, Tasks, and anything custom) and a Metadata API for the schema itself. That means your CRM is not a dead end where data goes to sit. It is a system other tools can read from and write to.
Pulling your companies out is this simple:
curl -X GET "https://your-twenty.vm.elestio.app/rest/companies" \
-H "Authorization: Bearer YOUR_API_KEY"
No export button, no CSV dance, no waiting on a vendor to approve an integration. The data is yours and it is one request away.
The 2026 twist: your CRM can talk to AI agents
Twenty 2.0 shipped something no legacy CRM has: a native MCP (Model Context Protocol) server. In plain terms, that means an AI assistant like Claude or a coding agent can connect directly to your CRM and act on it. "Summarize every open opportunity over $10k and draft a follow-up note on each" stops being a fantasy and becomes a thing an agent can actually do against your live data, because the CRM speaks a protocol agents understand.
This is the sleeper feature. The CRMs charging you per seat are not going to hand an autonomous agent the keys to your pipeline any time soon. An open one already has.
What it costs, honestly
Let me be straight about the trade-off, because "free software" is never the whole story. Twenty the software has no license fee. Running it does cost something, because it is a real application with a few moving parts: a PostgreSQL database, a Redis queue, S3-compatible object storage for files, the main server, and a background worker. That is infrastructure, and infrastructure has a bill.
The difference is what that bill is tied to.
| Model | What you pay for | What happens when the team grows |
|---|---|---|
| Typical SaaS CRM | Per user, per month | The bill climbs with every seat you add |
| Self-hosted Twenty | A fixed VM, regardless of seats | Same server serves 5 users or 50 |
For a growing team, that flip from per-seat to flat is the entire pitch. Ten seats on a hosted CRM can quietly become a four-figure annual line item. The same ten users on a self-hosted Twenty share one modest VM.
Deploy it without the DevOps homework
Those five services (database, cache, storage, server, worker) are exactly the kind of thing that turns a "quick self-host" into a lost Saturday. Deploying Twenty on Elestio wires them together for you, with TLS, automated backups, and updates handled, so you get a working CRM at a URL instead of a half-finished Docker Compose file and a nagging feeling you configured the storage wrong. Check the service page for current VM sizing and pricing.
A few things to know before you commit
Give it enough memory. Running five services on a tiny instance leads to the worker getting starved and background jobs (like email sync) lagging. Start with a mid-size VM rather than the smallest one.
Email sync needs credentials. Connecting a mailbox so conversations attach to records means setting up the provider connection properly. Budget ten minutes for it, and test with one account before rolling it out to the team.
Back up the database, not just the files. Your records live in PostgreSQL. On Elestio the automated backups cover this, but if you ever self-manage, a file backup without a database dump is not a backup of your CRM.
It is young, and moving fast. Twenty ships quickly, which is great for features and means you should read release notes before major upgrades. Own your data, but stay current on purpose, not by accident.
The bottom line
A CRM holds your relationships, your pipeline, and your history. Renting that on a meter that punishes you for growing was never a great deal, it was just the only option. Twenty makes owning it realistic: a genuinely modern interface, a real API, native support for AI agents, and a cost that stops tracking your headcount.
Spin one up on the Twenty page, import a few contacts, and see how it feels to run the system instead of renting it.
Thanks for reading ❤️ See you in the next one 👋