spiral@out:~/blog$ cat transmissions/twenty.md

Twenty: A CRM You Version Like Code

[2026-10-21] ::self-hosting, crm, typescript, postgres, business

Twenty bills itself as "the open alternative to Salesforce, designed for AI." It's a CRM for tracking contacts, companies, deals and everything else a sales or ops team keeps tabs on. The difference is that you can host it yourself and extend it with code that lives in your own repo.

It's on GitHub Trending today with about 59,000 stars and nearly 800 contributors. It ships fast, too: v2.50.0 landed yesterday. The core is AGPL-3.0, with some important exceptions covered in the fine print below.

What it does

Twenty gives you the usual CRM building blocks: records for people, companies and opportunities, customizable views like tables and kanban boards, workflows that automate the repetitive parts, and AI agents that work inside the data. The README's pitch is that it's "the CRM you build, ship, and version like the rest of your stack."

That last part is the real idea. Most CRMs are customized by clicking around an admin panel until nobody remembers why a field exists. Twenty lets you define your data model and logic as code, review it in a pull request, and deploy it like any other software.

How it works

Customizations are packaged as "apps." You scaffold one with the Twenty CLI, then declare objects, fields and views in TypeScript. This example from the README adds a deal object with name, amount and close-date fields:

import { defineObject, FieldType } from 'twenty-sdk/define';

export default defineObject({
  nameSingular: 'deal',
  namePlural: 'deals',
  labelSingular: 'Deal',
  labelPlural: 'Deals',
  fields: [
    { name: 'name', label: 'Name', type: FieldType.TEXT },
    { name: 'amount', label: 'Amount', type: FieldType.CURRENCY },
    { name: 'closeDate', label: 'Close Date', type: FieldType.DATE_TIME },
  ],
});

Then you publish it to your workspace from the command line. Apps can also contain views, agents and "logic functions," which are small pieces of code the platform runs for you. There are official agent skills too, so coding assistants like Claude Code, Codex or Cursor can build Twenty apps for you.

Under the hood it's a TypeScript monorepo: a NestJS backend on PostgreSQL and Redis with BullMQ for background jobs, a React front end, and REST and GraphQL APIs plus webhooks for integration.

Trying it

The fastest way is the hosted version at twenty.com. To self-host, the docs walk through Docker Compose. Grab the example environment file and compose file:

curl -o .env https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/.env.example
curl -o docker-compose.yml https://raw.githubusercontent.com/twentyhq/twenty/refs/heads/main/packages/twenty-docker/docker-compose.yml

Fill in the secrets in .env, then start it with docker compose up -d. The stack runs a server, a background worker, PostgreSQL 16 and Redis. The server applies its own database migrations on startup. The docs also offer a one-line install script, and an upgrade guide that's worth reading before your first version bump. Back up the database first.

To build your own app on top:

npx create-twenty-app my-app
npx twenty app:publish --private

The fine print

  • It's mostly AGPL, not all AGPL. The licence file is worth reading. Files marked /* @license Enterprise */ are under a commercial licence and need a paid Enterprise Edition subscription for production use. You can still use them for development and testing. The app toolkit (the CLI, SDKs, create-twenty-app) and the UI component library are MIT.
  • Your apps can stay proprietary. A special "Twenty Application Exception" to the AGPL says apps that talk to Twenty only through its published APIs and SDKs aren't covered by the AGPL, so you can license your own customizations however you like. Modifying Twenty itself still triggers the AGPL in full, including the clause requiring you to share source with users of a network service.
  • Self-hosting means running a real stack. Postgres, Redis, a worker process, encryption keys and regular upgrades are all on you. It's well-documented, but it isn't a single binary.
  • It moves fast. 133 releases so far. That's great for features, but it means upgrades are routine maintenance.

Who it's for

Twenty suits technical teams who've outgrown spreadsheets but don't want to rent Salesforce, plus companies that need their customer data on their own servers and developers who want their CRM schema under version control next to the code that uses it. If you'd rather click than code, the hosted version and the built-in views cover the basics without writing a line.

The GitHub repo and the documentation are the places to start, and it's in the resource index now.

End of transmission.

<- BACK TO LOG