NocoBase

NocoBase is an open-source AI-augmented no-code/low-code platform for building business systems — CRM, ERP, internal tools, project management portals — without starting from scratch. It combines a WYSIWYG drag-and-drop interface for non-technical users with a full CLI and agent API surface for developers, so both can collaborate on the same system simultaneously.

Under the hood, NocoBase uses a data-model-driven architecture where your business data lives in standard relational tables completely decoupled from the UI. You can build multiple views, forms, and workflows on top of the same data model, connect external databases and third-party APIs as additional data sources, and deploy the whole thing on your own infrastructure with zero vendor lock-in.

What sets NocoBase apart from typical no-code tools is its plugin microkernel design: every feature — blocks, actions, data sources, permissions, workflows, AI employees — is a plugin. You can install, replace, or build your own plugins using the same conventions the core team uses, making the platform genuinely extensible without forking. With 108 built-in plugins and growing, teams can assemble sophisticated applications from composable pieces rather than hitting walls when requirements become complex.

The platform now includes first-class AI integration: AI employees can be embedded directly into interfaces and backend workflows, with their own fine-grained role-based permissions. Mainstream coding agents (Claude Code, Cursor, Codex) can drive the entire NocoBase CLI to build and modify systems programmatically, with NocoBase skills that teach agents how to work with data models, pages, workflows, and permissions natively.

What You Get

• Data Model-Driven Architecture - Business data lives in standard relational tables fully decoupled from UI, letting you build multiple views, forms, and dashboards on the same collection without duplicating data logic.
• AI Employees with Permissions - Embed AI agents (analyst, translator, researcher roles) directly into workflows and interfaces; each AI employee has its own fine-grained role with field-level read/write permissions and a full audit trail.
• Dual-Interface Collaboration - WYSIWYG no-code canvas for humans and a full CLI + MCP API for coding agents; both Claude Code, Cursor, and Codex can drive NocoBase end-to-end using installed NocoBase skills.
• Plugin Microkernel - Every feature (blocks, actions, data sources, workflows, permissions, AI) is a plugin built on shared conventions; install official plugins, buy commercial ones, or write custom plugins using the same architecture.
• Multi-Source Data Access - Connect the main database (PostgreSQL, MySQL, SQLite, MariaDB), external databases, and third-party REST/GraphQL APIs as unified data sources under one query interface.
• Visual Workflow Automation - Design event-driven workflows visually with branching, approval nodes, AI employee participation, and trigger-based automation — covering notification routing, data processing, and multi-step approvals.
• Fine-Grained Permissions - Control access at the menu, page, block, field, and action level per role; permission boundaries apply equally to human users and AI employees.
• Flexible Deployment - Docker Compose, create-nocobase-app CLI, or Git source with support for PostgreSQL, MySQL, SQLite, and KingBase, plus Redis for pub-sub and caching in clustered setups.

Common Use Cases

• Building a custom internal CRM - A sales operations team models contacts, companies, deals, and activities in NocoBase collections, builds Kanban and table views for reps, connects workflows for automated follow-up reminders, and embeds an AI employee that summarizes email threads and suggests next actions — without a line of custom backend code.
• Replacing spreadsheet-driven approval processes - An HR team replaces a multi-sheet leave approval tracker with a NocoBase portal: employees submit requests through a form block, managers receive workflow notifications and approve in-app, and all decisions are logged with audit trails for compliance.
• Constructing a client-facing data portal - A consulting firm builds a branded portal where clients can view project status, submit change requests, and download reports — using NocoBase’s permission system to isolate each client’s data and its external API data source plugin to pull live data from their ERP.
• AI-assisted data entry and monitoring - A logistics company connects NocoBase to their shipment database and configures an AI employee that monitors for anomalies in delivery data, auto-fills delay reason codes by analyzing carrier notes, and triggers escalation workflows when SLA thresholds are breached.
• Developer-accelerated system building with coding agents - A solo developer uses Claude Code with the NocoBase CLI skill to generate data models, configure page layouts, and set up permission roles in minutes, then refines specific UI interactions manually in the WYSIWYG canvas — cutting weeks of boilerplate development.

Under The Hood

Architecture

NocoBase is organized as a TypeScript monorepo with clear separation between a thin application core and an extensive plugin layer. The server is built on a Koa-based HTTP runtime that delegates all business logic to plugins loaded through a plugin manager with topological dependency resolution. A DataSourceManager abstracts heterogeneous backends — relational databases, external APIs, and introspected foreign data wrappers — into a uniform collection and repository interface, so application code treats all data sources identically. The new client runtime, built around a reactive FlowEngine, manages UI as a tree of observable FlowModel instances that load, persist, and move through a repository interface, completely decoupling UI composition from both data structure and backend implementation. This dual-layer extensibility — plugins on the server, FlowModels on the client — means third-party developers can extend behavior at any level without modifying core code.

Tech Stack

The server runtime is Node.js with TypeScript, fronted by Koa and koa-router for HTTP handling, with commander powering an extensive CLI used by both human operators and coding agents. Sequelize serves as the primary ORM with dialect support for PostgreSQL, MySQL, MariaDB, SQLite, and KingBase; Umzug handles schema migrations. On the client, React with Ant Design v5 provides the component foundation, while Formily drives reactive form schemas and the new FlowEngine layer uses @formily/reactive for observable state. The build pipeline runs on a Lerna monorepo with Vitest for testing, ESLint plus Prettier for code quality, and multi-stage Docker builds for production packaging. Redis is available for pub-sub messaging and distributed caching in clustered deployments. The AI layer exposes MCP, HTTP APIs, and CLI surfaces for external agent frameworks (n8n, Dify, Coze) alongside the native AI employee system.

Code Quality

With over fourteen hundred test files organized across more than three hundred test directories, NocoBase maintains comprehensive coverage at the unit and integration levels, with dedicated Vitest configurations and mock utilities that create deterministic test environments. The AGENTS.md team ruleset enforces Conventional Commits, prohibits fire-and-forget async patterns, bans new any introductions, and requires ESLint fixes before work is considered done — a disciplined standard for a large open-source project with ninety-four contributors. TypeScript strict mode is applied uniformly across the monorepo, with plugin interfaces and collection types strongly typed. Error handling is explicit throughout the server core, with typed error classes for application lifecycle, plugin loading, and database operations, though consistency varies across the larger plugin ecosystem.

What Makes It Unique

NocoBase occupies a genuinely distinct position: it is the only open-source no-code platform that treats coding agents as first-class builders alongside human users. The AGENTS.md file and the @nocobase/cli skill system are designed so that Claude Code, Cursor, and Codex can autonomously initialize, configure, and extend a NocoBase deployment without human intervention. The FlowEngine — a reactive model tree where every UI element is a persistable, moveable, observable model — is an architectural innovation that eliminates the traditional separation between configuration data and rendered UI, enabling AI agents to modify page structure through the same repository interface that humans use visually. The plugin microkernel, combined with a unified data-source abstraction that treats relational databases, external APIs, and federated query sources interchangeably, gives NocoBase a scalability ceiling that generic no-code tools cannot match.

Self-Hosting

NocoBase uses a custom proprietary license called the NocoBase License Agreement, distinct from both open-source licenses like AGPL-3.0 and permissive licenses like MIT. The Community Edition is free to download, self-host, and use commercially — you can build and run your own internal business applications without paying. However, the license prohibits distributing, selling, or transferring the software itself, and specifically bars selling or offering no-code, low-code, or AI platform products built on top of NocoBase without holding a Commercial Edition license. If you plan to build and sell Upper Layer Applications to external customers, the Standard Edition requires customers to have their own commercial license, and higher tiers expand those rights. For straightforward internal use, the Community Edition imposes no meaningful restrictions.

Operating NocoBase yourself is a moderate infrastructure commitment. The recommended path is Docker Compose with PostgreSQL or MySQL, which handles data persistence, migrations (via the nocobase upgrade command), and static asset serving through an included Nginx configuration. You are responsible for database backups, SSL termination, uptime monitoring, and applying version upgrades — NocoBase releases new versions frequently (multiple times per week based on release history), so staying current requires an active maintenance posture. For clustered or high-availability setups, Redis is needed for pub-sub and distributed caching, adding an additional service to operate. The codebase is large (271 MB, 24,000+ files) and the upgrade process involves running database migrations that can be time-sensitive.

Compared to a managed or commercial deployment, self-hosters give up access to commercial plugins (workflow approvals, advanced charts, audit logs, multi-workspace features, and more) that are sold separately and not included in the open repository. NocoBase’s commercial tiers (Standard, Professional, Enterprise) bundle these plugins and add priority support, SLAs, and in some tiers dedicated account management. The free community version has a healthy plugin set covering core CRUD, basic workflows, and AI employees, but teams with advanced automation, compliance, or multi-tenant requirements will likely need commercial plugins or a paid plan to avoid building those capabilities from scratch.