DOCSEARCHbyAlgolia
Submit Docs

Twenty CRM Documentation

website·Indexed 35 days ago

https://docs.twenty.com/

A full-featured CRM platform that can be deployed on the cloud or self-hosted. Twenty features a customizable data model with objects and fields, visual workflow automation, and AI-powered capabilities including an AI Chatbot and AI Agents. The platform supports email and calendar synchronization, custom dashboards for data visualization, and extensibility via TypeScript-based apps.

Tokens
182.2K
Snippets
586
Records
1.3K
Agent score
68%

What's inside Twenty

  1. Overview of Kanban Board Views

    Kanban views in Twenty visually map out process flows. Each column represents a distinct stage (based on a Select field value) and each card represents an individual record. They are ideal for sales pipelines, project management, recruitment, or any staged workflow.

  2. Overview of Twenty Install Hooks

    Install hooks are specialized logic functions that execute during an app's install, upgrade, or uninstall lifecycle. They allow developers to seed data, back up records, validate upgrades, or clean up external resources. They operate outside the standard trigger model (HTTP, cron, database events) and are automatically attached to the application manifest at build time.

    Key Constraints:

    • Each app can define at most one of each hook: pre-install, post-install, and uninstall.
    • They are not executed in dev mode (yarn twenty dev). To trigger them manually during development, use the CLI commands:
      • yarn twenty dev:function:exec --preInstall
      • yarn twenty dev:function:exec --postInstall

  3. Overview of Twenty Workflows

    Workflows in Twenty are an in-app automation tool designed to create custom business processes. They are primarily used for two purposes: creating internal automations to reduce manual data entry and repetitive tasks, and moving data in and out of Twenty using API calls and webhooks.

  4. Overview of the Document Generator app architecture

    The Document Generator app allows users to create personalized documents from CRM data using reusable templates with {{placeholders}}. The core logic involves selecting a template and a CRM record to fill placeholders and generate a polished document (including a PDF). This generation process can be triggered via multiple interfaces: the command menu, an AI agent, a workflow step, or a shareable link.

  5. Overview of Twenty App Layout surfaces

    The layout layer of a Twenty app defines the user interface elements where an app surfaces. This includes navigation, data presentation, and custom interactive components.

    Key surfaces and their controlling entities include:

    • Sidebar: Custom entries linking to views or external URLs via defineNavigationMenuItem.
    • Record list: Saved configurations for objects (columns, filters, groups) via defineView.
    • Record detail page: Tabs and widgets on a record page via definePageLayout, definePageLayoutTab, and definePageLayoutWidget.
    • Custom UI Widgets: Sandboxed React components (buttons, forms, dashboards) that can be placed inside other surfaces via defineFrontComponent.
    • App settings: Entries in the app's settings menu via defineSettingsMenuItem.
    • Command menu (Cmd+K): Pinned quick actions or hidden commands via defineCommandMenuItem.

  6. Overview of Twenty Dashboards

    Dashboards in Twenty are visual tools used to track key performance metrics and gain insights from CRM data. A dashboard consists of one or more tabs, which in turn contain widgets. Common use cases include tracking sales performance, team activity, pipeline health, and custom metrics.

  7. Overview of Twenty app entities

    Twenty apps are composed of entities, each defined as a TypeScript file with a single export default. Available entities include:

    • Objects & Fields: Custom data models with typed fields.
    • Logic functions: Server-side TypeScript triggered by HTTP, cron, or DB events.
    • Front components: React components for the UI (side panels, widgets, etc.).
    • Skills & Agents: AI capabilities and autonomous assistants.
    • Views & Navigation: Pre-configured list views and sidebar items.
    • Page layouts: Custom record detail pages with tabs and widgets.

  8. Overview of Messaging Channels

    Messaging channels allow apps to ingest conversations from external providers (LinkedIn, WhatsApp, SMS, etc.) into Twenty's Message and Message Thread records. This enables external conversations to appear on Person, Company, and Opportunity records, in the timeline, and in search without requiring a custom UI. The model is channel-neutral, relying on participants, text, timestamps, and threads.

  9. Overview of Twenty CRM capabilities

    Twenty is an open-source, production-ready CRM designed as a platform for building rather than just a product for configuration. Key technical characteristics include:

    • Modern Stack: Built with React, TypeScript, and PostgreSQL, allowing developers to extend the system without proprietary languages.
    • Agent-Ready: Designed for AI agents to operate within the data model using real permissions, skills, tools, and MCP.
    • Deployment Flexibility: Supports both cloud and self-hosted deployments to ensure data ownership and privacy.
    • No Vendor Lock-in: Features an open-source core and allows data export at any time.

  10. Overview of AI capabilities in Twenty

    Twenty provides two primary AI capabilities:

    1. AI Chatbot: A context-aware assistant capable of accessing Twenty data to answer queries.
    2. AI Agents in Workflows: Intelligent automation used to process data, make decisions, and execute tasks within workflows.

  11. Overview of the TabButton component

    The TabButton component is used to present route links and actions alongside tabs with consistent styling. It shares the appearance of the Tabs primitive but uses the Button primitive for interaction. It is ideal for navigation links or actions like adding a new tab or opening an overflow menu.

  12. Overview of Twenty's Permissions and Access Control

    Twenty uses a role-based access control (RBAC) system to manage how users interact with data and workspace settings. The system provides granular control across four primary areas:

    • Role-based access: Create custom roles with specific sets of permissions.
    • Object permissions: Define who can view, edit, or delete specific records/objects.
    • Field permissions: Restrict access to sensitive individual fields within an object.
    • Settings permissions: Control which users can modify workspace-wide configurations.
    • SSO Integration: Available for the Organization plan to secure access via an identity provider.