Skip to content
Docs home

GET STARTED · UPDATED AUGUST 2026

Architecture

How QUE is organized: three authority domains, one tenant per business, and a self-hosted infrastructure stack with no cloud vendor lock-in.

Three authority domains

A person may hold more than one role, but the interface always represents one authority context at a time. QUE separates its surfaces into three domains, each with its own shell, its own authorization, and its own route tree.

DomainRouteShellWho can access
Platform operations/root/*RootShellPlatform super-admin only, verified at route and server-function layers
Subscriber team management/dashboard/*TeamShellCompany owner and staff; navigation filtered to real capabilities
Customer account/account/*CustomerShellAuthenticated consumer identity and customer-record ownership

The public booking surface (/u/:slug/*) is a fourth surface, but it is not an authority domain: it validates tenant visibility and booking eligibility server-side on every request, and manages bookings through expiring tokens rather than logins.

The tenant model

Each business on QUE is a company record (a tenant) with a unique slug. The slug is the public identity of the business: it powers the public booking URL, the tenant sitemap and robots surface, and custom domain mapping. Every query the application runs against the database executes under the tenant's role through row-level security, so tenant boundaries are enforced by the database, not assumed by application code.

Infrastructure model: self-hosted only

QUE's production architecture is self-hosted only. There is no shared multi-tenant cloud queue in front of your data. A deployment is a Docker stack on a dedicated host: an OpenResty edge container is the only process with public ports (80 and 443), while the application, Redis, database, and observability services live on private networks or loopback addresses.

textTraffic flow in a self-hosted deployment
Internet :80/443
   └─ OpenResty edge (lua-resty-acme TLS)
        ├─ QUE application      → app:3000          (private network)
        ├─ Supabase (Postgres)  → loopback / private network
        ├─ Redis                → private network (queue + rate limits)
        └─ Observability        → Prometheus / Grafana / Loki /
                                  Promtail / Sentry / Alertmanager
                                  (loopback or authenticated proxy routes)

Only the edge is public

The application, database, Redis, and observability services must never publish their own public ports. The edge container is the only internet-facing process; everything else is reached through authenticated reverse-proxy routes on the private network.

Failure design

QUE fails closed at the boundaries that protect customers and fails open at the boundaries that protect availability. If Redis becomes unreachable, rate limiting denies requests rather than allowing them. If the database is unreachable, booking reads return typed errors rather than stale data. If an alertmanager receiver is misconfigured, the webhook sink refuses unauthenticated payloads rather than silently accepting them. This model is documented in detail under Security controls and Self-hosting.

STILL READING

Something here still feels worth checking together.

This documentation describes the product exactly as it is implemented. If a behavior you expected is not here — or is here and does not match your deployment — tell the team. Implementation questions start on the contact page.