Twenty CRM review: the open-source Salesforce alternative for solo founders (June 2026)

> Quick answer (June 21, 2026): Twenty CRM is a TypeScript + PostgreSQL open-source CRM that hit 51,000 GitHub stars and shipped v2.14.0 on June 15, 2026. For a solo founder it works in three out of four "fork lanes": ship-as-is, fork the data model, or use Twenty's GraphQL API as a headless backend. The fourth lane (replace the React frontend) costs more than most solo teams want to pay. If you need standard CRM shape, Twenty is the strongest open-source pick in 2026. If you need a CRM custom to your business that no off-the-shelf data model fits, you are better off building your own.

Twenty has been on our gallery shortlist for nine months. We finally added it after the v2.x line shipped built-in

-flavored AI agents and chat, which moved it from "promising" to "this is what we are recommending now."

This is a curator review, not a vendor demo. We pulled the repo, ran it on Docker Compose, broke a few things on purpose, and then asked the question we ask of every gallery exhibit: what does a solo founder actually sign up for in year two?

---

The exhibit card

The headline shift this year is the AI agent layer. The 2024 reviews positioned Twenty as a "cleaner Pipedrive clone." That is no longer the right frame. The 2026 framing is: a CRM data model with versionable configuration and pluggable agents on top of it. Whether that framing holds in 2027 depends on how fast the AI layer moves; the data model side is the safe bet.

---

What we tested

We did the boring curator pass.

1. Cloned, booted, signed in. docker compose up on a fresh Ubuntu 24.04 box. First boot completed in 9 minutes 12 seconds. Wizard to create the first workspace was three clicks.
2. Imported a contact list. 1,247 rows of CSV. Twenty inferred the column mapping correctly except for a freeform "lifecycle stage" column we had to enum-ify by hand.
3. Wrote a custom data object. We added a Project object linked to Company via a one-to-many. The code-based object definition in v2.x lets you ship the data model change with a git commit, which is the part of Twenty that we keep coming back to.
4. Exercised the GraphQL API. Built a small Node script that pulls contacts and pushes a status update.

   

   The schema is honest; nothing surprising.
5. Tried the v2.x AI agent panel. We pointed it at our own Anthropic key and asked it to "summarize the last 5 deals that stalled." It returned a plausible summary in ~4.8 seconds. We did not try to push it harder than that.

We also reproduced the install pain that the dev.to writeup comment thread flagged: on one machine, the backend container booted but the frontend could not reach it. The fix was a stale .env value for SERVER_URL. Twenty's docs cover it; the error message could be friendlier.

---

Four lanes for the solo founder

Most reviews tell you whether Twenty is "good." That is the wrong question for a solo founder. The right question is which of four lanes you are in, because each one has a different bet attached to it.

Lane A: Ship as-is

You fork nothing. You either run Docker Compose on a VPS or pay for Twenty Cloud. You use Twenty's stock data model: companies, people, opportunities, notes, tasks. You use the AI agent panel as-is.

• When this fits: you sell B2B services or B2B SaaS to companies. Your pipeline is "lead, qualified, proposal, won, lost." You do not need anything weird.
• Year-2 bet: you are betting that Twenty keeps shipping. With 51k stars and a clear roadmap, the bet is OK.
• Cost: $0 for self-host (plus VPS), or $9 per user per month on Twenty Cloud (June 2026 pricing per twenty.com).

Lane B: Fork the data model only

You keep Twenty's React UI and NestJS backend, but you redefine the objects. Add a Project, add a Subscription, rename Opportunity to whatever your team actually calls it. The v2.x code-based object definitions make this clean: it is just TypeScript.

• When this fits: your business is mostly a CRM, but the noun "Opportunity" hurts to type and you have one or two extra entities the stock model misses.
• Year-2 bet: your custom objects merge cleanly with upstream releases as long as you do not redefine the core ones. Treat the fork like a Postgres schema patch you maintain.
• Cost: about a week of focused engineering time to design and ship; then near-zero maintenance.

Lane C: Replace the React frontend

You keep Twenty's NestJS + PostgreSQL backend and the GraphQL API, but you throw away the React app and build your own UI in

Next.js or whatever your team prefers.

• When this fits: your team needs a UI that is so far from Twenty's defaults that customizing the React app is harder than building your own. This is rare.
• Year-2 bet: you are maintaining both a forked backend AND a fully custom frontend. Upstream Twenty releases are now your problem.
• Cost: more than most solo founders should spend. We recommend skipping this lane unless you have a specific reason.

Lane D: Use Twenty as a headless backend

You skip the React app entirely. You use Twenty as a GraphQL-API CRM service that powers a different product (a customer portal, a chatbot, an internal ops tool).

• When this fits: you are not really building a CRM; you are building a customer-facing product that needs CRM semantics as a backend. Twenty's API surface gives you contacts, companies, deals, notes, custom objects, all wired up.
• Year-2 bet: NestJS and GraphQL are durable. The API contract is the thing you build against, and it has been stable across the 2.x line.
• Cost: roughly the same as Lane B. The AgentNotebook tutorial on adding an AI agent to an existing SaaS without rewriting it walks through almost exactly this shape of integration if you want a worked example.

---

The honest gaps

We agree with the March 2026 production-readiness assessment on most of its critique. Twenty's gaps in 2026:

• Third-party integration ecosystem is young. Zapier and the built-in webhooks cover the common cases. If you need a deep

  

  HubSpot or

  

  Salesforce-grade marketplace, this is not it yet.
• Enterprise features are missing. Territory management, CPQ, multi-currency reporting. Not there. If your team needs those, Twenty is the wrong tool. Use Salesforce.
• Mobile is web-only. The web app is responsive; there is no native iOS or Android. For most solo founders that is fine; for field sales teams it is not.
• Self-host support is community. When the Docker Compose stack misbehaves, you are in Discord and GitHub issues. That is the open-source contract; just know what you are signing up for.

We are explicit about these because the curator promise is honesty. We would rather you skip Twenty for the right reason than pick it for the wrong one.

---

Twenty vs the rest of the open-source pack

The Twenty win on this rubric is consistent: modern UI, GraphQL, code-based data model, AI agents in core. The fair caveat is that EspoCRM is more mature for sales-ops users who want admin-UI customization without touching code. If your team is non-technical and you do not want to deploy code, EspoCRM is the honest recommendation.

---

A verifiable user quote

From the r/selfhosted thread (~12 months ago, top reply): "I use twentycrm since a few months and I'm really happy with how effortless it was to set up and run. And it looks and feels really stellar."

We agree with the setup experience for most installs. We disagree that it always feels effortless: the backend-unreachable Docker quirk above bit us, and on a slow VPS the initial build takes longer than the docs imply.

---

When a custom CRM is the better bet (the sidebar)

There is a fork in the road every CRM evaluation hits. If a generic CRM data model fits, take a generic CRM and stop. If a generic data model does not fit (your business has invoicing baked in, your business has a manufacturing workflow, your business is regulated and needs an audit trail no CRM ships with), forcing Twenty (or any CRM) into shape is more painful than just building the thing you actually need.

That second case used to mean a year of custom development. In 2026 it does not. A modern AI app builder emits real, owned Next.js applications with auth, payments, file storage, and a database wired up, and the codebase stays portable Next.js you can host wherever you want. It is not free (Twenty is); it is the bet you make when no off-the-shelf data model fits. Twenty if you want the standard CRM shape; a custom app builder if you need a custom one. The two are not in competition.

---

---

Aaron Brick curates the ShipGarden gallery. ShipGarden is an independent editorial gallery; we add an exhibit when it has earned its frame, and we say so plainly when it has not.

For the gallery's earlier entries this week: last week's curator review of Open SaaS by Yui Tanaka, and the Mastra AI agent starter gallery entry we added two days earlier.

Your move: pick your lane before you fork. If you do not know which lane you are in, you are not ready to fork.