The Complete Product Map

Everything Qrly does.

Twenty-two capability groups, one self-hostable binary, one licence. Connect a database, ask a question in a visual builder or in SQL, model it, cache it, chart it, schedule it, embed it, audit it — and let a supervised agent layer do the first draft. Below is the whole surface, including the parts that are not built.

Data & query surface

What Qrly can reach, and what it compiles to
  • Connection types 40
  • SQL dialect compilers 12
  • QQL filter operators ~35
  • Chart types 13 (+ TREND on dashboards)
  • Spreadsheet worksheet functions ~500
  • Cache tiers 4 + per-question materialization
  • Background schedulers 15

AI, API & platform

The programmable and machine-facing surface
  • Agent tools 29 (16 read, 13 write)
  • Agent personas 4
  • LLM provider adapters 5, ~15 provider types
  • MCP tools published 8, read-only
  • Data API output formats JSON, CSV, NDJSON, Parquet
  • API explorer code samples 11 languages
  • Interface languages shipped 5
Connectivity

40 connection types, 12 dialects

  • Native engines plus managed AWS, Azure and GCP variants with their own type strings
  • Per-dialect quoting, pagination, NULL ordering and date bucketing — Sybase rejects OFFSET, SQLite rejects week and quarter buckets, and the compiler knows it
  • Opt-in schema sync, manual or nightly, feeding autocomplete and the visual builder
  • Curated table and column metadata; a data dictionary exportable as CSV, XLSX, PDF and Markdown
  • Mermaid ERD viewer with pointer-anchored zoom, and freshness probes on a five-minute sweep
  • Azure Synapse tooling: browse external tables, generate OPENROWSET Delta Lake view DDL
  • Deep dive: databases & dialects →
Questions

Visual, native SQL or model-backed

  • Three authoring paths: a visual builder producing QQL, raw SQL, or a question over an OLAP model
  • SQL → visual reverse engineering, reporting CTEs and UNIONs as lossy rather than pretending
  • NDJSON streaming with a live row counter, progress bar and cancel-aborts-request
  • Interactive filters with lookup SQL, calculated fields validated server-side, question-as-view up to five levels deep
  • Drill-down in ROWS or FILTER mode, verification with an audit log, and a "why did this change?" badge at a 5% move
  • Performance analyzer with ranked findings — AI recommendations are an explicit step, so no tokens are spent by default
Visualisation

13 chart types and the full option set

  • TABLE, BAR, LINE, AREA, PIE, SCATTER, NUMBER, PROGRESS, GAUGE, FUNNEL, PIVOT, MAP_REGION, MAP_POINT — plus TREND on dashboards
  • Least-squares trendlines, N-period moving averages, and 1–24 period forecasts drawn as a discontinuous series
  • Conditional formatting on cells or rows across sixteen operators
  • Column totals and subtotal rows grouped by a breakout column
  • Drill-through from any chart point or table row — "see these rows" or "filter to this group"
  • Number formatting per column feeds axis labels, tooltips and data labels; charts re-theme live in dark mode
QQL

One query document, twelve dialects

  • Source tables or question references, nested AND/OR filter trees, aggregations, breakouts, having, joins, order-by with NULL placement, limit and offset
  • Roughly 35 filter operators — comparison, null-safe, sets, text, regex, quantified, JSON path, array and range, temporal and Postgres full-text
  • A type system spanning twenty categories with a per-dialect classifier, so the filter UI offers the right operators
  • SQL sanitizer: native SQL must start with SELECT or WITH; three dozen keywords are refused outright
  • Monaco editor with schema-aware autocomplete, hover docs, signature help and inline error markers
  • Deep dive: the QQL language →
OLAP models

Star and snowflake semantics

  • Fact table, typed joins, a dimension and measure catalogue, named hierarchies, and always-applied model filters as a security boundary
  • ROLLUP, CUBE and GROUPING SETS where the engine supports them; MySQL and MariaDB fall back to WITH ROLLUP
  • Time hierarchy drill from year to hour, compiled through each dialect's date bucketing
  • Prior-period and prior-year comparisons emitted as their own columns, and Top-N within group
  • Nightly modeller suggestions classify tables FACT, DIMENSION or BRIDGE for a human to approve or reject
  • Deep dive: OLAP models →
Dashboards

12-column grid, live push

  • Drag to move and resize, snapped to the grid, with a live column/row/size readout; drag a question onto the canvas to create a card
  • Cascade filters authored once and mapped per card in a card × filter matrix, with parent→child refinement
  • Viewers may only supply a filter id and a value — never a column or an operator, and the binding operator comes from an allow-list
  • Live dashboards by INTERVAL re-run or by a Postgres LISTEN/NOTIFY channel on the data source, pushed over WebSocket
  • Morning briefing with a yesterday-versus-today delta per card, subscribable
  • AI narration with re-explain, per-card explain popovers, and a per-user hide preference
Reports

Card reports, analysis reports, packages

  • Card-based reports, Markdown analysis reports, and a two-question comparison shape with a join config
  • Settings in four tabs — sharing, export, access and auto-refresh — with access private, organisation-wide or per group
  • Viewer exports to CSV, JSON, XML and XLSX; analysis reports add Markdown and PDF
  • Report bursting: mark a filter burst and a scheduled run explodes into one page per value, dropping empty pages
  • Report packages run an ordered bundle to a ZIP, delivered by download or email, with per-run history
  • Public share links mint an unauthenticated viewer URL that stays revocable
Spreadsheets

A real workbook, bound to live SQL

  • Roughly 500 worksheet functions with an own tokenizer, parser and evaluator — named ranges, dynamic-array spilling, cycle detection and the full Excel error set
  • Point mode, fill handle with series detection, paste-special including transpose, frozen panes, merged cells, find and replace, undo/redo
  • 17 one-click conditional-format presets plus a full rule dialog with colour scales, data bars and icon sets
  • Four data-source bindings: a saved question, stored QQL, ad-hoc SQL, or an AI prompt resolved to SQL once and refreshed as plain SQL thereafter
  • Refresh-safe blocks address source columns by name, so inserted columns survive a refresh and key columns return each record to its row
  • Deep dive: spreadsheet reports →
Collections & permissions

Five levels, most-permissive wins

  • Tenant → organisation → project → collection → question, dashboard or report
  • Collection access NO_ACCESS → VIEW → EXPLORE → CURATE → MANAGE, with parent-inherited permissions unless overridden
  • Data access NO_ACCESS → RESTRICTED (run saved questions only) → FULL (author SQL, RPC, table writes, apply a Construction)
  • Most permissive group permission wins; unknown level strings are rejected at the boundary rather than ranking below no-access
  • Personal collections per user, and collections that sit outside any project
  • Deep dive: security & access →
Alerts & subscriptions

Conditions, schedules, five channels

  • Alerts on rows returned, goal reached or below goal, with a threshold and an hourly, daily or weekly cadence
  • Subscriptions on a question or a dashboard — daily, weekly or monthly — as PDF, CSV or inline
  • Per-subscription toggles for narration, period comparison and AI commentary
  • Channels: email over SMTP, Slack, flat-JSON webhook, SMS and an in-app inbox with unread counts
  • Delivery is best-effort by design — a failed Slack post never breaks the run
  • Per-user preferences for insight type, minimum severity and digest frequency
AI agents

Four personas, propose then approve

  • Analyst answers questions, Composer builds dashboards, Modeler proposes OLAP models, Investigator runs a fixed six-step root-cause method with every write tool filtered out
  • 29 tools — 16 read, 13 write — where every write stages a proposal a human approves or rejects
  • Four independent stop conditions: step cap, daily token budget re-queried mid-run, wall-clock deadline and provider error
  • Repetition circuit breaker, per-session tool allow-list enforced server-side, and cross-session memory injected into every prompt
  • Every tool call audited with step, input, output, duration and status; the AI context drawer shows the exact prompt that was sent
  • Deep dive: the agent layer →
Proactive intelligence

Insights that arrive unasked

  • Detectors for trend change, milestone, new record, stale data, correlation, seasonality and data quality
  • Anomaly detection at |z| > 2.5 and week-over-week deltas above 25%, deduplicated within 24 hours
  • Any insight can be promoted to an alert in one dialog
  • An anomaly plus a question spawns an Investigator session; a weekly digest launches up to three per organisation on Monday mornings
  • An independent outlier validator re-checks every segment the Investigator claims, so reviewers do not take the narrative on trust
Caching & sync

Four tiers, then CDC replication

  • T1 in-process JVM cache with an optional columnar store of typed primitive arrays
  • T2 persistent cache in the application database or a per-connection SQLite WAL file, laid out per tenant and organisation
  • T3 materialized tables written as real tables in a customer-owned database, directly queryable by other tools
  • T4 table sync replicating raw source tables by full reload, watermark, snapshot-delta or CDC via embedded Debezium
  • AES-256-GCM at rest in both cache tiers — the cache never stores plaintext rows — and every cache failure degrades to a miss
  • Deep dive: caching & table sync →
Query governance

Concurrency caps and daily budgets

  • A per-connection semaphore with a FIFO wait queue, a queue-full error and a wait timeout
  • Live admin stats per connection — active, queued, max concurrent, last wait — plus a recent-events table
  • Per-user daily query budget resolved from user override, then organisation default, then 1000
  • Atomic check-and-reserve before every query, with bytes returned and AI tokens recorded asynchronously
  • Full query audit log — SQL, rows, duration, status and error — with retention enforced by a daily scheduler
Embedding

Signed tokens with locked params

  • Self-verifiable JWTs per question or dashboard, carrying locked params and an expiry, signed with a per-organisation key
  • The shipped placeholder signing key is rejected outright
  • A public render surface at /embed/{token} honouring the hide-powered-by brand flag
  • A JS SDK served from the app, with iframe auto-resize over postMessage
  • An embeddable agent widget whose token carries allowed connections, questions and tools, per-session caps and a per-day session cap
  • Deep dive: embedded analytics →
API, RPC & MCP

Programmable, and machine-readable

  • Data API v1 runs saved questions, renders reports and executes ad-hoc SQL, in JSON, CSV, NDJSON or Parquet
  • Token scopes are checked in addition to the creator's collection permissions
  • RPC calls stored procedures with PostgREST-style filtering, ordering and pagination on SETOF output
  • Table writes accept JSON or CSV with Prefer handling — upsert, ignore duplicates, RETURNING, max-affected and a rollback dry run
  • An MCP server at /mcp publishing 8 read-only tools, authenticated with existing API tokens, with an admin page and per-session tracking
  • Deep dive: API, RPC & MCP →
Constructions

The only DDL path in the product

  • Design schemas, tables, columns, indexes and foreign keys in the browser against seventeen portable logical types
  • Plan and preview render an ordered statement list with warnings — Snowflake has no CREATE INDEX, SQLite inlines foreign keys
  • A three-tier cascade: tenant, organisation and connection must each enable DDL, all default off, and the policy service names the outermost blocker
  • A SQL importer reads existing DDL back into a design, folding dialect spellings and warning on inexpressible features
  • The AI assistant proposes a design document, never SQL — it is rebuilt field by field through the DDL generator as a trust boundary
  • Deep dive: Constructions →
Lineage & governance

Who feeds what, drawn from source

  • Node types CONNECTION, TABLE, QUESTION, DASHBOARD, ALERT and SUBSCRIPTION, with USES, PRODUCES and REFERENCES edges
  • Organisation-wide, per-project and per-node views, rebuildable from the source-of-truth tables rather than hand-maintained
  • A neighbourhood viewer with a BFS depth selector, click-to-navigate and a truncation notice
  • A lineage report drawer with a Mermaid flowchart, a source → tables → caches → question detail tree and Markdown, with Markdown download and PDF export
  • Verified questions carry a trust badge backed by a verification audit log
BCBS 239

Risk data aggregation, in the tool

  • All 14 Basel principles held in code, grouped governance, aggregation, reporting and supervisory
  • Self-assessments per project and reporting period, DRAFT → SUBMITTED → APPROVED, scored 0–4 with rationale and evidence
  • A critical-data-element register with risk category and materiality, and seven executable data-quality check types
  • Column-level lineage coloured from the latest data-quality result, a risk-report register with sign-off, and an issue tracker
  • Every AI assist is recorded under its own audit code, so machine-drafted content stays distinguishable
  • Deep dive: BCBS 239 module →
Administration

Fifteen admin pages, eight settings tabs

  • Users, groups, permission matrices for collections and connections, and a filterable query audit
  • Settings across query, DDL, SMTP, Slack, Outboundly, identity providers, embed signing and notifications — every secret encrypted on write
  • API tokens with scopes, rate limits and expiry, a rotate-all action and a one-time secret reveal
  • Custom domains per tenant and organisation, driving both branding and which sign-in methods the login page offers
  • AI provider management with pricing, budgets, a security system prompt, connection tests and spend charts
Platform & operations

Self-hosting without a support contract

  • Java 25 on Spring Boot with a PostgreSQL application database, GraalVM native-image capable
  • An eight-step first-run wizard that writes nothing until Confirm, with systemd detection, install, start, stop and status
  • A platform console for config, logs with per-logger levels, heap and GC, and pg_dump backups on an operator-editable cron
  • Migrations resolved by name rather than classpath scanning, so a native image installs the schema identically to a JVM build
  • One initialisation latch: while false, pages redirect to /setup, other API calls answer 503 JSON and no scheduled job runs
  • Deep dive: self-hosting →
Languages & branding

Five languages, two-tier whitelabel

  • English, German, French, Dutch and Vietnamese ship complete — the same five the help-article library covers
  • DeepL machine translation for single keys, batches, missing per locale or everything, with usage metering and hot reload without a restart
  • Over 30 client-side JSON islands merged into one dictionary, so JS-built strings translate too
  • Branding resolves organisation → tenant → platform default, first non-null per field, so an organisation can override colours and inherit the logo
  • Logos, favicon, four theme colours and a custom CSS block, all passed through a sanitizer; branded email on every scheduler path; a flag hides Qrly attribution in embeds
Frontend

A shell built for daily use

  • Three zones — primary icon rail, contextual secondary rail, content column — with an off-canvas sidebar on small screens
  • A command palette on Cmd/Ctrl+K searching questions, dashboards and connections alongside recently viewed
  • The agent chat sidebar on every authenticated page, with an askAbout hook so any page can add an "Ask agent" button
  • A help drawer any element can open with hash routing, a notification bell, an insights badge and recently-viewed tracking
  • Light, dark and system themes applied by a blocking head script before first paint, with live chart re-theming
Not implemented

Multi-factor authentication

  • There is no TOTP code, no filter and no endpoint. The project notes describe columns and properties; the implementation is not there
  • What does exist: password, LDAP, Active Directory, Azure AD and Google OIDC — platform-wide and per organisation — plus API tokens, signed request JWTs, a JWT denylist, session limits and per-IP lockout after repeated failures
  • If MFA is a hard requirement, enforce it at your identity provider and put Qrly behind it
Not implemented

Row-level security and sandboxing

  • There is no per-row policy engine and no data sandbox that rewrites a user's query to their own rows
  • The nearest shipped equivalents are embed locked params, the embed-agent allow-lists, and always-applied OLAP model filters used as a security boundary
  • Below that, access is enforced at connection, project and collection level, with RESTRICTED data access limiting a user to running saved questions
By design

MCP publishes no write tools

  • The MCP server exposes 8 tools and every one of them reads. Nothing an MCP client says can create, modify or delete
  • It authenticates with the existing qrly_ API tokens rather than a new credential type, so a client cannot widen its own scope through arguments
  • Writes stay behind the in-product propose-then-approve flow, where a named human signs off on a verbatim payload
Is everything on this page in the shipping product?

Yes. This page is generated from the feature inventory of build 787, version 1.1.695. Where something is not implemented — multi-factor authentication, row-level security, MCP write tools — it is listed in the gaps section above rather than quietly omitted.

How many databases does Qrly connect to?

40 connection types, compiled through 12 SQL dialect strategies. Native engines are PostgreSQL, MySQL, MariaDB, SQL Server, SQLite, H2, HSQLDB, Derby, DuckDB, Snowflake, Redshift, BigQuery, ClickHouse, Vertica, Trino, Presto, SingleStore, DB2, Sybase and Pervasive. On top of those sit the managed variants with their own type strings — AWS Aurora, RDS, Redshift and Athena; Azure SQL, Synapse, Postgres, MySQL and MariaDB; GCP Cloud SQL, AlloyDB, BigQuery and Spanner.

Wire-compatible engines fold into an existing dialect: CockroachDB, Vertica, Trino, Presto, DuckDB, ClickHouse, Athena and Spanner compile as PostgreSQL, SingleStore as MySQL, HSQLDB and Derby as H2.

Do the AI agents write to my data?

No. Agent SQL is read-only and DDL or DML is rejected outright. Every write-side tool stages a proposal with a verbatim payload; the write tools have no path to the real service call at all. A human approves or rejects, and only then does the owning domain service run. The require_approval_for_writes setting defaults to true, and the whole agent layer is off by default per organisation.

Which capabilities cost extra?

None. Qrly ships as one platform with one licence — the agent layer, the OLAP engine, four cache tiers, CDC table sync, the spreadsheet engine, embedding, the public API, the MCP server and the BCBS 239 module are all part of the product. Pricing is on company revenue rather than per seat, so adding users never increases the bill.

Can Qrly run entirely on our own infrastructure?

Yes. Qrly is self-hostable on Java 25 and Spring Boot with a PostgreSQL application database, and is GraalVM native-image capable. First-run setup is an eight-step wizard that writes nothing until you confirm, with systemd install, start, stop and status built in, pg_dump backups on an operator-editable cron, and a platform console for config, logs, memory and languages.

The AI layer never has to leave the building either — Ollama, LM Studio, Jan.ai, LocalAI, GPT4All, LibreChat, Lobe Chat and Open WebUI are all supported provider types alongside Claude, OpenAI, Azure OpenAI, Gemini and Mistral.

What happens when a cache or an AI provider fails?

It degrades rather than breaks. Cache failures always fall through to a miss and a live query. Agent tool exceptions are returned to the model as observations so the loop self-corrects instead of dying. Every prompt side-block — connections, recent questions, schema, existing models — degrades to an in-prompt note, so a dead data source never blocks a session from starting. Alert and subscription delivery is best-effort: a failed Slack post is logged, never propagated.

One platform. One licence.

Priced on your revenue, not your seat count. Self-hosted, so your data never leaves your infrastructure.