A source saved without its credential says No credential is stored for this source. Test connection identifies the missing credential as the likely cause of a failure. On the source’s page, Invite them (under “Invite the person who does.”) opens Settings → Users in your tenant with the data_engineer role selected. That person can sign in and enter the credential themselves. PostgreSQL and ClickHouse can be saved without their secret, and kinds that use an ambient identity (an AWS IAM role, workload identity, an anonymous Iceberg catalog) need none; Redshift, Snowflake with a password, Google Sheets, BigQuery and Jira need it to register, so invite the holder first and let them add the source. Test connection reports a refused login (“The source refused the stored credentials.”) for PostgreSQL, ClickHouse and Redshift; for other kinds the connector’s own error is shown as it is.

What Test connection does

Test connection dials the external system with the integration’s stored credentials, from your data plane, running as your own connector process — the same connector that would eventually move or federate that source’s data. It isn’t a ping or a syntax check: it’s a real, synchronous round trip to a real system, so it can take a little while (up to around 25 seconds isn’t unusual for a slow warehouse). While it runs, the button shows a spinner rather than letting you assume it’s instant. You can test in two situations:
  • A draft, before you’ve saved — from inside the register or edit dialog, against the values currently in the form.
  • A saved integration — from the Integrations list or the integration’s own page, against what’s actually stored.
The result is a single pass/fail: a version string on success, or the reason it failed (invalid credentials, an unreachable host, a missing database). Common failures are shown as a plain-English summary — a host that doesn’t resolve reads as “We couldn’t find that host. Check the hostname, or set up an SSH tunnel if it’s private.” — with the underlying driver’s exact text kept available under Technical detail; anything not recognized is shown verbatim. A test of a saved integration is kept on the record: the list and the integration’s page show Never tested, Test failed (with when, and the reason on hover) or Connected (with when). Registering a source is not the same as connecting it, so a record nobody has tested reads Never tested, never Connected. Editing the host, the credentials, the capabilities or the data plane clears the badge back to Never tested, because the old result no longer describes what would be dialled; so does re-minting the key of an SSH tunnel the source goes through. A rename keeps it. A draft test inside the dialog is not stored; after saving a draft that passed, Dippr tests the saved record in the background and refreshes its badge.

Connect tests before it saves

When a source can be probed, clicking Connect (or Save when editing) runs the connection test first and won’t save if that test fails. A saved integration is therefore one Dippr actually reached with the exact values in the form — not one that merely passed the local validation. The dialog shows the current verdict inline: not tested yet, verified, failed, or no longer verified once you change a value, because a passing test only counts for the values it ran against. Editing a credential silently retracts an earlier success — a new probe has to pass for the new value. If the probe fails, the source is not saved. You can fix the credentials and try again, or — when you genuinely mean to register a source that can’t be reached yet (it’s behind a firewall you’ll open later, say) — tick Register anyway, without a verified connection and save deliberately. Some kinds can’t be probed before saving at all: an SSH tunnel and other kinds whose key Dippr generates only exist once the record is saved, so those register unverified and are tested afterwards. In every case the dialog says which situation you’re in rather than reporting a success that wasn’t checked.
Testing counts as an authoring action, not a read, because it dials a third-party system with a stored credential. You need the same role that can register or edit an integration — a read-only role can see that a source exists but can’t probe it.

How your secrets travel and are stored

Every secret field (a password, a key, a token) is sealed to the public key of the data plane you register the integration on, before it’s ever written to storage. Only that plane holds the matching private key — nobody else, including Dippr’s own control plane, can open it.
  • Reading an integration back never shows a secret’s value. The console always renders it as hidden, whether you’re looking at your own integration or exporting its configuration.
  • There’s no API or console action that retrieves a stored secret, by design. If you’ve lost track of a credential’s value, you have to get it again from wherever it originated and re-enter it.
  • Editing preserves a secret you don’t touch. Leave a secret field blank when editing and the stored value is kept exactly as it was — the blank field means “no change,” not “clear this.”
  • A secret can’t start with enc:v1:. That prefix marks a value Dippr has already sealed, so a secret you enter that begins with it is refused with an error naming the prefix, and nothing is saved. Enter the credential itself.
  • Clearing is explicit. An integration’s edit form shows a Remove action next to each stored secret; only that removes it.
  • Moving an integration to a different data plane requires re-entering every secret. A value sealed to one plane’s key can’t be transferred to another’s — there’s no re-encryption path, so the form asks you to type them again.
  • Changing where an Azure or Iceberg credential is sent requires re-entering it. These two kinds send their OAuth client secret to an endpoint you set on the integration — an Azure authority host or tenant ID, or an Iceberg catalog URI or token endpoint. If you edit one of those endpoints, you also have to re-enter the secret in the same save, so a saved secret is never sent to a destination you didn’t re-confirm it for. Pointing at a private or sovereign endpoint is fully supported; you just type the secret again when you change the target. This applies to the Azure and Iceberg OAuth credentials only — it is not a guarantee about a database password on other kinds, which stays with the integration when you edit its host.

Rotating a generated credential

Most kinds hold secrets you supply yourself. One kind is different: an SSH tunnel holds a key pair Dippr generates for you, and you never see (or supply) the private half at all. For that kind, the integration’s page shows a Rotate key action, separate from an ordinary edit — rotating immediately invalidates the current key pair and mints a new one. The tunnel stops working until you install the new public key on your bastion; nothing reconnects on its own, and the confirmation dialog says so before you commit.

The audit gap, stated plainly

Registering, editing, deleting or testing an integration doesn’t currently produce an audit trail entry naming who did it. Query engines already record a lifecycle event for comparable actions; integrations don’t yet, which means a credential’s history — who pointed it at a different host, who deleted it — isn’t reconstructable after the fact today. This is a known, tracked gap rather than an oversight nobody has noticed, and it doesn’t change what’s actually authorized: every one of these actions is still gated by your role exactly as described in Integrations overview. It only means the record of who did what isn’t there yet.