Twenty

Open-source CRM, honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Open-source (GPL-licensed) CRM positioned as a modern alternative to Salesforce — self-hostable, fully customizable, with kanban views, email sync, workflow automation, and custom data models [website].
• Who it’s for: Non-technical founders and small sales teams who are paying Salesforce or HubSpot per-seat fees and want to own their customer data on their own infrastructure [website][GitHub README].
• Cost savings: Salesforce Starter runs $25/user/month; Enterprise goes to $150+/user/month. Twenty self-hosted runs on a $6–20/mo VPS with unlimited seats and no per-record pricing [website].
• Key strength: 40,537 GitHub stars, YC-backed, built on a modern TypeScript/NestJS/React stack, with the UX deliberately modeled after tools like Notion and Linear rather than the Salesforce school of UI design [GitHub README][website].
• Key weakness: Still a young product. Workflow automation, email sync, and permissions are present but not as battle-tested as Salesforce’s decade-old equivalents. If your sales ops depend on deep integrations with legacy enterprise tools, you’ll hit gaps fast.

---

What is Twenty

Twenty is a self-hostable CRM built as a direct counter-argument to Salesforce’s pricing model. The GitHub README is unusually blunt about the motivation: “CRMs are too expensive, and users are trapped. Companies use locked-in customer data to hike prices. It shouldn’t be that way.” [GitHub README].

That’s not marketing copy. That’s a product thesis. The team built Twenty because they believe the SaaS CRM model has a structural problem — the data you generate about your customers becomes the vendor’s leverage to raise your bill. GPL licensing is the technical answer to that: you can self-host, fork, and extend without negotiating a commercial agreement.

The product is built on a modern TypeScript stack: NestJS on the backend, React on the frontend, PostgreSQL as the database, Redis for caching. The architecture is designed to be extended — the README references plugin capabilities as a planned feature that will let a broader ecosystem build on top of the core [GitHub README]. As of this review, it sits at 40,537 GitHub stars with hundreds of contributors, backed by Y Combinator [website][GitHub].

The UX is deliberately modeled after newer tools rather than traditional CRM interfaces. The README explicitly names Notion, Airtable, and Linear as design references — tools that non-technical people actually enjoy using. That framing matters. Traditional CRMs are built around a sales ops specialist’s mental model. Twenty is built around a founder’s.

---

Why people choose it over Salesforce, HubSpot, and Pipedrive

The honest answer is: cost and control. The third-party review coverage of Twenty specifically is sparse in the provided sources, but the self-hosting rationale is consistent across the broader category [1].

The per-seat pricing math on incumbent CRMs is brutal for small teams. Salesforce Starter at $25/user/month for a 10-person team is $3,000/year before any add-ons. Salesforce Professional at $75/user/month for the same team is $9,000/year. And both tiers come with data that lives entirely in Salesforce’s infrastructure — migrating out is painful by design [website].

Twenty’s counter-offer: the software is free, you run it on a VPS you control, and the only limit on seats or records is your server’s resources. For a 10-person team on a $10/month Hetzner instance, you’re looking at $120/year instead of $3,000–9,000/year. The savings math is obvious enough that it doesn’t require a spreadsheet [website][1].

The second reason people choose it is the data ownership argument. When your CRM runs on your server, your customer contact history, deal pipeline, and company data aren’t hostage to a vendor’s pricing department or acquisition event [1]. This matters more than it sounds. Several high-profile SaaS CRMs have repriced aggressively after hitting scale or after private equity buyouts. GPL-licensed software running on your own infrastructure removes that risk category entirely.

The third reason is the UX. Salesforce’s UI is famous for being confusing to non-technical users. Twenty’s interface is built around the Notion/Linear design language: clean, keyboard-navigable, with a ⌘K command palette that lets you fly through the app without touching the mouse [website]. The website quotes community feedback that reads like relief: “Modern, powerful, affordable platform to manage your customer relationships” [website]. That framing — versus Salesforce’s enterprise-complexity positioning — tells you who Twenty is actually for.

---

Features

Based on the website, README, and product screenshots:

Core CRM objects:

• Companies and People as first-class objects [website]
• Custom objects — you can create new record types beyond the defaults [website]
• Custom fields on any object [website]
• Relationships between objects [website]

Views and navigation:

• Table view with sorting, filtering, and grouping [website]
• Kanban view for pipeline visualization [website]
• Group-by on any field [website]
• Favorites for keeping key accounts visible [website]
• Global search with keyboard-first navigation [website]

Notes and activity:

• Rich notes with markdown and text blocks, attached to records [website]
• Task management linked to deals and contacts [website]

Email:

• Email synchronization — emails appear in the CRM against the relevant contact or company [website]
• Granular sharing controls: sync everything (subject + body + attachments), subject only, or metadata only per thread [website]

Workflows:

• Trigger-and-action workflow builder for automating repetitive tasks [website]
• Webhook and API connectivity [website]

Permissions:

• Custom roles and role-based access control [website]
• Per-object and per-field permission management [website]

Developer surface:

• Full PostgreSQL database — you own and can query your data directly [website]
• API and webhook access [website]
• Plugin architecture in progress — once shipped, this will enable a third-party extension ecosystem [GitHub README]
• TypeScript throughout — the same language stack that most modern engineering teams use [GitHub README]

What’s notably absent (or not yet mature):

• Deep native integrations with tools like LinkedIn Sales Navigator, Outreach, or Gong — enterprise CRM staples
• AI-native features (no lead scoring, deal health signals, or AI-assisted note-taking mentioned in current materials)
• Native phone calling or SMS sequences
• A mobile app (not mentioned)

Twenty is a solid foundation for managing contacts, companies, deals, and activity history. It is not a full sales engagement platform. If you need call recording, cadence automation, or Salesforce-grade reporting, you’ll need to build those integrations yourself or live without them.

---

Pricing: SaaS vs self-hosted math

Twenty self-hosted:

• Software license: $0 (GPL) [website]
• Infrastructure: $6–20/month on Hetzner, Contabo, or DigitalOcean for a small team
• Your time for setup and maintenance

Twenty Cloud (managed):

• Pricing details were not available in the data provided for this review. The website has “Get Started” and “Talk to us” CTAs, suggesting there may be a managed offering, but terms and pricing were not published at time of writing. Check the current website for updated plans.

Salesforce (for comparison):

• Starter: $25/user/month (billed annually)
• Professional: $75/user/month
• Enterprise: $150/user/month
• Unlimited: $300/user/month
• Add-ons (analytics, CPQ, service cloud) layer on top of base seat pricing

HubSpot (for comparison):

• Free CRM: limited features, HubSpot branding
• Starter: $15/user/month
• Professional: $90/user/month (minimum 3 seats)
• Enterprise: $150/user/month (minimum 10 seats)

Concrete savings math for a 5-person founding team:

Option	Monthly	Annual
Salesforce Professional (5 seats)	$375	$4,500
HubSpot Professional (5 seats)	$450	$5,400
Twenty self-hosted (Hetzner VPS)	~$10	~$120

The gap is roughly $4,400–5,300/year. For a pre-revenue or early-revenue startup, that’s a meaningful number. For a 20-person team on Salesforce Enterprise, the gap approaches $36,000/year.

---

Deployment reality check

Twenty self-hosting runs on Docker Compose. The documentation references standard deployment targets: a Linux VPS with Docker installed, with PostgreSQL and Redis as dependencies (both bundled in the default compose setup) [GitHub docs].

What you actually need:

• A Linux VPS with 2GB RAM minimum (4GB recommended once you have real data volume)
• Docker and docker-compose
• A domain name and reverse proxy (Caddy or nginx) for HTTPS
• SMTP credentials for email-based notifications and invites

What can go sideways:

• The email sync feature requires OAuth configuration with your email provider (Gmail, Outlook) — this is not a one-click setup and requires creating API credentials in your provider’s developer console
• Custom objects and fields are powerful but require some upfront schema planning — the default structure may not match your specific business model without configuration
• The plugin ecosystem doesn’t exist yet at time of writing — planned but not shipped, so custom integrations currently require code-level work [GitHub README]
• RBAC and permission configuration is present but will require time to set up correctly for teams with different access needs

Realistic time estimate: 1–2 hours to a working instance for someone comfortable with Docker and a Linux terminal. For a non-technical founder following documentation step-by-step: half a day including domain and SMTP setup. If you’ve never configured a reverse proxy, budget extra time or have someone do the initial deployment for you.

The 40,537 GitHub stars suggest a large community that has successfully self-hosted this, which translates to a large volume of answered questions in the Discord and GitHub issues if you hit problems [website][GitHub].

---

Pros and Cons

Pros

• GPL-licensed. Unlike many “open-source” CRMs that use restrictive licenses to gate commercial use, Twenty is GPL. You own the running instance. No vendor can revoke that [website].
• 40,537 GitHub stars. This is not a toy project. That level of community validation means real users running it in production, real bug reports being filed, and real contributors improving it [GitHub].
• UX that non-technical founders actually want. Built against the Notion/Linear design vocabulary, not the Salesforce-admin vocabulary. The keyboard-first navigation and clean interface are genuine differentiators [website].
• Modern tech stack. TypeScript/NestJS/React is exactly what most developers are using in 2026 — which means hiring, contributing, and extending are realistic [GitHub README].
• YC-backed with community momentum. Hundreds of contributors and active development signals this isn’t going to be abandoned [website].
• Full data ownership. PostgreSQL on your infrastructure means you can query your own CRM data directly, export it freely, and migrate without vendor permission [website].
• Custom objects and fields. Not locked into a fixed schema — you can model your business data the way your business actually works [website].
• No per-seat or per-record pricing. Add 50 users, 100,000 contacts — the infrastructure cost is the only thing that scales [website].

Cons

• License listed as NOASSERTION in automated metadata, which suggests the machine-readable license field in the repository may be inconsistent. The website explicitly claims GPL [website]. Verify directly at the GitHub repository before making licensing decisions.
• No AI-native features at time of writing. No lead scoring, deal health, AI-assisted notes, or predictive analytics. If you need these, you’ll integrate an external AI tool or go without.
• Integration catalog is thin. Twenty connects via API and webhooks, but doesn’t have native integrations with common sales tools (LinkedIn, Outreach, Gong, Mixpanel). This matters less if you self-build integrations; it matters a lot if you need plug-and-play.
• Plugin ecosystem not yet available. The README promises it, but it’s not shipped. Until it is, extensibility requires code [GitHub README].
• Email sync requires OAuth setup. Not technically hard, but it’s a step that will block non-technical founders if they don’t have a guide.
• No documented mobile app. Salesforce and HubSpot both have mobile apps for deal updates on the go. Twenty’s current posture is web-only.
• Reporting is basic. Deep analytics and custom report builders are Salesforce’s strongest suite; Twenty’s current reporting surface is limited to views and filters.
• Young product. The workflow automation, permissions, and email features are present but less battle-tested than eight-year-old enterprise CRM features. Expect rough edges.

---

Who should use this / who shouldn’t

Use Twenty if:

• You’re a founder or small team paying $100–500/month for Salesforce or HubSpot and the per-seat math is hurting.
• Your CRM needs are core: contacts, companies, deals, notes, activity history, pipeline views.
• You have someone on the team (or you yourself) who is comfortable with Docker and a Linux VPS, or you’re willing to pay someone once for a deployment.
• You care about owning your customer data on your own infrastructure — either for compliance reasons, privacy, or just principle.
• You want a CRM that non-technical team members will actually log into, instead of the Salesforce-shaped object they avoid.

Skip it (stay on HubSpot) if:

• You need HubSpot’s native marketing automation, landing pages, and form builder tightly integrated with your pipeline.
• Your team is not technical and you don’t want to own infrastructure maintenance.
• You rely heavily on HubSpot’s partner/integration marketplace.

Skip it (stay on Salesforce) if:

• You’re past 50 people with complex territory management, multi-currency deal tracking, CPQ, and custom approval flows.
• Your sales team uses Salesforce integrations from vendors who only certify against Salesforce (some enterprise deal rooms, forecasting tools).
• Your compliance team requires SOC 2 Type II or similar certifications for your CRM vendor — Twenty self-hosted puts that compliance burden on you.

Skip it (use Pipedrive or Attio instead) if:

• You want managed SaaS with a modern UI and don’t want to self-host — Attio in particular covers a similar “modern CRM” positioning as a hosted product.
• Your team size and deal volume are small enough that even Pipedrive’s lowest tier is reasonable.

---

Alternatives worth considering

• Attio — the closest spiritual alternative in managed SaaS. Modern, data-model-first CRM with similar UX sensibility to Twenty. Fully hosted, no self-hosting option, but worth evaluating if infrastructure management isn’t something you want.
• HubSpot Free CRM — zero cost, managed, and the integration ecosystem is vast. Gets expensive fast once you need any paid features, but the free tier is genuinely functional for small teams.
• Pipedrive — pipeline-focused, easier to use than Salesforce, managed SaaS. Runs $15–70/user/month depending on tier. Not self-hostable but well-regarded for small sales teams.
• SuiteCRM — mature open-source CRM, GPL-licensed, self-hostable. Far older and more feature-complete than Twenty, but the UI shows its age (built in the Salesforce-admin tradition, not the Notion tradition). Worth considering if you need deep functionality over modern UX.
• ERPNext CRM — if you’re eventually going to want ERP (inventory, accounting, HR) connected to your CRM, ERPNext bundles all of it in one self-hosted system.
• Salesforce — the incumbent. Mention it here only to say: if you’re reading this review, you already know what Salesforce is and why you’re looking for an alternative.

---

Bottom line

Twenty is the most credible open-source Salesforce alternative available in 2026 for small teams and non-technical founders. The 40,537 GitHub stars, YC backing, and active community mean you’re not betting on a solo maintainer’s weekend project. The GPL license means you genuinely own your instance. And the UX, built against the Notion and Linear design vocabulary instead of the Salesforce-admin playbook, means the people on your team who aren’t sales ops specialists will actually use it.

The trade-offs are real and worth naming: this is a young product, the integration catalog is thin, there’s no AI-native functionality, and self-hosting requires a minimum of technical comfort. If you need a battle-hardened enterprise CRM with a ten-year integration ecosystem, Twenty is not ready for you yet. But if you’re paying $200–500/month for Salesforce or HubSpot and your actual CRM needs are contacts, companies, deals, pipeline views, and email history — Twenty self-hosted on a $10 VPS is worth a serious look. The math is not complicated.

If the deployment is the part you want to skip, that’s what upready.dev does for clients: one-time setup, you own the infrastructure.

---

Sources

1. Jason Fitzpatrick, How-To Geek — “Here’s Why Self-Hosting a Server Is Worth the Effort” (Nov 21, 2022). https://www.howtogeek.com/846979/heres-why-self-hosting-a-server-is-worth-the-effort/

Primary sources:

• GitHub repository: https://github.com/twentyhq/twenty (40,537 stars, GPL-licensed, hundreds of contributors)
• Official website: https://twenty.com
• Documentation / self-hosting guide: https://docs.twenty.com/developers/self-host/capabilities/docker-compose