# ToolJet: the quickstart image is the EE LTS build, and the root version is 1.18.0

> ToolJet builds internal tools, dashboards and admin panels on the databases and APIs you already have, under AGPL-3.0, with a free Community Edition and a paid Enterprise Edition. Reading the repository closely, the edition split, the five-service compose stack and a 64-zero master key in the example environment file matter more than the feature list.

**ToolJet/ToolJet** — ToolJet is an open-source low-code platform for internal tools, dashboards, workflows, and AI agents, with a drag-and-drop builder, 60+ components, and 80+ data sources.

- Repository: https://github.com/ToolJet/ToolJet
- Website: https://tooljet.com
- Stars: 40,998 · Forks: 5,457
- Language: JavaScript
- License: AGPL-3.0
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/tooljet-tooljet

## The quickstart image is ee-lts-latest, mounted on Postgres 13

The one command the README offers for a local run is this:

```bash
docker run \
  --name tooljet \
  --restart unless-stopped \
  -p 80:80 \
  --platform linux/amd64 \
  -v tooljet_data:/var/lib/postgresql/13/main \
  tooljet/try:ee-lts-latest
```

Three details in it decide your first hour. The image is `tooljet/try:ee-lts-latest`, so the fast path is the Enterprise Edition's LTS line rather than the Community Edition, and the pinned platform is `linux/amd64`, which matters on Apple silicon. The single named volume points at `/var/lib/postgresql/13/main`, so your app data and the database share one volume, and the only published port is 80.

The README also gives upgrade advice before you have upgraded anything: for users moving between versions it recommends the LTS version over the latest one, on the grounds that LTS carries production bug fixes, security patches and performance work. Releases show the line is real, with v3.20.235-lts and v3.20.234-lts both published on 2026-09-29 and v3.21.73-beta on 2026-09-28. The last commit to the repository was on 2026-09-25.

## Three npm prefixes, three build passes, and a version field that lies

The root package.json is an orchestrator, not an application. The build runs three sub-builds in order:

```json
"build": "npm run build:plugins:prod && npm run build:frontend && npm run build:server",
"build:frontend:cloud": "NODE_ENV=production TOOLJET_EDITION=cloud npm --prefix frontend run build:cloud"
```

Each sub-build has a `pre` step that installs with `--production=false` and a `post` step that prunes to `--production`, so a checkout is not a single `npm install`: plugins, frontend and server each get their own install and prune cycle, driven by `npm --prefix`. The edition is a build variable rather than a runtime switch, with `TOOLJET_EDITION=cloud` producing a different frontend bundle than the default. The pinned engines are exact, node 22.15.1 and npm 10.9.2.

The version field is the trap. The root package.json says 1.18.0 while the published tags are v3.20.235-lts and v3.21.73-beta. So do not pin a deployment from the root manifest, and do not read that file as a release number. The same manifest carries the guard rails: `ci:changed` runs `bash scripts/test-changed.sh`, husky and lint-staged run eslint over `frontend/src/**/*.{js,jsx,ts,tsx}` with `frontend/eslint.config.mjs` and over `server/**/*.ts` with `server/eslint.config.js`, and the ToolJet CLI itself sits in devDependencies at ^0.0.13.

## PostgREST and Redis are not optional extras in the dev stack

The compose file is not one service. It defines plugins, client, server, redis and, by the server's `depends_on`, postgres and postgrest as well. The server service states its wiring in the environment rather than in code:

```yaml
environment:
  - SERVE_CLIENT=false
  - TOOLJET_EDITION=${TOOLJET_EDITION:-ce}
  - PGRST_HOST=postgrest
```

`PGRST_HOST` alongside `PGRST_SERVER_PORT=3000` means a PostgREST instance sits between the ToolJet server and Postgres, which is why the server waits on it. Redis is `redis:7-alpine` with `appendonly yes` and a healthcheck that runs `redis-cli ping` every ten seconds, so a queue or cache that survives a restart. `SERVE_CLIENT=false` on both client and server splits the frontend dev server, published on 8082, from the API on 3000, which is the arrangement you want in development and not the one you ship.

The volumes explain the rest. Source directories come in as `delegated` mounts, `./plugins` is shared by all three services, and each of client and server gets an anonymous volume at its own `node_modules` path so the host tree does not shadow the installed packages. The server also mounts `./.env` and `./.env.test` directly and starts with `npm run --prefix server start:dev`, with `FORCE_COLOR=1` set so its logs stay readable.

## The example environment ships a 64-zero master key

.env.example is unusually explicit, and what it hands you is a set of placeholders:

```bash
TOOLJET_HOST=http://localhost:8082
LOCKBOX_MASTER_KEY=0000000000000000000000000000000000000000000000000000000000000000
SECRET_KEY_BASE=replace_with_secret_key_base
```

`LOCKBOX_MASTER_KEY` is a 64-character string of zeros and `SECRET_KEY_BASE` is the literal instruction to replace it, so copying the file unchanged gives you a known encryption key and a known session secret. The file also asks for `SERVER_HOST` and a `MFA_MASTER_SECRET` that is required for two-factor authentication in the Enterprise Edition only.

One variable deserves a careful decision rather than a quick paste. `TJ_ADMIN_API_KEY` is optional, and the comment says that when it is set, a request carrying a matching `tj-admin-api-key` header together with a `tj-workspace-id` header bypasses the user session check and is authenticated as the workspace admin. It ships empty, which disables it. That is the correct default: anyone who enables it has turned off session checking for a header, so treat the value as a credential and not as configuration.

## Workflows, environments and GitSync sit on the Enterprise side

The README splits the product in two, and the split is where a purchase decision is made. The Community Edition has 80-odd responsive components, the built-in ToolJet Database, multi-page apps with multiplayer editing, 90-odd data sources, deployment on Docker, Kubernetes, AWS, GCP and Azure, inline comments and access control, plugins and connectors through the ToolJet CLI, JavaScript and Python inside apps, and AES-256-GCM encryption with proxy-only data flow and SSO support.

The Enterprise column adds AI app generation, an AI query builder, AI debugging, an agent builder, and workflows with branching logic on a schedule or a webhook. It also adds modules for reuse, SOC 2 and GDPR readiness with audit logs, RBAC with custom groups and SCIM, dev/stage/prod environments, GitSync and CI/CD with GitHub and GitLab, white labelling, access control down to the row and query level, embedded apps, and support with SLAs.

So the free edition is the builder, the data sources and the deployment. The operational parts of running a platform team, promotion between environments and version control of apps, are the paid ones.

## The agent route runs on your subscription, and it is beta

There are two AI paths and they cost different things. ToolJet AI, in the Enterprise list, generates apps, queries and fixes from natural language inside the platform. The other path is a Model Context Protocol server: the coding agent you already use generates pages, queries and components, and can modify apps in place. The README says the agent works from the platform's real component and data contracts rather than guessing, and that operations run on your own model subscription instead of drawing down ToolJet AI credits.

That path ships as plugins bundling ToolJet's app-builder skill for Claude Code, Codex and Grok Build, and over the MCP server alone for Cursor or any other MCP client. The reason it is worth knowing is the output shape: an agent edits apps your team keeps editing in the visual builder, under the same permissions, environments and version history, rather than emitting a separate codebase. The catch is stated in one line: ToolJet MCP is currently in beta, with setup in the MCP guide in the documentation.

## AGPL-3.0, two marketplaces, and thirteen documented deployment targets

The licence is AGPL-3.0, and the repository carries the paperwork to match: a LICENSE file, THIRD-PARTY-NOTICES, SECURITY.md, SECURITY-INCIDENT-RESPONSE.md, CODE_OF_CONDUCT.md, CONTRIBUTING.md, CODEOWNERS, AGENTS.md, CLAUDE.md and a UBIQUITOUS_LANGUAGE.md that fixes the vocabulary. The README does not offer any exception to the AGPL terms, so read them yourself before you plan to modify and host it.

Deployment is documented as a table of thirteen targets rather than one path: Digital Ocean, Docker, AWS EC2, AWS ECS, OpenShift, Helm, AWS EKS, GCP GKE, Azure AKS, Azure Container, Google Cloud Run, deploying the ToolJet client, and deploying ToolJet on a subpath. That last one matters behind an existing reverse proxy, and the client entry exists for teams who want the UI served separately. ToolJet is also listed on the AWS and Azure marketplaces.

The cadence is high and split across lines: v3.20.235-lts and v3.20.234-lts on 2026-09-29, v3.21.73-beta on 2026-09-28, last push 2026-09-25. Read the LTS and beta labels before you pick a tag, not just the version number.

## Conclusion

Use ToolJet when a team needs an internal admin panel or operations dashboard on its own Postgres and SaaS data and can live with a visual builder plus JavaScript and Python inside the app. Do not pick it for AI app generation, scheduled workflows, dev/stage/prod promotion or Git-based deployment, because the README places all four in the Enterprise Edition, and the coding-agent route through MCP is still beta. Before you deploy anything, replace the placeholder secrets in .env.example, decide whether CE or EE is the edition you are actually licensed for given that the quickstart image is ee-lts-latest, and read the LTS note, since the README recommends the LTS line over latest for anyone upgrading.

## FAQ

### What is ToolJet?

It is an open-source platform for building internal tools: admin panels, dashboards and operational apps that run on existing databases, APIs and SaaS systems. Apps are assembled in a visual builder from 80-odd components and 90-odd data sources, with JavaScript and Python usable inside the app, and it is licensed AGPL-3.0 with a Community Edition and an Enterprise Edition.

### Is ToolJet open source?

The repository is licensed AGPL-3.0 and ships the matching LICENSE, THIRD-PARTY-NOTICES, SECURITY.md, SECURITY-INCIDENT-RESPONSE.md and CODEOWNERS files, with the full frontend, server and plugins source at the root. The README describes no exception to those terms, and the Enterprise Edition adds paid features on top of the Community Edition rather than replacing the licence.

### Is ToolJet free?

The Community Edition is the free part, covering the visual builder, the ToolJet Database, 90-odd data sources, deployment on Docker, Kubernetes, AWS, GCP and Azure, and JavaScript and Python inside apps. AI app generation, workflows, modules, RBAC with SCIM, multi-environment management, GitSync and CI/CD, and enterprise support are Enterprise Edition features, and ToolJet Cloud is the hosted option.

### How does ToolJet compare with Retool?

The repository makes no comparison, so there is nothing to quote. What it does state about itself: AGPL-3.0 licensing, a visual builder with 80-odd components and 90-odd data sources, thirteen documented self-hosting targets from Docker to Google Cloud Run and Kubernetes on AWS, GCP and Azure, an edition split with a free Community Edition, and listings on the AWS and Azure marketplaces.

### How does ToolJet compare with n8n?

The repository draws no comparison. What it documents is that workflows, with branching logic, running on a schedule or triggered by a webhook, sit in the Enterprise Edition next to an agent builder for orchestrating processes, while the free Community Edition covers the visual builder, 80-odd components and 90-odd data sources. The scheduling and agent features are the part to price.

## Sources

- [Official documentation](https://tooljet.com)
- [Official README](https://github.com/ToolJet/ToolJet#readme)
- [Project repository](https://github.com/ToolJet/ToolJet)
- [Release notes](https://github.com/ToolJet/ToolJet/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tooljet-tooljet