Data Peek: a small Electron SQL client for Postgres, MySQL, SQL Server and SQLite

What Data Peek is for, and who actually needs it

Most SQL clients are built around writing and managing a database. Data Peek is built around looking at one. The README calls it "a minimal, fast SQL client desktop application with AI-powered querying", aimed at "developers who want to quickly peek at their data without the bloat", and that framing decides most of its design choices. The target user is a backend or full-stack developer who has a connection string, a question about a table, and no patience for a client that takes ten seconds to start.

The supported engines are PostgreSQL, MySQL, Microsoft SQL Server and SQLite, which covers the common case for application developers. The feature list is read-heavy: a schema explorer, inline editing, CSV import and export, a JSON editor for JSONB columns, per-column statistics, and a data generator that uses Faker.js with foreign-key awareness. There is also a table designer for creating and altering tables, so it is not purely a viewer, but the emphasis is clearly on inspection rather than administration.

Two features signal who this is really for. Watch Mode re-runs a read-only query on a cadence and highlights changed cells, which is a debugging tool, not an analytics tool. Time Machine snapshots successful SELECT results locally so you can scrub back through past runs. Both assume you are iterating on a query while something else is writing to the database, which is the shape of day-to-day application development.

How the pieces fit together: Electron, local storage, and an MCP server

The repository is a pnpm and Turborepo monorepo. The root package.json defines workspaces under apps/ and packages/, and the scripts target a desktop app through a filter: `turbo run dev --filter=@data-peek/desktop`. The desktop app is Electron, which matches the topics listed on the repository (developer-tools, electron, typescript) and the presence of `electron-builder` commands in the build scripts for Windows, macOS and Linux.

Credentials are stored locally, encrypted with the OS keychain according to the README, and the project states there is no telemetry. That is the whole persistence story for connection details. Separately, two features write data to disk on your machine: Time Machine snapshots and the audit log. The README is explicit that Time Machine storage is capped at 50 runs per query and a 512 MB global budget, that masked columns are stored redacted, and that Settings has a one-click wipe. The audit log is described as a hash-chained local record of every executed statement with CSV and JSON export and integrity verification, off by default, and the README warns that SQL text can contain data values.

The most unusual component is the MCP server. It exposes your saved connections to AI agents over streamable HTTP on `127.0.0.1:4722`, configurable, secured with a bearer token, and off by default. The read-only tools are `list_connections`, `list_schemas`, `run_query` and `explain_query`. `run_query` is capped at 500 rows, wrapped in a rollback, and on Postgres additionally runs with `READ ONLY` at the database level. Writes go through `execute_statement`, which raises an in-app Approve or Reject dialog for every write, with a 60 second timeout that auto-rejects. Settings offers a ready-made `claude mcp add` snippet.

There is a second AI path that avoids API keys entirely. Version 0.29.0 is titled "Bring your own agent" and lets the assistant point at a locally installed Claude Code, Codex or Antigravity (`agy`) CLI, using your existing subscription and sign-in. The README states that Claude Code grounds answers against the live database via MCP, while Codex and Antigravity grounding depends on headless tool approval landing upstream. That is an honest limitation written into the feature description, and it tells you the agent integration is not uniform across providers yet.

Installing Data Peek and running your first query

The repository ships `install.sh` and `install.ps1` at the top level, plus a `homebrew/` directory, so the intended path for most people is a packaged installer rather than a build from source. The homepage is https://www.datapeek.dev/, which is where the README points readers for the application itself.

If you do want to build from source, the root package.json defines the workflow. Dependencies are installed with pnpm, and there is a combined setup script that also rebuilds the native Electron dependencies:

pnpm install
pnpm setup:electron

The repository also provides `pnpm setup`, which runs `pnpm install` followed by `pnpm setup:electron` in one step. The `setup:electron` script runs `electron-builder install-app-deps` against the desktop package, and there is a `rebuild` script that runs `pnpm rebuild better-sqlite3` first. That native module is worth noting: if you build from source and see SQLite-related errors, the repository's own `rebuild` script is the intended remedy, and it exists because `better-sqlite3` is a native dependency.

To start the desktop app in development mode, run the dev script filtered to the desktop workspace:

pnpm dev

That resolves to `turbo run dev --filter=@data-peek/desktop` per the root package.json. Platform builds are separate scripts: `pnpm build:win`, `pnpm build:mac` and `pnpm build:linux`, each filtered to the desktop package.

Once the app is open, the first real use is a connection. You add a PostgreSQL, MySQL, SQL Server or SQLite connection, and the README notes that SSH tunnels are supported through bastion hosts with either password or key authentication. For PostgreSQL you can pin a connection's `search_path` and focus the sidebar on a single schema, which matters on databases with many schemas where the explorer otherwise becomes noise. After that, `Cmd+K` opens the command palette, which the README presents as the entry point to everything. The query editor is Monaco, so syntax highlighting and autocomplete behave the way they do in VS Code.

Watch Mode and Time Machine: the two features that define the tool

Watch Mode pins a read-only SELECT and re-runs it on a cadence from 500ms to 5 minutes, with live diff highlights. Changed cells flash amber, new rows enter with a green band that fades over a configurable window, and a tab-bar pulse indicator keeps running on watched tabs you have switched away from. When the window is hidden, polling pauses, so background tabs do not keep hitting the database.

The interesting part is the refusal. Watch Mode will not poll mutations. A pre-execution gate rejects `INSERT`, `UPDATE`, `DELETE`, DDL, transaction and multi-statement queries, and shows a tooltip explaining why. That is a deliberate constraint rather than a missing feature, and it is the right call: a polling loop against a mutating statement is a way to generate load and change data by accident. The diff logic also has to survive reordering. The README describes smart row keying that prefers explicit primary keys, then falls back to a heuristic on `id`, `uuid` or `*_id` columns, then to row position. When it falls back to row position, diffs on a re-sorted result set are going to be wrong in ways the UI cannot detect. That is a real limitation of the approach, not a bug.

Time Machine takes the opposite direction in time. Successful SELECT results are snapshotted locally, and a timeline strip opened with `Cmd/Ctrl+Shift+H` lets you scrub back through past runs. You can load a past result read-only with a "viewing the past" banner and a row-count sparkline, and diff any two runs with the same cell-level highlighting and keying Watch Mode uses. The privacy handling is stated plainly: masked columns are stored redacted, storage is capped, and Settings has a one-click wipe. If you work with production data, that wipe button is the thing to know about before you enable anything.

Where Data Peek is the wrong tool

The README does not claim to be a database administration console, and it should not be used as one. There is no mention of user management, backup and restore, replication configuration, or server-level monitoring. If your job is running a database rather than reading from one, this is not the client for it.

The AI features are the second place to be careful. The assistant is bring-your-own-key across OpenAI, Anthropic, Google, Groq and local Ollama models, and the agent mode depends on a locally installed CLI. Schema-aware prompting means your table and column names are sent to whichever provider you configure, and if you use the MCP server, query results travel over a local HTTP endpoint to an agent. The endpoint is bound to `127.0.0.1`, bearer-token protected and off by default, and writes require an in-app approval, but the read path still hands rows to a model. On a database with personal data, that is a decision to make deliberately rather than by default.

The audit log has a similar shape. It is hash-chained and verifiable, which is more than most desktop clients offer, but it is off by default and the README notes that SQL text can contain data values. Enabling it is a trade: you gain a tamper-evident local record and you start writing query text, and whatever literals are in it, to disk.

Finally, the version number. The current release is 0.29.0, and the recent releases show a fast cadence: 0.28.2, 0.28.3 and 0.29.0 all landed within about a week in August 2026. The last push to the repository was on 2026-08-20. A 0.x project moving this quickly will change things under you, and the README does not document a migration or rollback path for local data such as Time Machine snapshots or the audit log.

How it compares to DBeaver and TablePlus

The obvious alternatives are DBeaver and TablePlus, and the difference is not the feature list. It is what the application is optimised for.

DBeaver is a broad database tool built on JDBC, covering a much wider set of engines and leaning toward administration, metadata browsing and data export across many systems. If you need to connect to Oracle, Snowflake, Cassandra and Postgres from one window, Data Peek is not in that conversation. Its four engines are a deliberate scope, and the payoff is that the app does not carry a JDBC layer or a driver manager. DBeaver is also Java-based, so startup and memory behave differently from an Electron app that the README says opens in under 2 seconds.

TablePlus is closer in spirit: a native, fast, multi-engine client with a clean grid. The split there is the AI and agent surface. Data Peek ships an MCP server, an audit log and a bring-your-own-agent mode that points at a local CLI, none of which TablePlus offers. If you do not want a model anywhere near your database, that entire layer is dead weight, and TablePlus or DBeaver is the simpler answer.

Against both, Data Peek's distinguishing bet is Watch Mode and Time Machine: treating a query as a thing you observe over time rather than a thing you run once. Neither DBeaver nor TablePlus is described in their own documentation as diffing successive runs of a pinned query. That is the feature to evaluate first, because if you do not need it, the rest of the client is a smaller, less mature version of tools you already have.

Maintenance cost, licensing and what to verify before adopting

The repository is not archived, and the last push was on 2026-08-20. With releases in the 0.28.x and 0.29.0 range appearing within days of each other, expect to update often if you want fixes. The monorepo layout means a source build pulls a Turborepo pipeline, a pnpm workspace and an Electron native dependency chain; the `rebuild` script for `better-sqlite3` exists precisely because that chain breaks. If you install from a packaged build via `install.sh`, `install.ps1` or the Homebrew directory, you avoid that entirely, and for most users that is the right choice.

Licensing needs your own reading. The repository metadata reports the licence as NOASSERTION, and the top level contains `LICENSE.md`. NOASSERTION means the automated detection could not match the file to a known licence, so the terms are whatever that file says. If you are adopting this in a company, read `LICENSE.md` and get your own answer rather than assuming a permissive licence from the presence of a LICENSE file. There is also a `SUSTAINABILITY.md` in the repository, which is worth a look if you care about how the project is funded.

The upgrade surface to watch is local state. Time Machine snapshots and the audit log live on your machine, the audit log is hash-chained, and the README does not describe how either is migrated across versions. Before you rely on the audit log for anything, verify that the integrity verification still passes after an upgrade, and keep the CSV or JSON export as your portable copy. For the MCP server, confirm in Settings that it is off until you need it, and check the bearer token handling before pointing an agent at a production connection.

Editorial conclusion

Adopt Data Peek if your daily work is reading and inspecting data across Postgres, MySQL, SQL Server or SQLite and you want a client that opens fast and stays out of the way, and if you are comfortable with a young 0.x project whose MCP server and audit log ship off by default. Skip it if you need a shared, server-side SQL workspace with role-based access, or if you want an AI assistant that has been through a long support cycle. Before rolling it out, check LICENSE.md, since the repository reports the licence as NOASSERTION and the README does not settle the question, and confirm that the MCP server on 127.0.0.1:4722 is off until you deliberately enable it.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. Rohithgilla12/data-peek on GitHub