Kottster

Self-hosted admin panel generation, honestly reviewed. Based on available documentation and third-party listings — independent review coverage is thin for this tool, which itself tells you something.

TL;DR

• What it is: Apache 2.0-licensed admin panel generator for Node.js apps. Connect it to your database, get a visual CRUD interface in minutes — running as a separate service from your backend [README][5].
• Who it’s for: Small engineering teams and technical founders who need an internal admin panel fast but don’t want to pay Retool rates or embed AdminJS inside their production app [5][4].
• Cost savings: Retool starts at $10/user/month on the Startup plan [4], scaling well past $50–100/mo for any real team. Kottster’s core is free and self-hosted. The professional plan is a flat $35/mo regardless of user count [1].
• Key strength: Runs as a standalone service, not embedded in your backend. If the admin panel crashes or runs a heavy query, your production API keeps running [5].
• Key weakness: 1,139 GitHub stars as of this review, minimal independent community, no third-party reviews to speak of — most published comparisons are written by the Kottster team itself. You’re betting on a young tool with a thin track record.

---

What is Kottster

Kottster generates admin panel pages on top of your existing database. The pitch is blunt: run npx @kottster/cli@latest new, connect to PostgreSQL (or MySQL, MariaDB, MSSQL, SQLite), and you get table pages for viewing and editing records, dashboard pages with charts, and a visual builder for both — all without writing the CRUD boilerplate yourself [README].

The architecture decision that sets it apart is that it’s not a library you embed. AdminJS, the incumbent in the Node.js admin panel space, installs as a dependency inside your application and runs in the same process. Kottster runs as a separate Node.js service in its own repository. You connect it to the same database, but admin traffic stays isolated from your production backend [5].

Technically it’s built on Node.js, React, Vite, Mantine, and TypeScript [README][website]. Each generated page produces actual source files you can edit directly — it’s not a black-box CMS where you’re locked out of the internals. If you need custom logic, you open the file and change it [5].

The license is Apache 2.0 [README]. That means you can self-host, modify, embed in a client project, or white-label it — the professional plan even has an option to remove Kottster branding [1]. No “fair-code” restrictions, no commercial-use clauses.

As of this writing: 1,139 GitHub stars, 70 forks, listed as developed by Kottster LLC [2].

---

Why people choose it

Honest caveat: the review landscape here is sparse. AlternativeTo has one user review — posted by “arthur-kottster,” who also added the app to the directory [2]. The main published comparison is Kottster’s own blog post comparing itself to AdminJS [5]. SaaSHub lists it as an alternative to Jet Admin without a review [4]. There’s no Trustpilot presence, no independent deep dives, no r/selfhosted threads to cite. For a tool at this stage, that’s expected — it’s a legitimate early-stage project, not an established platform.

What exists is the AdminJS comparison, which does lay out a coherent argument [5]:

Versus AdminJS. AdminJS is the historical default for Node.js admin panels. It works but requires you to define resources in code, runs inside your backend process, and customizing pages means modifying React components inside your project. Kottster’s case against it has three planks [5]:

1. Isolation. Since AdminJS shares a process with your backend, a crash or memory leak in the admin panel can affect your production API. Kottster, running separately, cannot cause this.
2. Setup speed. AdminJS requires code configuration before it generates anything. Kottster claims you connect the database and get working pages without writing code first.
3. Relation detection. Kottster says it auto-detects foreign key relations between tables, while AdminJS requires manual configuration of associations.

The counterargument — which the Kottster blog doesn’t address — is that AdminJS has a much longer track record, a larger community, and integrates natively with Express, Fastify, and other frameworks you’re already using. If your team already has AdminJS deployed and working, the isolation benefit doesn’t justify a migration.

Versus Retool, Appsmith, ToolJet. These are the broader “internal tools” category. Retool starts at $10/user/month [4] and scales significantly for any team. Appsmith and ToolJet are open source and self-hostable but are full application builders — you’re dragging and dropping widgets, writing SQL queries, building forms. They’re more powerful but they take longer to set up and maintain. Kottster’s pitch is narrower: admin panel on top of a database, with less flexibility but less configuration [4].

Versus Budibase. Budibase is also open source, also does admin panels, but bills itself as a WordPress equivalent for web apps. If you need multi-data-source views, conditional logic across tables, or complex user-facing interfaces, Budibase is more capable. If you need a fast CRUD interface for your internal team on a single database, Kottster is simpler [4].

---

Features

Based on the README, website, and the AdminJS comparison article:

Database connectivity:

• PostgreSQL, MySQL, MariaDB, Microsoft SQL Server, SQLite [README]
• MongoDB and Firebase listed as “coming soon” on the website [website]
• You connect once and Kottster reads the schema to generate pages

Page types:

• Table pages — view, filter, edit, and delete records. You configure which columns show, who can view/edit/delete [website]
• Dashboard pages — charts and metrics from database queries, built with the visual builder [website]
• Custom pages — if you know JavaScript and React, you can build pages from scratch or start from templates [website]

Visual builder:

• Add and configure pages without touching code
• For anything beyond the builder’s scope, the generated source files are editable [5]
• Ready-to-use templates for common admin pages (dashboards, settings, etc.) — more templates behind the professional plan [1]

Authentication:

• Built-in user management out of the box [README]
• SSO/SAML gated behind the professional plan [1]

Deployment:

• npm CLI (npx @kottster/cli@latest new) or Docker [README]
• You deploy and host it yourself — Kottster LLC provides no hosting [1]
• Runs at localhost:5480 in development mode [README]

Professional plan adds:

• External IdP / SSO integration [1]
• Sidebar sections and groups (navigation organization) [1]
• Detailed audit log (who did what, when) [1]
• Change log per record (before/after values with timestamps) [1]
• Unlimited apps and users per license [1]
• Ready-to-use page templates [1]
• Priority support [1]
• Attribution (branding) removal [1]

---

Pricing: free tier vs professional math

Kottster Community (free):

• Apache 2.0, no license fee
• Unlimited users, unlimited database tables
• No SSO, no audit logs, no change history
• You pay for the server you run it on

Kottster Professional:

• $35/month flat, or $28/month billed annually (~$336/year) [1]
• One license covers unlimited apps and unlimited users [1]
• Adds SSO, audit logs, change tracking, priority support, branding removal [1]
• Note: pricing is per-license, not per-user — a meaningful difference from Retool’s per-seat model

Comparison with commercial alternatives:

Retool starts at $10/user/month on Startup [4]. For a team of 5, that’s $50/mo minimum, scaling as headcount grows. Kottster Professional is $35/mo flat — no headcount math. Over a year with a 5-person team: Retool ≈ $600+, Kottster Pro ≈ $336. The gap widens with team size.

Self-hosted infrastructure cost:

• A 2GB RAM VPS on Hetzner or Contabo: ~$4–8/month
• Node.js process, connected to your existing database — not a heavy workload
• Total for community tier: $4–8/month ongoing

What you give up with the free tier: If you have a compliance requirement (SOC 2, HIPAA adjacent), no audit log is a real gap. If your team uses Google Workspace SSO, you’ll be managing separate credentials for the admin panel. These aren’t hypothetical concerns — they’re the exact features the professional plan unlocks [1].

---

Deployment reality check

Setup is straightforward for anyone comfortable with Node.js:

npx @kottster/cli@latest new
npm run dev

That gets you a local instance at http://localhost:5480. You create an account on first run, connect your database, and start generating pages [README].

Docker alternative: The README links to a Docker quickstart for those who prefer container-first deployment [README]. No Compose file details in the provided documentation, but it’s a supported path.

What you actually need for production:

• A VPS or cloud instance with Node.js v20+ [README]
• Your database credentials (Kottster stores config files locally, doesn’t transmit database content externally) [website FAQ]
• A domain and reverse proxy if you want HTTPS
• That’s roughly it — Kottster doesn’t bundle Redis or additional services the way heavier tools do

What can go sideways:

• No hosting is provided. If you can’t deploy Node.js to a server yourself, you’re on your own or paying someone else to do it [1].
• MongoDB is not yet supported, despite being a common choice for Node.js projects [website].
• Community support means Discord and GitHub issues [README]. With 1,139 stars, the community is small. If you hit an obscure bug, the answer may not exist yet.
• The project is maintained by Kottster LLC — a small company. If they stop development, you own the Apache 2.0 source code, which is the protection the license gives you. But you’d also own the maintenance burden.

Realistic setup time for a developer: 15–30 minutes to a working local instance, 1–2 hours to a production deployment with HTTPS. The CLI does most of the work.

---

Pros and cons

Pros

• Apache 2.0 license. No commercial restrictions, no fair-code caveats. Fork it, embed it, white-label it [README][1].
• Runs outside your app. Admin panel traffic and potential performance issues stay isolated from your production backend. This is the core architectural argument and it’s valid [5].
• Flat professional pricing. $35/mo regardless of user count is better than per-seat tools for any team larger than 3–4 people [1].
• Editable source code. Generated pages produce real TypeScript/React files you can modify directly [5]. You’re not trapped in a config schema.
• Supports five major databases with no additional setup [README].
• Built-in auth means you’re not building a login system on top of it [README].
• Modern stack (Vite, Mantine, TypeScript) — if something breaks, a JavaScript developer can fix it [README].

Cons

• Very small community. 1,139 stars, one published external review, no significant Reddit or forum presence. Independent validation of how well this works in production is essentially absent [2][4].
• Published comparisons are first-party. The main “review” of Kottster versus AdminJS is Kottster’s own blog post [5]. This is normal for early-stage tools but worth noting if you’re trying to form an unbiased view.
• No MongoDB support yet — a significant gap given the Node.js ecosystem [website].
• No hosted option. You deploy and maintain it. There is no “just give us a credit card and we handle the server” path [1].
• SSO and audit logs require the paid plan. If you need either, you’re committing to $28–35/mo [1].
• Young project. The GitHub repository shows active development but limited track record. AdminJS, Appsmith, and Retool all have years of production usage behind them.
• Visual builder has limits. Anything beyond standard CRUD pages requires writing code. The builder is a starting point, not a no-code solution [5][website].

---

Who should use this / who shouldn’t

Use Kottster if:

• You’re a small team (2–10 people) building a product on PostgreSQL, MySQL, or SQLite and need an internal admin interface without building it from scratch.
• You already tried AdminJS and dislike having admin code inside your production application.
• You want Apache 2.0 with no commercial strings attached.
• You have a JavaScript developer who can handle a self-hosted Node.js service and occasionally edit TypeScript files.
• Your team is 5+ people and Retool’s per-seat pricing is adding up.

Skip it (pick Appsmith or ToolJet instead) if:

• You need a mature, battle-tested tool with years of production track record and an active community forum.
• Your database is MongoDB — Kottster doesn’t support it yet.
• You need complex multi-source views, external API connections, or custom business logic beyond what a CRUD interface supports.

Skip it (pick AdminJS) if:

• Your team is already on AdminJS and it works. The isolation benefit doesn’t justify a migration unless you’ve actually had AdminJS-caused production incidents.
• You’re comfortable with the embedded architecture and want tighter integration with your existing Express/Fastify setup.

Skip it (stay on Retool) if:

• Your company has a compliance requirement that needs SOC 2-certified infrastructure — Retool’s managed cloud provides this, Kottster’s self-hosted doesn’t by default.
• Your team has zero tolerance for self-hosted infrastructure maintenance.

---

Alternatives worth considering

• AdminJS — the Node.js incumbent. Embeds in your app, requires code configuration, has a larger community. Use it if you want tighter backend integration and can accept the shared-process tradeoff [5].
• Appsmith — open source, self-hostable, much more capable (multi-source, drag-and-drop widgets, custom JS). Steeper setup, more powerful [4].
• ToolJet — open source Retool alternative. Similar capability tier to Appsmith [4].
• Forest Admin — admin panel builder with a polished UI and good SQL support. Partially open source but more commercial in orientation [4].
• Budibase — broader than admin panels; full internal app builder. More setup, more flexibility [4].
• Retool — the commercial gold standard for internal tools. Most integrations, best support, per-seat pricing that stings at scale [4].
• Basedash — AI-generated interface over your database, similar positioning to Kottster. Freemium, starts at $25/mo [4].

For the specific use case Kottster is targeting — fast Node.js admin panel on a SQL database, self-hosted, small team — the realistic shortlist is Kottster versus AdminJS. Pick Kottster if architectural isolation and Apache 2.0 matter. Pick AdminJS if community size and embedded integration matter more.

---

Bottom line

Kottster makes one architectural bet and executes it cleanly: the admin panel should be a separate service, not a dependency inside your production app. That’s a sensible call, and if you’ve ever had AdminJS bring down an Express server, you’ll appreciate it immediately. The Apache 2.0 license is genuine, the setup is fast, and the flat professional pricing is more honest than per-seat tools for any real team.

The honest caveat is that this tool is early. The community is small, independent reviews don’t exist yet, MongoDB support is missing, and you’re committing to infrastructure you maintain yourself. If you need a proven, community-validated tool, look at Appsmith or ToolJet instead. If you’re comfortable being an early adopter on a clean architecture with a permissive license, Kottster is worth a 30-minute test.

If self-hosting is the blocker, that’s what upready.dev handles for clients — one deployment, you own the infrastructure.

---

Sources

1. Kottster — Professional Plan pricing page. https://kottster.app/professional
2. AlternativeTo — Kottster listing (1 review, 7 likes, 14 alternatives). https://alternativeto.net/software/kottster/about/
3. SaaSHub — Jet Admin Alternatives (includes Kottster in the comparison list). https://www.saashub.com/jet-admin-alternatives
4. Kottster Blog — Best AdminJS Alternative? Kottster vs. AdminJS (February 11, 2025). https://kottster.app/blog/modern-adminjs-alternative

Primary sources:

• GitHub repository and README: https://github.com/kottster/kottster (1,139 stars, Apache-2.0 license)
• Official website: https://kottster.app
• Documentation: https://kottster.app/docs/