Twenty

Twenty is a full‑stack, open‑source Customer Relationship Management (CRM) platform engineered for developers who need a flexible, self‑hosted solution. At its core, it exposes a rich data model that can be customized through an intuitive UI while simultaneously offering programmatic access via GraphQL, REST, and webhook endpoints. The system is designed to be modular: core objects such as Accounts, Contacts, and Deals are defined in a schema‑driven manner, but developers can extend the model with custom entities and fields without touching the codebase. This approach reduces friction when adapting the CRM to niche business processes, making it attractive for startups and enterprises that require bespoke data structures.

Twenty follows a micro‑service inspired monolith architecture built with React (Vite) for the front end and NestJS for the API layer. The backend leverages TypeScript across both layers, ensuring type safety and a unified developer experience. Data persistence is handled by PostgreSQL with a schema‑first design; migrations are generated via TypeORM, and the ORM layer is abstracted to allow future database swaps. Real‑time updates are powered by WebSockets (via Socket.io), enabling instant UI refreshes when records change. For background jobs and workflow automation, the platform uses BullMQ backed by Redis, allowing developers to hook custom processors into triggers such as record creation or status changes. Containerization is native; the entire stack can be deployed via Docker Compose or Kubernetes manifests, and a Helm chart is available for cloud‑native deployments.

• Schema Customization: Add or modify fields and objects through the admin UI; changes propagate to the GraphQL schema automatically.
• GraphQL API: Full CRUD, filtering, sorting, and pagination. Schema introspection is enabled for tooling integration.
• REST API: Lightweight endpoints for legacy or third‑party integrations; supports OAuth2 for authentication.
• Webhooks & Event Bus: Subscribe to domain events (e.g., contact.created) and publish custom actions.
• Workflow Engine: Define triggers (record events, time‑based) and actions (API calls, email sends). The engine exposes a declarative JSON schema that developers can manipulate programmatically.
• Authentication & Authorization: Role‑based access control (RBAC) with granular permissions per object and field; supports SSO via OAuth/OIDC.

The project ships with a docker-compose.yml that brings up PostgreSQL, Redis, the API server, and the web client in minutes. For production, a Kubernetes deployment is recommended: the Helm chart manages secrets via Vault or KMS and supports horizontal pod autoscaling. The application is stateless aside from the database, making scaling straightforward. Backups are handled through PostgreSQL’s native tools or via scheduled snapshots in cloud providers, and the platform supports multi‑region deployments with read replicas for low latency.

Twenty’s extensibility is twofold. First, developers can write plugins in TypeScript that hook into the event bus or expose new API endpoints; the plugin system is still under active development but already allows adding custom UI panels. Second, the open API specification (OpenAPI 3) and GraphQL introspection enable third‑party tools to generate clients automatically. The platform also offers a custom script runner that can execute arbitrary Node.js code in the context of a workflow, allowing rapid prototyping of integrations with services like Zapier, Make, or custom SaaS products.

The documentation is hosted under the /developers section and includes a detailed API reference, deployment guides, and a plugin development tutorial. A Discord community provides real‑time support, while the GitHub repository follows semantic versioning and a clear contribution workflow. The codebase is heavily typed, with linting rules enforced by ESLint and formatting via Prettier. Continuous integration pipelines run unit tests, lint checks, and build validation on every PR, ensuring that contributors can ship high‑quality code with confidence.

• Startup CRMs: Quickly spin up a customized CRM without vendor lock‑in, integrating with existing SaaS tools via webhooks.
• Enterprise Data Lakes: Use Twenty as a front‑end to a shared customer data repository, leveraging its schema flexibility for diverse business units.
• Automation‑First Teams: Build complex sales pipelines with the built‑in workflow engine, triggering emails, Slack notifications, or external API calls.
• Developer Portals: Expose a self‑hosted CRM as part of an internal developer platform, allowing teams to manage leads and support tickets within a single stack.

• Open Source & No Vendor Lock‑In: Full control over data and code, with a permissive license that encourages community contributions.
• Performance & Scalability: TypeScript, PostgreSQL, and Redis provide a low‑latency, high‑throughput foundation suitable for thousands of concurrent users.
• Flexibility: Schema customization and plugin support mean the platform can evolve with business needs without major rewrites.
• Cost‑Effective: Eliminates subscription fees and allows hosting on existing infrastructure or cloud credits.
• Community & Ecosystem: Rapid feature development, a growing plugin market, and active discussion channels reduce the learning curve for new contributors.

In summary, Twenty offers a robust, developer‑centric CRM that balances the convenience of an out