Database backups that actually restore.

1. 01

   Connect

   Add a connection or pick a saved one. SQLite asks for a file path; the others want host, port, and credentials. Tag it dev/staging/prod — the tag changes how Quay protects the connection later.

2. 02

   Browse

   One rail spans every engine — databases, tables, collections, and Redis keys. Right-click anything for actions: backup, restore, indexes, columns, copy to another connection.

3. 03

   Edit

   Every change — a cell, a JSON field, a Redis hash, a list member — stages into a per-session pending buffer. Multi-tab SQL editor for parallel queries; query history is persistent.

4. 04

   Commit

   Review the diff. ⌘S to commit, ⌘R to refresh. On a production connection you type the connection name first. Every time.

• Restore-safe SQL exports

  Foreign-key topological order. Charset and collation preserved. AUTO_INCREMENT and sequences intact. Triggers, views, and routines emitted in dependency order. Round-trip verified — MySQL, Postgres, and SQLite each have an integration test that exports → drops → reimports a real schema.

• Encrypted backups (.qenc)

  Single-file envelope: AES-256-GCM with an Argon2id-derived key. Auth tag on every blob, so tampering or wrong passwords fail fast. Restore picks up .qenc automatically — paste the password, Quay decrypts, then runs the import.

• Edit as draft

  Cells, JSON fields, Mongo documents, Redis hash/list/set/zset members — every change stages into a session-scoped buffer. Review the diff. ⌘S commits all. ⌘R refreshes.

• Production feels different

  Typed-name confirmation gates every commit to a prod-tagged connection — pending edits, raw INSERT/UPDATE/DELETE, ALTER TABLE, CREATE/DROP INDEX, restore, copy table. The friction is the feature.

• Six engines, one feel

  PostgreSQL, MySQL, MariaDB, SQLite, MongoDB, and Redis. Same context menus, same edit-as-draft, same review modal, same shortcuts across all six.

• Schema diff between connections

  Pick two open SQL connections. Quay walks every table, surfaces tables present on only one side, and per-column diffs the rest — type, nullability, primary key, default. Side-by-side, no SQL needed.

• EXPLAIN with plain-language interpretation

  Run any SELECT, click Explain. Quay parses the dialect-specific plan (MySQL row format, Postgres FORMAT JSON, SQLite QUERY PLAN) and surfaces the issues — full scans, filesort, missing indexes — with concrete suggestions. Deterministic. No AI.

• Result grid that works like a spreadsheet

  Click row index to select; ⇧-click ranges; ⌘-click toggles. Same for columns. Right-click for: copy as TSV/JSON/SQL, export selection (CSV/JSON/SQL/Markdown/NDJSON), DELETE rows by primary key, sort by column, hide columns.

• Multi-tab editor, history, saved queries

  Run several queries in parallel — each tab keeps its own SQL. History is persistent per connection (last 200, deduplicated). Star a query to save it under a name; reload from the Saved dropdown.

• Native, zero-CLI, zero-AI

  Quay implements every export, import, EXPLAIN, and structure operation natively. No mysqldump, pg_dump, mongodump dependency. No LLM call, no API key, your schema never leaves the machine.

• Restoring after an incident

  Bring production back from a dump without manual SQL editing — FK-ordered, charset-preserved, optional .qenc decryption.

  Read →

• Editing production data safely

  Stage, review, type the connection name, commit. Same pattern across SQL, Mongo, and Redis.

  Read →

• Catching schema drift

  Diff dev, staging, and prod side-by-side. Per-column type / nullability / PK / default differences surfaced in one pass.

  Read →

See all use cases

• Which databases does Quay support?

  PostgreSQL, MySQL, MariaDB, SQLite, MongoDB, and Redis. Same workflow — pending-edits buffer, ⌘S commit, prod-tag confirmations — across all six.

• When can I use it?

  v0.1 is feature-complete on macOS, Windows, and Linux — backup, restore, encrypted exports, schema diff, EXPLAIN, full CRUD across all six engines. Public build is closing in. Join the waitlist for the first invite.

• Which platforms is Quay on?

  macOS, Windows, and Linux — all three from day one. Quay is built on Tauri, which compiles each platform into a native app. The database layer is identical across platforms; chrome (titlebar, menus, file dialogs) follows each OS's conventions.

• What's in an encrypted backup?

  A single file with a 4-byte magic, version, 16-byte salt, 12-byte AES-GCM nonce, and the ciphertext + auth tag. Key derivation is Argon2id (m=64 MiB, t=2). Wrong password and tampered files fail fast. There is no recovery without the password — Quay never escrows it.

• Will it cost money?

  Pricing isn't decided. The first builds will be free. If a paid tier ships later, anyone on the waitlist gets clear notice and a generous trial.

• Does Quay use AI?

  No. Every operation — exports, EXPLAIN interpretation, schema diff, slow-query suggestions — is deterministic. No LLMs, no API keys, your schema and queries never leave your machine. If optional AI features are ever added, they'll be off by default with non-AI fallbacks.

• Do I need mysqldump or pg_dump installed?

  No. Quay implements export and import natively in Rust — that's why backups round-trip on the first try regardless of which CLI is on the host. Official CLIs can be wired in as an optional fast path, but they're never required.