Skip to content
STACK IT FAST

ToolJet

Curated OSSHybridLow-Code Developer Tool Platform6-20 people

Audited from github.com/ToolJet/ToolJet

Open-source low-code application platform for building enterprise internal tools, business workflows, and AI agents.

Language
JavaScript
Database
PostgreSQL
Hosting
Docker
License
AGPL-3.0
Running for
3 years 6 months
Team
6-20 people

Why this architecture

ToolJet allows teams to build complex internal web applications and dashboards with drag-and-drop React UI components and 50+ data connectors.

Tech stack by layer

8 technologies · audited Sep 17, 2026
Frontend & UI
  • ReactVisual drag-and-drop app builder and reactive component rendering engine
  • Tailwind CSSUtility styling foundation for dashboard layouts and customizable UI widgets
  • TypeScriptType-safe architecture across frontend state models and builder controls
Backend & APIs
  • JavaScriptDynamic query transformation runtime and sandboxed client script evaluator
  • NestJSEnterprise backend application framework organizing services, auth, and workers
Data & Persistence
  • PostgreSQLRelational system database and ToolJet DB internal data persistence layer
  • RedisIn-memory cache and queue broker powering BullMQ background jobs and events
Infrastructure & Deploy
  • DockerMulti-service container definitions orchestrating app server, PostgREST, and Redis

ToolJet architecture diagram

Open SVG
ToolJet architecture diagramApp builder → Server (REST); App builder → Multiplayer (canvas sync); Server → PostgreSQL (metadata); Server → ToolJet DB (built-in tables); Server → JS sandbox (transformations); Server → Redis (enqueue); Redis → Workflows & jobs (jobs); Server → Data connectors (query proxy)CLIENTSSERVICESWORKERS & JOBSDATA & STORAGEEXTERNALApp builderReact · TailwindServerNestJS · CASLMultiplayerYjs over WebSocketsJS sandboxisolated-vmWorkflows & jobsBullMQPostgreSQLsystem DBToolJet DBPostgRESTRediscache · queuesData connectors50+ pluginsRESTcanvas synctransformationsjobsmetadatabuilt-in tablesenqueuequery proxy
How the main components of ToolJet connect, drawn from the audited repository.
Diagram as text
  • App builder (React · Tailwind) → Server (NestJS · CASL): REST
  • App builder (React · Tailwind) → Multiplayer (Yjs over WebSockets): canvas sync
  • Server (NestJS · CASL) → PostgreSQL (system DB): metadata
  • Server (NestJS · CASL) → ToolJet DB (PostgREST): built-in tables
  • Server (NestJS · CASL) → JS sandbox (isolated-vm): transformations
  • Server (NestJS · CASL) → Redis (cache · queues): enqueue
  • Redis (cache · queues) → Workflows & jobs (BullMQ): jobs
  • Server (NestJS · CASL) → Data connectors (50+ plugins): query proxy

Key architectural decisions

4 decisions
  1. 01

    Sandboxed JavaScript Execution via isolated-vm

    Executes custom user-provided JavaScript expressions securely inside V8 isolates to prevent unauthorized system and process access.

  2. 02

    Built-in ToolJet DB via PostgREST Integration

    Embeds a managed PostgreSQL schema exposed over HTTP via PostgREST, providing out-of-the-box relational tables without external database setup.

  3. 03

    Pluggable Marketplace Connector Architecture

    Isolates data source integrations into modular Lerna packages under plugins/ and marketplace/, decoupling vendor SDK dependencies.

  4. 04

    Realtime Canvas Collaboration with Yjs

    Synchronizes visual canvas modifications and multi-user cursor presences using Yjs CRDTs over persistent WebSockets.

How ToolJet is built

How ToolJet is structured

ToolJet is structured as a multi-package monorepo containing frontend presentation layers, server services, and a modular plugin ecosystem:

  • frontend: The React-based visual drag-and-drop application builder, component catalog, query editor, and application runtime.
  • server: The NestJS enterprise backend handling authentication, RBAC authorization (CASL), workflow scheduling, encryption, and data proxying.
  • plugins & marketplace: Decoupled Lerna workspaces containing over 50 data connectors (databases, cloud storage, AI models, and SaaS APIs) built with standardized query and connection interfaces.
  • cli: An oclif-powered command-line interface for creating, scaffolding, and managing custom plugins.

Frontend

The frontend is a single-page application built with React 18 and bundled via Webpack:

  • Canvas Builder: Features a grid layout canvas supporting drag-and-drop repositioning with @dnd-kit and react-rnd.
  • UI Primitives: Built on Radix UI (@radix-ui/react-*), Tailwind CSS, and Tabler Icons, providing accessible forms, modals, tables, and tabs.
  • Code & Query Editor: Embeds @uiw/react-codemirror with auto-complete and syntax highlighting for JavaScript, SQL, and Python transformations.
  • Data Tables: Leverages @tanstack/react-table and @tanstack/react-virtual for virtualized rendering of large query datasets.
  • Workflow Diagrams: Uses reactflow to visualize automated logic graphs and data pipelines.

Backend & APIs

The backend application is implemented using NestJS in server:

  • API Architecture: Exposes REST and WebSocket endpoints for managing apps, credentials, versions, organizations, and user permissions.
  • Sandboxed Execution: Evaluates user-defined JavaScript and query transformations within isolated V8 contexts using isolated-vm.
  • Background Jobs: Uses BullMQ backed by Redis for asynchronous query dispatching, webhook notifications, and automated workflows.
  • Long-Running Orchestration: Integrates the Temporal TypeScript SDK (@temporalio/workflow) for managing reliable multi-step workflows.

Data & persistence

ToolJet relies on PostgreSQL for both internal metadata and application persistence:

  • System Storage: Manages organizations, users, app definitions, component trees, and credentials (encrypted at rest) using TypeORM.
  • ToolJet DB: An internal database feature running on a dedicated PostgreSQL database and exposed via a sidecar PostgREST container. This allows users to create tables, relations, and schemas without provisioning external databases.
  • Data Connectors: Standardized drivers connect to third-party databases (MySQL, MongoDB, Snowflake, ClickHouse, BigQuery) dynamically during query runs.

Realtime / collaboration

ToolJet enables concurrent multi-user editing in the visual app builder:

  • Yjs & WebSockets: Employs yjs and y-websocket along with @y-presence/react to coordinate collaborative state updates across active user sessions.
  • Presence Tracking: Displays live collaborator avatars and component selections to prevent conflicting edits in real time.

Build, test & deploy

The build and deployment pipeline is orchestrated with npm scripts, Docker, and GitHub Actions:

  • Frontend assets are compiled with Webpack (npm --prefix frontend run build).
  • NestJS services are compiled with the Nest CLI (nest build).
  • End-to-end regression suites are executed via Cypress (cypress-tests/) across LTS and edge releases.
  • Container images are defined in docker/ for development, preview environments, and production deployments.

Self-hosting notes

ToolJet can be self-hosted using Docker Compose, Helm charts on Kubernetes, or cloud templates:

  • Quickstart setups use docker-compose.yaml to spin up the ToolJet server, client, PostgreSQL, PostgREST, and Redis.
  • Environment variables configure database connection strings (PG_HOST, PG_USER, PG_PASS), secrets encryption keys (SECRET_KEY_BASE, LOCKBOX_MASTER_KEY), and authentication providers (SAML, Google OAuth, LDAP).

What to copy (and what not to)

What to copy:

  • Isolating third-party integration drivers into individual plugin packages with consistent schema contracts, allowing community contributions without polluting core dependencies.
  • Using isolated V8 sandboxes (isolated-vm) to execute untrusted user code safely within a Node.js backend.
  • Pairing PostgreSQL with PostgREST to offer an instant, zero-configuration internal relational database.

What not to copy:

  • Distributing monolithic container setups that bundle both frontend compilation and multi-language backend tooling without strict build layer caching, which leads to large image sizes.

Sources & repo audit

Audited
Sep 17, 2026
Commit
7f406ab
License
AGPL-3.0

Independent analysis of repository at github.com/ToolJet/ToolJet. Spotted an inaccuracy? Use the claim form to request a correction.

Show this stack on your README or website
Tech stack of ToolJet
[![Tech stack of ToolJet on STACK IT FAST](https://stackitfast.com/badge/tooljet.svg)](https://stackitfast.com/project/tooljet)

Paste it into your README. It shows your current stack and links to this page.

Use this stack

Scaffold it with your agent

Paste this prompt into Claude Code, Cursor, Windsurf or AGY to start a project with ToolJet's architecture.

  1. 1Copy the promptThe full markdown spec, with every layer and decision.
  2. 2Open your AI toolClaude Code, Cursor, Windsurf or Copilot, in a new repo.
  3. 3Paste and scaffoldUse it as the first instruction; review before you ship.
use-this-stack.md · 58 lines · 5.4 KB
# MISSION: Scaffold "ToolJet" Production Architecture
You are an expert Senior Staff Software Architect and Full-Stack Engineer. Your mission is to scaffold and implement a production-grade, highly reliable, and modular codebase following the proven architecture of **ToolJet**.
---
## 1. PROJECT SPECIFICATIONS & BENCHMARK
- **Reference Architecture**: ToolJet
- **What It Does**: Open-source low-code application platform for building enterprise internal tools, business workflows, and AI agents.
- **Domain & Category**: Low-Code Developer Tool Platform
- **Production Scale**: 6-20 people
- **Development Mode**: HYBRID
- **Architectural Rationale**: ToolJet allows teams to build complex internal web applications and dashboards with drag-and-drop React UI components and 50+ data connectors.
- **Live Website Reference**: https://tooljet.com
- **Source Repository**: https://github.com/ToolJet/ToolJet
---
## 2. PRODUCTION TECH STACK
- **Full Stack Array**: JavaScript, TypeScript, React, NestJS, PostgreSQL, Redis, Tailwind CSS, Docker
- **Primary Language(s)**: JavaScript, TypeScript, SCSS, Dockerfile, Shell, Handlebars
- **License of the reference repo**: AGPL-3.0
- **Frontend**: React — Visual drag-and-drop app builder and reactive component rendering engine; Tailwind CSS — Utility styling foundation for dashboard layouts and customizable UI widgets; TypeScript — Type-safe architecture across frontend state models and builder controls
- **Backend & APIs**: JavaScript — Dynamic query transformation runtime and sandboxed client script evaluator; NestJS — Enterprise backend application framework organizing services, auth, and workers
- **Data & persistence**: PostgreSQL — Relational system database and ToolJet DB internal data persistence layer; Redis — In-memory cache and queue broker powering BullMQ background jobs and events
- **Infrastructure & deploy**: Docker — Multi-service container definitions orchestrating app server, PostgREST, and Redis
---
## 3. KEY ARCHITECTURAL DECISIONS (audited from https://github.com/ToolJet/ToolJet @ 7f406ab)
1. **Sandboxed JavaScript Execution via isolated-vm**: Executes custom user-provided JavaScript expressions securely inside V8 isolates to prevent unauthorized system and process access.
2. **Built-in ToolJet DB via PostgREST Integration**: Embeds a managed PostgreSQL schema exposed over HTTP via PostgREST, providing out-of-the-box relational tables without external database setup.
3. **Pluggable Marketplace Connector Architecture**: Isolates data source integrations into modular Lerna packages under plugins/ and marketplace/, decoupling vendor SDK dependencies.
4. **Realtime Canvas Collaboration with Yjs**: Synchronizes visual canvas modifications and multi-user cursor presences using Yjs CRDTs over persistent WebSockets.
---
## 4. NON-NEGOTIABLE ARCHITECTURAL GUARDRAILS
1. **Monorepo & Modular Separation**:
   - Structure as a Turborepo monorepo with strict package boundaries:
     - `apps/web`: Application UI, routing, layouts, and server endpoints.
     - `packages/ui`: Shared design tokens, CSS variables, and Radix UI primitive components.
     - `packages/db`: Database schemas, client singleton, declarative migrations, and seed scripts.
     - `packages/config`: Shared TypeScript, ESLint, and build configurations.
2. **Strict Type Safety & Zero `any` Policy**:
   - Enable `strict: true`, `noImplicitAny: true`, and `strictNullChecks: true`.
   - Validate ALL external inputs, API request bodies, and query parameters with **Zod** schemas before execution.
3. **Frontend & Rendering Guidelines**:
   - Isolate interactive UI state to leaf components. Keep core pages lightweight and performant.
4. **Design System & Aesthetics**:
   - Keep every color, radius, shadow and font in a single token file (CSS variables) and consume tokens everywhere; never hardcode hex values in components.
   - Prefer crisp 1px borders and one subtle shadow scale over blurry default shadows. Pair one sans-serif for body/headings with one monospace for tags, badges, metrics, and code.
5. **Data Layer & Reliability**:
   - Write declarative schema definitions with foreign keys, composite indexes on queried filters, and automated timestamp triggers.
   - Use connection pooling and prepared statements for serverless database execution.
---
## 5. STEP-BY-STEP SCAFFOLDING ROADMAP
- **Phase 1: Workspace & Root Config**: Initialize package manager, monorepo configuration (`turbo.json`, `tsconfig.base.json`, `package.json`).
- **Phase 2: Database Schema & Client**: Set up the data layer (PostgreSQL, Redis): client, connection pool, models, and migration scripts.
- **Phase 3: Design Tokens & UI Primitives**: Build accessible `Button`, `Input`, `Card`, `Badge`, and layout wrappers inside `packages/ui`.
- **Phase 4: Core Application Routes & Handlers**: Implement primary authentication, user session handling, and application routes.
- **Phase 5: Quality Assurance & Build Verification**: Run `tsc --noEmit`, ESLint, Prettier, and smoke test suites to ensure zero compilation or runtime errors.
---
## 6. EXECUTION INSTRUCTIONS
1. Review all specifications, architectural guardrails, and stack choices above.
2. Present the full monorepo directory tree structure.
3. Systematically generate the complete, production-ready codebase according to the 5-phase roadmap above — starting with the root workspace setup, followed by the database schema, UI design system package, and full-stack application routes until the repository is fully scaffolded and ready to run.
Scaffolded something with this prompt?
Would you pick this stack for a low-code developer tool platform project?

Frequently asked about ToolJet

How does ToolJet prevent malicious code in user-written queries?

Backend user JavaScript scripts run inside isolated V8 execution contexts provided by isolated-vm with strict CPU and memory limits.

What is ToolJet DB and how is it hosted?

ToolJet DB is an internal PostgreSQL database served through PostgREST that provides instant table storage for low-code apps.

One email a month: new deep dives and stack trends

New source-audited architectures, head-to-head comparisons and the monthly stack report. No spam, unsubscribe anytime.

use-this-stack.md