Qelos

Auth, workspaces, storage, AI agents — one plugin, every framework.

Qelos is the application layer for any product. Drop in the plugin, get a branded admin panel, and skip the months you'd spend rebuilding the same backend you've built before.

Get the admin panel Read the docs
No rewrite required
Typed SDK & middleware
Multi-tenant ready

@qelos/integrator-express

SDK Ready

Plug Qelos into your framework

User, workspace, and a ready SDK on every request.

import express from 'express'
import { qelos } from '@qelos/integrator-express'
const app = express()
app.use(qelos({ tenant: 'acme' }))
app.get('/me', (req, res) => {
  // req.user, req.workspace, req.qelos
  res.json(req.user)
})

Available on every request

Authenticated user

Workspace context

SDK client

Permissions

The same quarter, every time

The problem

Every new product starts the same way. A week on auth. Two on users and clients. Another on permissions, then RBAC creeps in, then storage, then an admin UI nobody wanted to build. By the time you're shipping the actual product, half the runway is gone — and you've built the same thing you built last time.

Everything included

What you get on day one

A branded admin panel. A plugin that drops into your framework — no rewrite, no lock-in. Authentication and authorization. Workspaces to model your clients and their teams. A REST API over a permissioned database. File and asset storage. AI agents and in-app chatbots. Everything you'd otherwise spend a quarter building.

Admin panel

Auth & RBAC

Workspaces

REST API

File storage

AI agents

Framework plugin

Typed SDK

One platform. Every framework.

Stay in your stack. We meet you there.

Pick your framework. Drop in the integrator. Every request arrives authenticated, scoped to a workspace, and wired to a typed SDK — without a single line of glue code.

Express integrator

@qelos/integrator-express

A single line of middleware.
import { qelos } from '@qelos/integrator-express'
app.use(qelos({ tenant: 'acme' }))
app.get('/me', (req, res) => {
res.json(req.user) // authed + scoped
})
req.userreq.workspacereq.qelos
View docs

Don't see your stack? Talk to the unified SDK directly — every integrator is built on top of it.

Why it's different

Supabase gives you a database. Auth0 gives you auth. Retool gives you an admin panel. Qelos gives you the whole application layer — wired together, in the framework you already use.

How it works

Spin up a Qelos tenant. Install the plugin in your app. Start shipping. Each of your clients lives in their own workspace, with users, roles, content, AI, and storage managed from the admin panel.

1

Spin up a tenant

Get a Qelos instance with an admin panel, API, and SDK ready to go.

2

Install the plugin

Drop the integrator into Express, Nest, Next, Fastify, or whatever you use.

3

Start shipping

Each client gets their own workspace. Users, roles, content, and AI — managed from the panel.

Who it's for

Founders

Skipping the plumbing. Shipping the product instead of rebuilding the backend.

Agencies

Who build the same thing for every client. One tenant per client, each with their own workspaces.

Teams

Adding AI to a product they already have. No rewrite, no new infrastructure.

The Tuesday morning you realize you need user invites again.

You're three weeks into the new project. The product demo went well. Now someone needs to invite their teammate, and you're staring at a blank file called invitations.ts.

You've written this file before. Twice. The token logic, the email template, the expiry, the "already a member" edge case, the resend flow, the accept-but-account-doesn't-exist-yet branch. None of it is the product. All of it is on the critical path.

With Qelos: invites, roles, and team management are already there. You spent Tuesday on the feature your users actually asked for.

The week you spent on RBAC instead of the feature your investor asked about.

It started simple. Admins and members. Then a customer asked for a "viewer" role. Then "billing access but not user management." Then a workspace owner who isn't the billing owner. By Friday you have a permissions matrix on a whiteboard and a Notion doc called "Auth, take 3."

The investor update goes out Monday. The feature you promised is still in a branch.

With Qelos: roles and permissions ship on day one, scoped per workspace, editable from the admin panel. The matrix is someone else's problem.

The third client project where you copy-pasted last project's auth.

The agency pitch was clean: we ship fast because we have a stack. What "the stack" actually means is that you git clone the last project, rip out the branding, pray nothing in the auth flow has rotted since the last engagement, and rediscover the workspace bug your previous self left a TODO about.

Every client gets a slightly different version of the same plumbing. None of it gets better over time. All of it is yours to maintain.

With Qelos: one tenant per client, each with their own workspaces, branding, users, and data. Your stack is now a product instead of a folder you copy.

You didn't start this project to build auth again. Plug in Qelos and get back to the part you wanted to build.

Get the admin panel Read the docs