Database Node

The Database node reads from and writes to real databases inside a workflow — pull rows in, push results out, and chain the data into the rest of your flow. It's built so you can start with zero setup: pick SQLite — WASM and you have a working database immediately, even on an iPad, with no server and no keys. When you're ready for something bigger, point the same node at your Supabase, Postgres, or MySQL database.

Quick start

1. Drop a Database node onto the canvas.
2. Open it (double-click) — the body is a SQL editor with autocomplete.
3. Pick a backend in the config panel and add credentials (or a name, for local SQLite).
4. Write a query, or press the ✨ SQL wizard button to generate one in plain English.
5. Run the node. The result rows flow on to the next node — a Sheet, a Report, a Loop, or an Agent.

Wiring the node into a Loop iterates over the result rows one at a time.

Databases we support

Managed cloud databases

Most managed cloud databases speak the Postgres or MySQL wire protocol, so you can connect them with the Postgres or MySQL backend using their connection string — no separate option needed:

• AWS — RDS & Aurora (Postgres or MySQL), Redshift
• Google Cloud — Cloud SQL (Postgres or MySQL); plus BigQuery as its own backend
• Azure — Database for PostgreSQL / MySQL; plus Azure SQL via the SQL Server backend
• Others — CockroachDB, Neon, Timescale, Supabase-as-Postgres (Postgres wire); MariaDB, PlanetScale, TiDB (MySQL wire)

Document stores — MongoDB, DynamoDB, Firestore — are on the roadmap (they use a non-SQL query model, so they'll get their own mode).

Where each backend runs

A sandboxed browser tab can't open a raw database socket or touch the disk, so the server/file backends — Postgres, MySQL, SQL Server, Oracle, Snowflake, BigQuery, and SQLite — file — need either the desktop app or a connected EServer. The backend menu makes this clear: those options are labelled (EServer) when one is connected and greyed out (needs EServer) when not. Supabase (HTTPS) and SQLite — WASM (runs in the app) always work, including on iPad with nothing else set up.

A throwaway local database (SQLite — WASM)

Pick SQLite — WASM to create a database for testing in seconds:

1. Give it a name (e.g. scratch — the .db is added for you).
2. Click Create.
3. Write CREATE TABLE …, INSERT …, SELECT … and run.

It's stored locally in the app, persists between sessions, and a Delete button (with a confirmation) clears it when you're done. On the desktop app or with an EServer you can instead pick SQLite — file, choose a folder with the native picker, and get a real .db file on disk you can hand to other tools.

The database editor

Press Edit DB (the table icon in the node header) to open a full database editor in a split pane:

• Browse tables — pick a table and page through its rows.
• Edit data — change cell values inline.
• Schema — view and adjust table definitions.
• SQL console — run ad-hoc queries against the same connection.
• Export — pull the data out.

It works against whichever backend the node is configured for, so you can inspect and shape your data without leaving Circuitry.

Credentials

You supply credentials two ways:

• Inline / environment variables — type them into the node, or reference your Circuitry environment variables so secrets stay out of the workflow. For example set the connection string to {{env.DATABASE_URL}}, or the Supabase key to {{env.SUPABASE_ANON_KEY}}. These resolve when the workflow runs.
• Saved connection — store a named, encrypted connection once (Postgres / MySQL / Supabase) and pick it by name. The secret is encrypted and kept on the EServer; the workflow only references the connection, never the password. (Saved connections need the desktop app or a connected EServer.)

Using your data — template variables

Both the query and its parameters understand template variables, so you can pull values from the connected upstream node:

• {{input.value.fieldName}} — a field from the previous node's output
• {{__iteration.item.fieldName}} — the current row when running inside a Loop
• {{env.NAME}} — one of your environment variables

Put values in parameters, not glued into the SQL text — that keeps queries safe from injection. Write placeholders in the SQL ($1 for Postgres / Supabase, ? for MySQL / SQLite) and list the templated values as parameters:

INSERT INTO orders (name, total) VALUES ($1, $2)

with parameters ["{{input.value.name}}", "{{input.value.total}}"].

The SQL wizard

Press the ✨ button in the node header to open the SQL wizard. Describe what you want in plain English — "save the connected rows to the orders table" or "get the 10 most recent users" — and it writes a dialect-correct, parameterized query for you. It reads the shape of the data connected upstream (a Sheet, a Text node, a collection) and, when it can reach your database, the real table columns, so the generated SQL matches your schema.

Writes and safety

When a query changes data (INSERT / UPDATE / DELETE / DROP / …), the node asks you to confirm before running it. You can:

• Bypass write confirmation with a toggle in the config panel (per node), and
• writes run automatically in headless contexts (webhooks, scheduled runs) — there's no one to ask.

Tips

• Query results flow on as rows. Wire the node into a Loop to process them one by one, or into a Sheet / Report to display or summarise them.
• For a quick experiment, SQLite — WASM + the SQL wizard gets you from idea to working query in seconds.
• Keep secrets in environment variables ({{env.…}}) or saved connections rather than typing them into a workflow you might share.