Skip to content

Changelog: October 2026

Section titled “2026-10-31 (IST) — API keys: a rolled or expired key stops on the database’s clock, and a card’s consent can be removed right after it is added”
  • A key rolled with overlap_hours: 0 stops at once. The old key’s stop is stamped by the database, and since this change it is also judged by the database’s clock when the key is presented. Before, it was judged by the serving process’s clock, so a process whose clock lagged the database’s kept accepting the old key for the lag. The same verdict now decides a key’s state in GET /v1/api-keys and GET /v1/api-keys/{id}, so the list never calls a key active that authentication already refuses, or the reverse.
  • A key’s last_used_at is the database’s instant for every process that records a use.
  • Removing a saved card’s consent right after adding it no longer fails. The revocation is stamped by the same clock as the grant, so it can never land before it.

2026-10-31 (IST) — History mode and append-only can be asked for, behind a flag; a change of a table’s shape is confirmed and names where its old rows go

Section titled “2026-10-31 (IST) — History mode and append-only can be asked for, behind a flag; a change of a table’s shape is confirmed and names where its old rows go”
  • (2026-11-06 (IST)) The app offers history and append in a table’s mode menu where your account and the pipeline are offered them, never on a table the pipeline has read with no primary key or on a pipeline that reads its source by query. Each says what becomes of a row deleted at your source, a truncate and the next copy; a change into or out of either says where the table’s rows go (copied into a new table, the old one kept aside, or changed in place) and is confirmed before it is sent.
  • (2026-11-06 (IST)) pending_mode.aside names the table the old rows are kept in, for a change that copies the table, from the moment it is asked for.
  • (2026-11-06 (IST)) A history table whose copy waits for another session’s lock is never told it has no primary key (waiting.reason history_copy_lock, and after the third try in a row parked.cause history_copy_lock_held, naming the sessions that hold the lock). It was given the reasons a table with no primary key is given (copy_lock, copy_lock_held), so append was refused on it with 422 mode_not_offered (“has none at the source”) and the app offered to give it a primary key. The pipeline tries the copy again on its own, as before.
  • (2026-11-06 (IST)) A change out of history or append on a table parked keyless_mode_not_offered with nothing written in that mode is applied at the pipeline’s next start, while the table is parked (pending_mode.waits_for_streaming is false for it, and its pending_mode names no aside: none is kept), in place, with no table kept aside; its 422 confirm_required and its history entry say so. A table merely waiting for its copy is not changed in place (its destination table may already be in the old mode’s shape): its change waits for it to sync, as every other. This is how a table parked keyless_mode_not_offered is freed, and its parked.remedy now says it (or, where rows of it are kept in that mode already, that only a primary key at your source frees it). It used to read “Fix the cause, then resume the table”, and the app told it “cancel the change to resume it first”, which cancelled the one request that frees it.
  • (2026-11-05 (IST)) A table with no primary key is not kept in history or append yet: asking for either on a table the pipeline has read with no primary key answers 422 mode_not_offered; one that reaches either anyway (the pipeline’s default, or a key dropped later) is stopped alone at the next start, keyless_mode_not_offered, before anything of it is written, and the pipeline syncs its other tables. A request for soft_delete or live is applied to it while it is stopped (nothing of it was written in the old mode); then resume it.
  • (2026-11-05 (IST)) A pipeline that reads its source by query is not offered history or append: asking for either, on a table or as the pipeline’s default, answers 422 mode_not_offered, because a query sees each row’s latest state only, never each change a version or a log row is made of. Switch the pipeline to logical replication with a full re-sync first (the re-sync to query_based is already refused while a table is kept so).
  • history and append are offered on PUT /v1/pipelines/{id}/tables/{table_id}/sync-mode, the pipeline’s default (PUT /v1/pipelines/{id}/sync-mode), POST /v1/pipelines and GET /v1/connectors’ offer, at a Snowflake and a PostgreSQL destination, for a PostgreSQL source, to an account they are available to. For another account they answer 422 not_yet_available (they were 422 mode_not_offered). Available to every account from the next release.
  • A change of a table’s shape needs confirm: true (422 confirm_required otherwise, saying what happens and naming the table its old rows are kept in): out of history or append, into append, and into history at a PostgreSQL destination. At Snowflake the table is copied into a new table built beside it, which then takes its name with its grants; at PostgreSQL the pipeline stops the table with the statements that build the new one. The old table is kept under a name fixed when you ask (<table>__<old mode>_<UTC yyyymmddhhmmss>), with every row it has: it is yours, and the pipeline never writes it or drops it. The copy is metered as copy work. A change made in place (between soft_delete and live, and from either to history at Snowflake) needs no confirm, as before.
  • table_mode_change_requested and table_mode_changed carry aside_table for a change of shape: the name the old table is kept under. A new event, table_mode_change_refused (table, from, to, reason, statements), says a change of shape was refused before anything was built, the table going on as it was.
  • A table parked while a change of its mode is begun can be resumed (POST …/tables/{table_id}/resume). Before, it was refused 409 table_action_pending, and since a begun change cannot be cancelled, the table could not be resumed at all. Every other request on such a table still waits for the change.
  • A PostgreSQL table parked for the statements its new shape needs is told what they do (parked.remedy): they build a new table beside it and swap it in, the old one kept aside, and its resume copies it into the new table. It said “it adds the two columns soft delete keeps”, which is true only of soft delete.
  • A truncate’s soft_delete and delete answers say what they do to a history or append table: every current version is closed at the truncate, its history kept, or one row is added saying the table was truncated. Nothing of either is deleted.
  • At Snowflake, a change of shape the pipeline’s role cannot carry a grant for is refused before anything is built: a grant on the table to a share or an application, or a managed-access schema the role does not own. The request is handled refused, the table syncs on in its mode as if nothing had been asked, and table_mode_change_refused names what blocks it (reason: grantee or managed_access). Ask again once it is removed. Before, the table was copied in full and then stopped at its swap.
  • A history table waiting for the source’s primary says so (waiting.reason history_standby): a history table’s first copy is never read from a standby, and it was told keyless_standby, which says the table has no primary key. Point the pipeline at the primary for the copy.

2026-10-30 (IST) — A table kept in soft delete waiting for its column is told what its copy does there, and a wider column is taken

Section titled “2026-10-30 (IST) — A table kept in soft delete waiting for its column is told what its copy does there, and a wider column is taken”
  • A table kept in soft delete whose copy waits for a column is told that the copy marks the rows it does not write deleted. At a PostgreSQL destination, a copy that waits until you change a column the source retyped (cause copy_needs_column_type, type_change_rewrote or type_change_rewrote_key) was worded as if the table were kept live, because the pipeline wrote that line before its destination had been told the table’s mode: a table with no primary key was told its copy removes them, a table with a primary key that they are kept, and a table whose key column was retyped that its resume is refused, while the API offered the plain resume that marks them. The line now says what the table’s own mode does, as the API’s remedy and its record of the resume always did.
  • A column of a wider type than the one shown is taken. The line said to change the column to the source’s new type “exactly: another type, a wider one too, is not taken”; a wider type that the new one changes to in place (a numeric(14,4) for a numeric(12,4), a longer character varying, text) was always taken, and the copy ran. The line, the API’s remedy and the app now say so. Nothing else changed.

2026-10-30 (IST) — A table with no primary key waiting for its column is told what its own copy does

Section titled “2026-10-30 (IST) — A table with no primary key waiting for its column is told what its own copy does”
  • A copy of a table with no primary key that cannot write a column yet stops with its own cause, copy_needs_column_type, and says what that copy does. At a PostgreSQL destination, where a column’s type cannot hold every value of the type your source changed it to (a numeric(10,2) column given numeric(12,4) values), the copy writes nothing until you change the column, whatever the table’s key. A table with no primary key was then stopped as type_change_rewrote and told that its copy keeps every other row your destination holds; its copy replaces what your destination holds, so a row of your own in that table was removed by the resume. Its line and the API’s remedy (GET /v1/pipelines/{id}/tables, parked.cause = copy_needs_column_type) now give the statement, then say that resuming it copies the table again replacing what your destination holds, a row your source no longer has removed (or, in soft delete, marked deleted). A table with a primary key is stopped as before.

2026-10-30 (IST) — A copy that deletes rows no longer deletes the rows outside a row filter that an earlier one kept

Section titled “2026-10-30 (IST) — A copy that deletes rows no longer deletes the rows outside a row filter that an earlier one kept”
  • A second copy that deletes, after one that kept the rows outside the table’s row filter, keeps them too. At a PostgreSQL destination, a table with a primary key kept live, Re-sync and delete them deletes no row outside the table’s row filter where the table keeps rows outside it or you changed that filter. Its first run kept those rows, but the table was then recorded as keeping none, so a later one judged nothing and deleted them, though the words of that copy say it deletes none of them. The table now records that it keeps them whenever a copy leaves them in place, and every later copy judges the filter again.
  • Re-sync after such a copy no longer counts the rows it kept outside the filter as rows your source no longer has, so the count Re-sync and delete them is offered over is true, and that copy deletes none of them either.

2026-10-30 (IST) — Query-based pipelines: no delete check in this release; a partitioned table’s first sync after its copy reads nothing again

Section titled “2026-10-30 (IST) — Query-based pipelines: no delete check in this release; a partitioned table’s first sync after its copy reads nothing again”
  • A pipeline that reads by queries does not find rows deleted in your database. A query sync reads the rows that changed since the last one; a deleted row leaves nothing to read, so it stays in your destination as it was, not marked and not removed, in soft_delete and in live, into PostgreSQL and into Snowflake. The delete check that would have found such rows (by comparing each table’s keys with your destination’s) is not in this release: it is a later feature. To bring a table’s rows in line with your database, re-sync it: the copy marks the rows your database no longer has (soft_delete) or removes them (live; on PostgreSQL only when you ask the re-sync to delete rows your database no longer has). A pipeline that reads your database’s change log still delivers every delete.
  • Removed before release, so nothing that shipped changes (and the three earlier entries of 2026-10-30 that described the check’s fixes are withdrawn with it; the Aurora refusal stays, below): PUT /v1/pipelines/{id}/tables/{table_id}/delete-check and PUT /v1/pipelines/{id}/tables/{table_id}/missing-rows; the create fields delete_check, delete_check_confirmed and delete_check_large (a body naming one is refused as an unknown field); the table fields missing_rows, delete_check, delete_checked_at, delete_check_failures, delete_check_large, delete_check_held and rows_found_deleted; the codes delete_check_unconfirmed, delete_check_not_applicable and delete_check_large_not_applicable; the alert and notification delete_check_failing; the audit actions table.missing_rows_changed and table.delete_check_changed; and the history kinds deletes_counted, keys_missing_in_destination, key_compare_mismatch, delete_check_held, delete_check_failed, delete_check_found_empty and witness_missing. query_read no longer carries deleted, and its sentence is “table: N rows changed since the last sync.” (api/openapi.json regenerated.)
  • The words now say it everywhere. A query-based table’s mode menu, its mode-change confirmation and its “Delete the rows marked deleted” confirmation say a row deleted at your source stays as it was, unmarked, in every mode; the create form asks no Deletes question and its method hint says deleted rows are not found; the table’s sync_mode description and the pipeline’s default-mode route say the same. The setup test’s history step no longer says a restore that has caught up is noticed when a row found deleted is back: nothing finds deleted rows, so such a restore goes unnoticed, and the step says so. After any restore you know of, re-sync.
  • A partitioned table’s first sync after its copy reads only what changed. It read every partition whole again: every row written again (your warehouse paid to merge each one) and told “N rows changed since the last sync” when none had. The copy now records the partitions it read, and the next sync reads each from where the copy began, as it reads a table that is not partitioned. A partition attached while the copy ran is read whole once at the next sync, and told as rows read again (rows_reread, reason attached).

2026-10-30 (IST) — Query-based pipelines: Aurora’s names elsewhere are refused

Section titled “2026-10-30 (IST) — Query-based pipelines: Aurora’s names elsewhere are refused”
  • A source where a function named as one of Aurora’s own exists outside pg_catalog, and none in it, is refused by a query-based pipeline as a logical one refuses it: the connection test’s provider step fails aurora_unconfirmed with the same sentence as the server step, and a sync stops before reading anything, saying to drop or rename the function, or to connect to the cluster’s writer and tell us which schema holds aurora_version(). It was read as plain PostgreSQL.
  • Guides: Query-based capture.

2026-10-30 (IST) — A table with no primary key that PostgreSQL refuses stops alone, and a soft Copy again counts a moving row once

Section titled “2026-10-30 (IST) — A table with no primary key that PostgreSQL refuses stops alone, and a soft Copy again counts a moving row once”
  • A table with no primary key whose write PostgreSQL refuses (a trigger of yours that raises an error, for one) stops that table only, with PostgreSQL’s words, and every other table keeps syncing, as a table with a primary key already did. It used to stop the whole pipeline, which restarted and met the same refusal again.
  • Kept in soft delete, a row your own session moves across the new row filter while the Copy again waits for it is counted once, on the side it was on when it was marked, so the rows told not in the source and the rows told marked never disagree about it.

2026-10-29 (IST) — A table with no primary key is copied again, never stopped as a rewrite, when a type change may change its values

Section titled “2026-10-29 (IST) — A table with no primary key is copied again, never stopped as a rewrite, when a type change may change its values”
  • A table with no primary key is not stopped as type_change_rewrote by a column type change that may change its values (the change of 2026-10-26 below stops a table with a primary key; a copy of either kind still waits for a PostgreSQL column that cannot hold the new type, as the 2026-10-30 entry above says). Each of its rows is identified by a hash of all its values, so such a change gives every row a new identity, and the table is copied again under the new ones by its rule for a change of its key, as before 2026-10-26: at once under a confirmed Copy the table again, otherwise stopped (replica_identity_key_changed) until you resume it. That copy replaces what your destination holds (or, in soft delete, marks deleted every row it does not write), so the table ends exact with nothing for you to choose.
  • Which type changes copy such a table again is now judged by the same list as what stops a table with a key, What keeps every value: a change outside it, and one in it that makes the column another type (text made varchar; an integer made numeric or numeric(p,0); an integer or a numeric made text or varchar; a numeric(p,s) made numeric; a time or timetz given a finer precision), because the destination column of a table with no key is never changed to another type in place. That is the list such a table had before, with two differences: a numeric given fewer digits at the same scale now copies it again, and a timestamp(6) or timestamptz(6) made the same type with no precision, or back, no longer does (both spell the same precision).

2026-10-27 (IST) — Copy again under a changed row filter: one statement removes or marks the rows, and never one outside the filter

Section titled “2026-10-27 (IST) — Copy again under a changed row filter: one statement removes or marks the rows, and never one outside the filter”
  • A PostgreSQL table with a primary key, copied again under a row filter you changed: the rows your source no longer has are deleted (when you asked for that, Re-sync and delete them) or, kept in soft delete, marked, by ONE statement that locks them and acts on exactly them, as every such Copy again already was without a filter; and that delete still never removes a row outside the new filter, which your source may well hold. So what it tells you it found and what it removed are that one statement’s numbers, even while your own session writes to the table, and a trigger of yours that keeps one of those rows stops the table’s copy whole, saying a BEFORE DELETE trigger can keep a row with no error, instead of being told as removed. Kept in soft delete, the rows outside the new filter are marked too, and told apart. Where the destination cannot judge the filter on its own values (a column the pipeline hashes, or one declared otherwise at the destination), the delete removes nothing, as before. A table with no primary key is copied as before.
  • A table with no primary key: its purge of the rows marked deleted is decided by one statement too. It removes exactly the rows it locked and tells that number, never a count a rule of yours on the table could make; a trigger that keeps one of them stops that purge whole, with nothing removed. A purge you asked for then stays pending, and the table cannot be resumed while it waits: cancel the purge, then resume the table, and ask for the purge again once your trigger lets those rows go. The purge that follows each save of a table kept live stops the table, which waits for you with PostgreSQL’s words; once your trigger lets those rows go, resume it, and the purge after the save of its next change removes them (it used to remove the others and keep that one, telling nothing).

2026-10-27 (IST) — A query-based pipeline knows which table each name is, and checks what it resumes

Section titled “2026-10-27 (IST) — A query-based pipeline knows which table each name is, and checks what it resumes”
  • A table replaced under its name is never read as the table the pipeline was syncing. The first sync records which table each name is, as a log pipeline does, and every sync after checks it before it reads anything. A table dropped and created again, or a rebuilt copy renamed into its place, is stopped (table_parked, cause table_replaced) while the other tables keep syncing; resuming it copies the table that has the name now. Under a change rule that re-copies a replaced table, once confirmed, it is copied again at the next sync instead. Until now such a table was read from the old table’s place, so its older rows never arrived.
  • A first sync’s copy that a later sync resumes is checked against the database it began on: another database at the address, or one behind what the first sync read (a restore), stops the pipeline before it reads; a replica behind it is waited for.
  • Every sync repeats the Aurora writer test before it reads anything: a sync that reaches an Aurora instance that cannot show it is the writer ends without reading, is not charged, and tries again (aurora_not_writer, a new event kind).
  • source_restarted is told wherever your database answers: a server of the same database that started since the last sync is told at another address too (a restore onto another host behind the same name), in a sentence that says where.
  • The sessions a query-based pipeline reads through look names up in pg_catalog only (search_path set when the connection opens, then checked): a connection pooler that drops the connection’s startup options is refused with a sentence that says what to change.
  • The delete check’s Never warning now says what is true: once a restored database has caught up, the delete check is the only check that can still notice it.

2026-10-26 (IST) — Snowflake: wide numerics can land as NUMBER(38,s), exactly or told (behind a flag)

Section titled “2026-10-26 (IST) — Snowflake: wide numerics can land as NUMBER(38,s), exactly or told (behind a flag)”
  • A Snowflake destination can choose how a numeric with no declared precision, or wider than 38 digits, lands. settings.wide_numeric_as on POST /v1/destinations is VARCHAR (the default when absent: exact text, as before) or NUMBER(38,<s>) for a scale s from 0 to 37. Under a number, in a table synced by a key, a value with more digits than the type holds is written as NULL, its exact original kept in the row’s _REYANSH_META under does_not_fit, and the pipeline’s history names the column and the rows; copying an added column’s existing values stops the table at such a value instead (fill_failed), writing nothing as NULL. A key column, and every column of a table synced without a key (each row identified by a hash of all its values), is always exact text, whatever the setting. A declared numeric(p,s) lands as NUMBER(p,s) as before, and a column a table already holds as a narrower NUMBER keeps that type: a value too wide for it stops the pipeline, as without the setting. Offered only to accounts GET /v1/me marks wide_numeric_enabled; others are refused 422 not_yet_available. Chosen at create: PATCH answers 422 setting_not_editable.
  • A table parked because a column’s existing values could not be copied (fill_failed) now says its way out, on the tables page and in the API’s parked.remedy: resume it to copy the column’s values again, and if it stops again with the same message (a value the destination cannot take, such as a number too wide for a Snowflake destination’s wide-numeric setting), re-sync the table instead. It said only the refusal’s own words.

2026-10-26 (IST) — Snowflake: Time Travel (days) for every account

Section titled “2026-10-26 (IST) — Snowflake: Time Travel (days) for every account”
  • Every account can now choose a Snowflake destination’s Time Travel retention when creating it. The form’s Time Travel (days) field, 0 to 90, and settings.time_travel_days on POST /v1/destinations were offered only to some accounts; the others were refused 422 not_yet_available and did not see the field. Nothing changes for a destination created without it: Snowflake’s own retention is left as it is. GET /v1/me’s time_travel_enabled is true for every account from this release, and the field is still chosen at create only.

2026-10-26 (IST) — A type change that may change your rows’ values stops the table, and copying it again makes it exact

Section titled “2026-10-26 (IST) — A type change that may change your rows’ values stops the table, and copying it again makes it exact”
  • A column’s type change that may change the values its rows already hold now stops the table (cause type_change_rewrote), whatever the change policy says, instead of being kept or converted in place. PostgreSQL rewrites every row to change a column’s type and sends none of them through its change log, so a rounding or a new scale (timestamp(6) to timestamp(3), a numeric given a scale) left your destination holding the old value: in a key column, the next change to such a row was written as a second row and its delete missed it; in any other column, the old value stayed. Found by our own review; no customer pipeline had met it.
  • The table’s line says what to do. At Snowflake, resume it: the copy changes the column’s type itself, and the rows written with a key’s old values are marked deleted. At PostgreSQL the table waits, keeping its place, and where your column’s type cannot hold every value of the new one, its line ends with the ALTER TABLE ... ALTER COLUMN ... TYPE statement: run it, then resume. The pipeline checks the column first and copies nothing until it has the new type; the resume then copies the table again, keeping every other row (a plain recopy, which deletes only rows outside a row filter you changed answering delete), and a soft_delete table marks rather than deletes. A column of the key is never resumed: its line names the two copies to choose between, and the table’s row offers both and no Resume: Re-sync, which keeps the rows written with the key’s old values beside the new ones, and Re-sync and delete them, which deletes every row the copy does not write, those rows among them, but none outside the table’s row filter where the table keeps rows outside it or you changed that filter (and nothing where your table’s values cannot be judged against it). That one is offered there before any copy has counted those rows, and its confirmation says what it deletes in words, never a number. A copy is billed like any other work.
  • A change that keeps every value changes nothing: a varchar lengthened or made text, an integer widened, a numeric given more digits at the same scale, a timestamp given a finer precision, an integer or numeric made text. The full list is in When a source table’s shape changes.
  • GET /v1/pipelines/{id}/tables names the new park cause, type_change_rewrote, with a remedy that never promises to keep the rows your destination already has. POST /v1/pipelines/{id}/tables/{table_id}/resume on such a table at a PostgreSQL destination records the copy it is, shown as the table’s pending_action: recopy for a column outside the key or on a soft_delete table; for a column of the key (cause type_change_rewrote_key) on a table kept live it is refused, 409 copy_choice_required, whatever the table’s row filter, naming the two copies (POST .../recopy, with or without delete_rows_not_in_source). The endpoint’s reference says so.

2026-10-26 (IST) — Security: a copy never runs a domain’s CHECK; a key of an extension’s type is copied whole; the stream checks its search path first

Section titled “2026-10-26 (IST) — Security: a copy never runs a domain’s CHECK; a key of an extension’s type is copied whole; the stream checks its search path first”
  • A security fix to shipped behaviour: a copy no longer runs code that a key column’s domain calls. When a table’s key column has a domain type, the resumable copy (since 2026-10-11 (IST)) wrote each part’s bounds as values cast to that domain, and a cast to a domain runs the domain’s CHECK, which can call any function the domain’s owner wrote, with the pipeline’s rights. The bounds are now written as the domain’s underlying type, which runs nothing of anyone’s. If someone other than you can create domains your tables use, review what their CHECKs call.
  • A key whose type compares through an extension’s operators is copied in one statement, and the page says why (key_index_order). Since 2026-10-25 (IST) the pipeline’s sessions look names up in pg_catalog only, and a resumable copy compares key values: for a key column of type citext that comparison became text’s, while the rows still came in citext’s order, so under a C or POSIX collation (or PostgreSQL 17’s builtin provider) a copy in several parts could skip rows of a key such as (tenant_id, email citext) and say nothing; for ltree the copy could not start and was tried again for ever. Such a table is now read in one statement, every row once. If a table with a citext part in its key was copied since 2026-10-25 (IST), copy it again from the table’s page.
  • The replication stream checks its search_path before it runs anything, as the pipeline’s other sessions already did. It used to check it inside its first statement, after that statement’s own operators had been looked up through your role’s path: behind a pooler or proxy that drops the setting, a schema ahead of pg_catalog on that path could put its own operators in their place. The stream now stops (search_path_unpinned) before running anything.
  • A copy waiting for a standby lets go of its share lock only for a session that lock is blocking (an ALTER TABLE, a VACUUM FULL, a TRUNCATE). It let go for any session queued on the table, so an ANALYZE queued behind autovacuum could keep a copy from finishing for as long as it waited, behind a standby that trails.

2026-10-26 (IST) — A credential’s rotation refuses a value that is a source reached through an SSH tunnel

Section titled “2026-10-26 (IST) — A credential’s rotation refuses a value that is a source reached through an SSH tunnel”
  • POST /v1/credentials/{ref}/rotate answers 422 ssh_tunnel_in_credential when value is a source document that names an SSH tunnel (connect), with or without a key’s seed in it. A tunnel is set and changed only on its source, through PATCH /v1/sources/{id}, where it is tested with the account’s SSH key and its host key is approved by a person. Nothing is stored or tested: the credential is as it was. Every other rotation is unchanged.
  • Why: a rotation’s value is opaque text, and its identity check tested such a document as it came, so a tunnel could be dialled with a key the caller supplied, even while tunnels were switched off for the account. Found by the SSH tunnel’s third review (SSHR3), before the feature was enabled for any account.

2026-10-26 (IST) — Fixes and releases no longer stop when a month’s hosted CI minutes do

Section titled “2026-10-26 (IST) — Fixes and releases no longer stop when a month’s hosted CI minutes do”
  • When GitHub’s included Actions minutes run out, our CI runs on our own machines, so a fix that is ready can still be checked and merged before the 1st of the month. Nothing about the product changes: every check that gates a merge still runs, in full, before it. A release is still built, and its live suite still measured, on GitHub’s runners, so a release waits for them.
  • Some of our internal safety checks could report a pass without having checked, on Linux. A shell idiom they used can lose its own match under load on the Linux machines CI runs on; it never did on the machine the checks are written on. Every instance is rewritten, a new check refuses the idiom, and nothing is known to have slipped through.
  • While CI runs on our own machines, the full test-coverage measurement waits for GitHub’s. It needs more disk than the machine we borrow can spare, so it is skipped there and shown as skipped. It still gates every release: nothing ships until a run on GitHub’s runners has measured that exact commit, which happens when the month’s minutes return.

2026-10-26 (IST) — The app creates query-based pipelines

Section titled “2026-10-26 (IST) — The app creates query-based pipelines”
  • New pipeline asks How we read your database for a PostgreSQL source: from its change log (as before) or by queries. A query-based pipeline’s test needs no slot or publication and shows no statements to run; after you pick tables, Test again checks each one (that it can be read, row security, how much each sync reads) and keeps them picked.
  • A query-based pipeline is asked Find rows deleted in your database (Every sync, Once a day, or Never, which says what it loses and needs “I understand.”), the default every table follows; its schedule is asked into any destination; and the existing-rows question becomes a statement, since its first sync copies every row.
  • The test’s skipped slot and publication steps now say so in a readable sentence (“uses no publication”).
  • A pipeline’s schedule preview (GET /v1/schedule-preview) is now asked with the pipeline’s update_method on the pipeline’s page, so a query-based pipeline’s schedule says when it runs.

2026-10-26 (IST) — A query-based pipeline’s delete check is chosen when it is created

Section titled “2026-10-26 (IST) — A query-based pipeline’s delete check is chosen when it is created”
  • POST /v1/pipelines accepts delete_check for a query-based pipeline (update_method: query_based): how often its tables’ keys are compared with your destination’s to find rows deleted in your database: every_sync (the default when left out), daily, or off, which leaves deleted rows in your destination and needs delete_check_confirmed: true (422 delete_check_unconfirmed without it). It is the pipeline’s default: every table without an answer of its own follows it, including tables added later.
  • And delete_check_large (ask, the default, or remove): every table’s standing answer for a check that would remove more than half of a table and more than 1,000 rows, for a Snowflake pipeline whose tables are kept live only (422 delete_check_large_not_applicable for any other).
  • A pipeline that reads your database’s change log refuses all three (422 delete_check_not_applicable); a word outside the lists is 422 invalid_field.
  • A table’s delete_check now shows the pipeline’s default when the table has no answer of its own (it showed every_sync). Setting only large, or answering a held removal, through PUT /v1/pipelines/{id}/tables/{table_id}/delete-check leaves a table following its pipeline’s default.

2026-10-26 (IST) — A query-based sync asked to stop is shown stopped, and not charged

Section titled “2026-10-26 (IST) — A query-based sync asked to stop is shown stopped, and not charged”
  • GET /v1/pipelines/{id}/runs gains the outcome stopped: a query-based sync asked to stop before it finished (a pause, an edit, our service restarting). It saved nothing, the next sync writes its rows again, and it is not charged; it was shown running, then failed or partial. ?outcome=stopped finds them.
  • A stopped query-based sync now tells sync.ended with status: stopped and the stop’s reason; before, it told no sync.ended at all.
  • The app’s run history says “Stopped before it finished — not charged”.

2026-10-26 (IST) — A query-based table’s delete check can be set, and a held removal answered

Section titled “2026-10-26 (IST) — A query-based table’s delete check can be set, and a held removal answered”
  • PUT /v1/pipelines/{id}/tables/{table_id}/delete-check sets a query-based table’s delete check, any of three answers in one request: check, how often its keys are compared with your destination’s (every_sync, the default, daily, or off, which leaves deleted rows in your destination and needs confirm: true, 422 delete_check_unconfirmed without it); large, for a table kept live in Snowflake, what a check that would remove more than half of the table and more than 1,000 rows does (ask, the default, or remove; 422 delete_check_large_not_applicable for any other table); and answer_held with held_rows, your answer to such a removal waiting now: remove (removed at the table’s next sync, unless more rows are gone by then, which asks again) or keep (nothing removed; asked again only when more rows are gone). 409 delete_check_nothing_held when nothing waits, 409 delete_check_held_changed when the waiting count is no longer the one you were shown; 422 delete_check_not_applicable for a pipeline that reads your database’s change log. Settings, written at once and read at the table’s next sync: nothing restarts. Audited as table.delete_check_changed.
  • Every table gains delete_check, delete_checked_at, delete_check_failures, delete_check_large and delete_check_held (rows, since, answer, answered_rows): null on a table of a pipeline that reads your database’s change log, and delete_check_large null unless the table is kept live in Snowflake.
  • And its last read: last_read_at, rows_changed, rows_found_deleted, rows_reread and reread_reason, as its last sync told them on the feed (query_read, rows_reread); null before any read, and on a table of a pipeline that reads your database’s change log.

2026-10-26 (IST) — A query-based pipeline can write to Snowflake

Section titled “2026-10-26 (IST) — A query-based pipeline can write to Snowflake”
  • A pipeline that reads your PostgreSQL by queries (query-based capture) can now write to Snowflake. Its first sync copies every table; each sync after reads only the rows changed since the last, and writes them through the same staging, MERGE and lock on the destination as a pipeline that reads your database’s log.
  • Rows deleted in your database are found and applied in Snowflake: after each table’s changes, the sync compares the keys your database has with the rows in Snowflake. A table kept in soft delete marks the gone rows deleted (_REYANSH_DELETED_AT); a table kept live removes them, except rows already marked deleted, which stay until you purge them.
  • A large removal waits for you. When a live table would lose more than half of its rows, and more than 1,000, nothing is removed: the sync tells you how many rows your database no longer has (delete_check_held), keeps the table’s other changes flowing, and asks again only if the count changes.
  • The sync keeps a small record in the pipeline’s own schema (_REYANSH_WITNESS) of the rows it marked or removed, so a row that comes back in your database in an older version (a restore from a backup or a snapshot) stops the sync before anything is saved (source_history_rewound), as on a PostgreSQL destination.

2026-10-26 (IST) — A query-based pipeline recognises a row it marked deleted coming back after a restore

Section titled “2026-10-26 (IST) — A query-based pipeline recognises a row it marked deleted coming back after a restore”
  • A soft_delete table’s delete check now keeps a small record in your destination (_reyansh_witness_v1, beside the table) each time it marks rows deleted. When a row it marked comes back in your database in a version older than that mark (a restore from a backup or a disk or VM snapshot, or a crash of a database that runs with synchronous_commit = off), the sync stops before saving anything (source_history_rewound) and asks you to re-sync the pipeline.
  • A row your destination holds as deleted while your database has it in a version the pipeline delivered (a destination that discarded the write, a trigger for example) is now counted with the rows missing from your destination: “missing from your destination or held there as deleted”.
  • When that table cannot be created (the user the pipeline writes as may not create tables in that schema), each sync says so (witness_missing, info) and marks rows as before.

2026-10-26 (IST) — A delete check that keeps failing is a warning, and a notification

Section titled “2026-10-26 (IST) — A delete check that keeps failing is a warning, and a notification”
  • A new alert, delete_check_failing (a warning): a query-based table’s delete check has failed at three syncs in a row or more. Its changed rows are still delivered at every sync; the rows deleted at your source are found late, never wrongly. The alert names the tables in tables, on GET /v1/pipelines/{id}/alerts and GET /v1/alerts, and ends at the first sync whose check completes.
  • A new notification trigger, delete_check_failing (warning; emailed when warnings are on): told once, naming the tables, and ended by a check that completes (or a stop), never by the alert disappearing. Its webhook body carries tables.

2026-10-26 (IST) — A query-based table’s missing rows can be marked expected

Section titled “2026-10-26 (IST) — A query-based table’s missing rows can be marked expected”
  • PUT /v1/pipelines/{id}/tables/{table_id}/missing-rows sets a query-based table’s answer for rows your database has and your destination does not: {"answer": "tell"} (the default: you are told, once and again only when their number grows) or {"answer": "expected", "confirm": true}, for a destination that removes rows on purpose (a retention rule, a trigger). Expected stops the telling for that table, including rows a restore of your database would leave missing, so it needs confirm: true every time (422 missing_rows_unconfirmed without it). It never silences a stop. The answer is read at the table’s next delete check, so nothing restarts; the same answer again records nothing. Audited as table.missing_rows_changed, before and after.
  • 422 missing_rows_not_applicable for a table of a pipeline that reads your database’s change log, which delivers every delete and reports no missing rows; 422 invalid_field for any other answer; 409 table_removed.
  • Every table gains missing_rows: the answer on a query-based pipeline’s table, null elsewhere.
  • keys_missing_in_destination’s sentence ends again with how to stop it: “If your destination removes rows on purpose, set this table’s missing rows to Expected.”

2026-10-25 (IST) — Snowflake: a value too long for its column is cut or written as NULL, a crash no longer blanks a deleted row’s column, a lost fence history is waited out and told, and a clock running ahead is named

Section titled “2026-10-25 (IST) — Snowflake: a value too long for its column is cut or written as NULL, a crash no longer blanks a deleted row’s column, a lost fence history is waited out and told, and a clock running ahead is named”
  • A value longer than its Snowflake column holds no longer stops the pipeline. A VARCHAR the destination creates holds 16,777,216 characters and a BINARY 8,388,608 bytes. A longer text is cut to its first 16,777,216 characters, as Fivetran cuts one; a longer binary, or a JSON value whose text is longer than 16,777,216 characters, is written as NULL. The row’s _REYANSH_META says which and how long the value was, but keeps no original (it would not fit); the pipeline’s history and a warning alert name the column and the rows. A key that long still stops the pipeline: a key is never changed. Before, such a value refused its whole batch and the pipeline restarted on it for ever.
  • A row’s _REYANSH_META always fits, however many updates wrote it. When Snowflake had to rewrite a JSON value (a repeated key, a number it cannot hold exactly), the note keeps your source’s original text beside it. Each update keeps the notes of the columns it did not change, so a row holds a note per column, and Snowflake refuses a row’s _REYANSH_META past 134,217,728 bytes. Each note now keeps its original only up to its share of that column, 16,777,215 characters divided by the table’s value columns (about 1.6 million characters on a table of ten); past it, the note keeps the original’s length instead (original_characters, with original_kept: false). The value itself is written as before. Before, a long enough value refused its batch on every restart.
  • A soft-deleted row keeps its columns across a crash. When the worker stopped between a batch’s delete and its confirmation, the batch’s replay could write a column the update had not changed as NULL in the deleted row. The row now holds what your source held, as it does without a crash.
  • A pipeline whose Snowflake fence history was lost waits up to about an hour before it writes again, and says so as the wait begins. If the destination’s own working schema or its _REYANSH_FENCE table is dropped while the pipeline’s tables hold data, the next start waits for any statement an earlier writer may still have queued to end (at most 3,630 seconds), whichever Snowflake user it signs in as, then carries on. The same holds when a row of _REYANSH_FENCE is deleted, unless the table was created after _REYANSH_FENCE and no other table of the pipeline has been written, which still reads as a new pipeline’s. The decision is read from Snowflake by every start, so a start that stops partway hands the wait to the next. The pipeline’s history says destination_fence_waiting (“Waiting for earlier statements to end”) with the minutes as the wait begins, and also when the fence waits for another Snowflake user’s statements, and it says which of these Snowflake’s own record showed: another user’s last write, a table that already held rows when the pipeline’s record of its writers was made, a deleted row of that record, or a wait an earlier start began. A pipeline whose start creates its own tables never waits; one started over tables that already hold rows may wait once, on its first start, because those rows’ writer cannot be seen.
  • A sign-in refused because the worker’s clock runs ahead is named as the clock from 29 seconds ahead. Snowflake refuses a key-pair token dated more than about 30 seconds ahead of its own clock, with the answer it gives a key it cannot read. The pipeline named the clock only from 40 seconds ahead, so a clock between about 30 and 40 seconds fast stopped the pipeline with “your key was refused”. It now says the machine’s clock is ahead, by how much, and restarts once it is put right. A key Snowflake truly refuses, on a machine whose clock agrees with Snowflake’s, still stops the pipeline as the key.
  • A refused sign-in for loading from files no longer turns that route off until the pipeline restarts. Snowflake answers a sign-in token our clock dated a few seconds ahead of its own exactly as it answers a key it cannot read, so large batches went by INSERT, at about ten times the warehouse time, for as long as the worker ran. Such a refusal now counts like any other that may clear: after two large batches in a row, loading from files rests for 30 minutes and is tried again. A key Snowflake truly refuses still stops the pipeline, at the next statement it sends.

2026-10-25 (IST) — A row that moves into a publication’s row filter is never written with an empty value

Section titled “2026-10-25 (IST) — A row that moves into a publication’s row filter is never written with an empty value”
  • What was wrong. When a publication has a row filter (for example WHERE (id > 100)) and an UPDATE moves a row into it, PostgreSQL sends that row as a new row, and under REPLICA IDENTITY DEFAULT or REPLICA IDENTITY USING INDEX it leaves out any large value the update did not change (a long text, bytea or jsonb value stored out of line). The pipeline accepts a row-filtered publication by default, and it wrote such a row with that column NULL (Snowflake) or empty at its default (PostgreSQL destination), while your source held the value. Nothing said so, and the row counts matched. A MySQL source with binlog_row_image = MINIMAL could do the same for an INSERT that names only some columns.
  • What happens now. Such a row is never written with a value missing. The table pauses (its row on the pipeline’s page says why, naming the column), the pipeline’s other tables carry on, and resuming the table copies it again, which brings the row whole. That copy is not charged. The table’s row also shows the statement that gives it REPLICA IDENTITY FULL where PostgreSQL allows it; under FULL PostgreSQL sends the whole row, and the table does not pause for this again. Where the row moves out of the filter again within the same batch and the destination deletes rows for real, nothing pauses: the row is removed either way.
  • If you have a row-filtered publication with REPLICA IDENTITY DEFAULT or USING INDEX: a row that moved into the filter before this release may hold NULL (or its default) in a large column at your destination. Copying the table again repairs it; a copy you ask for is billed as any copy is.

2026-10-25 (IST) — Security: the pipeline’s own sessions on your source look up PostgreSQL’s names only; a copy waits for a standby that is only behind

Section titled “2026-10-25 (IST) — Security: the pipeline’s own sessions on your source look up PostgreSQL’s names only; a copy waits for a standby that is only behind”
  • A security fix to what the pipeline runs on your PostgreSQL source. Every session the pipeline opens to your source (the stream, the copy, the connection test) now starts with search_path = pg_catalog, pg_temp, so every name its queries use is PostgreSQL’s own, whatever search_path your role or database sets. Before, a function created in a schema on that path with the name of one the pipeline calls could run instead, with the pipeline’s rights (the connection test’s Aurora check called two functions that exist only on Aurora, by name, and ran whatever was found). If a pooler or proxy between the pipeline and your server drops the setting, the pipeline does not use the session: the test’s sign-in step fails with search_path_unpinned, and a running pipeline stops and says so. Connect it to the server directly, or have the pooler pass the options startup parameter through.
  • Aurora’s functions are trusted where Aurora keeps its own, in pg_catalog. When a function named like one of them exists only in another schema, the connection test’s server step now fails (aurora_unconfirmed), saying it could not confirm the server is not an Aurora reader, rather than running it.
  • A copy, or a fill of a column’s existing values, waits for a standby that is behind for as long as the standby keeps receiving. Corrects the entry below: a copy stopped after 30 seconds whatever the standby was doing, so a standby constantly more than about 10 seconds behind stopped every copy for good, and a fill gave up after a second. Now only a standby that receives nothing for 30 seconds stops a copy (and says so); a copy waiting lets go of its share lock on the table at once when another session, such as an ALTER TABLE, queues for one.
  • On a PostgreSQL destination, a column added at the source whose type lives outside pg_catalog (citext, a vector) is added with the type of the same name in your destination, schema first, as before.
  • The create form names a column’s type outside pg_catalog with its schema (public.money3, public.mood), whatever search_path your role sets.

2026-10-25 (IST) — Security: every statement we give you to run calls PostgreSQL’s own functions, by name

Section titled “2026-10-25 (IST) — Security: every statement we give you to run calls PostgreSQL’s own functions, by name”
  • A security fix to statements we already gave. Every statement the setup, a stop, a re-sync, an alert, the pipeline’s deletion page and the guides give you to run on your PostgreSQL source or destination now names each function and catalogue it uses by its schema, pg_catalog. (for example SELECT pg_catalog.pg_drop_replication_slot('<slot>');). Before, a role allowed to create functions in your public schema (every role, before PostgreSQL 15, unless you revoked it) could define a function of the same name that PostgreSQL would choose instead, and it would run with the rights of whoever ran our statement, usually a superuser: every statement we give, the slot’s first, could be taken over that way. Statements you ran before were the unqualified ones; if a role you do not trust could create in public, check public for functions named like PostgreSQL’s (\df public.pg_*, \df public.format) and revoke CREATE ON SCHEMA public FROM PUBLIC.
  • The webhook body of old_slot_holds_log carries the qualified drop statement too.

2026-10-25 (IST) — A copy across a failover writes nothing the standby has not received

Section titled “2026-10-25 (IST) — A copy across a failover writes nothing the standby has not received”
  • A first copy, or any copy, no longer outruns the standby that keeps the slot through a failover. With a failover slot and synchronized_standby_slots listing a standby, each part of a copy, and each read of a column’s existing values, now waits until that standby has received the log the read saw before anything of it reaches your destination, as the stream already did. Before, a copy could read rows the standby never received; after a failover to it, the destination kept rows and values the new primary never had, while the pipeline said “nothing is skipped”. A copy that has waited 30 seconds stops this attempt and says so (worker_refused, naming the standby’s slot and where it is), and the pipeline tries again on its own.
  • failover_without_standby_slots and the guide now say what the pipeline can and cannot notice when nothing holds a failover slot behind a standby: it stops when its saved position is past where the standby took over, and cannot tell otherwise.
  • The connection test’s server step says what AWS’s record of an Aurora cluster showed. An instance the record does not name the writer is refused as such (aurora_writer_unconfirmed), never as “a reader”; a record that could not be read is said (aurora_writer_unverified), never taken as nothing to check.
  • A standby’s cancel of a filtered copy’s last check (its sample of the rows it left out) stops naming the setting, as a cancelled window does, instead of restarting with nothing said.

2026-10-25 (IST) — Failover slots: a pipeline kept through a failover on PostgreSQL 17 and later

Section titled “2026-10-25 (IST) — Failover slots: a pipeline kept through a failover on PostgreSQL 17 and later”
  • Every slot statement we give makes a failover slot on a PostgreSQL 17 or later primary. The setup’s slot statement and every stop that says to create the slot again now give one DO statement that, run on a 17+ primary, creates the slot with failover => true, and elsewhere (a standby, or before 17) an ordinary slot. The connection test, which has read the server, gives the plain statement for it: failover => true on a 17+ primary, without it elsewhere.
  • The connection test reports the slot’s failover facts. The replication slot step of POST /v1/connections/test gains details.slot with failover and synced (from pg_replication_slots, each absent before 17), for a slot it found, beside an empty details.chain: chain stays required on /v1, so a client generated from the earlier spec reads the new line too.
  • New warning failover_without_standby_slots: a failover slot on a primary whose synchronized_standby_slots is empty (or, before 17, the pg_failover_slots extension loaded with an empty standby_slot_names), where a standby can take over behind what the pipeline has read.
  • The PostgreSQL source page gains Keeping a pipeline through a failover: the failover slot, the primary’s synchronized_standby_slots, the standby’s sync_replication_slots, hot_standby_feedback, primary_slot_name and dbname, pg_failover_slots for 11 to 16, and what each provider documents.

2026-10-25 (IST) — A standby as the source: the test reads the standby, and a copy it cancels stops with the setting named

Section titled “2026-10-25 (IST) — A standby as the source: the test reads the standby, and a copy it cancels stops with the setting named”
  • The connection test’s slot statement runs on a standby. On PostgreSQL 17 and later the statement the replication slot step offered carried failover => true everywhere, which PostgreSQL refuses on a standby, so a customer reading a standby could not run it there. On a standby the statement now makes an ordinary slot, and the step says to run it on the standby and what to run on the primary if it waits.
  • A first copy the standby cancels stops, naming the setting. A standby that cancels a read of the first copy to replay its primary’s changes (SQLSTATE 40001 or 40P01) used to restart the pipeline with nothing said. It now stops (worker_refused), naming the table, the standby’s max_standby_streaming_delay and the remedies; started again after the change, the copy carries on from the last part it saved. The settings step’s standby_delay_short warning now says the value the standby runs under, in the same words.
  • An Aurora reader is refused by AWS’s own record of the cluster’s writer (aurora_replica_status()), as well as when it is in recovery.
  • The PostgreSQL source page gains a standby section: hot_standby_feedback, max_standby_streaming_delay, where the slot and the publication are made, and what to do when a copy is cancelled.

2026-10-25 (IST) — A PostgreSQL source can be reached through an SSH tunnel on your bastion (not yet enabled)

Section titled “2026-10-25 (IST) — A PostgreSQL source can be reached through an SSH tunnel on your bastion (not yet enabled)”

Written behind the deployment flag REYANSH_SSH_TUNNEL, off in the release that ships it: until an account is enabled, the routes below refuse a new key with 403 ssh_tunnel_not_enabled and a tunnelled source with 422 ssh_tunnel_not_enabled.

  • POST /v1/ssh-keys generates the account an Ed25519 SSH key. We keep the private half sealed and never show it; the answer is the public key, its SHA256: fingerprint and the authorized_keys line. At most five keys that are not retired (409 ssh_key_limit).
  • GET /v1/ssh-keys lists the account’s keys, retired ones included, each with the sources that use it and the line each bastion needs.
  • GET /v1/ssh-keys/{id}/authorized-keys-line is the line to paste on a bastion for that key: restrict,port-forwarding,permitopen="db:5432" ssh-ed25519 AAAA... <comment>, one permitopen for each database the key’s sources reach through that bastion and the one you are setting up. The key can reach those databases and nothing else.
  • The line route checks every host it renders: bastion_host and database_host must be a host name of letters, digits, hyphens and dots, or a bare IP address, the rule a source’s host follows; anything else is 422 invalid_host (with details.field) and no line, so nothing typed can add an option or a second entry to the line you paste.
  • POST /v1/ssh-keys/{id}/retire deletes a key’s private half and keeps its record; refused while a source uses it (409 ssh_key_in_use, naming the sources).
  • A source’s connection gains connect: {"method": "ssh_tunnel", "ssh": {"host", "port", "user", "key_id", "host_key"}}. host_key is the bastion’s host key you approve: a SHA256: fingerprint as ssh-keygen -l prints it, or what ssh-keyscan prints, several lines included (the Ed25519 line is taken, whatever order they come in, and a host name is never read as an algorithm). A bastion with only RSA host keys is refused (host_key_algorithm_unsupported): add an Ed25519 one. Changing any part of the tunnel on an edit needs the password again (secret_required). The connection test reaches the bastion first and judges its address, not the database’s: the database is resolved by your bastion, inside your network.
  • New error codes: ssh_tunnel_not_enabled, ssh_key_limit, ssh_key_in_use, ssh_key_retired, ssh_key_not_found, host_key_algorithm_unsupported. The reference ssh-key: is reserved (credential_ref_reserved).
  • The connection test’s ssh step opens the tunnel and a channel to the database. With no host key approved it fails host_key_approval_needed and hands back details.host_key ({"algorithm", "sha256"}) beside an empty details.chain ([]: chain stays required on /v1, as on the slot line), the key the bastion presents: compare it with ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub on the bastion, then send <algorithm> <sha256> as connection.connect.ssh.host_key. A different key than the approved one fails host_key_changed with the presented key; a pass hands back the key it trusted. Other codes: ssh_unreachable, ssh_handshake_failed, ssh_auth_refused, ssh_forwarding_refused, ssh_target_unreachable, ssh_failed.
  • GET /v1/me gains ssh_tunnel_enabled: whether the account may create SSH keys and save a tunnelled source now. The app’s source form offers the SSH tunnel only then.
  • The feed: each worker session through a tunnel tells source_tunnel_opened (tunnel: the bastion, the host key, our key’s fingerprint, the database). A running pipeline whose bastion presents another host key, refuses our key or refuses to forward stops with worker_refused and its tunnel facts (source_host_key_changed with both keys, source_host_key_approval_needed, source_ssh_auth_refused, source_ssh_forwarding_refused). A host key is never re-trusted by a restart.
  • Switched off for an account, the tunnel stops and nothing dials your bastion: a pipeline whose source is reached through a tunnel is not started, and its feed says why (supervisor_gave_up), including that its replication slot keeps your database’s WAL meanwhile; it starts again on its own once tunnels are back on. A connection test or an edit of a tunnelled source answers 422 ssh_tunnel_not_enabled without dialling; editing the source to connect directly still works.
  • A changed host key is shown beside the one you approved before, in the app’s dialog that asks you to approve it, so you compare the two fingerprints rather than read one alone.

2026-10-25 (IST) — Single sign-on: each sign-in is answered once, and nobody else’s requests hold yours (not yet released)

Section titled “2026-10-25 (IST) — Single sign-on: each sign-in is answered once, and nobody else’s requests hold yours (not yet released)”
  • A sign-in we started is answered once. Its answer from your identity provider can no longer be sent to us again and again to make us do work for it: once we have begun to answer it, any further copy of that answer (a reload of the page after it, the link opened again, a second click while the first is being answered) is told “That sign-in did not finish in time, or was already used” at once, and counts towards the network’s limit like any answer we did not start. A reload of a sign-in that never reached us still works. Before, one sign-in’s answer sent thousands of times could hold everyone else’s for up to twenty seconds.
  • Every answer waits its fair turn, whether your identity provider sent a code or an error, so none can crowd out your colleagues’ sign-ins or anyone’s start.
  • “Too many sign-in attempts came from your network” is said only when your own network sent too many. When the whole service is turning away a flood from elsewhere, an answer that is not a sign-in we can finish is told so at once, and a sign-in you started goes on as before.
  • Corrected 2026-10-25 (IST), before release: an earlier draft of this entry said such an answer “waits (at most twenty seconds)” before it is told. That wait was removed: answers we did not start are never held, however many arrive, so a flood cannot tie up what everyone’s sign-ins are carried on.

2026-10-25 (IST) — Single sign-on: a sign-in you started is never turned away for your network’s volume, and every word about a wait is measured (not yet released)

Section titled “2026-10-25 (IST) — Single sign-on: a sign-in you started is never turned away for your network’s volume, and every word about a wait is measured (not yet released)”
  • A sign-in started from our pages is never refused because of what else your network sent. The callback’s limit (600 a minute per network and connection) now counts only answers that are not sign-ins we started: each sign-in we start carries a value we sign, checked before anything else is done. Before, 600 junk requests a minute from an office’s own network turned everyone there away with “Too many sign-in attempts came from your network”; now they are answered at once and the office’s people sign in. A sign-in of ours waits its fair turn at most.
  • The turns are shared fairly whatever the requests ahead were. A request that named no sign-in used to cost its network nothing in the fair queue, so many networks sending such requests could hold an office back for twenty seconds and turn 18 of 19 colleagues away as busy; every turn now counts.
  • “Your identity provider is taking a long time” is said only when every sign-in your network had at your provider was one we had sent and it had not yet answered. Sign-ins left behind when one of our servers stopped are ours, and are worded as ours.
  • “Try again in N seconds” is how long the queue ahead takes at the pace it is really moving, not a fixed rate.

2026-10-25 (IST) — A query-based pipeline finds the rows deleted at the source

Section titled “2026-10-25 (IST) — A query-based pipeline finds the rows deleted at the source”
  • After each table’s changes, a query-based pipeline compares the table’s keys with your destination’s, and finds the rows your database no longer has. A query cannot see a deleted row, so without this a delete never reached the destination. In soft_delete those rows are marked deleted in the destination (_reyansh_deleted_at), and a row inserted again under its key is brought back by the next sync. In live, a PostgreSQL destination table’s gone rows are counted and kept (deletes_counted): the table is yours, and nothing removes your rows unasked.
  • Each table’s read is told (query_read): the rows changed since the last sync and, when the check ran, the rows found deleted.
  • Rows your destination lacks that the pipeline will not read again are told (keys_missing_in_destination): once, and again only when their count grows; “at least” when more were missing than were read back. Re-sync the table to bring them back.
  • A check that cannot finish marks nothing (delete_check_failed, with the reason): the table’s changes are still delivered and the next sync checks again. Two key sets that barely meet mark nothing either (key_compare_mismatch): they usually spell their keys differently. A table emptied in your database is told, and nothing is marked.
  • A partitioned table is checked partition by partition. A partition attached or detached while its keys are read fails that sync’s check (told, nothing marked), and the next sync checks again.
  • Not yet: choosing how often a table is checked (every sync for now) or marking its missing rows as expected (added 2026-10-26, above), and a Snowflake destination’s check.

2026-10-25 (IST) — A query-based pipeline asks before continuing after a switchover it cannot read

Section titled “2026-10-25 (IST) — A query-based pipeline asks before continuing after a switchover it cannot read”
  • A query-based pipeline whose user cannot read where a new timeline began (no REPLICATION) asks instead of stopping for a re-sync. After a move to the next timeline in which everything it can check continues (the same server identity, the transaction counter and the log position past what it last read), it stops before reading with source_history.code source_timeline_unverified and acceptable: true. Continue it on the pipeline’s page, or with POST /v1/pipelines/{id}/source-history/accept and the stop’s facts: it carries on from where it last read and skips nothing. Re-sync instead if the move lost transactions.
  • source_history gains query_position for a query-based pipeline, its position as a transaction counter, and the acceptance body carries it too. A pipeline that reads the log never has one.
  • A new primary found behind what the pipeline read stops with source_history_behind, which cannot be accepted, and stays stopped after the server catches up: what the move lost stays lost. Re-sync the pipeline.
  • A user with REPLICATION whose server cannot give the new timeline’s history is asked the same question.

2026-10-25 (IST) — A query-based pipeline follows a switchover it can read

Section titled “2026-10-25 (IST) — A query-based pipeline follows a switchover it can read”
  • A query-based pipeline whose user has REPLICATION (or is a superuser) carries on after a switchover or a failover that kept everything it had read. It reads where the new timeline began and, when that is at or after the last point it read, continues and says so with a source_failed_over event. It used to stop and ask for a full re-sync.
  • When the new timeline began before the last point it read, the pipeline stops and names that point, because rows it read may be gone. A user without REPLICATION cannot read where a timeline began: see the entry above.

2026-10-25 (IST) — The setup test of a source read by queries

Section titled “2026-10-25 (IST) — The setup test of a source read by queries”
  • POST /v1/connections/test takes update_method and tables. With update_method: query_based the source is signed in to as an ordinary user (no REPLICATION needed), its settings, publication and slot steps are skipped (query_based), no setup is answered, and nine steps check what reading tables by queries needs: query_privileges (the lock and xmin each sync takes, with the GRANT that fixes a refused table), row_security, scan_size (tables above 100 GB), standby_reads, durability, history (what a failover or a restore does to this pipeline, for this user and server), provider (an unproven Aurora reader is refused), servers (an address that reaches several servers) and locks. tables names the tables to probe (at most 1,000); without it the picked stream is probed.
  • A full re-sync that switches the update method runs the new method’s setup test first, on the pipeline’s own source and tables, and is refused with 409 method_switch_untested naming the step that failed (details.step, every step in details.steps). Nothing is switched or recorded.

2026-10-25 (IST) — A run asked to stop is never called a failure

Section titled “2026-10-25 (IST) — A run asked to stop is never called a failure”
  • GET /v1/usage/days: a closed day gains stopped_runs, beside failed_runs, with the same entries in the same four states (credited, pending, refused, nothing_charged). A run that a query-based pipeline was asked to stop before it finished (a pause, an edit, our service restarting) is in stopped_runs and never in failed_runs. Neither is charged; nothing about the money changed. Today’s stopped runs were already stopped_run entries of not_charged.
  • The Usage page tells a stopped run as a stop, in each state a failed run has, and the Credited back column, the refund line on Billing and every billing email now say runs that did not finish (was failed runs), which is true of both.

2026-10-25 (IST) — A source card lists its update methods

Section titled “2026-10-25 (IST) — A source card lists its update methods”
  • GET /v1/connectors: a source card gains methods, each with its name (logical_replication, query_based), completion, first_run and position_dialect. A pipeline reads by one method, and these are that method’s facts.
  • Deprecated: the card’s own completion, first_run and position_dialect. They are its logical_replication method’s, and stay until 2027-10-25: every answer carries Deprecation (@1792886400, 2026-10-25) and Sunset (Mon, 25 Oct 2027 00:00:00 GMT). Read methods instead.

2026-10-25 (IST) — A pipeline can read its source by queries

Section titled “2026-10-25 (IST) — A pipeline can read its source by queries”
  • POST /v1/pipelines takes update_method: logical_replication (left out means this: the source’s log through a replication slot and a publication) or query_based (each table read by queries, one run at a time on the schedule), where the source offers it. A query-based pipeline copies every table on its first run, so historical_load left out is recorded requested, and refuses declined (422 historical_load_needs_logical_replication), slot names (422 source_names_need_logical_replication) and a history or append default mode (422 mode_needs_logical_replication). A method the source does not offer is 422 update_method_not_offered. A query-based pipeline is shown no slot or publication anywhere.
  • Every pipeline view says its update_method.
  • POST /v1/pipelines/{id}/resync takes update_method, for a full re-sync only, and switches how the pipeline reads its source: every table is copied again into the same tables, billed like the first copy. To queries, setup names the drop statements of the slot and publication it leaves (yours to run once the re-sync has settled; until then the pipeline names that slot, and its deletion names it too); to the log, a pair drawn by GET /v1/pipelines/{id}/new-source-names is required and setup creates it. New refusals: 422 method_switch_needs_full_resync, 422 method_switch_needs_source_names, 409 method_switch_blocked_by_mode.
  • GET /v1/schedule-preview takes update_method, so a query-based pipeline’s schedule is previewed as runs.

2026-10-25 (IST) — Sync now can answer next_run

Section titled “2026-10-25 (IST) — Sync now can answer next_run”
  • POST /v1/pipelines/{id}/sync has a fifth effect, next_run, for a running pipeline that reads your source in runs on its schedule (a query-based pipeline): such a pipeline holds nothing between its runs, so its next run reads every change made up to it. It is asked before the other effects except a running copy, and nothing changes for a pipeline that reads its source’s log (logical_replication).

2026-10-23 (IST) — Single sign-on: nobody is refused because of rejected sign-in codes; sign-ins wait their turn, fairly, and are told what held them (not yet released)

Section titled “2026-10-23 (IST) — Single sign-on: nobody is refused because of rejected sign-in codes; sign-ins wait their turn, fairly, and are told what held them (not yet released)”
  • No sign-in is refused because of codes your identity provider rejected. “Your identity provider rejected sign-in codes that came from your network” (#error=sso_codes_refused) is gone, at any load, during an attack or not: a stale link or an expired tab only fails that one sign-in, with your provider’s own reason, and never turns anyone else away (the entries below refused colleagues in several situations; each is fixed).
  • Your identity provider sees at most a fixed number of our sign-ins, from every network together: 200 at once and 20 a second after that (at most 1,400 in any minute), and at most 50 at once from one network. Past that a sign-in waits its turn with us, and the turns are shared fairly between networks: one network’s flood takes one share, and an office’s people get theirs.
  • A sign-in waits at most twenty seconds, counted from when it reached us, so a code that lives only 30 seconds is still sent in time. If it waits longer it is told what held it, in its own words: “Many sign-ins are waiting their turn with us for this single sign-on right now. Try again in N seconds.” (#error=sso_busy&retry=N); “Your identity provider is taking a long time to answer the sign-ins from your network” (#error=sso_provider_slow, only when sign-ins we had sent to your provider were what held it); or “Single sign-on is not working at our end right now” (#error=sso_unavailable, when our own systems held it).
  • The staff sign-in waits its turn the same way; one that waits past the bound is answered 503 staff_sign_in_busy with Retry-After, or 504 identity_provider_slow, instead of 429 or “could not be verified”.

2026-10-23 (IST) — Single sign-on: a quiet office is never refused, a code that expires while we hold it is never your network’s, and junk is bounded whatever your provider answers (not yet released)

Section titled “2026-10-23 (IST) — Single sign-on: a quiet office is never refused, a code that expires while we hold it is never your network’s, and junk is bounded whatever your provider answers (not yet released)”
  • A network is refused only while the connection is under attack: when your identity provider has rejected thirty or more sign-in codes for the connection in the last minute, from anywhere, AND that network brought at least two more rejected codes than accepted ones. On a quiet connection nobody is refused: two people at an office clicking stale links, or one person with two expired tabs, no longer turn the office away for the rest of the minute (they did under the entry below).
  • A code that expires while it waits its turn with us is never your network’s: if your provider rejects a code we held waiting fifteen seconds or more (some providers’ codes live only 30 seconds), it is counted as the provider’s trouble, not as a rejection from your network, so it never refuses your colleagues, and a colleague who arrives later with a fresh code signs in.
  • Codes your provider answers with any error are bounded too: each failed exchange holds its network’s place for two seconds after the answer, so past the first thirty a network sends at most about thirty a minute, whatever error your provider gives (before: as fast as the provider answered, up to 600 a minute). An office whose sign-ins work barely notices it.
  • A sign-in we could not send in time is said to be ours: “Single sign-on is not working at our end right now” (#error=sso_unavailable), where it said your identity provider could not be reached though nothing reached it.

2026-10-23 (IST) — Single sign-on: only your own network’s rejected codes refuse it, a sign-in cut off mid-way frees its place within seconds, and a broken client secret is told to the account’s owner (not yet released)

Section titled “2026-10-23 (IST) — Single sign-on: only your own network’s rejected codes refuse it, a sign-in cut off mid-way frees its place within seconds, and a broken client secret is told to the account’s owner (not yet released)”
  • A sign-in from an address is refused only when the identity provider rejected codes from that address: two or more than it accepted from it in the minute. Nothing else refuses anyone: not codes still waiting on the provider, not another address’s rejected codes, not the provider’s own failures. One stale code at an office never turns its colleagues away. The refusal has its own sentence: “Your identity provider rejected sign-in codes that came from your network in the last minute. Wait a minute, then sign in again.” (#error=sso_codes_refused). The sentence for too many sign-ins from one address (#error=sso_rate_limited) is now said only for that.
  • What one connection’s identity provider sees from us stays bounded: 30 codes a minute in flight, rejected or unanswered, and past that at most two more rejected codes from each further address (30 + 2 per address a minute; it was 30 + 1, the cost of never refusing a colleague for one stale code).
  • A sign-in cut off mid-way (a server restart, a dropped connection) holds its address for at most 15 seconds, the longest one exchange with the identity provider and its bookkeeping can take; before, it could hold it for the rest of the minute and its people were told the provider was slow.
  • A client secret the provider refuses (invalid_client), or a client it refuses for another reason (unauthorized_client, invalid_request, unsupported_grant_type, invalid_scope), is the connection’s fault, and every person is told to ask the account’s owner (a test sign-in names the fix); before, past 30 such answers people were told too many attempts had come from their network. New refusal code sso_client_refused for the second kind.

2026-10-23 (IST) — Usage: a stopped query-based sync is not charged, and says so

Section titled “2026-10-23 (IST) — Usage: a stopped query-based sync is not charged, and says so”
  • GET /v1/usage reports a new classification, stopped_run: the work of a query-based sync that was asked to stop before it finished (a pause, an edit, or our service restarting). Such a sync keeps no progress, so the next sync reads the same tables again and is the one that pays for them; the stopped one is not charged, and is told apart from failed_run, because a stop is not a failure. The classification set was already documented as open.
  • GET /v1/usage/days reports today’s stopped syncs as not_charged entries with the reason stopped_run, beside failed_run, and never includes them in today’s estimate.
  • Nothing changes for a pipeline that reads its source’s log (logical_replication): its stops are charged as before, because it keeps its progress as it goes.

2026-10-22 (IST) — Single sign-on: a sign-in whose code works is never refused, and a refusal is a page, not an error envelope (not yet released)

Section titled “2026-10-22 (IST) — Single sign-on: a sign-in whose code works is never refused, and a refusal is a page, not an error envelope (not yet released)”
  • A person whose sign-in works is never refused for exchanges still in flight, or for someone else’s mistakes. What one connection’s identity provider sees from us stays bounded: 30 codes a minute in flight, rejected or unanswered, and past that a client address is refused only for a code the provider rejected FROM THAT ADDRESS this minute. An address whose sign-ins are still waiting on the provider waits its turn (each code the provider accepts from it lets one more through) instead of being turned away, so an office signing in at nine against a slow identity provider all gets in, and another address’s rejected codes never refuse it.
  • The callback’s refusals are the sign-in page’s words, never a JSON envelope. The identity provider’s redirect back to us is a navigation, so a refusal now sends the browser to the completion page with #error=sso_rate_limited (“too many sign-in attempts came from your network in the last minute”) or #error=sso_provider_slow (“your identity provider is taking too long to answer”); the sign-in request is not spent, and signing in again after a minute works.
  • The staff sign-in’s exchange follows the same rule.

Build note (2026-10-22 (IST)). The entry below said a code that works is never refused; at S4f that was not so (an exchange in flight counted as a rejection), and its first bullet’s 429 at the callback is replaced by the page above. Every unauthenticated route’s work now takes its reservation as a parameter of a type only internal/admission can make, bound to its scope or token and spent once.

2026-10-22 (IST) — Single sign-on: every limit is taken before the work it limits, and Off says what it leaves running (not yet released)

Section titled “2026-10-22 (IST) — Single sign-on: every limit is taken before the work it limits, and Off says what it leaves running (not yet released)”
  • Rate limits are reserved before the work, never counted after it. What one connection’s identity provider sees from us is now at most 30 codes in flight or rejected a minute, plus one for each further client address that has none (a burst of callbacks arriving at once could pass the old count), and a code that works is never refused. The callback answers 429 with Retry-After past it, before the sign-in request is spent, so the same sign-in can be finished once the minute is over. The staff sign-in’s exchange with its identity provider is limited the same way.
  • Each single sign-on route that names a connection or an email domain is limited to 600 a minute per client address for that connection or domain, and 1,200 a minute per address in all, however many connections or domains it names (a ninth domain no longer falls to a shared 30). A request that names nothing usable counts 30 a minute.
  • The routes that take only a secret token (the completion, the confirmation’s code, deny and “Was this you?”, the sign-in link’s peek) answer 429 with no database work past 30 tokens a minute per address that name nothing open, counting tokens still being looked up; a token this server issued (the sign-in’s own attempt, the confirmation’s cookie and email link, a sign-in link) still works past it.
  • At most three confirmation emails to one address of a connection an hour, also when several sign-ins finish at the same moment (they each sent one).
  • GET /v1/sso (owners) now carries session_hours, how long a single sign-on session lasts, and the Single sign-on page says beside Off, before you press it, that people already signed in with single sign-on stay signed in until their sessions end (at most that long), and that deleting the connection is what signs them out.

2026-10-21 (IST) — Single sign-on: an identity provider an owner has left speaks for nobody, the account switch tells nothing, and the rate limits fit an office (not yet released)

Section titled “2026-10-21 (IST) — Single sign-on: an identity provider an owner has left speaks for nobody, the account switch tells nothing, and the rate limits fit an office (not yet released)”
  • A single sign-on session counts only while the identity provider it came through is the live one. Every request checks the session’s linked identity against the connection’s live issuer, so a sign-in that was finishing while an owner applied a new identity provider no longer leaves a session behind (it is signed out at its first request), and an identity is never linked under an issuer that is no longer live (the person is asked to sign in again, sso_attempt_invalid). Applying a new issuer still signs out everyone signed in through the old one, and now also any other single sign-on session of the connection, so none can come back if you later apply the old issuer again.
  • POST /v1/auth/switch from a session made by single sign-on answers every account the same way: 409 sign_in_required, with no connection id and no domains of the account, whether you belong to it or not (it answered 403 not_a_member for an account you do not belong to, and the account’s facts for one you do). A session made by email link is unchanged.
  • New refusal sso_grant_rejected (the completion of a sign-in, and a test’s result grant_rejected): the identity provider did not accept the sign-in’s code (invalid_grant): it was used already, took too long, or belongs to another redirect URI. It used to be reported as the provider being unreachable.
  • Rate limits: the single sign-on routes are now limited per client address AND per the connection or email domain the request names, at 600 a minute (an office of thousands behind one address signs in at nine), and a request naming nothing usable is limited to 30 a minute per address. The completion, the confirmation’s code, deny and “Was this you?”, and the sign-in link’s peek are limited only by the requests whose token names nothing open (30 a minute per address): a working sign-in is never refused for them. When one connection’s identity provider is rejecting many codes, the callback answers 429 (with Retry-After) to the addresses that brought them, for the rest of the minute.

2026-10-21 (IST) — Single sign-on: refusals say their own reason, notices count people and point at what the page shows, Required reads the apply, and every dialog opens on Cancel (not yet released)

Section titled “2026-10-21 (IST) — Single sign-on: refusals say their own reason, notices count people and point at what the page shows, Required reads the apply, and every dialog opens on Cancel (not yet released)”
  • The last recovery owner has its own refusal. While single sign-on is required, demoting, removing or the departure of the last recovery owner who is an owner is 409 last_recovery_owner on PUT /v1/members/{user_id}, DELETE /v1/members/{user_id} and DELETE /v1/me/membership (it was 409 last_owner, “an account needs at least one owner”, with other owners present), with words naming the remedy: name another owner a recovery owner in Settings, Single sign-on. PUT /v1/sso/mode answers the same code when another owner’s change took the last one (it answered 500). Every database refusal the API words is now chosen by the name of the constraint that raised it; one nobody worded is a 500.
  • PUT /v1/sso/mode‘s answer gains people_signed_out: the distinct people a switch to required signed out (one person in two browsers is two sessions_revoked and one person). The owners’ notice and the page count people.
  • Required needs a live version, which an apply made live after its test passed. A later test of the live version is a report: passed or refused, it changes nothing that is live, and changes under Required (recovery owners, JIT) are no longer refused after a refused test.
  • GET /v1/sso/domains gains needs_record: whether the owner needs the TXT record in front of them (pending, lapsed, or verified with its record missing since a daily check). The settings page shows the record, the day it went missing and Check exactly then, so the day-1 “record missing” notice points at what the page shows.
  • sso_linked in GET /v1/members is an owner’s: answered to an owner, omitted for a member.
  • The different-identity notice names whose link refused the sign-in (sso.identity_mismatch gains linked_to): when an identity linked to one person signs in with another person’s address, the owners are told to unlink the person it is linked to, whose row has Unlink.
  • Words: deleting the connection, and applying a new issuer, say before the press that they sign out everyone signed in with single sign-on (you too, if you are), and the apply says after how many sessions ended; the lapse notice says what a lapse changes for members; the sign-in page, the Required refusal and the recovery owners’ section say when support is the only way back; pasting a new client secret clears the old expiry date.
  • Every confirmation in the app opens with focus on Cancel, through one dialog: single sign-on’s Require, Remove domain and Delete, the members page’s Unlink, role change and Remove, the API keys’ dialogs, and a notification channel’s Delete (which was the browser’s own confirm box).
Section titled “2026-10-21 (IST) — Single sign-on: a connection’s id is random, an owner can unlink from the members page, and cookies are read only by their own name (not yet released)”
  • A connection is named by a random public id, 32 lower-case hexadecimal characters (128 random bits), in its sign-in link (/sso/{id}), its redirect URI (/sso/oidc/{id}/callback), GET /v1/auth/sso/connections/{id}, the start’s connection_id (now a string), the link chooser’s and the refusals’ sso_connection_id, and the owner’s GET /v1/sso (id). The sequential id is in no answer: a number where the id goes is 400 invalid_connection. POST /v1/auth/sso/discover names no connection: it answers {"sso": {"required": ...}} or {"sso": null}.
  • The OpenID Connect callback has no per-connection budget any more: only its client address’s (30 a minute). Strangers’ requests, junk or started on purpose, can no longer spend a minute of an account’s sign-ins.
  • Settings → Members: Unlink single sign-on. An owner unlinks a person’s identity at the identity provider from their row, after a confirmation; it is DELETE /v1/sso/identities/{user_id}, now account-bound (a request naming another account in X-Reyansh-Account is 409 account_changed). GET /v1/members (and a member’s detail) gain sso_linked. Every owner is now told of an unlink (sso_identity_unlinked, a security notice). The refusal and the owners’ notice for a different identity say where the control is.
  • An issuer change ends what the old issuer proved. Applying a draft with a new issuer ends every session made through the old one (sessions_revoked in the answer and on sso.version_applied), and a sign-in the old provider answered that completes after the change is sso_attempt_invalid (start again). An apply that keeps the issuer ends nothing.
  • A single sign-on session sees only its own account: GET /v1/me’s accounts lists that account alone, so the switcher offers nothing; a link session lists every account, as before.
  • The header shows the address you are signed in as, on every page.
  • Cookies are read only under the name the server writes them (__Host-reyansh_session, __Host-reyansh_staff, and single sign-on’s three, on every deployment): a cookie of the same name without the prefix, which another subdomain can set, is ignored. Nobody holds one, so nobody is signed out.
  • Two completions linking one person at the same moment no longer answer 500: the second is told sso_identity_mismatch (a different identity) or signed in (the same one).

2026-10-21 (IST) — Single sign-on: the screens (not yet released)

Section titled “2026-10-21 (IST) — Single sign-on: the screens (not yet released)”
  • Settings → Single sign-on. Owners choose their identity provider (Okta, Microsoft Entra ID, Google Workspace, or another OpenID Connect provider), copy the redirect URI and the sign-in link into it with that provider’s own field names, save its details as a draft, verify their domains, test the draft, apply it, and turn single sign-on on (allowed or required, with recovery owners and joining on first sign-in). Members see one line: off, allowed or required. SAML is planned. The guide: Single sign-on: sign in with your identity provider.
  • The sign-in page asks for your address first. At a domain that uses single sign-on it takes you to your identity provider (or, where single sign-on is only allowed, offers it beside the email link); anywhere else it emails the link as before. Single sign-on not working? is always there, with an email link for recovery owners.
  • A connection’s sign-in link shows which account it signs in to, by its verified domains, and where you will sign in, and continues only when you press Continue. After any sign-in the page says who you are signed in as, with Not you? Sign out. The sign-in link’s page says whose sign-in it is before you press Sign in.
  • Buttons that change who you are signed in as wait a moment after they appear, so a click meant for another page cannot press them; a press that comes too early says so.
Section titled “2026-10-21 (IST) — Sign-in links say whose sign-in they are; a single sign-on names where it signed you in (not yet released)”
  • POST /v1/auth/link/peek {token} (public, same-origin, 30 a minute per client address) answers {"email"}, the address an emailed sign-in link signs in, before the link is used, so the link’s page can say “This link signs in {address}.” It spends nothing: the link still works afterwards, and a mail scanner that opens the page changes nothing. A link that has expired, was already used or was never issued is one answer, 410 link_ended.
  • POST /v1/auth/sso/complete and POST /v1/auth/sso/confirm, when they sign the person in (outcome: signed_in), now also answer address (the address now signed in), domains (the account’s verified domains) and host (the identity provider’s sign-on host the sign-in went through), so the page can say “Signed in to the account that owns {domains} as {address} through {host}.” Never the account’s name, which its owners type.

2026-10-21 (IST) — Single sign-on: support can unlock an account that requires it (not yet released)

Section titled “2026-10-21 (IST) — Single sign-on: support can unlock an account that requires it (not yet released)”
  • When an account requires single sign-on, single sign-on is not working, and no recovery owner can use the email link, the owners can ask support. After support has verified the request with an owner at an address on record, they set the account to Allowed, so everyone can sign in with an email link again. Support can only loosen: never require single sign-on and never turn it off, and only for an account that requires it.
  • Every owner is emailed at once, as a security notice nobody can mute: “{product} support ({name}) changed single sign-on from required to allowed on {time}: {the reason support recorded}.” The audit log shows the same sso.mode_changed, by our staff, with the reason.
  • Requiring single sign-on again is the owners’ own step, with a passed test and a recovery owner, as before.

2026-10-21 (IST) — Single sign-on: an owner sets up the identity provider, tests it and applies it (not yet released)

Section titled “2026-10-21 (IST) — Single sign-on: an owner sets up the identity provider, tests it and applies it (not yet released)”
  • POST /v1/sso {protocol, idp} (owners; not API keys) begins setting up single sign-on: the account’s one connection, off, with no version yet. The answer names the redirect URI to register in the identity provider and the connection’s sign-in link, both of which carry the connection’s id. OpenID Connect with okta, entra, google or oidc (another provider); SAML is 422 sso_protocol_unavailable until it is available; 409 sso_exists when the account already has a connection.
  • PUT /v1/sso/draft {issuer, client_id, client_secret, client_secret_expires_on} saves the identity provider’s details as a draft, replacing any draft. The endpoints are read now from the issuer’s own discovery document, which must name the issuer exactly as it was typed, a trailing / included (422 idp_issuer_mismatch: Auth0, for one, writes its issuer with a slash; Okta, Entra and Google without). Of the endpoints it names, none may be an address of ours (422 idp_endpoint_ours, naming the field) or anything but https (422 idp_endpoint_insecure), the provider must sign with RS256 (422 idp_no_rs256), and a document that cannot be read is 502 idp_discovery_failed. Leave client_secret out to keep the current one (422 client_secret_required when there is none); it is never returned, only its last four characters. A draft that changes nothing the identity provider sees (only the secret’s expiry date) keeps the test it was based on.
  • POST /v1/sso/draft/test starts a test sign-in of the draft (or of the live version when there is no draft): the answer is where to send the browser, and the result is recorded on the version when the identity provider sends it back (sso.draft_tested). 409 sso_no_version before a draft is saved.
  • POST /v1/sso/draft/apply makes the draft live; its test must have passed (409 sso_draft_not_tested). With a new issuer, the answer counts the people who will link again at their next sign-in and the remembered browsers that were forgotten. DELETE /v1/sso/draft discards the draft (404 sso_no_draft when there is none); the live version is unchanged.
  • GET /v1/sso reads the connection: owners all of it (the versions, what was read from the provider, the last test, and for a draft at a new issuer how many people would link again); members the mode only. DELETE /v1/sso deletes the connection and everything of it, with single sign-on off (409 sso_not_off).
  • The audit log records sso.connection_created, sso.draft_saved (the secret as changed, never its value), sso.draft_discarded, sso.version_applied and sso.connection_deleted.
  • Every owner is emailed before the client secret expires, when a draft was saved with client_secret_expires_on: 30, 7 and 1 days before the date and once after, saying what an expired secret stops in the account’s mode (sso.client_secret_expiring in the audit log; the notice cannot be muted).

2026-10-20 (IST) — The setup test offers no publication statement of its own, and a table’s sync-mode help says one thing

Section titled “2026-10-20 (IST) — The setup test offers no publication statement of its own, and a table’s sync-mode help says one thing”
  • A missing publication is told without a statement of its own. The connection test’s publication step said “make it with CREATE PUBLICATION ... FOR TABLE <the table you picked>;”. A publication made that way sends the table’s UPDATE and DELETE, so for a table with no primary key and no REPLICA IDENTITY FULL your database would then refuse every UPDATE and DELETE of it. The step now points to the pipeline’s setup statements, which check each table’s replica identity before adding it.
  • A table with no primary key passes the connection test under REPLICA IDENTITY FULL, DEFAULT or NOTHING, and partitioned: the test reads its key as the pipeline does, skips the destination table’s check (the first start judges it and says what, if anything, to run), and is never refused with “add a primary key”.
  • A table’s sync-mode help, the change confirmations and the purge confirmation no longer add “unless the table has no primary key and is synced as new rows only”, nor the API’s sync_mode description and the PUT /v1/pipelines/{id}/sync-mode summary: no pipeline syncs a table as new rows only in this release.

2026-10-20 (IST) — A table with no primary key syncs every change through REPLICA IDENTITY FULL; new rows only is not offered in this release

Section titled “2026-10-20 (IST) — A table with no primary key syncs every change through REPLICA IDENTITY FULL; new rows only is not offered in this release”
  • A table with no primary key syncs every change once it, and each of its partitions, has REPLICA IDENTITY FULL: its row on the pipeline’s page shows the statement that sets it and adds the table, in one transaction, or changes nothing and says why where your database would refuse the table’s UPDATE and DELETE even under it (a publication that sends them has a column list for it, or, on PostgreSQL 18 or later, does not send one of its generated columns), and what it costs your database (an ACCESS EXCLUSIVE lock while it runs, and more write-ahead log for as long as the table keeps it). The pipeline starts syncing the table by itself within about a minute of the change.
  • Syncing only a table’s new rows, through a second, insert-only publication, is not offered in this release. No pipeline has such a publication, so no wait, history line, page or guide offers to move a table to one any more: a partitioned table whose partitions send whole old rows while the table does not, a table waiting for a source release that checks writes, and a table whose updates and deletes your source refuses are each told the statement that gives it REPLICA IDENTITY FULL. In the API, TableWaiting.reason keyless_new_rows and PipelineTable.mode new_rows_only are reserved and not produced.

2026-10-20 (IST) — Switching a table with no primary key to live says what becomes of its rows marked deleted; Remove names the publication that lists it

Section titled “2026-10-20 (IST) — Switching a table with no primary key to live says what becomes of its rows marked deleted; Remove names the publication that lists it”
  • A table with no primary key switched from soft delete to live removes its rows marked deleted the next time the pipeline writes to it, because a table with none kept live removes every row marked deleted after each write. Its change confirmation said those rows “stay until the table is copied again”, and PUT /v1/pipelines/{id}/tables/{table_id}/sync-mode’s summary said they “stay (purge them to remove them)”: both now say it, and a table with a primary key still keeps them until you purge them or a copy removes them.
  • Removing a table synced as new rows only offers a statement your source accepts. Its row is in the pipeline’s new-rows-only publication alone, and the statement offered took it out of the main one, which your source refused. A pipeline with both publications is now offered one statement that takes the table out of whichever of the two lists it.

2026-10-20 (IST) — What a truncate at your source and a table’s next copy do is said wherever a deleted row is

Section titled “2026-10-20 (IST) — What a truncate at your source and a table’s next copy do is said wherever a deleted row is”
  • A truncate at your source empties a table with no primary key whatever the pipeline’s truncate rule says: every row is removed when the table is kept live, and marked deleted when it is kept in soft delete. A table synced as new rows only was told a row deleted at your source “stays here as it was, in either mode”, which a truncate made false. Its mode menu, a change of its mode, the change policy’s truncate answers (GET /v1/change-policy and the pipeline’s change policy page), and the API’s descriptions of a table’s sync_mode and of PUT /v1/pipelines/{id}/sync-mode now say so; a table with a key is said to do what the rule says.
  • Every sentence about a row deleted at your source now says what the table’s next copy does with it too: marked in soft delete; removed when it is kept live, unless the table has a primary key in a PostgreSQL destination, which keeps it until you delete it.
  • “Delete the rows marked deleted” names every way a row comes to be marked: deleted or truncated at your source, replaced by a change there (a key changed, or any value of a table with no primary key: the row as it was), found no longer in your source by a copy, or moved out of the table’s row filter, though still in your source. So does the API’s description of POST .../tables/{table_id}/purge-deleted.

2026-10-20 (IST) — A region’s backups, off the box and drilled every week

Section titled “2026-10-20 (IST) — A region’s backups, off the box and drilled every week”

For the people who run a deployment. Nothing changes in /v1.

  • GET /internal/status, outside /v1 like /healthz: a cell’s release, migration level, last backup, last restore drill, last door audit and the start of its clock, as numbers, booleans, timestamps and fixed words only, never a name. It answers only the bearer token in REYANSH_STATUS_TOKEN (minted on the box by bootstrap-secrets.sh); unset, every /internal/ path answers 404.
  • A nightly backup set in the region’s own bucket: the roles, the database with its owners and grants, the KEK and the env file, encrypted, signed by the box, and committed by a manifest uploaded last (cell-backup.sh).
  • A weekly restore drill from the bucket that proves the copy the way the product would use it: every table’s row count and a checksum of its rows’ content, the large objects’, and every sequence at least as far along as it was, in its own direction; the restore dumped exactly as the backup dumped the source, and the two dumps compared (the schema, grants, owners, roles, the database’s and roles’ settings, policies, functions: everything pg_dump and pg_dumpall --roles-only carry, and only that, so a database’s history, such as an extension one version behind its server, a grant given and taken back, a replica identity whose index went or an object made in pg_catalog, can never read as a broken backup); a read as the application role, the KEK and its escrowed copy, a sample of sealed credentials opened, and the env file; every other retained set opened in full (cell-drill.sh). Every expression (a check, a default, an index’s predicate, a tenant policy, a view) is also judged by its meaning, parsed again on the restored object itself, so a restore whose rules mean something else is always red; a round-trip corpus of every kind of object, and every world of grants, owners and history the reviews found, prove it on PostgreSQL 18 and 17, and every schema change runs it. A backup is never refused over a detail of the schema: a part of its facts the server cannot answer is recorded, the set is still taken whole, and only the drill refuses it, naming the part. The drill checks, before it restores, that the disk holds the database, its largest rewrite (a partitioned or inherited table’s whole tree) and the WAL, from sizes the backup recorded, and leaves 2 GiB free for the production server sharing that disk. A set written before a change of the manifest’s format is still restored once in its life, judged by its restore, its KEK and its sealed sample, and the journal says what was not compared. A database with no pipeline yet is backed up too.
  • Nothing deletes a copy of the database unless a newer copy has passed a drill: retention of sets, and the release dumps (/root/reyansh-pre-*.dump, which the deploy writes before each release), which release.sh now removes only past the newest five, only where the cell’s backups run, only when the set the last green drill restored is still whole in the bucket (it asks), and only when they are older than that set. A release never waits on the bucket: its question ends within a minute whatever the bucket does, and every network call a cell or a release makes goes through one wrapper that always gives it a connect timeout and a total time, reads no .curlrc, and accepts only the calls the cell makes.
  • The daily verdict stops every merge only when a cell whose backups were good goes red; a cell not yet set up is a comment, counted from the first release on its box (or, until its box can be read, from the day its pending record reached main), with WARNING from day 7 and OVERDUE past day 14 said every day; an endpoint that does not answer is “could not tell”, said on its second day.
  • The by-hand total-loss page checks that a new box has the database’s locale before it restores (and clears what an interrupted check left first).
  • A drill stopped while it cleans up still removes the plaintext KEK and writes its result, and a stop whose cleanup is itself cut short is still recorded as an interruption, never as a failure. A drill stopped or killed before it could judge anything (a shutdown, a reboot, a power cut) is recorded as interrupted: “could not tell” for one cycle, run again at the next boot, and red if it happens twice in a row.
  • A door audit, weekly and after every release that serves, of what the box exposes, against its allowlist (cell-doors.sh; release.sh starts it wherever its weekly timer is on).
  • backup-postgres.sh now fails when asked to upload with no aws CLI, instead of keeping the dump locally and exiting 0.
  • The notifications history names every API key notice (created, rolled, revoked, used owner power, exposed, about to expire, expired, still in use as a rolled key stops). It showed their message keys before.
  • The address you typed to ask for a sign-in link is deleted within about an hour of the link being used, or of its expiry (a link works for 15 minutes). The control plane sweeps used and expired links at start and hourly; nothing deleted them before, so every address used to ask for a link was kept.
  • Sign-in and sessions are harder to misuse from inside. The application’s own database role can no longer read the addresses typed into the sign-in form or write a sign-in link, and a signed-out session stays signed out whoever writes: signing out, a member’s removal and signing in over an old cookie end a session for good. An account id can never be empty.

2026-10-19 (IST) — A table synced as new rows only is told its deletes are not sent

Section titled “2026-10-19 (IST) — A table synced as new rows only is told its deletes are not sent”
  • A table with no primary key synced as new rows only is no longer told that a row deleted at your source is deleted here. Such a table is read through the pipeline’s insert-only publication, which sends no delete, so that row stays here as it was, in either mode. Its mode menu and a change of its mode now say so, and where the pipeline has not yet read the table’s class they say both. The API’s descriptions of a table’s sync_mode and of PUT /v1/pipelines/{id}/sync-mode say it too.
  • In a table kept live, the rows already marked deleted are said to stay until the table is next copied, where that copy removes them (a table with no primary key, or one on Snowflake); they were said to stay until you delete them.
  • “Delete the rows marked deleted” no longer calls a row a row filter left out “no longer in your source”. It is still in your source. The confirmation, in the app and in the API’s description of POST .../tables/{table_id}/purge-deleted, now says so, and names a delete at your source only where one is sent.
  • “Re-sync and delete them” is offered only on a pipeline whose source is PostgreSQL, the only source a table is copied again from (a re-sync of any other is refused, 422 resync_not_supported).
  • 422 not_yet_available for soft delete into PostgreSQL no longer says what becomes of a row deleted at your source.
  • The Snowflake guide no longer names a Stripe source, which a Snowflake destination does not take, and says _REYANSH_DELETED_AT is when a row was marked deleted, in any of the three ways.

2026-10-19 (IST) — A soft-delete copy says how many rows it marked, apart from how many it counted

Section titled “2026-10-19 (IST) — A soft-delete copy says how many rows it marked, apart from how many it counted”
  • A PostgreSQL table with a primary key kept in soft delete is told the rows it counted and the rows it marked as two numbers. Its copy counts every row in your table it did not write that is not already marked deleted, and marks deleted only the rows a pipeline wrote while the table was kept in soft delete: a row another writer left, or one from before the table was switched to soft delete, is counted and left as it is. The page said “4 rows the source no longer has were marked deleted” where none was; it now says “4 rows in your table were not in the source; 0 were marked deleted, and 4 were not”, with why. The API’s rows_not_in_source.removed already carried the marked number; its description now says it can be fewer than count.

  • A filter change’s line in the observation feed says the answer you gave for the rows it leaves out, never their fate. “removing the rows already there that do not match (counted first)” was said where those rows were kept (a filter the destination could not judge on their values) or marked deleted (soft delete); what the copy did with them is its own observation.

  • A pipeline whose source sends no deletes (Stripe) is no longer told its deletes are applied here. A Stripe source writes the rows it reads and sends no deletes, so a customer deleted in Stripe stays in your table as it was. The 422 mode_fixed_by_source and 422 purge_not_offered answers and the API reference’s sync-mode texts said otherwise of every such pipeline; they now say so for a Stripe pipeline, and a MySQL pipeline’s still say its deletes are applied. The page’s mode menu says the source sends no deletes in place of a mode’s help.

  • “Delete the rows marked deleted” says every way a row comes to be marked. Its confirmation, in the app and in the API’s description of POST .../tables/{table_id}/purge-deleted, said the rows “were deleted at your source”: a row a narrowed row filter left out, and one a copy found no longer in your source, are marked too. It now names all three.

2026-10-19 (IST) — Single sign-on: an account proves its domains (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: an account proves its domains (not yet released)”
  • POST /v1/sso/domains (owners; not API keys) adds a domain to verify, pending until its DNS record is found; the answer names the TXT record to publish (record.name, record.value). A public mail domain cannot be verified (422 public_mail_domain), a name that is not a domain is 422 invalid_domain, and a domain the account already has is 409 domain_exists.
  • POST /v1/sso/domains/{domain}/check looks the record up now: found, the domain is verified (again, when it had lapsed). 409 domain_record_not_found when it is not there yet; 502 dns_unavailable when the lookup did not answer.
  • GET /v1/sso/domains lists the domains, a cursor page, each with its state, record, and when it was verified, last checked and first found missing; DELETE /v1/sso/domains/{domain} removes one. The last verified domain cannot be removed while single sign-on is on (409 domain_required).
  • Every day each verified domain is checked again. A record missing for 14 days in a row lapses the domain: people at it can no longer join through single sign-on or find the account’s sign-in by their address; members already in are unaffected, and single sign-on stays as it is. Every owner is told on the first day and on the fourteenth (sso_domain_lapsing), and the audit log records both (sso.domain_missing, sso.domain_lapsed), beside sso.domain_added, sso.domain_verified and sso.domain_removed.

2026-10-19 (IST) — Single sign-on: an owner turns it off, allows it or requires it (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: an owner turns it off, allows it or requires it (not yet released)”
  • PUT /v1/sso/mode (owners; not API keys) sets single sign-on off, allowed or required, and optionally its recovery owners and whether people at the verified domains join on their first single sign-on. On needs a verified domain (409 domain_required); required needs a tested identity provider (409 sso_not_tested) and at least one recovery owner (409 recovery_owner_required), each an owner (409 recovery_owner_not_owner).
  • Requiring single sign-on ends every email-link session in the account except the recovery owners’, counted in the answer (sessions_revoked, recovery_sessions_kept). A change that would sign out the owner making it is refused (409 would_sign_you_out): on an email link, name yourself a recovery owner first.
  • Every owner is told when single sign-on is turned off, allowed or required, with what a switch to required ended and kept. The audit log records sso.mode_changed, sso.jit_changed and sso.recovery_owners_changed.

2026-10-19 (IST) — Single sign-on: every refusal says what happened, with a code of its own (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: every refusal says what happened, with a code of its own (not yet released)”
  • Every refusal of the single sign-on routes has a code of its own and a sentence in the app. A refusal of the identity provider’s answer is sso_<reason> (sso_audience, sso_clock, sso_client_secret_rejected, …), with fault upstream when the provider refused or could not be reached. A sign-in whose account turned single sign-on off meanwhile is sso_turned_off.
  • POST /v1/auth/sso/start’s “confirm first” is 409 sso_confirm_required (it was confirm_required, the re-sync’s code, whose sentence is about a second press).
  • A server that has not wired single sign-on answers its routes 503 sso_unavailable (ours), not 404.
  • The remembered browser’s cookie is set only once the sign-in has committed.
Section titled “2026-10-19 (IST) — Single sign-on: an owner can unlink a person’s identity (not yet released)”
  • DELETE /v1/sso/identities/{user_id} (owners; not API keys) unlinks a person’s identity at the account’s identity provider: after an identity provider migration, or when a mailbox is handed to someone new. The sessions they made through it end now, counted in the answer ({"sessions_revoked": n}), their remembered browsers are forgotten, and they link again at their next single sign-on. Sessions from an email link are kept. 404 identity_not_found when the person has none in the account, 404 sso_not_set_up when the account has no single sign-on. The audit log records sso.identity_unlinked, one row per identity, with its issuer and the sessions it ended.
  • Whatever the timing, a single sign-on finishing at the moment of the unlink is refused at its first request, and never follows the person’s next identity.

2026-10-19 (IST) — Single sign-on: making a member an owner signs them out of single sign-on once (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: making a member an owner signs them out of single sign-on once (not yet released)”
  • PUT /v1/members/{user_id} to owner ends the person’s single sign-on sessions in the account that came through an identity their mailbox has not confirmed, in the same change, and the answer counts them (sessions_revoked; 0 when there were none). Their next single sign-on asks for a code by email, which confirms the identity; sessions from an email link, and through an identity already confirmed by email, are kept. A demotion ends nothing, and its answer carries no count.
  • The membership trail’s member_role_changed row records the same count (sessions_revoked) for a promotion.
  • Whatever the timing, an owner never acts through an unconfirmed identity: a single sign-on finishing at the moment of the promotion is refused at its first request (403 sso_reconfirm_required) and the person confirms by email.
  • Removing a person, or a person leaving, also unlinks their single sign-on identity in the account; someone invited back links again at their next single sign-on.

2026-10-19 (IST) — Single sign-on: owners are told who got in, and who said it was not them (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: owners are told who got in, and who said it was not them (not yet released)”
  • Every owner is emailed, whatever their notification switches say, when a single sign-on is refused because it came from a different identity at the identity provider (sso_identity_mismatch), when a person answers No, it wasn’t me to a confirmation code (sso_link_denied: it names the identity provider’s host the person was shown, and an owner invitation the sign-in would have accepted, which stays open), and when a recovery owner signs in or switches in with an email link while the account requires single sign-on (sso_recovery_sign_in). Like the membership and API key notices, these cannot be muted or sent to a channel. A confirmation code nobody entered tells nobody. Each notice links the account’s audit log.
  • The audit log’s sso.link_denied row records host, the identity provider the confirmation named.
  • The notifications history names every API key notice (it showed their message keys before).
  • Changing a member’s role, removing a member or leaving no longer answers 500 when it races a person joining the account: the change is retried once, as the join already was.
  • GET /v1/membership-events documents member_joined_by_sso, the kind a person joining through single sign-on writes, and Settings, Members names it (“… joined through single sign-on”).
Section titled “2026-10-19 (IST) — Single sign-on: discovery, the link’s page and the start (not yet released)”
  • POST /v1/auth/sso/discover {email} answers {"sso": {"connection_id", "required"}} when exactly one account has verified the address’s domain with single sign-on on, and {"sso": null} otherwise. Whether the address is known is never read: every address at a domain gets the same answer. It changes nothing.
  • GET /v1/auth/sso/connections/{id} is what a connection’s sign-in link page shows before anyone continues: the account’s verified domains (a lapsed one with verified_until), the discoverable_domains, the identity provider’s host the browser will go to, and whether this browser is remembered or holds an open_request_unanswered. Never the account’s name or the IdP’s label. 404 sso_not_found for a connection that cannot be started; 400 invalid_connection for an id that is not one.
  • POST /v1/auth/sso/start {connection_id | email, return_to, by} starts a single sign-on on a person’s click: it sets the __Host-reyansh_sso binding cookie (SameSite=Lax, ten minutes) and answers redirect_url, the identity provider’s sign-in URL. 400 one_of_required unless exactly one of connection_id and email; 409 confirm_required for by: remembered from a browser that is not remembered; 422 return_to for a destination that is not a page of this app; 404 sso_not_found; 409 sso_misconfigured (with details.field) when the account’s identity provider address is one that cannot be used.
  • GET /sso/oidc/{id}/callback, the address an OpenID Connect identity provider sends the browser back to, answers 303 /auth/sso#attempt=<code> (the code in the fragment, for POST /v1/auth/sso/complete), or 303 /auth/sso#error=sso_attempt_invalid for a sign-in that is no longer open. It sets no cookie and signs nobody in.
  • Rate limits, per client address a minute: discovery 20; the start and the link’s page 30 between them; the callback 30, and 300 a minute per connection.
  • Signing out forgets the browser for single sign-on (POST /v1/auth/logout): a browser that a single sign-on remembered (so its account’s sign-in link starts without asking) is forgotten in every account, and its __Host-reyansh_sso_known cookie cleared, so the next link asks first.
  • Codes nobody entered are recorded (sso.link_confirmation_expired) within a minute of expiring, and the pre-account sign-in rows are deleted past their life, by the control plane’s own sweep.

2026-10-19 (IST) — Single sign-on: “Was this you?”, the confirmation email, and rate limits (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: “Was this you?”, the confirmation email, and rate limits (not yet released)”
  • POST /v1/auth/sso/confirm/describe {token} is the read behind the confirmation email’s “Was this you?” page: the token from the link’s fragment (the page strips it from the address bar at once and posts it; it is never in a URL). It answers the account’s verified domains, the identity provider’s host the sign-in went through, the address the code was sent to, owner_invitation, and this_browser_started (the browser holds the sign-in’s confirmation cookie, so it can take the code there), every one read from the confirmation itself and never from the link. It changes nothing. A link that can no longer be used (used, denied, expired or unknown) answers {"open": false} and nothing else, whichever it was.
  • The confirmation email is delivered through the deployment’s mail provider: the code, how long it works (15 minutes), the facts above, and the “No, it wasn’t me” link with its token in the fragment. Without a provider the control plane records the codes in memory and says so at every boot.
  • Rate limits on the single sign-on surface (per client address, a one-minute window, 429 with Retry-After past it): 30 a minute for POST /v1/auth/sso/complete, and 30 a minute shared by POST /v1/auth/sso/confirm, /confirm/deny and /confirm/describe.
  • The OpenAPI document’s x-reyansh-audit names a POST that only reads reads: the invitation preview (was not_account_scoped) and the confirmation’s description. Neither records anything, and the server’s own test holds each to changing nothing at all.

2026-10-19 (IST) — Single sign-on: the mailbox code and “No, it wasn’t me” (not yet released)

Section titled “2026-10-19 (IST) — Single sign-on: the mailbox code and “No, it wasn’t me” (not yet released)”
  • POST /v1/auth/sso/confirm {code} finishes a single sign-on that needed the person’s mailbox: the eight-character code the email carried (case, spaces and hyphens do not matter), typed in the browser that started, which holds the __Host-reyansh_sso_confirm cookie. It answers 200 with outcome: signed_in (the session cookie set, the confirmation and binding cookies cleared), granting what the account’s rules grant NOW: an owner invitation withdrawn in the meantime makes a member where single sign-on may add one, and the answer’s invitation_ended says why. Refusals: 403 sso_wrong_browser (no confirmation cookie), 403 sso_code_wrong with details.remaining (the fifth wrong code ends the confirmation), 410 sso_code_expired (expired, used, denied or ended: sign in again), 410 invitation_ended with details.reason, and the completion’s other refusals.
  • POST /v1/auth/sso/confirm/deny {token} is the email’s “No, it wasn’t me”, from any browser: the confirmation can never complete, every owner is told (sso.link_denied, naming an owner invitation when the confirmation carried one; the invitation stays open), 204; 410 sso_deny_expired for a link that can no longer be used, which changes nothing.
  • code_sent answers also carry return_to, for the page to go to once the code is entered.
  • The audit log gains sso.link_denied and sso.link_confirmation_expired (a code nobody entered within its 15 minutes, recorded once by the sign-in sweep, with no notice).
  • Every signed-in request now checks the account’s single sign-on rules, in the same lookup as the session: in an account that requires single sign-on, a session from an email link answers 403 sso_required with details.sso_connection_id (unless it is a recovery owner’s recovery sign-in), and an owner whose single sign-on has not been confirmed by their mailbox answers 403 sso_reconfirm_required. A single sign-on session whose linked identity was removed is signed out (401). Accounts without single sign-on see no change; API keys are not sessions and are unaffected. Both refusals carry details.sso_connection_id, details.domains (the account’s verified domains) and details.address (the person’s own).
  • The sign-in link and the account switcher follow the same rules. The link’s chooser (409 account_choice_required) gives each account with single sign-on an sso object: connection_id, required, and link_admitted (true for a recovery owner who is an owner of an account that requires it). Choosing, or a link for, an account that requires single sign-on is 403 sso_required and the link is NOT spent; for its recovery owners it signs in, and the audit log’s session.signed_in says recovery: true. POST /v1/auth/switch answers 409 sign_in_required (with the same details) from a single sign-on session to any other account, and into an account that requires single sign-on for anyone but its recovery owners, whose switch the audit log records as session.switched with recovery: true.

2026-10-19 (IST) — A row your source writes again is never left marked deleted after a switch to live

Section titled “2026-10-19 (IST) — A row your source writes again is never left marked deleted after a switch to live”
  • PostgreSQL destination: a table switched from soft_delete to live no longer keeps the deleted mark on a row your source writes again. The rows marked deleted before the switch still stay marked when you switch, as PUT /v1/pipelines/{id}/tables/{table_id}/sync-mode says, but a row whose key your source inserts or updates again is now written unmarked (_reyansh_deleted_at cleared), as a soft-delete table and every Snowflake table already were. Before this, such a row was written with its new values and stayed marked, and a purge (POST /v1/pipelines/{id}/tables/{table_id}/purge-deleted) then deleted a row your source still had. A purge removes the rows marked deleted: rows your source deleted and has not written since; rows whose latest write your destination did not keep, each of which you are told about (rows_discarded) or the table stops on; and, in a table with a row filter, rows that left the filter, which your source still has outside it.
  • PostgreSQL destination, a table with a primary key: a trigger on your table can no longer leave a row marked or unmarked in silence. A BEFORE UPDATE trigger that skips or rewrites an update which changes only _reyansh_deleted_at used to be read as done: a row your source wrote again stayed marked and was purged, a row your source deleted stayed live, and a Copy again told you a row was deleted that it had left live. The pipeline now reads the mark back. A clear your trigger skipped is a discarded row, told as one (rows_discarded) or stopped on, as your pipeline is set; a mark your trigger skipped, a delete’s, a truncate’s or a Copy again’s, always stops the table, naming the trigger, and resuming it after you let that update through marks the row (a Copy again’s table is copied again).
  • PostgreSQL destination: every number a purge, a Copy again or a changed row filter tells you is the rows the statement removed or marked, read from your table. It used to be PostgreSQL’s command count, which a rule on your table can make count another table’s rows: “1 was deleted” for a row still there. A purge or a Copy again’s delete now removes every row it should, or none, decided by the one statement that locks the rows it removes and removes them, and every number told is that statement’s own: a row your own session inserts while it runs is neither counted nor removed, and one your session is changing is waited for and removed with its newest values, as a plain delete would, so the purge, a truncate’s marks and a column’s clear finish beside your own writers as they do on a quiet table; a DO INSTEAD rule (which PostgreSQL refuses such a delete under) or a BEFORE DELETE trigger that keeps a row stops that one table, in PostgreSQL’s own words, with nothing removed (a purge waits, and the table cannot be resumed until you cancel it; a Copy again asked again once your rule or trigger lets it). Under an audit rule of yours (ON DELETE DO ALSO ...) PostgreSQL allows no such statement, so there the delete is the plain one, its count PostgreSQL’s own for that delete, and a BEFORE DELETE trigger that keeps rows of that same table is not detected, as before.
  • PostgreSQL destination: PostgreSQL refusing a write to one destination table now stops that table only, with PostgreSQL’s own words, and every other table keeps syncing. Before, each such refusal (a trigger of yours that raises an error, or stores a value too long for an audit column; any rule on INSERT or UPDATE, which PostgreSQL never allows under INSERT ... ON CONFLICT; a CHECK or foreign key the row breaks, at the statement or, deferred, at commit; a revoked INSERT; a destination table you publish onward without a replica identity) stopped the whole pipeline, which restarted again and again with only “stopped with exit code 1” to read, and was paused after 14 days. The table now waits for you with PostgreSQL’s message (any part of it that could quote a row’s values is held back) and, where PostgreSQL’s own report says so, the constraint and the table it is on. Which table stops is decided by the table the refused statement was for, never by a guess at whose object refused it, so a server setting of yours such as log_parameter_max_length_on_error changes nothing. If the words name a trigger, rule, constraint or permission of yours, fix it and resume the table: it writes everything from where it stopped, and nothing is lost; if they do not, contact us. A refusal that passes by itself (a lock not granted in time, a deadlock, a serialization failure, the server out of a resource, the connection, or a read-only moment while your destination fails over), raised anywhere, your own trigger included, is tried again by the pipeline and never stops a table, a schema change’s step included. From the third start in a row that meets it, the pipeline’s feed says so at each start, with PostgreSQL’s words and what happens next: the pipeline is restarted automatically at most 5 times within 60 seconds, and then stopped until you start it again (stops further apart are restarted for up to 14 days). A stopped pipeline’s page shows those words, not only that its restarts ran out. The same is told when your destination refuses the pipeline’s connection for a reason that passes by itself (it is at its connection limit, or it does not answer). A statement_timeout of yours that cancels a write is told as one, with the value in force, and resuming the table once you change it writes it.
  • What a failing pipeline is told comes from what was recorded (2026-10-21 (IST), #1274). The count in its words (“PostgreSQL has given this answer at 3 of the starts”) is now every start that met the answer, the first two included (it said one of three before); the restart policy it names is the one the running control plane restarts by, written into each restart row, so a worker released apart from its control plane cannot name another; and the control plane’s own “no longer restarted after N days” says its policy’s days. A destination that does not answer at all (a closed port, a host that is down) is told as the destination not answering, with the address dialled and what the operating system said, and never as an answer PostgreSQL gave or with a promise to retry. A pipeline that is retrying now shows what its newest start was told on its page, as a stopped one does. The destination’s connection test no longer says “The pipeline will retry”.
  • A server that answers is told as answering, and every count counts what its sentence names (2026-10-21 (IST), #1274). A destination PostgreSQL that refuses the pipeline’s connection before any session begins (as it does when it cannot start a process for it, out of processes or memory), or that ends the TLS handshake with an alert, is now told as the server answering, with its own log and resources as the place to look, never as nothing answering and never with firewall advice. “The destination has not answered at M of the starts” now counts every start the destination did not answer, whether a statement’s connection was lost or the address refused the connection (a destination that went away while the pipeline ran was told 6 starts and 5 of them before); PostgreSQL’s answers are counted by their code and the table they were given for, never by their words. A restart of the control plane (a deploy) no longer starts the pipeline’s count of stops, or its 14 days of restarts, again: a person’s start still does.
  • A server that began to answer and then stopped is told so, never as one that did not answer (2026-10-21 (IST), #1274). A destination PostgreSQL that agreed to TLS, or asked the pipeline to sign in, and then reset the connection or went quiet (a sign-in that waits on a slow LDAP, RADIUS or PAM service does) was told “The destination did not answer … Nothing answered”, with firewall advice. It is now told what the server sent and how it stopped, with its own log, its TLS settings or the services its sign-in uses as the place to look. The words state the restart policy of the supervisor that started the worker (a deploy that changed it was told the previous one), the counts are both of the pipeline’s recorded starts (after a rollback the second could read 7 of 3), and a page whose pipeline gave up no longer shows what an earlier start was told when a later start stopped without telling anything. The supervisor’s restart window and its 14 days are kept on the database’s clock, so a control plane on a host whose clock is off neither gives up early nor late.
  • A server is told the furthest point it reached, and every count counts only the starts its sentence names (2026-10-22 (IST), #1274). A destination PostgreSQL slowed by a login trigger of yours, or by a pooler in front of it waiting for its own server, was sent to its LDAP. It is now told how far the server got (it sent the next step of the sign-in, it accepted the password, it signed the pipeline in, it had begun a session) and pointed at what fits; because PostgreSQL sends the end of a sign-in only once the session is ready, a login trigger that runs long looks exactly like a sign-in that has not finished, so every sign-in that went quiet now names an event trigger ON login first. The services a sign-in uses (LDAP, RADIUS, PAM) are named only where the server asked for the password in the clear, which is how they ask, and a connection that ended during the sign-in is never told it waited on them (this corrects the bullet above, which named them for any sign-in that went quiet). A first statement that a server never answers is told what it is, where the pipeline used to wait with its page saying healthy. “Its worker has recorded N starts” counts only the starts since the pipeline was last started, made progress, stayed up for the supervisor’s stable run (now said from the supervisor’s own setting) or was run by a release of Reyansh that keeps no such count, and says so: a start under a previous release, or a run that stayed up, is no longer counted across.
  • What to look at is chosen from how far the server got and how the connection ended, together (2026-10-23 (IST), #1274). A destination PostgreSQL that asks for no password (trust, or a client certificate) and whose login trigger runs long was sent to its TLS settings, or told to look for what ended the connection, when the pipeline had simply stopped waiting: PostgreSQL holds the end of a sign-in back until the session is ready, so all that server sends first is its TLS handshake or its refusal of TLS. A connection that goes quiet after the pipeline’s start now names an event trigger ON login among the causes, whatever the server sent before; “what ended the connection” is said only of one that ended; a first statement the server never answers is pointed at what the session waits on (pg_stat_activity); and a request for TLS that nothing answers is never blamed on a login trigger. The destination’s connection test and a source’s stop say the same, and a connection that was made but answered nothing is no longer told it “could not be reached”.
  • A server that asks for a password the pipeline’s connection does not have is told so (2026-10-23 (IST), #1274). A destination URL with no password, against a server that asks for one (by SCRAM, MD5, or in the clear as LDAP, RADIUS and PAM do), was told “the destination could not be reached” by the connection test, as worth trying again, and the pipeline restarted until its supervisor gave up with only “5 restarts in 60s” on the page. The connection test’s sign-in step and the pipeline now both say the server asked the role for a password the destination does not have, and the pipeline stops for a person instead of restarting. A reply the pipeline itself refuses is said so, never “could not be reached”.
  • A destination session that stops answering is told which of its requests went unanswered, as counted (2026-10-23 (IST), #1274): “answered the first request the pipeline sent in it, and nothing of the second”, where it said “answered nothing of its first statement” of a session that had answered it. And a session that stops answering after the pipeline’s lock is told within the same bound as the lock itself (the connection’s sign-in deadline, 15 seconds by default), where it was left healthy with nothing told.
  • A destination connection that ended is pointed at the server’s own timeouts by name (2026-10-25 (IST), #1274). Its advice listed “an idle or statement timeout” among what ends a connection, and a statement_timeout cancels a statement and never ends a connection. It now names the server’s idle_session_timeout and idle_in_transaction_session_timeout, beside a restart, a failover, and a proxy or load balancer.
  • A pipeline is not told it is retrying because the control plane restarted (2026-10-25 (IST), #1274). A scheduled pipeline that stopped twice and then completed a sync, met by a control plane restart (a deploy) within the hour, was told “This pipeline’s worker was stopped when the control plane restarted”, read retrying and sent a retrying notification, while no worker was running; a Sync now pressed while a pipeline waited to be restarted was counted the same way. A completed sync now ends the run of stops across a restart too, and only the worker’s own records say a run was stopped. A control plane that was down for more than an hour no longer forgets a pipeline’s count of stops and its 14 days of restarts, and the number of restarts on a pipeline that was given up counts restarts only, never the scheduled syncs that completed (it was one more for each).
  • A source’s connection test no longer says “The pipeline will retry”: a test retries nothing, and a pipeline’s restarts are its supervisor’s to tell.
  • PostgreSQL destination: a table whose row-level security applies to the role the pipeline writes as is stopped at start, naming the role and the fix (ALTER ROLE … BYPASSRLS;, or the table’s owner without FORCE ROW LEVEL SECURITY), as a source table under row-level security already is. A policy could hide rows from that role, and a delete of a hidden row matched nothing, so a row your source deleted stayed in your table with nothing said. A policy that shows every row is stopped too: the pipeline cannot tell it from one that does not. Every write checks that table again, under the lock the write takes on it anyway, so a policy added while the pipeline runs stops that table before a row is written, and your own migration beside a write (an index built, then a column added, in one transaction) is never deadlocked by the check; your triggers that write other tables under those tables’ own policies work as before. Upgrade note: a destination table whose policy is USING (true), written by a role that does not own it, was written before this release and now stops at start, naming the fix.
  • PostgreSQL destination: _reyansh_deleted_at and _reyansh_synced_at are reserved. A source table whose publication sends a column of either name is stopped before anything is written, saying how to leave the column out of what your publication sends: take that table out of the publication and add it back in one transaction, ONLY both times, with a column list of its other columns and its row filter kept (the publication’s other tables are not touched); or, on a FOR ALL TABLES or FOR TABLES IN SCHEMA publication where PostgreSQL allows no column list, to rename the column at the source. It says this in words, clause by clause, and names no statement of its own, as every refusal about your source does (corrected 2026-10-27 (IST): this entry first said it gave the statement ready to run). Leave the column out that way, then resume the table; or rename it at the source, unless that table is another pipeline’s destination, where the column is that pipeline’s own and renaming it takes its marks away. It used to be written into the pipeline’s own column, and a purge then removed rows by your source’s values.
  • A rows_discarded report under continue now says the destination does not hold the row as it was sent: missing there, or as it was before, still marked deleted if it was. It said the row was “not in the destination”, which was not true of a discarded update.
  • If you switched a PostgreSQL table from soft delete to live before this release, a row your source wrote again after the switch may still be marked deleted. Copy that table again (POST /v1/pipelines/{id}/tables/{table_id}/recopy) before you ask for a purge: the copy clears the mark of every row your source has, and removes nothing.
  • In such a live table, an update of a row marked deleted that leaves out a column (a filtered table’s) is now refused, as it is in a soft-delete table, instead of being written over a row your source deleted.

2026-10-18 (IST) — A copy’s record of what it deleted or marked keeps its word after you change the table’s mode, and every answer about the rows a new filter leaves out says what happens where no delete runs

Section titled “2026-10-18 (IST) — A copy’s record of what it deleted or marked keeps its word after you change the table’s mode, and every answer about the rows a new filter leaves out says what happens where no delete runs”
  • What a copy did with the rows your source no longer has is now recorded with its count, and its sentence reads that, never the table’s mode now. Switching a table between soft delete and live is made in place and copies nothing, so the last copy’s count stays while the mode changes. A table switched after its last copy was told the other mode’s word: rows the copy had deleted read “marked deleted”, and rows still in your table, marked, read “deleted”. The table’s rows_not_in_source in the API now carries removed_as (marked or removed), and the table_reconciled event on the pipeline’s feed says the same. A copy an earlier release recorded says “marked deleted or removed”.
  • The answer the API asks for when a filter change leaves rows out (422 rows_outside_required) says what each answer does for that table. It promised “delete (they are removed, counted first)” also where the destination cannot judge the filter on its own values or the pipeline may not delete from it, where the rows are kept (or marked deleted, in soft delete) instead. The same on the answer to another pipeline’s record, and in the filter route’s description.
  • A table with no primary key whose destination table holds rows another pipeline wrote is told what resuming it does by its mode. It said “resuming copies it again, replacing what your destination holds” of every such table; kept in soft delete, its copy keeps them and marks the ones your source no longer has.
  • Where a table with no primary key is said to be copied “replacing what your destination holds” (the delete’s refusal in the app, a stopped source history’s way out), it now says “kept live”: in soft delete its copy marks them.

2026-10-18 (IST) — Every sentence about what a copy does to a table’s rows is chosen by the table’s mode and destination, not one of them alone

Section titled “2026-10-18 (IST) — Every sentence about what a copy does to a table’s rows is chosen by the table’s mode and destination, not one of them alone”
  • A Snowflake table with a primary key kept live is no longer told its rows are kept or “marked deleted”: its copy deletes the rows your source no longer has, as any table kept live does except a PostgreSQL table with a primary key. The way back of a parked table, a re-sync’s line, a reconcile’s “Up to date” line, the filter dialog’s sentence for the rows a new filter leaves out, the change policy’s help for “Copy the table again”, and the API’s descriptions and refusals now all say, for every table, what its copy does by its key, its mode and its destination: in soft delete every row is kept and a row your source no longer has is marked deleted; kept live, such a row is removed, unless the table has a primary key and its destination is PostgreSQL, which keeps it (and “Re-sync and delete them” deletes it).
  • A table whose key no start has recorded is never worded as a keyed table’s, on its Re-sync confirm and in the re-sync dialog too: both cases are said where they differ.
  • New field tables[].filter_change: a row filter added or narrowed that waits for the table’s next copy, with rows_outside (keep, delete, or null where none is asked); null when none waits. What a copy will do with the rows that filter leaves out is said from it.
  • delete_rows_not_in_source is refused (422 delete_not_applicable) for every table whose copy does not keep those rows, by POST .../tables/{table_id}/recopy and POST .../resync alike, the refusal naming the table and what its copy does: a table kept in soft delete, a table with no primary key, a Snowflake table, and a table whose key no start has recorded. Before, the pipeline’s re-sync accepted it for a table with no primary key.
  • A delete you asked for of the rows a new row filter leaves out is said where it cannot run. On a PostgreSQL table with a primary key, the copy removes them only where the filter can be judged on the table’s own values; where it reads a column this pipeline hashes or one the table declares differently, or the pipeline may not delete from the table, they are kept (marked deleted, in soft delete) and the history says why. Every sentence that promised their removal (a parked table’s way back, the re-sync line, the filter dialog’s and another pipeline’s record’s “Remove them”, the rows_outside description) now says both.
  • The change policy’s confirmation and the source history’s acceptance say what copying each table again does by the whole rule, where they said every table with a primary key keeps every row; and every API description or refusal that states the rule now says what becomes of a row a new row filter leaves out, which the rule alone said was kept. The re-sync’s reference lists every table delete_not_applicable answers, where it named only Snowflake and a table kept in soft delete.
  • tables[].rows_not_in_source.count gains not_told_apart: a copy under a row filter added or narrowed whose rows outside it could not be told from the rows your source no longer has (always on Snowflake), with removed saying what it removed or marked. not_counted now means only a count that could not be proven, beside which nothing is removed. Before, the two were one value; a PostgreSQL table with a key kept live that could not tell them apart is now told so (“none were deleted”), not that its rows could not be counted.

2026-10-18 (IST) — A table stopped before its key was read is told what either kind of copy does, and a row filter’s copy counts the rows it leaves out apart

Section titled “2026-10-18 (IST) — A table stopped before its key was read is told what either kind of copy does, and a row filter’s copy counts the rows it leaves out apart”
  • A table the pipeline stops or leaves waiting at a start now has its key recorded there, whatever stopped it (its destination table missing, which is every PostgreSQL destination’s first run; row-level security; a filter that cannot be judged; a publication that does not list it): tables[].key is the key your source has. Before, a table stopped at its first start had no key recorded, and its way back was worded as a keyed table’s, rows kept, which a table with no primary key’s copy does not do. A table whose key cannot be read (one your source no longer has) still has none, and its way back now says what happens for either kind: it is copied keyed as your source keys it then.
  • A copy under a row filter that was added or narrowed counts the rows the filter leaves out apart from the rows deleted at your source, for every table. On PostgreSQL the filter is judged on your table’s own values in the copy’s own statements: rows_not_in_source counts only the rows inside the filter, and the rows outside it are told as rows_deleted_by_filter, removed (a table with no primary key kept live) or marked deleted (marked, new, for a soft-deleted table), or kept where your answer was keep. Re-sync and delete them (recopy with delete_rows_not_in_source) never deletes a row outside the filter. Where the filter cannot be judged on your table’s values (it reads a column the pipeline hashes, or one your table declares differently), and always on Snowflake, the two cannot be told apart: rows_not_in_source.count is not_counted, removed says how many rows the copy removed or marked, and the table’s row says so. Before, the rows outside the filter were counted and shown as not in your source while your source still held them.
  • A table with no primary key is not offered Re-sync and delete them, and POST .../recopy with delete_rows_not_in_source is refused for one (422 delete_not_applicable): its copy already replaces what your destination holds.
  • A re-sync with new source names says what its copies do for either kind of table: it said nothing written would be lost, which is not so for a table with no primary key kept live.

2026-10-18 (IST) — Single sign-on: the completion (not yet released)

Section titled “2026-10-18 (IST) — Single sign-on: the completion (not yet released)”
  • POST /v1/auth/sso/complete {attempt} finishes a single sign-on in the browser that started it: the attempt code the identity provider’s answer leaves in the page’s fragment, with the browser’s __Host-reyansh_sso binding cookie. It answers 200 with outcome: signed_in (the session cookie is set and the binding cookie cleared; return_to says where to go), code_sent (the person’s mailbox must confirm first: an owner, someone accepting an invitation to be one, or a member whose address is outside the account’s verified domains, the first time; the __Host-reyansh_sso_confirm cookie is set) or tested (an owner’s test sign-in, recorded on the details it tested). Refusals: 401 sso_attempt_invalid (unknown, used, or past its two minutes), 403 sso_wrong_browser (another browser: nothing is spent), 403 sso_not_allowed, 403 sso_not_invited, 403 sso_identity_mismatch, 403 remembered_identity_changed, 403 sso_unavailable (the account turned single sign-on off), 410 invitation_ended with details.reason, 429 sso_confirmations_exhausted with Retry-After, and 403 naming the identity provider’s own refusal. Same-origin JSON only, like every sign-in route.
  • The audit log gains sso.identity_linked, sso.identity_mismatch, sso.link_confirmation_sent, sso.draft_tested and sso.remembered_identity_changed; session.signed_in records method: "sso" for a single sign-on; the people trail gains member.joined_by_sso.

2026-10-17 (IST) — A table with no primary key can be picked when you create a pipeline, every word about copying it again is true, and a column change that stopped it can be withdrawn

Section titled “2026-10-17 (IST) — A table with no primary key can be picked when you create a pipeline, every word about copying it again is true, and a column change that stopped it can be withdrawn”
  • The new-pipeline form lets you pick a table with no primary key, marked “No primary key: each row is identified by a hash of all its values”, where it said “Cannot be synced yet”. The connection test’s listing (catalogue.tables[].key.source) names such a table row_hash; none is now only a table that cannot be synced at all (one whose replica identity Reyansh does not recognise).
  • What a copy does with the rows your destination already has is said for the table in front of you. A table with a primary key is copied again keeping every row your destination already has. A table with no primary key is copied again replacing what your destination holds: a row your source no longer has is removed in live, and kept, marked deleted, in soft_delete. Before, every stopped table’s remedy, the re-sync and copy-again descriptions, the change-policy answers and the history said “keeping the rows your destination already has” of every table (parked.remedy, GET /v1/change-policy, the reference for POST .../resync and .../recopy).
  • A column change that stopped a table with no primary key can be withdrawn (cause keyless_shaping_change): under Columns and filter, Withdraw this change sets the column back to how it is synced now. PUT /v1/pipelines/{id}/tables/{table_id}/columns takes it with no existing_rows (one sent is refused, 422 existing_rows_not_offered), any member may, and the history says the setting was withdrawn and the values already there were not changed. Before, the page could not change a pending setting, the API asked what to do with values nothing had changed, only an owner could send it, and the history said the values were left NULL while every row still held them. Then resume the table.
  • Block and Hash are no longer offered on such a table once it holds rows, and 409 keyless_table_holds_rows says that giving the table a primary key means dropping its destination table and copying it again.
  • Copying a table with no primary key again counts, in the table’s rows_not_in_source and removed, only rows that were still live: a row an earlier delete had already counted out is not counted a second time, on PostgreSQL and Snowflake alike, and table_reconciled in the history carries the same numbers.

2026-10-16 (IST) — A table with no primary key keeps your row filter and hashes the columns you chose; copying begun again after a pause stays free

Section titled “2026-10-16 (IST) — A table with no primary key keeps your row filter and hashes the columns you chose; copying begun again after a pause stays free”
  • A table with no primary key honours its row filter and its hashed columns while it copies and while it syncs changes: a row your filter keeps out never reaches the destination (a row that moves out of the filter is removed there, one that moves in is added), and a column you chose to hash arrives hashed, its row’s identifier computed from the hash rather than the value. Each change your filter leaves out is counted with the table’s other filter counts. A row your filter cannot judge pauses the table and says why, as it does for any table.
  • A copy nobody asked for, paused before it finished, is still not charged when the table is resumed: the resume copies the table again as the same repair, recorded and free, whatever paused it. A copy that was already due (a table’s first copy, an added table’s, a re-copy you asked for) and was paused before its first row, by another session’s lock on the table or by the table’s two publications disagreeing, stays that copy when you resume it, priced as that copy.
  • A column of a table with no primary key that holds rows cannot be blocked, hashed or un-hashed (PUT /v1/pipelines/{id}/tables/{table_id}/columns, and a table’s columns when it is added back): such a table’s rows are each identified by a hash of all of their values, so the change would give every row already in your destination a new identity, a later update or delete would no longer find its row, and an identity computed from the value you meant to hide would still reveal it. It is refused with 409 keyless_table_holds_rows, which says what you can do: keep the column as it is, or give the table a primary key at your source. existing_rows: fill is not offered for such a table (a fill finds each row by its key). Before the table holds rows, any setting is taken, and its first copy applies it. A setting saved before this rule stops the table instead (cause keyless_shaping_change, nothing written): withdraw the change (2026-10-17 (IST): any member can, see the entry above), then resume it.
  • rows_outside is not asked of a table with no primary key when its filter changes, and is refused if sent (422 rows_outside_not_applicable): its copy keeps only the rows that match, and marks the rows already there that do not as deleted in soft delete (removes them in live), as the table’s mode does with a delete.
  • The keyless tables release’s database change is migration 0091 (it was built as 0077, then numbered 0079 and 0083); upgrading applies it after 0078, and it is reversible.

2026-10-16 (IST) — A filter that needs whole old rows shows one statement, which never makes your source refuse a write

Section titled “2026-10-16 (IST) — A filter that needs whole old rows shows one statement, which never makes your source refuse a write”
  • Fixed: a row filter’s advice to give a table REPLICA IDENTITY FULL printed a statement that could make your source refuse the table’s UPDATE and DELETE. Since 2026-10-02 (IST) a filter on a table that is not REPLICA IDENTITY FULL (the form’s choice for a row entering the filter, the note under a filter, a table kept as a log of changes), and the three stops such a table can make (a row entered the filter with a value left out, the filter needed a value left out, a log of changes met a change without its whole old row), told you to run ALTER TABLE ... REPLICA IDENTITY FULL. Run on a table that a publication sending its updates and deletes has a column list for, or, on PostgreSQL 18 or later, one with a generated column that publication does not send, PostgreSQL then refuses every UPDATE and DELETE of the table.
  • Now every one of them shows the same statement, run on your source as the table’s owner. It gives the table and each of its partitions REPLICA IDENTITY FULL, in one transaction, where PostgreSQL allows it. Where it would not, it changes nothing and says what must change first: take the table out of that publication and add it back with no column list, naming it ONLY both times and keeping its row filter, in one transaction (which then sends every column of it, the ones the list left out included); have the publication send stored generated columns; or drop a VIRTUAL column or add it again as STORED. It never offers a primary key, which makes no change carry the whole old row.
  • The API carries it, so nothing composes its own: parked.statement on a table stopped for one of those three causes (empty for every other stop), whole_rows_statement on a table’s columns (GET /v1/pipelines/{id}/tables/{table_id}/columns) and on the create form’s read of a table’s columns, and details.statement on the 422 filter_needs_full_identity refusal of a filter.
  • If you ran the old statement on a table that a publication sending its updates and deletes has a column list for, its UPDATE and DELETE are refused now: run the statement its columns view shows (whole_rows_statement), which changes nothing on that table and says what must change first.

2026-10-16 (IST) — A PostgreSQL source is set up field by field

Section titled “2026-10-16 (IST) — A PostgreSQL source is set up field by field”
  • POST /v1/sources takes the connection itself: connection, its fields (host, port, database, user, password, TLS mode and trust, an uploaded CA), or connection_url, a pasted postgres:// URL the API parses once into those fields and shows back. A URL key the service would not apply is refused by its name (url_not_understood, details.parameters), never quietly dropped, and no refusal ever repeats a value. Sending credential_ref for a source still works and is deprecated: the response carries Deprecation and Sunset (twelve months).
  • GET /v1/sources/{id} shows the connection, the password as its ****last4 hint, and standing_warnings for every TLS mode below verify-full for as long as it is chosen.
  • PATCH /v1/sources/{id} edits it: any part, tested through the changed connection before anything is saved, then saved with a restart of every pipeline that reads the source. The database is not editable. A change of host, port, TLS mode, trust, CA, approved certificate or channel binding must carry the password again, and the client key when one is stored (secret_required), so a stored secret can never be sent to a server the change points at. A change that reaches a different database server while a pipeline reads it is refused (source_would_move).
  • Every connection to a source binds its sign-in to the TLS session (SCRAM-SHA-256-PLUS, tls-server- end-point) whenever the server offers it, as libpq’s channel_binding = prefer does: a middleman who terminates the TLS can no longer relay the sign-in, which matters most under require, where nothing verifies the certificate. connection.tls.channel_binding (disable, prefer, require; a pasted URL’s channel_binding is read, as Neon’s carry require) chooses; require refuses a server that cannot be bound before any password is sent, and is refused with the modes that connect in the clear (channel_binding_needs_tls). The shown connection carries it as chosen, and omits it for prefer.
  • A refused sign-in says what refused it, on every connection to a source or a PostgreSQL destination and in the connection test. Something between us terminating TLS (or rewriting the server’s offer), a reject line, a line that requires a client certificate, LDAP or another method refusing the password, a role that does not exist or may not log in (NOLOGIN), a missing CONNECT grant and a missing REPLICATION attribute are each told as themselves, where every one used to read “add a pg_hba.conf line”. A server that answers in another language is read the same way where its answer allows, and otherwise the sentence names the causes it could be, with the server’s own words. A refusal we cannot place says so; it is never guessed.
  • The connection test names its steps (POST /v1/connections/test’s report gains steps): finding the server, reaching it, securing the connection, signing in for replication, reading the server, its settings, the publication, the slot, the tables, and the destination’s five, each passed, warning, failed, skipped or not_run, with a stable code, a sentence, the field it is about and how long it took. The test signs in for replication, as a pipeline does, so a role without REPLICATION no longer passes it. It always reports before its deadline and names the step it was on: a catalogue lock held by another session is told as a lock on the step that met it, two seconds later, never as your firewall. usable and refusal read as before (the first failed step).
  • The connection test answers within 50 seconds of your request, and tests a source alone or as you would save it. Both host names are looked up side by side, each within 5 seconds: a lookup that does not finish is the resolve step failing with timed_out, which you can retry, where it used to hold the request until the connection dropped. A test whose worker does not report in time is 504 check_timed_out with fault ours, never a firewall of yours. The source can now be connection (its fields), connection_url (a pasted URL, read by the parser POST /v1/sources uses), or source_id (a stored source) with optional connection_changes, which obey the same secret_required rule as PATCH; the destination is optional for a PostgreSQL source. The answer carries source_tls, and the resolve step leads the worker’s.
  • A test of a pasted connection_url shows what the URL was read as: the answer’s connection holds its fields, the password as its ****last4 hint, on every answer of such a test (a resolve failure included), so you see what a save would store before anything is saved. Absent for every other form of source.
  • In the app, a PostgreSQL source is added field by field and tested before it is saved (Sources, then Add a source): host, port, database, user, password, the TLS mode with each weaker mode’s warning under it, what verifies the server (the system’s store, Amazon RDS and Aurora, an uploaded CA, or one certificate you approve), channel binding and a client certificate, or a pasted connection URL shown as it was read. The test is a checklist of named steps with the server’s own sentence under each; a certificate nothing trusts opens the approval dialog with the chain the server presented and the one to approve marked (Amazon RDS recommended instead for an RDS chain), and a name mismatch offers verify-ca. Each source has a page: its connection, standing warnings, the end date of every certificate it watches with the days left, its approvals with Revoke, a re-test, an edit tested before it is saved, and the addresses to allow, with a copy button. Sources lists every approved certificate in the account; the Alerts page lists an expiring-certificate alert’s certificates; the pipeline form shows its test’s steps. The setup guide is A PostgreSQL source.
  • The worker dials the addresses we checked, never resolving the host again, and every connection to a source or a PostgreSQL destination has TCP keepalive, so a copy whose network path goes silent ends instead of waiting for ever: in about two minutes when nothing the worker sent is still unacknowledged, which is a copy mid-stream, and in about fifteen, the system’s retransmission limit, when a write was in flight.
  • A source can trust one certificate you approve, and present a client certificate. connection.tls.trust = approved with connection.tls.approved_pem, one certificate: a root (a self-signed certificate authority that may sign certificates) becomes the anchor, and its chain and the name are checked as the mode says; any other certificate, the self-signed one PostgreSQL’s own guide makes included, is the server’s own and is matched exactly, its name not checked; an intermediate is refused (certificate_not_approvable). A pipeline whose server then presents another certificate stops rather than connect. connection.client_certificate (certificate_pem, leaf first, and private_key_pem: PKCS#8, PKCS#1 or SEC1, unencrypted; RSA, ECDSA P-256 or P-384, or Ed25519) is presented on every connection a pipeline opens, for a cert line or clientcert=verify-full; the key is write-only and shown as the certificate’s SHA-256, and a key that is not the certificate’s is refused (client_key_mismatch). A certificate whose name is not the role’s, on a password line with clientcert=verify-full, is told as the certificate’s name, not as a wrong password, which is how PostgreSQL words it.
  • The connection test tells a refused certificate for what it is, and shows you the certificates to approve. The tls step fails approval_needed when no authority this connection trusts signed the server’s certificate, and hands back the chain the server presented, leaf first, under details.chain (PresentedCertificate: subject, issuer, SHA-256, dates, whether it is a certificate authority and signed itself, the role an approval of it takes, and the one recommended: the root when the server sent one, which survives its renewals, otherwise its own certificate). Send that certificate’s certificate_pem as connection.tls.approved_pem and test again. name_mismatch names what the certificate lists and offers verify-ca; expired names the date; certificate_changed names the certificate the server presents instead of the one you approved, with its chain. A PostgreSQL destination’s certificate refusals stay certificate_rejected.
  • A pipeline whose source stops presenting the certificate you approved stops, and says which one it saw. Its worker_refused carries certificate: source_certificate_changed with the approved and the presented certificate’s SHA-256, or source_certificate_untrusted with the reason (approval_needed, name_mismatch, expired, certificate_rejected) when no anchor of its trust vouches for what it presents. Test the source, approve the new certificate if it is the server’s own, then start the pipeline again.
  • A source’s certificates are warned about before they expire. A source’s connection shows expiry: every certificate whose end its pipelines watch (the client certificate, each uploaded CA certificate and the approved certificate, each with its subject, SHA-256 and not_after); a server certificate under a CA is not watched, because its CA renews it. A running pipeline tells source_certificate_expiring on its feed, naming each watched certificate under 30 days from its end, then once more under 7, with the days left: at its start and once a day while it runs. It keeps delivering. New alert kind source_certificate_expiring (a warning) on GET /v1/pipelines/{id}/alerts and GET /v1/alerts, with certificates (certificate, subject, sha256, not_after, days_left, threshold): it stands for the certificates the source still has, and ends when you replace them on the source. New notification trigger source_certificate_expiring, on by default for email: told once at 30 days and once more at 7, and its webhook body’s details.certificates names each one. GET /v1/alerts may now return up to 11 more alerts than asked for (one pipeline raises at most 12).
  • A source on Amazon RDS or Aurora can trust Amazon’s own roots. connection.tls.trust = aws_rds (with verify-ca or verify-full; send no certificate with it) verifies the server against Amazon’s RDS and Aurora root certificates, built into the worker and kept current by each release, so an RDS server’s routine certificate rotation never stops a pipeline. The connection test recommends it: a chain an Amazon RDS certificate authority issued carries details.recommended_trust: "aws_rds" and recommends no certificate (a pinned RDS certificate would stop at the next rotation). Uploading Amazon’s bundle as ca_pem is answered with use_aws_rds rather than a size refusal; one RDS root uploaded alone is still a CA like any other.
  • GET /v1/trust lists every certificate your account approved for a source (TrustedCertificate: the source, kind tls_certificate, its role, subject, SHA-256 and expiry, who approved it and when, and the pipelines reading that source), by source, with cursor pagination; a read key may call it. POST /v1/sources/{id}/revoke-trust ({kind, sha256}) removes one without a test: the source then trusts the system store (its mode kept, or verify-full from verify-ca), and every pipeline reading it restarts and stops at the TLS step until a certificate is approved again (it answers the source and those pipelines, as an edit does). Anything but the approved certificate’s exact SHA-256 is 404 trust_not_found and changes nothing. In the audit log as source.trust_revoked.
  • GET /v1/network says where this service connects from: published, the region, each address to allow (cidr, family), any change announced at least 30 days ahead (upcoming), and the families a worker connects in (dial_families); published: false alone when a deployment publishes none (self-hosted). A read key may call it. A source whose host has only IPv6 addresses, where this service connects from IPv4, fails the connection test’s resolve step with ipv6_only, naming the addresses to allow and Supabase’s IPv4 add-on, and a pipeline reading it is not started and is told the same.
  • POST /v1/credentials/{ref}/rotate answers 409 use_source_patch for a source’s field-shaped connection, which changes through its source.
  • A change made while another was being tested is never written over. PATCH /v1/sources/{id}, POST /v1/sources/{id}/revoke-trust and POST /v1/credentials/{ref}/rotate each replace only the connection they read: when another request changed it in the meantime (an edit’s test can take up to 50 seconds), the later one answers 409 source_changed (a source) or 409 credential_changed (a credential), saves nothing and writes no audit row, so a revoked certificate is never sealed again by an edit that began before the revocation. Read it again, and make the change again over what is there now.
  • verify-ca is refused with the system’s trust store, everywhere. It checks the certificate and not its name, so with the operating system’s store any certificate a public CA issued, for any host, would pass; libpq refuses the pair too. connection.tls.mode = verify-ca with trust = system is 422 verify_ca_needs_a_ca (field connection.tls.mode); a pasted connection_url with sslmode=verify-ca is 422 url_not_understood naming sslmode (a URL cannot carry a CA); verify-ca with an uploaded CA, an approved certificate or aws_rds is unchanged. The worker refuses the pair too, for a source and for a PostgreSQL destination’s URL, and so does the MySQL source’s REYANSH_SOURCE_SSLMODE=verify-ca with no CA. A revocation under verify-ca reseals verify-full with the system’s store (shown in the answer, and the source.trust_revoked audit row records the mode it moved from); under any other mode the mode is kept. A name mismatch under the system’s store no longer suggests verify-ca: connect by a name the certificate lists.
  • ⚠ UPGRADE NOTE: a stored connection string with sslmode=verify-ca and no CA of its own now stops. Until this release a source’s or a PostgreSQL destination’s connection string with sslmode=verify-ca and no sslrootcert ran against the system’s trust store, which accepts any certificate a public CA issued, for any host. Such a pipeline is now not started, and its history and its page say why and what to do: a source is edited on its page (the edit reads verify-ca as verify-full, saves the TLS choice you make, and its audit row names tls.mode as changed), or, where the account’s sources are saved field by field, given a CA of its own there (a source whose URL also carries a parameter its page cannot edit, application_name say, has its connection string replaced instead, since its page answers such an edit with 409); a destination’s connection string is replaced with one that says sslmode=verify-full. The same now holds for every TLS parameter a pipeline’s worker refuses in a connection string (an unknown sslmode or channel_binding, sslrootcert naming a file, sslrootcert=system below verify-full, a parameter given twice): the pipeline is not started, and its history says which, where it used to stop with nothing there to read.
  • A stored connection string is read before a launch exactly as the pipeline reads it. The question asked before a pipeline starts now reads the whole string as its worker does (the white space around it set aside, every parameter, the host it dials), held to one corpus of over two thousand strings both are tested against. A string the pipeline runs is never stopped (a line break after sslrootcert=system was “a file path”; a ^ in a password was “could not be read as a URL” for a judged host), and one it would refuse is not started, with the reason in its history (a parameter the connection does not know, no database, an unencoded @), where it used to stop with nothing to read.
  • A connection a pipeline’s worker cannot be handed is refused when it is saved, and never started. A pipeline’s worker receives its connection in its process environment, which cannot carry a NUL byte, reads text only as UTF-8, and on Linux takes at most 128 KiB in one setting. POST /v1/credentials, its rotation, a source saved with its connection and a source’s edit now refuse such a value with 422 value_not_carriable (more than 96 KiB is refused, the cap a source saved field by field already had, whose refusal connection_too_large now names the password and the certificates rather than only the CA certificates), and store nothing; so does the seed tool. One stored before this release is not started, and its history says which limit it breaks, where its worker used to be refused again and again until it was given up on; a connection test of it says so too, rather than “something went wrong at our end”. A connection test of a connection you send judges it as its save would, in the form the save stores it (POST /v1/connections/test answers 422 value_not_carriable past 96 KiB too), so a connection the save refuses never tests green first.
  • A connection URL is stored without the white space around it. POST /v1/credentials and its rotation store a postgres:// or postgresql:// value trimmed (libpq reads no white space around a URL: a line break after it joins the last parameter), so its hint is the URL’s own last characters. Any other value is stored exactly as sent.
  • A source whose connection URL its fields cannot read says so. GET /v1/sources/{id} answers connection_unread: true for a source saved as a connection URL with a parameter the fields have no place for (application_name, say), and for one made from an existing credential’s reference that holds such a URL: its page no longer offers an edit that would be refused with 409 source_url_not_understood, says to create a new source instead, and still warns about a connection in the clear, from the URL’s own sslmode. A source made from a reference whose URL the fields can read shows them, as one saved with its connection does.
  • Every error code the API returns has the app’s own words, chosen for the code; a refusal the app has no words for is told by the answer’s fault and never as a failure of ours. A source whose connection is changed by someone else while an edit or a revocation is tested answers 409 source_changed and is shown again as it is now, the edit kept over it. A rotation of a source’s connection string (POST /v1/credentials/{ref}/rotate) now updates what the source’s page shows, and a connection string the fields cannot read shows none rather than the one it replaced.
  • A server that never proves it holds the password is refused as such (server_unproven, the setup test’s sign-in step), in every channel-binding mode: one that ends the SCRAM sign-in before its proof, or whose proof does not verify. The sentence says whether our own proof had been sent, and so whether the password is worth changing; it is no longer called a bug on our side.
  • GET /v1/me says source_fields_enabled: whether this account’s sources are saved as their fields now. While it is off, the app offers only the system’s trust store and no client certificate (a source is then saved as a connection URL, which carries nothing else), and 422 source_fields_unavailable names Amazon RDS among what cannot be saved yet. A source saved as its connection URL now shows its fields and its standing warning (GET /v1/sources/{id}’s connection and standing_warnings).
  • The OpenAPI document (api/openapi.json) describes PATCH /v1/sources/{id}, the connection and connection_url request fields and the connection and standing_warnings response fields, and the connection test’s connection, connection_url, source_id and connection_changes request fields and its steps (CheckStep, with its details) and source_tls (SourceTLS) response fields, and PresentedCertificate.

2026-10-16 (IST) — Money alerts and a monthly budget, and an empty wallet paused on time

Section titled “2026-10-16 (IST) — Money alerts and a monthly budget, and an empty wallet paused on time”
  • PUT /v1/wallet/alerts (owners, signed in; never an API key) sets the account’s money alerts and monthly budget: low_balance_days (1 to 60, default 7) and low_balance_minor for the low-balance warning, monthly_budget_minor, and budget_action: notify, or stop_new_runs. Every field is required, an amount is null for none, and the change is in the audit log as wallet.alerts_changed. GET /v1/wallet returns them as alerts, with alerts.budget_reached while a budget that stops new runs is reached, and billing_mode is now the mode in force today.
  • A budget that stops new runs stops scheduled runs only. Once this UTC month’s billed net charge reaches it, the scheduled runs of pipelines whose source runs on a schedule are skipped (each pipeline’s history says so once, “Not started: this month’s budget is reached”) and their start is refused 409 budget_reached, until the budget’s stop lifts: next month (UTC), an owner raising the budget above this month’s charges, an owner removing the budget or setting it to tell owners only, or refunds of failed runs bringing this month’s charges back under it (an owner’s change lifts it at once). Pipelines that stream continuously are never stopped by a budget, not even after a restart, and keep costing. The budget is checked against billed days, so the month’s spend can pass it before its stop takes effect (by today’s spend so far, by a day still being measured, and by a run already going): a UTC day’s charges count once that day is billed, at the first hourly check after it ends, or later while its usage is still being measured, as each check retries the last three closed days.
  • An empty prepaid wallet is paused on the next hourly check whatever happened before it. The pause was written only by the pass that charged the day, so a restart between the charge and the pause, or a later pass that charged nothing new, left an empty wallet unpaused. It is now recomputed from the ledger every hour, for every account, and a run that ended in failure, refunded in full, still never pauses a wallet.
  • A paused wallet now skips the scheduled runs of a pipeline already between two runs, as it always said: it stopped only a pipeline that was not yet running.
  • alerts.budget_stops_pipelines (in GET /v1/wallet and the PUT’s answer) says how many of the account’s running pipelines a budget set to stop_new_runs would stop today: those whose source runs on a schedule. The Billing page says it beside the setting, so an owner learns before the cap, not after, that a budget stops none of their streaming pipelines.
  • held_by says what holds the account’s pipelines now: credit (out of credit), budget (a budget that stops new runs is reached), credit_and_budget, or null. It is in GET /v1/wallet (alerts.held_by), the PUT’s answer, GET /v1/overview (spend.held_by), the start’s 409 budget_reached (details.held_by) and every billing webhook’s details, and the Billing page and the overview say it in one sentence. GET /v1/overview’s spend.billing_mode is documented as prepaid or postpaid, as it has answered since the mode in force became readable. held_by, spend.billing_mode and a pipeline’s health are open sets (x-extensible-enum in the API reference): a later release may add a value, which a client should treat as one it does not know rather than as an error.
  • Every billing sentence says what is true in the account it reaches, whichever holds stand. One composer writes what holds the pipelines, what starts them and what a budget step means next, for every notice, the Billing page, the overview and the start’s refusal. A step names the step passed and the share actually spent (“Your charges for October 2026 (UTC) are $11.00: 110% of your $10.00 budget, past the 100% step”); to an owner who chose to stop new runs it says what reaching the budget will do, never that the budget stops nothing; and a budget that stops new runs, reached by one day’s charges, is told once, by the budget-reached notice, with no step beside it. While the account is out of credit AND the budget is reached, every one of them says the scheduled runs wait for both, never that adding credit or raising the budget alone starts them: the reached budget, its end, the out-of-credit notice and its end, the start’s 409 budget_reached. A pipeline’s out-of-credit alert, and the API reference’s description of the out_of_credit health word, no longer say “We stopped it”: nothing running is stopped, and nothing is started while credit is out.
  • A billing email’s footer is true whatever the recovery switch. A billing notice goes to every owner whatever their notification settings, and says so, and says whether the notice that it is over will be sent: that one follows the account’s recovery notifications. The ending notice no longer claims it goes to every owner whatever their settings; it says it came because recovery notifications were on when it ended.
  • A Slack message says why that channel got it. A channel hears the end of a notice by its own recovery switch, whatever the account’s recovery email says, and a billing end posted to Slack said “it was sent again on request: recovery notifications were off for your account”, which nobody had asked. Every Slack message now gives the channel’s reason: an end, that recovery notifications were on for the channel when it ended; any other message, that the channel’s settings include it (a billing notice: that it concerns your account’s billing).
  • Out of credit lasts until credit brings the balance above zero, with the one exception below, and every sentence says so. An account usually runs out below zero, by a billed day’s charges, so credit smaller than the deficit starts nothing; the notices, the Billing page and the start’s refusal promised that adding credit would. They now say credit must bring the balance above zero, and every billing email sent while the account is out of credit names the balance.
  • A new health word, budget_reached: a monthly budget set to stop new runs is reached, and the pipeline’s source runs on a schedule, so its scheduled runs wait. Such a pipeline read delayed (“Behind schedule”), and was alerted and emailed as a sync that “may be a long run rather than a failed one”, while its runs were simply not started. It now reads “Budget reached”, its alert says the budget holds it (an error, as out-of-credit’s is), and no late-sync alert or email is raised for it. out_of_credit still leads when the account is out of credit too; a pipeline that streams continuously never reads budget_reached. The pipeline list’s health filter takes it.
  • A low-balance warning ended because the account became invoiced monthly says so, rather than “Your balance is no longer low”.
  • A late-sync email after a hold lifted says what the run since is doing. It said the pipeline’s runs were not started while the account was out of credit or the budget was reached, “and nothing holds them now: it runs again at its next scheduled time”, while the first run after the lift was often already going. It now says that only when no run has been tried since; a run going since is said as one (“it may be a long run rather than a failed one”), and a run tried since that failed as failed, in every order the worker and the supervisor write it: a start refused before its run opened, a refusal written before anything else, a re-entry’s refusal, a restart the supervisor is waiting to make, a launch whose credential read failed before any worker ran, and a give-up. A start whose first record is all there is so far is said as going. The Slack message says the same.
  • The end of an out-of-credit notice says what ended it: credit (“Your account has credit again.”), the account becoming invoiced monthly, or refunds of failed runs that brought an account that has never had a top-up, a credit grant or a paid invoice back to zero. It said “Your account has credit again.” for all three, at a negative balance after the account became invoiced. And when a charge has taken the balance back to zero or below since the pause was lifted, the end names the balance, says the account is paused again at its next hourly check, and lists what keeps it unpaused before then: credit bringing the balance above zero, or, for an account that has never had a top-up, a credit grant or a paid invoice, refunds of failed runs bringing it back to zero (such an account is not paused at zero).
  • Out of credit names its one exception to “above zero”. An account that has never had a top-up, a credit grant or a paid invoice stops waiting for credit once refunds of failed runs bring its balance back to zero (a failed run is free, and never pauses a wallet), and every out-of-credit sentence, the Billing page, the start’s refusal and the API reference’s held_by now say so in those words. An account given a credit grant is not one of them, and is never told it is. The rule itself is unchanged.
  • A test of a billing notice shows an account that could be in that state. The out-of-credit test (POST /v1/notification-settings/test with out_of_credit, and a channel’s test) shows a balance below zero, where the pause holds, and every billing test, by email, to Slack or to a webhook, describes a balance, a month’s charges and a hold that a real account’s ledger can hold together.
  • resolved_by names every way each billing notice ends (GET /v1/notification-triggers, and the notifications guide in the same words). out_of_credit said “credit added (the wallet no longer paused)”, which credit smaller than the amount below zero does not do; it now names credit bringing the balance above zero, the account becoming invoiced monthly, and refunds of failed runs bringing an account that has never had a top-up, a credit grant or a paid invoice back to zero. The three new notices name theirs whole: low_balance the balance lasting long enough and above the amount, or the account becoming invoiced monthly; spend_threshold the next UTC month, the budget removed, or a higher step; budget_reached every way the budget’s stop lifts. Each way is proved by the dispatcher itself taking it.
  • Every money message opens with one short sentence, then a list of what starts the pipelines again (2026-10-17 (IST)): the Billing page’s banner and the overview, and every billing email (text, HTML and Slack). The start’s 409 budget_reached names what holds the pipeline and points to the Billing page, which lists every way. A billing email reads the account’s ledger, so it states the exception for an account that has never had a top-up, a credit grant or a paid invoice only to such an account, and the budget-reached email says once that a budget never stops a pipeline that streams.
  • The budget-reached notice lists the pipelines that stream continuously, each with what it was charged this month (2026-10-17 (IST)): up to 20, then “and more”. When a running pipeline could not be told apart as one that streams (a source kind it does not know, or more running pipelines than it reads), the list ends “(possibly others)” rather than claiming that more streams run, or, when the notice can name none, it names none and says they keep running and costing. The webhook’s details carry continuous_pipelines, with continuous_pipelines_truncated when the list was cut and continuous_pipelines_partial when it may miss a running pipeline it could not tell apart as one that streams, also when it names none; with neither the list nor that flag, no pipeline that streams is running.
  • GET /v1/usage/days says which amounts are read from the ledger (2026-10-17 (IST)): charged_minor, refunded_minor and a failed run’s credited_minor are, net_minor is the first less the second, and estimated_minor, amount_minor_decimal and pending_minor are computed. Its description said money was read from the ledger, never recomputed. No amount changed.

2026-10-16 (IST) — Event webhooks: a webhook can be told what happened, not only what is wrong

Section titled “2026-10-16 (IST) — Event webhooks: a webhook can be told what happened, not only what is wrong”
  • A webhook channel can subscribe to events (events on POST and PUT /v1/notification-channels): sync.started and sync.ended, table.copied, table.parked, schema.changed, connection_test.succeeded and .failed, and every action of the audit log (pipeline.created, pipeline.schedule_changed, api_key.created, member.removed, …), by exact type, by noun.*, or *. Fivetran’s sixteen events map onto them (the guide has the table). A subscription is sent only what happens after it is saved; a type kept by an edit keeps delivering without a gap, whatever pattern takes it now, and a pipeline added to the channel’s filter is sent only what happens after it is added (a channel’s events_since says from when each pattern is sent, and events_pipelines_since from when each pipeline is). Slack channels take no events (422 events_not_for_slack); a type that is not one is 422 unknown_event_type, naming it.
  • GET /v1/notification-event-types lists every type, where it comes from, and Fivetran’s name for it.
  • An event’s body is {"id", "type", "version": 1, "created_at", "test", "account_id", "pipeline", "sequence", "data"}, under 16 KB, signed in both schemes exactly as an alert is, retried on the same schedule, listed in the history and resendable. It never carries a row’s value, a secret (a changed credential is {"changed": true}), or a person’s address or browser. Delivered at least once and in no promised order: dedupe on id, and order a pipeline’s events by sequence (increasing, with gaps).
  • POST /v1/notification-channels/{id}/test takes event_type and sends a sample of that event, marked "test": true.
  • GET /v1/notifications takes phase (repeatable: raised, resolved, test, occurred). Events are listed only when phase=occurred is asked for, or when trigger names an event type (then its events and tests), so the default page is unchanged for every existing client; an event’s alert_id is null. A phase a trigger never has (trigger=sync.ended&phase=raised) is 422 phase_not_for_trigger, never an empty page.
  • An item’s phase in GET /v1/notifications is an open set (x-extensible-enum in the API reference, as health, held_by and billing_mode are), and occurred and a null alert_id reach only a client that asks for events (phase=occurred, or a trigger that is an event type); a later phase should be treated as one a client does not know rather than as an error.
  • Events are delivered as fast as the receiver answers. Each webhook’s events wait in their own queue, apart from its alerts, and are sent one at a time, oldest first, for up to 40 seconds of every minute: a webhook’s ceiling is 40 s divided by its receiver’s answer time plus about 10 ms of ours per event (about 150 a minute at a quarter of a second, 78 to 80 at half a second). A webhook’s alerts never wait behind its events.
  • Webhooks share the sending fairly. Up to four webhooks of an account are sent at once, and a turn that ends early goes at once to the next webhook waiting. A webhook with nothing due (its deliveries all wait for a retry) takes no turn, and one whose receiver is failing is sent after every webhook whose receiver answers, so neither can hold back one that answers: beside nineteen failing webhooks, or thirty other accounts’ idle ones, an answering webhook at forty events a minute is sent everything every minute. A failing webhook is still tried every minute while the answering ones leave a lane free, and waits its turn behind them when they need all four. A slow receiver holds a lane for as long as it takes to answer (up to 15 seconds an event). The guide states when a webhook keeps up (“Keeping up”).
  • Self-hosted: REYANSH_NOTIFY_CHANNEL_POOL sets how many webhook and Slack lanes are sent at once (32 by default, three quarters for events; at least 2, because one is always kept for alerts: 1 is refused at boot, saying so); the boot banner states it.
  • A pipeline whose worker keeps crashing tells one story. Each restart is a run of its own (a new run id); when the restarts are given up on, every attempt still open ends, in the run history (GET /v1/pipelines/{id}/runs: partial or failed, the last one with the reason) and on the webhook alike: each is told its own sync.ended (failed; the last one, the attempt whose worker process started last, with the reason, also when it died before its sync.started, copying a table or waiting for one; the earlier ones dated at their own last events, the last ones carrying their own run ids: what we write ourselves carries none, a relaunch or your own edit while it crash-loops included, so it is shown in the newest attempt’s run while that one has not ended; of it, only the give-up ends a run, and nothing else moves a run’s start, end or duration_ms). Before, the earlier attempts read as running for ever. This changes existing histories too, and more than crash loops: an attempt left open by an earlier restart that was not given up on (its next attempt ran fine) is ended by the pipeline’s next give-up within 30 days, dated in the history at its own last event, and told sync.ended (failed, no reason) then, so that event’s created_at (when the ending became known) can be days after the attempt stopped.
  • A run that began before a page of the run history is read as the whole run. A page (up to 20,000 events within the 30 days) no longer shows a run that ended before it as still running (a cleanly stopped run whose last meter window opened the page read as running), and nothing on it ends that run again, a give-up included: the run is told one sync.ended, its own. A run that began before the page keeps its outcome (partial when it moved rows before the page and then failed), shows no start or counts unless the page holds its start and every row it moved (a run whose copy lay before the page showed the page’s rows as its total), and a session says when it last wrote even when that was before the page. A run whose start the page holds, and nothing it moved before, still shows both.
  • An event’s delivery can be resent from the history after its webhook is switched back on, which is what the channel_disabled email tells an owner to do.
  • A webhook disabled for failing says whether the deliveries that failed were events (failed_on in the channel_disabled body: events, alerts or both).

2026-10-15 (IST) — Re-adding a table as told keeps its row filter, touches no table that inherits from it, and never sends a column you left out

Section titled “2026-10-15 (IST) — Re-adding a table as told keeps its row filter, touches no table that inherits from it, and never sends a column you left out”
  • Fixed: the words that tell you to take a table out of its publication and add it back named no row filter. A column added outside the publication’s column list (not_sent), a column or key the list withholds, and a column list under REPLICA IDENTITY FULL are each told as such a re-add, and followed as told it removed the table’s row filter: the rows the filter left out were then published and synced. Every re-add now names the filter, exactly as your database prints it, and keeps it; only the fix for a filter that stops the pipeline removes it, and says so. If you followed one of these before, the table’s entry has no filter now: to put it back, take the table out of the publication and add it back naming it ONLY both times, with its column list as it is now and your WHERE clause, in one transaction. The rows already synced from outside the filter stay in the destination until you copy the table again.
  • Fixed: those words did not say to name the table ONLY. Without it, taking an inheritance parent out of the publication is refused when its child is not in it, and adding it back publishes the child as well, whose UPDATE and DELETE your database then refuses when it has no primary key. Every re-add now says ONLY.
  • Fixed: on PostgreSQL 18 under publish_generated_columns = stored, a re-add could drop a column list that left a stored generated column out, and with no list your database sends every stored generated column. The list is now kept, so a column you left out stays out.
  • Changed: a key that holds a generated column is told that PostgreSQL 17 or earlier cannot publish it at all (give the table a primary key that is not DEFERRABLE, or a replica identity index, on columns that are not generated; your database then refuses the table’s UPDATE and DELETE while a publication’s column list for it leaves out a column of that key, or its row filter reads a column outside it), and on 18 or later how to re-add the table naming that column, or, only where the table’s entry has no column list (a list overrides the option), to have the publication send stored generated columns.
  • Changed: a table with REPLICA IDENTITY FULL and a VIRTUAL generated column is told, on PostgreSQL 18, that no publication sends a VIRTUAL column, so only dropping that column, adding it again as STORED, or another replica identity lets your database take its UPDATE and DELETE; it is no longer told to re-add the table without its column list, which publishes every column and still leaves them refused.
  • Changed: the re-add for a column list under REPLICA IDENTITY FULL says it then sends every column, the ones the list left out included; and every text advising publish_via_partition_root says that with it on, a row filter the publication has for a partition by its own name no longer applies.

2026-10-15 (IST) — A table with no primary key: what a pipeline that copies nothing does with it, and a wait an earlier release left, told true

Section titled “2026-10-15 (IST) — A table with no primary key: what a pipeline that copies nothing does with it, and a wait an earlier release left, told true”
  • Fixed: the tables guide said a table with no primary key is parked at the first start of a pipeline created without copying existing rows, and to add a key. It is not: one that syncs every change syncs from that first start, and one that syncs new rows only may wait, needing nothing from you, then syncs the rows inserted from then on. Neither is copied. Only a table that would wait for a change at your source is parked there, and resuming it copies it. A primary key added for nothing takes an ACCESS EXCLUSIVE lock and builds an index.
  • Fixed: a table an earlier release left waiting key was told to add a primary key, on its row, in the refusal of a purge asked of it, and in the API’s description of waiting.reason, and its row promised that it is “copied by itself within about a minute”, which a stopped pipeline never does. A table with no primary key is now synced by its whole row, and nothing waits key any more: such a row is judged again at the pipeline’s next start, and every surface now says so (a running pipeline: stop it and start it again to have the table judged now). Nothing needs to be run on your source.
  • Fixed: where the table’s root is in a schema the publication publishes, the refusal of the statement that turns publish_via_partition_root on named “the publication’s entry for” the root, which the publication does not have. It now names the entry PostgreSQL judges by: the one for the root’s schema.
  • Corrected: two earlier entries print advice not to follow as written. The 2026-10-07 (IST) entry on a partitioned table published without publish_via_partition_root prints the statement that turns the option on with no check: on PostgreSQL 18 or later, turning it on can make your database refuse a partition’s UPDATE and DELETE, where a partition the publication also lists by its own name has a generated column in its replica identity that only its own column list sent. Run the statement the table’s row shows instead, which changes nothing there and says why (the 2026-10-14 (IST) entry below). The 2026-10-03 (IST) entry says a DEFERRABLE primary key needs REPLICA IDENTITY FULL first; your database still refuses UPDATE and DELETE under FULL while a publication that sends them has a column list for the table, or, on PostgreSQL 18 or later, does not send one of its generated columns. Use the statement the setup or the table’s row shows, which changes nothing there and says why. The same holds of the 2026-09-25 (IST) entries that name REPLICA IDENTITY FULL as the fix for a key change or for an old row sent in part, and the 2026-09-26 (IST) entry prints the statement that added a table back to its publication with no check: add a table back with the statement its row shows, which checks it first.

2026-10-15 (IST) — A statement that re-adds a table to your publication keeps your row filter

Section titled “2026-10-15 (IST) — A statement that re-adds a table to your publication keeps your row filter”
  • The statement told when your source adds a column that the publication’s column list does not send now keeps the table’s row filter, printed exactly as your database shows it, and says so. Since v0.1.63 it took the table out of the publication and added it back with no WHERE, so running it as given removed your row filter, and the rows you had filtered out were sent and synced. If you ran such a statement on a table with a row filter, check the table’s entry (SELECT rowfilter FROM pg_publication_tables WHERE pubname = ... AND tablename = ...) and set the filter again. Setting it again stops new rows outside the filter from being sent; the rows outside it that were already synced stay in the destination until you remove them there.
  • The same holds for every other statement that re-adds a table: a column the destination needs, a key the list leaves out, and a column list under REPLICA IDENTITY FULL. A statement that is the fix for the row filter itself still removes it, and says so.
  • On PostgreSQL 18, a re-add keeps a STORED generated column the column list sends. It named only columns that are not generated, so where the table’s key or replica identity index holds such a column, your database refused the table’s UPDATE and DELETE after it ran. And it never replaces a column list by none where none would send a generated column you left out (publish_generated_columns = stored).
  • Every re-add names ONLY, so it touches the one table’s entry and no inheritance child’s. Without it, the statement was refused on a parent whose child is not in the publication.

2026-10-15 (IST) — A resumed table that has reached its end keeps every row; Sync now waits for it

Section titled “2026-10-15 (IST) — A resumed table that has reached its end keeps every row; Sync now waits for it”
  • Data loss fixed: a table you resumed after it stopped, which the pipeline then finds at its end (taken out of your publication, dropped or renamed), is stopped only once every change made to it before then is written. Since v0.1.63, when such a table’s catch-up spanned more than one write (a large transaction elsewhere in your database between where it stopped and its last changes), it could be stopped after the first write: the changes after it were never written, while its message said every change had arrived. How to tell whether it happened to you: the table stopped within a few seconds of your resume, with a message saying every change before its end reached the destination. Adding it back and resuming it copies it again, which restores the missing rows.
  • Sync now no longer reads done while a table you resumed is still catching up. Since v0.1.66 it could read handled with that table’s latest rows not yet at your destination; they arrived only at the pipeline’s next scheduled write. It now reads done once every table holds everything received up to your press.

2026-10-15 (IST) — On a quiet database: Sync now finishes, a new column is filled, a removed table is told

Section titled “2026-10-15 (IST) — On a quiet database: Sync now finishes, a new column is filled, a removed table is told”
  • Sync now finishes on a pipeline whose source database is quiet. Since v0.1.66 a press of Sync now could read “not handled” for as long as your database wrote nothing more, although everything up to the press had been written.
  • A column you add on a quiet database gets its existing values copied. Since v0.1.63 the new column could read empty (NULL) in every existing row at your destination until your database wrote something else. No row was lost. A destination an earlier release left like that is filled when the pipeline next starts.
  • A table taken out of your publication on a quiet database is shown as stopped, saying why, instead of as syncing while nothing of it arrived (since v0.1.63).
  • A held table whose place was let go releases your database’s change log on a quiet database too (since v0.1.53 the replication slot could stay behind until the next write).
  • A type change or a column removal your pipeline applies on its own is recorded as done on a quiet database, instead of waiting for the next write.

2026-10-15 (IST) — A resumed table reads streaming again on a quiet database

Section titled “2026-10-15 (IST) — A resumed table reads streaming again on a quiet database”
  • A table you resumed after it stopped (a schema change you answered, a busy destination table, a row filter you answered) now reads streaming once it has caught up, even when your source database writes nothing more. Since v0.1.53 it could read catching up for as long as the source stayed quiet, though every row had been written: the status was false, and no data was missing. Anything waiting for that table to stream (a sync mode change, a new column’s existing values being copied) waited with it. It cleared by itself at the next write to your database.

2026-10-14 (IST) — Turning on publish_via_partition_root refuses where it would make a partition’s writes refused; the guides print no statement of their own

Section titled “2026-10-14 (IST) — Turning on publish_via_partition_root refuses where it would make a partition’s writes refused; the guides print no statement of their own”
  • On PostgreSQL 18 or later, the statement that turns on the pipeline’s publication’s publish_via_partition_root option, shown for a partitioned table waiting root_sent_as_partitions, now changes nothing, and says why, where turning the option on would leave your database refusing a partition’s UPDATE and DELETE. With the option on, a partition is judged without the column list the publication gives it by its own name, so a partition keyed by a STORED generated column that only that list sent had its UPDATE and DELETE refused once the option was on: the statement did that before. The words beside it (the table’s row, its history, the API’s purge refusal and its description of waiting, the tables guide) and a start’s own refusal for such a table say so too.
  • A refusal of the statement that gives a table REPLICA IDENTITY FULL names only the writes the publication would refuse: a publication that sends updates but not deletes refuses the UPDATE alone, and the words said both.
  • A partition told to take its table’s key (leaf_identity) is told when that identity would itself be refused: a column list that leaves out a column of it, or, on PostgreSQL 18 or later, a generated column the publication does not send.
  • The guides print no statement of their own. The guide to deleting a pipeline printed an old copy of the query that sets a table back to REPLICA IDENTITY DEFAULT, which, for a partition another publication sends through its table, printed a statement that made your database refuse that partition’s UPDATE and DELETE. It now points to the query the deleted pipeline’s page shows (the API’s source_cleanup.identity_reset.check), which does not. The schema-change guide’s statement for sending truncates is words now, with the warning that adding updates or deletes to a publication makes your database refuse them on a table it lists with no replica identity, and the tables guide says how a table without a key syncs (by the whole row: every change, or new rows only).

2026-10-14 (IST) — A partitioned table its publication sends under its partitions’ names is told so; advice about REPLICA IDENTITY FULL says when it is still refused

Section titled “2026-10-14 (IST) — A partitioned table its publication sends under its partitions’ names is told so; advice about REPLICA IDENTITY FULL says when it is still refused”
  • A partitioned table the pipeline’s publication lists, but sends under each partition’s name because the publication’s publish_via_partition_root option is off, now waits with its own reason, root_sent_as_partitions (waiting.reason, the table’s row, the history, the API’s purge refusal), keyed or not, and its row’s waiting.statement turns the option on (the setting the pipeline’s publication is created with). Before, a table with no primary key was told that neither of the pipeline’s publications lists it, and offered a statement whose ADD TABLE the publication already held, so it never synced; a keyed one was shown “the source does not publish it yet” and a statement that left it as it was. On PostgreSQL 18 or later the statement changes nothing, and says why, where turning the option on would make your database refuse a partition’s writes (the entry above); a partition the publication also lists by its own name is then sent under its table’s name too, which the words say. A table with no primary key that syncs and then finds the option off is parked with the same truth, and a resume copies it again.
  • Every sentence that advises REPLICA IDENTITY FULL now says when PostgreSQL still refuses a table’s UPDATE and DELETE under it (a publication that sends them has a column list for it; on PostgreSQL 18 or later, one does not send one of its generated columns), or points to the statement the table’s row or the setup shows, which changes nothing and says why in exactly those cases: a published table with no replica identity, a DEFAULT identity with no primary key, a DEFERRABLE primary key, a key change whose new key the change did not carry, a keyless table’s waits, the new-pipeline form’s words beside its statements and their costs, the API’s description of waiting.reason, and the guide to deleting a pipeline.

2026-10-14 (IST) — A statement offered for a table refuses where its identity would still refuse your writes, and says why

Section titled “2026-10-14 (IST) — A statement offered for a table refuses where its identity would still refuse your writes, and says why”
  • The statement that gives a table REPLICA IDENTITY FULL and publishes it now refuses, changing nothing, where FULL itself would make a publication refuse the table’s UPDATE and DELETE: while a publication that sends them has a column list for the table or for a table it is a partition of (PostgreSQL 15 and later), and on PostgreSQL 18 or later while a publication that sends them does not send one of the table’s generated columns (a VIRTUAL one is never sent; a STORED one only under publish_generated_columns = stored). Before, such a table, or a partition that kept its own primary key beside a generated column, was given FULL and published, and its writes were then refused. The same holds for the statement a waiting table’s row shows for its identity alone.
  • The checked ADD TABLE names what each table or partition lacks: no primary key, a DEFERRABLE one, REPLICA IDENTITY NOTHING, an identity index that no longer exists, or (18) a replica identity holding a generated column the publication does not send; and its hint offers only what works for it (REPLICA IDENTITY DEFAULT where a primary key is there to use, the key re-created NOT DEFERRABLE, FULL only where it would be accepted). It said “has no primary key” for all of them, and adding a primary key changes nothing for the last three.
  • A deleted pipeline’s identity reset (identity_reset.check) counts a partition as still sent when a publication sends a table it is a partition of, and covers each partition of a selected table. It printed REPLICA IDENTITY DEFAULT for a partition whose root another publication sends via the root, after which, with no primary key, the partition’s writes were refused; and a partitioned table’s partitions stayed FULL.
  • No sentence from a pipeline carries a statement for your source any more; each says what to change and, for a table’s way into a publication or its replica identity, points to the statement the setup, the pipeline’s page or the table’s row shows (the one generator above). This covers a key change’s park on a table that left its publication (its own statement adding the table back, run as given, published a table with no replica identity and your database refused its UPDATE and DELETE), the initial copy’s and a fill’s “not covered by publication”, a narrowed publication (the publish kinds, a row filter, a column list), a column list under FULL, unsent generated columns, a partitioned table sent under its partitions’ names, a partition whose identity does not carry its table’s key, and a keyless table’s hazard and waits. Where the change has a cost, the words say it: a column list is refused under REPLICA IDENTITY FULL; once a publication publishes updates and deletes, a table it lists with no usable replica identity has every UPDATE and DELETE refused.

2026-10-14 (IST) — Every statement offered for a table’s publication keeps your writes working, by its own check

Section titled “2026-10-14 (IST) — Every statement offered for a table’s publication keeps your writes working, by its own check”
  • Each table’s statement in SourceSetup.statements is now ONE DO block, from one generator on the server, on every surface that shows one: a connection test, a create, a pipeline’s page, a full re-sync’s new names (GET /v1/pipelines/{id}/new-source-names) and its answer, and an add’s answer. It names the table by string constants, quoted as an identifier on your source (format('%I.%I', ...)), and carries no comment: a table name that held a newline could end a -- comment the statements carried and run the rest of itself as SQL.
  • A table no start has found with no usable key (a create, a table added for the first time, a keyed table) is added (ADD TABLE ONLY) only if the table and each of its partitions has a replica identity on your source when the statement runs; otherwise the statement changes nothing and raises an error saying why. Published without one, PostgreSQL refuses every UPDATE and DELETE of the table, or of the partition. It was added unchecked.
  • A table a start found with no usable key is given REPLICA IDENTITY FULL, on it and on each of its partitions, and then added, in one transaction: if any part fails, nothing changed. The two separate statements it was offered could be run apart (psql goes on after an error, so a FULL that gave up on its lock left the ADD TABLE after it to publish the table with no identity), and a partitioned table’s partitions kept none.
  • The statement bounds its own lock wait: it waits at most 5 seconds for each ACCESS EXCLUSIVE lock (SET LOCAL lock_timeout) and gives up whole. The app no longer asks you to run SET lock_timeout first. A table the publication already lists is not added again, so running a statement twice does no harm, and a table published with no identity is given one by running its statement.
  • TableWaiting.statement for keyless_publication is now that one statement (it was empty), and for keyless_unchecked_writes and keyless_root_identity it gives the table and each of its partitions FULL. The pipeline’s history, a park for a table that left its publication, and a purge’s refusal no longer carry an ADD TABLE of their own: they name the statement the table’s row and the setup (a connection test’s, or the pipeline page’s) show. The one they carried had no ONLY, so an inheritance parent brought its children, published with no identity.
  • What REPLICA IDENTITY FULL costs is said beside every statement that sets it: the pipeline page’s source setup, an add’s answer and a waiting table’s row, as the create step and the re-sync already did.
  • The offer to add a table with no primary key to the pipeline’s new-rows-only publication is withdrawn until a pipeline can have one, so that it can say how to create that publication safely.

2026-10-14 (IST) — Tables with no primary key: never offered a statement that breaks their writes

Section titled “2026-10-14 (IST) — Tables with no primary key: never offered a statement that breaks their writes”
  • TableWaiting.reason gains keyless_new_rows and keyless_publication. A table with no primary key that the pipeline’s new-rows-only publication lists, and that the pipeline can read only from a point after it found that publication, now waits keyless_new_rows: it is published, nothing needs to be run, and the pipeline starts syncing it by itself. It was told “the source does not publish it yet. Run this on your source”, under publication. A table with no primary key or replica identity in neither of the pipeline’s publications, or a name no table on the source has, waits keyless_publication, and its row serves the one statement that keeps its writes working (the entry above).
  • TableWaiting.statement is the publication’s ADD TABLE only for publication, which now means a table whose key the pipeline read (checked again on the source: the entry above). Every reason but the four the entry above names, and a table no start has judged yet, is served an empty statement. Run on a table with no primary key and no REPLICA IDENTITY FULL, the statement adding it to the publication makes PostgreSQL refuse every UPDATE and DELETE of that table, so it is never offered for one.
  • The source setup on a pipeline’s page, and an added table’s statements, now say first what publishing a table with no usable key does, as the create step does.
  • SourceSetup.statements give a table the pipeline read with no usable key REPLICA IDENTITY FULL wherever a start has read the table: the pipeline’s source setup, a full re-sync’s new names and its answer, and a table added back (how, the entry above). They offered the ADD TABLE alone, which makes PostgreSQL refuse every UPDATE and DELETE of such a table. A table with no key that syncs new rows only is not listed, because its new-rows-only publication lists it. The full re-sync’s two statement blocks in the app now say first what publishing a table with no usable key does, and what FULL costs, as the create step does. The field’s description warns API clients of the same.
  • A start-from-now pipeline whose new-rows-only publication could not be settled at its first start (a write transaction left open past it) keeps every row inserted into such a table from the point where the running pipeline sees that transaction end, and says so; it lost the rows inserted between that point and the moment the table was taken up.
  • A waiting table’s hold on the source’s log is let go when the source runs short of room for it, as a parked table’s is, and told: the rows inserted into it until the pipeline reads it are not synced. A table taken out of its publication before it was taken up no longer keeps the source’s log without bound.
  • The feed’s title for a wait reads “A table is waiting to sync”, and the waits of a table with no primary key no longer promise “within about a minute”, or a restart, of a pipeline that is stopped.

2026-10-14 (IST) — Tables with no primary key: each way such a table waits says what lifts it

Section titled “2026-10-14 (IST) — Tables with no primary key: each way such a table waits says what lifts it”
  • TableWaiting.reason gains four values for a table with no primary key: keyless_standby (its first copy must be read from the source’s primary), keyless_unchecked_writes (the source’s release lets an upsert’s or a MERGE’s update or delete past the refusal of a table published as it is), copy_lock (another session held a lock on it past the copy’s bound) and keyless_root_identity (a partition sends whole old rows while the table does not). The app names each, with its remedy.
  • TableWaiting.statement is the statement that lifts the wait, where one does: for keyless_unchecked_writes and keyless_root_identity, the one that gives the table and each of its partitions REPLICA IDENTITY FULL (or changes nothing and says why, where your database would still refuse its UPDATE and DELETE), and empty for keyless_standby and copy_lock. It was the statement that adds the table to the pipeline’s publication for every reason, which lifts none of these. Every other reason is unchanged.
  • copy_lock is tried again by the pipeline on its own: TableWaiting.retry says when (about once a minute while the pipeline runs; a third time in a row parks the table), and a purge is no longer refused on such a table.
  • TableKey.source is documented as what it is: the replica identity’s letter (d, i, f) as the pipeline recorded it, or row_hash for a table with no primary key. The document listed primary_key, replica_identity and none, which a pipeline table’s key has not carried.

2026-10-14 (IST) — Tables with no primary key: a destination table holding another pipeline’s rows is never written over silently

Section titled “2026-10-14 (IST) — Tables with no primary key: a destination table holding another pipeline’s rows is never written over silently”
  • A table with no primary key now stops, released, before anything is written to it, when its destination table holds rows this pipeline did not write whose place in the source’s change log is at or past the pipeline’s first change to it. Before, such rows (left by another pipeline, or by a server restored from a dump) were taken for the pipeline’s own, and the changes up to them were skipped as already written. The table’s sentence says: “…its destination table already holds rows this pipeline did not write: this pipeline has written nothing to it, and the last of those rows was written at a point in the source’s change log at or past this pipeline’s first change to it … Drop or rename that destination table, or keep it: resuming it copies it again, “ and what that copy does with the rows the destination holds, by the table’s facts (corrected in place 2026-10-17 (IST): it said “let a copy replace what it holds”; and 2026-10-18 (IST), KM15: it said “replacing what your destination holds” of every table, and a table kept in soft delete is copied keeping them, marking the ones its source no longer has). Rows left there from before the pipeline’s first change are kept and written on top, as before.

2026-10-14 (IST) — Tables with no primary key: a pipeline that syncs changes from now on keeps every row inserted since its first start

Section titled “2026-10-14 (IST) — Tables with no primary key: a pipeline that syncs changes from now on keeps every row inserted since its first start”
  • A table with no primary key that syncs new rows only, on a pipeline that syncs changes from now on, now keeps every row inserted into it since the pipeline’s first start. While the pipeline cannot read it yet, it holds its place in the source’s log from the point where it can, and when it reads the table it syncs from there. Its waiting sentence now says: “Nothing of it is copied, because this pipeline syncs changes from its first start on. The rows inserted into it from the point where the pipeline could read the publication on are kept for it and synced when the pipeline reads it; rows inserted before that point are not synced.” Before (the entry below, the same day), the rows inserted between the pipeline’s first start and the moment it read the table were lost.
  • Such a table that gains a primary key while it waits is never copied or charged: it syncs from where it waited, as it would have.

2026-10-14 (IST) — Tables with no primary key: a pipeline that syncs changes from now on, and a source that lost its money locale

Section titled “2026-10-14 (IST) — Tables with no primary key: a pipeline that syncs changes from now on, and a source that lost its money locale”
  • A pipeline that syncs changes from now on no longer pauses its tables with no primary key that sync new rows only. At its first run such a table waits, told: “Nothing of it is copied, because this pipeline syncs changes from its first start on: it syncs the rows inserted into it from the start that reads it, and rows inserted into it before then are not synced”. The pipeline starts again by itself once it can read the table, which then syncs its new rows, with no copy and no charge. Before, it was paused for good, told it would be read from the next start, and resuming it copied the existing rows you had chosen not to copy. (Corrected the same day, in the entry above: the rows inserted while it waited are now kept.)
  • A copy the product makes to repair a table is never charged, even if the table is paused while it runs. Resuming such a table finishes the same repair, free. Before, the resume was charged as a copy you had asked for.
  • A partitioned table with no primary key whose root’s replica identity was not full while it streamed is copied again, free, once the root is full, instead of being paused with a promise that nothing was lost.
  • Clearer words: a table that syncs new rows only and waits behind another paused table now names that table; when the new-rows-only publication disappears, the pipeline says what happens whether it was recreated or is gone; and the “copy waited for a lock” sentence no longer carries runs of spaces.
  • A pipeline whose tables all have a primary key is never stopped by its source’s money locale. Only a pipeline that syncs a table with no primary key records the source’s lc_monetary and renders money values under it. If the source’s server no longer has that locale, the stop now names a second way out: ask for a full re-sync of the pipeline, which records the source’s own setting again and copies every table under it.

2026-10-14 (IST) — Tables with no primary key: a move to new rows only, and a destination table another pipeline wrote

Section titled “2026-10-14 (IST) — Tables with no primary key: a move to new rows only, and a destination table another pipeline wrote”
  • Moving a table with no primary key to the new-rows-only publication no longer stops it. If the pipeline was still behind when you moved it, the updates and deletes you made before the move are applied first, then the table syncs new rows only, with no copy. You are told once, after those changes are in: “It was moved to the new-rows-only publication alone, so since the move only the rows inserted into it are synced”. Before, such a table could be paused and told, wrongly, that it had been put back in a publication that sends every change.
  • A table with no primary key whose destination table already holds rows this pipeline did not write is paused before anything is written, with destination_table_unusable and a sentence saying so. Before, if those rows came from another pipeline that had read further (or from a source restored to another server), every change could be taken as already applied and dropped without a word. Drop or rename that destination table, or keep it and resume the table: resuming copies it, which replaces what the destination table holds.
  • On Snowflake, a table with no primary key can be copied and can change shape. Copying one used to restart the whole pipeline again and again without a word, and a column added to one while it synced did the same. A column whose type changed while the pipeline was stopped, in a way that can change how its values are written, now pauses the table, told that it must be copied again (its rows’ identities changed); resuming it copies it. It used to be paused with a promise that resuming would carry the change on, which never happened.

2026-10-14 (IST), updated 2026-10-15 (IST) — A table taken up while a transaction was writing it keeps that transaction’s writes

Section titled “2026-10-14 (IST), updated 2026-10-15 (IST) — A table taken up while a transaction was writing it keeps that transaction’s writes”
  • A copy now waits for every transaction that may have written to its table before the table was published. A transaction that wrote to a table before the table was added to the pipeline’s publication, and committed after, had those earlier writes (inserts, updates and deletes) never sent by PostgreSQL; if the table’s copy was taken while that transaction was still open, they were lost, and the table read as syncing normally. This could happen to a table added to a running pipeline (since v0.1.53) and to a first copy over a replication slot created before the table was published. Every copy and every refresh of a column’s existing values now first waits for each transaction that holds a lock writing to the table takes (ROW EXCLUSIVE, which every INSERT, UPDATE, DELETE, MERGE and COPY FROM takes, or ACCESS EXCLUSIVE, which TRUNCATE takes), usually for milliseconds. A reader, a SERIALIZABLE reader, an index build, ANALYZE, a trigger or a foreign key being added is never waited for.
  • If one stays open, that table waits on its own, and you are told. After at most one second the table reads Waiting, and its row and the pipeline’s history name the sessions it waits for (by process id, and how many prepared transactions); pg_stat_activity and pg_prepared_xacts on your source show them. The pipeline’s other tables keep streaming (no wait ever pauses them for longer than that second), nothing restarts, and nothing is charged for the wait. The table is copied on its own once the transactions its copy first saw have ended (the pipeline checks about once a minute): a transaction that began later is never waited for, so a source that is never quiet still lets the table through, behind a synchronous standby too, whatever role the pipeline connects as (below).
  • Copying an added column’s existing values waits the same way, for that table alone. If a transaction writing the table is open when the pipeline is about to read the column’s existing values, that table pauses (its row names the sessions), the other tables stream, and the pipeline reads the values on its own once the transactions it first saw have ended, also after a restart: you never resume it. Before, under long overlapping transactions the values were never copied while they ran, every table paused 30 seconds at each attempt, and a restart left the table for you to resume.
  • Behind a synchronous standby, one unrelated open transaction no longer stops every table (#1274 narrowed). A copy there waited for every open transaction on the whole server and restarted the pipeline after 30 seconds, over and over, so a session left idle in a transaction on any table stopped them all. Now it waits only for a transaction that wrote the table being copied and whose commit the pipeline’s own stream has already passed while the standby has not confirmed it, at most a second, and then that table alone waits. Its row and the pipeline’s history say that the commit waits for the standby named in synchronous_standby_names, and what to do if that standby is not coming back. The pipeline keeps track of such a commit until your source makes it visible, however many other commits pass meanwhile. This needs no extra privilege: the role the setup guide asks for, without pg_read_all_stats, is waited on exactly as a superuser would be. (Before, a source role without pg_read_all_stats could not see what another role’s sessions were doing, so behind a synchronous standby a table written by another role’s overlapping transactions was never copied while they ran, and you were told that nothing needed doing.)
  • Another table’s ALTER TABLE waiting for a lock no longer stops the pipeline. On PostgreSQL 16 and later the pipeline read a table’s columns (when its shape changed, when a column’s values were to be copied, when a removed column or a key change was decided) through pg_publication_tables, which opens every table the publication lists. With an ALTER TABLE of any of them queued behind a long transaction, that read failed after a second, and the pipeline stopped and restarted into the same wait until the transaction ended. It now reads the publication’s own catalogue and opens no table, so such a lock queue holds nothing of the pipeline.
  • A copy that must wait leaves nothing in your destination. A table re-copied while keeping your rows used to leave an empty _reyansh_recopy_<token> table in your destination schema at every wait. The copy now asks first and makes nothing until it can read; and every such table the pipeline made and no copy uses is dropped at its next start, identified by its name and the pipeline’s own comment on it, never one it cannot prove it made.
  • On a standby source, one narrow case remains. A standby cannot see the primary’s locks, so there the copy waits for every transaction the primary was running when it first looked, as far as the standby can tell. It cannot tell a transaction whose first write came while your own ALTER PUBLICATION ... ADD TABLE (or the transaction it ran in) was still open, if no later transaction on the primary has finished by the time the copy first looks (a later attempt keeps that first look); such a transaction’s writes to the table made before the publication change committed can be missing from the copy. Publishing the table in a statement of its own makes that window milliseconds, and on a primary that is writing anything at all it closes as soon as another transaction finishes.

2026-10-14 (IST) — A run with nothing to sync is not charged, and four sentences made true

Section titled “2026-10-14 (IST) — A run with nothing to sync is not charged, and four sentences made true”
  • A restarted pipeline whose Snowflake destination parks every table as it opens is no longer charged while nothing syncs. The worker keeps running to release your source’s log, and those windows are measured as no_table_syncing, never charged, as the rules have always said. They were measured as ordinary work, and charged, from the destination’s open until the run ended, since v0.1.68. The same is true of a first sync that declined its existing rows, or whose tables to copy were all parked by the open. The seconds the open itself takes, before it knows, are charged as any start’s are.
  • The Audit log says its own limit when a range is too long: “The audit log is read at most 366 days at a time, counting From through To”. It said the usage export’s “An export covers at most 92 days and 250,000 rows … or one pipeline”, which is none of its limits. A page that does not name its own says only that the range is longer than one read covers.
  • GET /v1/wallet/statements/{month}: a month that ended within the debit job’s lookback, with no entry yet, is open, not none. Its last days’ billing can still be your account’s first entry, and the Billing page said “There is no statement for this month: it is before your account’s first” of a month that then had one. Past the lookback, such a month is none as before.
  • Usage tells every run that ended in failure once in the month it shows, where its charge stands, and never for its rows or bytes. A run is told in one sentence: credited back, still to be credited back, the charge stands until we correct it, or nothing was charged. A run that used resources on both sides of midnight UTC, as a continuous pipeline’s run ordinarily does, is one run in the month: told in the state of its worst day (the charge standing, then still to be credited back, then credited back, then nothing charged), with its credits and the amount still to come added over its days. The page could leave runs out (three runs credited back were in no sentence, and their credit was said of a fourth still owed one), count a run twice in a day (a run still charged for its compute was also told “not charged: credited back” for memory already credited in full), and count a run once for every day it failed on: “2 runs ended in failure, so they are not charged: $2.00 was credited back” of one run, for good. A failed run’s rows and bytes are told with all the others, measured and not priced, so today’s Usage no longer reads “500 rows (of which 500 not charged)”.
  • GET /v1/usage/days: a closed day’s failed runs are failed_runs, one object per run. Each has run_id, refund (credited, pending, refused or nothing_charged: the run’s one state for the day), credited_minor (what the ledger has credited back to the run for the day), pending_minor (for pending, what the refund rule still owes it, which the refund pass writes) and usage. A run is listed once in a day, so the day’s entries count its failed runs once and say each credit and each amount still owed once. A run that used resources on several days is in each day’s failed_runs under the same run_id: count each pipeline_id and run_id once to tell a range. The refund pass credits an account in one transaction, so while any failed run of the account is refused, on any day, it credits none of the account’s runs, and a pending amount waits for that correction too. Closed days’ failed_run entries of not_charged, and that array’s runs, refund and pending_minor fields, are gone; today’s failed runs are still failed_run entries of not_charged. No amount charged or credited changes.
  • “Copying we began again ourselves, without your asking (a repair, or a table copied again from its start), is not charged.” It said “A repair re-sync we asked for”, which was not true of a copy begun again after an upgrade.

2026-10-14 (IST) — Usage and billing say only what is true: the credit adds up to the balance, today’s estimate is what will be charged, and a month before your first has no statement

Section titled “2026-10-14 (IST) — Usage and billing say only what is true: the credit adds up to the balance, today’s estimate is what will be charged, and a month before your first has no statement”

Nothing charged changes in any of these: each is what a page or an answer SAID.

  • GET /v1/wallet’s credit adds up to balance_minor. It gains failed_run_credits_minor, what runs that ended in failure were credited back (added to your balance, not to the top-up or grant they were charged to), and other_minor, the rest of the balance, which is negative when usage was charged while no top-up or grant had credit left. Before, credit held only what remains of your top-ups and grants, so the Billing page could show $63.04 of credit beside a balance of $63.80; it now names every part, and the parts add up to the balance shown above them.
  • Today’s estimate is what the day will cost when it closes (estimated_minor on GET /v1/usage/days). A day with a run that ended in failure is charged for all of its usage, and the failed run’s share is then credited back, rounded up for each run, so you never pay a fraction of a free run. The estimate priced only the usage the failed runs had not used, and could read a cent more than the day will cost. It now works the charge and the credit out exactly as the billing job will.
  • A month before your account’s first statement has none. GET /v1/wallet/statements/{month} answers status: "none" with no rows and both balances 0, and the month’s CSV holds one row, no_statement; the Billing page says there is no statement for that month. It answered open, which the page told as “This month is still open: its rows change as entries arrive”, of a month that ended before your first entry. status is open, closed or none, and the set may grow in a later release.
  • A pipeline’s Usage tab shows no amount for a day that is not billed yet: it said “$0.00” beside “Not billed yet”, which reads as a day that cost nothing. It says “Not billed” until the day’s charge is in your ledger.
  • A run that ended in failure and is still to be credited back is told so without “($0.00 already was)” when nothing of it had been credited yet; the amount already credited is named only when there is one.

2026-10-14 (IST) — A copy interrupted under an earlier release starts again from the first row

Section titled “2026-10-14 (IST) — A copy interrupted under an earlier release starts again from the first row”
  • An initial copy (or a re-copy) that was interrupted while an earlier release (v0.1.65 to v0.1.68) was running it now starts again from the first row when it continues, and says so on the pipeline’s page (“Where this copy had reached was saved by an earlier release, which did not record enough to resume it safely, so it started again from the first row”; on the feed, snapshot_started with a new restarted reason, older_release). Those releases did not record which of the table’s columns each value was read from, so when two of the table’s columns traded names before or after the upgrade, the rows copied before the interruption kept each other’s values for good. The copy again is recorded as repair, which is never charged. A copy interrupted under this release still continues where it stopped.
  • A first sync interrupted after one table’s copy finished, whose other tables could not be opened at a Snowflake destination, continues without reading where the replication slot stands, which it has no use for there: the copied table syncs from where its copy began. Before, a slot that could not be read stopped the start each time until it could.

2026-10-14 (IST) — A Snowflake pipeline whose table cannot open at its first sync goes on

Section titled “2026-10-14 (IST) — A Snowflake pipeline whose table cannot open at its first sync goes on”
  • A Snowflake pipeline’s first sync no longer stops for good when one of its tables cannot be written as the destination opens (its Snowflake table holds a column of a type the source’s values cannot land in, or the table waits for your answer about a change). That table is parked, says why on the pipeline’s page, and waits for you; the other tables are copied and sync. Before, the worker stopped at every start trying to copy the parked table. A first sync whose every table is parked this way keeps the source’s log moving until you resume one, and that waiting time is recorded, not charged.

2026-10-14 (IST) — The two exports hold exactly what they counted; a run’s history refuses a changes-only filter

Section titled “2026-10-14 (IST) — The two exports hold exactly what they counted; a run’s history refuses a changes-only filter”
  • An audit log export with no to that holds exactly 200,000 rows no longer drops its oldest row. GET /v1/audit-events.csv records itself (audit_log.exported) inside the range it describes, and the newest-first file served that record in place of the oldest row it had counted, ending normally. Both exports, GET /v1/audit-events.csv and GET /v1/pipelines/{id}/observations/export, now hold the rows they counted: a row written after the export began is not in it, the export’s own record included. If a row is still to be read once 200,000 are out, the transfer is broken rather than ended, so a short file never looks complete.
  • GET /v1/pipelines/{id}/observations?run_id=… with kind=change alone, or with actor=, is 422 changes_not_in_run. It answered an empty 200: a change is never an event of a run, so the request could not find one.
  • A range whose from is not before its to is told “from must be before to.” on GET /v1/audit-events, GET /v1/audit-events.csv and GET /v1/pipelines/{id}/observations/export, where it read “from is before to.” (the same 422 invalid_field).

2026-10-14 (IST) — Usage and billing: a failed run’s credit says where it stands, and the ledger reads the same however it is walked

Section titled “2026-10-14 (IST) — Usage and billing: a failed run’s credit says where it stands, and the ledger reads the same however it is walked”
  • GET /v1/usage/days: a closed day’s failed_run entry carries refund and pending_minor. A run that ends in failure after its day was billed is credited back by the next billing pass, and until then its usage is still charged. refund says which: credited (amount_minor was credited back), pending (pending_minor is still to be credited back), refused (the credit could not be worked out automatically; the charge stands until we correct it) or nothing_charged (the usage took no charge). The Usage page says each in its own words, and never calls money still charged “credited back”.
  • A failed run’s runs counts the runs its refund state is about: for pending and refused the runs still owed a credit; for credited the runs credited back, and any other run on a credited line (a run the credit’s cap left nothing is free too); for nothing_charged the runs whose usage is on a line that took no charge. It counted every failed run of the day, so a run credited when its day was billed was also counted as one “charged” and still to be credited, and a run that WAS charged was counted among those “nothing was charged” for.
  • retrying is now served for a pending day too: true while the billing job still tries the day, false once it is past the days it retries, when the day is not billed automatically.
  • GET /v1/wallet/entries and the statement: a top-up’s card hint is an owner’s, as on GET /v1/wallet. A member or an API key reads the same rows without instrument_hint (null on a statement row; absent on a ledger row).
  • The statement CSV of a month still open ends with a balance_so_far row, dated the day its balance is of; only a closed month’s ends with closing_balance. A late entry appears on the first statement that is still open (the description said “the next month’s”).
  • The usage CSV breaks the transfer if it reaches its 250,000-row limit with rows still to send, rather than ending early as a file that looks complete.
  • Fixed: walking the ledger page by page while a charge and a credit were written at the same moment could show a balance after each row that was off by the charge, and skip the charge. Every writer of the ledger now takes the account’s ledger lock before it writes, so entries are numbered in the order they are committed, and a walk shows every entry with the ledger’s own balance after it.
  • Billing: the runway says what its daily figure is (“at $2.00 a day: the average of the 2 days with spend in the last 7”); an auto-recharge setting that only reminds is shown as auto-recharge off; an open month’s last row is “Balance so far”. Usage: a day whose estimate cannot be computed says so instead of “$0.00”, and a replayed batch is described as delivered again after a restart, without naming a cause the meter does not record.
  • The OpenAPI document (api/openapi.json) describes all of the above: refund and pending_minor on UsageNotCharged, retrying for a pending day, and whose instrument_hint a ledger or statement row carries.

2026-10-13 (IST) — A blocked column is never created in Snowflake

Section titled “2026-10-13 (IST) — A blocked column is never created in Snowflake”
  • A column you block, or one the pipeline blocks for safety after a rename it cannot prove, is never created in Snowflake when the pipeline creates the table, and is never expected there. Before, such a column was created empty; and a table whose initial copy was interrupted, and whose hashed column was renamed while the pipeline was stopped, was parked “the table has no column …” at every start, though nothing was ever to be written to that column.

2026-10-13 (IST) — A column set before it existed no longer parks an interrupted copy

Section titled “2026-10-13 (IST) — A column set before it existed no longer parks an interrupted copy”
  • A table whose initial copy was interrupted, and which gained a column you had already set to hashed or blocked (before the column existed) while the copy was stopped, no longer stops with “Reyansh’s records and your destination disagree about how the column is kept” at every start. The column is recorded and copied as its setting says.
  • A copy that meets such a column beside another column added while Reyansh was stopped now leaves that other column out of the copy, and tells you (“blocked” on the table’s columns, as it already does for a column it cannot place after a rename): it may hold the shaped column’s values under an older name. Before, a copy again delivered it as it is. Check it, then unblock it if it is safe.

2026-10-13 (IST) — A copy whose columns traded names starts again from the first row

Section titled “2026-10-13 (IST) — A copy whose columns traded names starts again from the first row”
  • An initial copy (or a re-copy) interrupted after two of its table’s columns traded names, or after a column was dropped and added again under its own name, now starts again from the first row when it continues, and says so on the pipeline’s page (“Columns being copied changed at the source, so the copy started again from the first row”; on the feed, snapshot_started with restarted: columns_changed). Before, it continued from where it stopped, and the rows it had copied before the change kept the values under each other’s names. A copy interrupted with no column moved still continues where it stopped.

2026-10-13 (IST) — A column change’s answer, and a request carrying a secret, are kept for a day only

Section titled “2026-10-13 (IST) — A column change’s answer, and a request carrying a secret, are kept for a day only”
  • PUT /v1/pipelines/{id}/tables/{table_id}/columns: its answer shows the table’s filter, values included, and that answer is kept for a retry with the same Idempotency-Key. It is now kept for a day, then deleted, like the filter’s own PUT (before, for ever: a retry after the filter was removed still showed its values). The request is fingerprinted with a key of your account’s.
  • Requests that carry a secret (POST /v1/connections/test, POST /v1/credentials, POST /v1/credentials/{ref}/rotate, POST /v1/notification-channels, PUT /v1/notification-channels/{id}, POST /v1/notification-channels/{id}/rotate-secret) are fingerprinted with a key of your account’s, never a plain hash of the body holding the secret, and their record is deleted a day after the request. A retry more than a day later runs as a new request: a credential’s create is refused 409 credential_exists, a channel’s create makes a second channel, a rotation runs again (a generate makes a new pending key, as a second generate always has). The release before this one recorded these requests with a plain hash of the body, and goes on doing so while this release is being installed and after any rollback to it; each such record is deleted a day after it was written, once this release is running (after a rollback, once it runs again), so a retry within that day is still answered from it.
  • A retried reveal or preview refused with 409 hash_salt_changed no longer says Idempotent-Replay: true: it is answered now, not replayed. A retry answered from the record still says so.

2026-10-13 (IST) — A setting saved for an earlier column never unhashes a renamed one

Section titled “2026-10-13 (IST) — A setting saved for an earlier column never unhashes a renamed one”
  • GET /v1/pipelines/{id}/tables/{table_id}/columns: each column gains held. When your database renames a blocked or hashed column onto a name that already has a looser setting (one you saved for an earlier column of that name), the renamed column keeps its Block or Hash, and that setting is held: it is not pending and no start applies it. A table copied again after such a rename while the pipeline was stopped treats a column it cannot tell apart from the renamed one the same way, blocked. applied says what the destination holds. To apply the setting to the renamed column, set the column again (PUT .../columns): it is judged as a change from what the destination holds (going back to Sync from Block or Hash is an owner’s, as always), and applied when the table next starts. The app shows such a column as the destination holds it, with a sentence saying the setting waits for you.

2026-10-13 (IST) — A retried reveal never shows a salt its request did not record

Section titled “2026-10-13 (IST) — A retried reveal never shows a salt its request did not record”
  • POST /v1/destinations/{id}/hash-salt/reveal and POST …/hash-salt/preview: a retry with the same Idempotency-Key still shows the same answer and records nothing twice, but only while the salt is the one that key’s request used. If an owner has set a new salt since, the retry is refused 409 hash_salt_changed and shows no salt (and no hash under one); send the request with a new key, and that reveal or preview is recorded with who asked, like every other. The API reference’s descriptions of both routes say so.
  • The salt panel sends a reveal whose answer never arrived again with the same key, so pressing Reveal after a lost answer shows the salt without recording a second reveal, or says the salt was changed since.
  • Only some request records are deleted after a day (correcting the entry below): the records of requests whose body may carry a salt, a sample or a filter’s values (the salt’s routes, the filter, and a create’s or an add’s tables). Every other request’s record, a wallet top-up’s included, is kept as before, so a top-up retried with its key, however late, is answered from the record and never charged again.
  • Answering another pipeline’s record: whether a press is held for a member now follows each column’s setting as it is now, as the server judges it, rather than as the record said it was; so does the sentence “this pipeline is set to …”. The salt panel reads its history again after a refused reveal.

2026-10-13 (IST) — A stopped pipeline’s tables are not said to be moving; a history stop is told how to get going again

Section titled “2026-10-13 (IST) — A stopped pipeline’s tables are not said to be moving; a history stop is told how to get going again”
  • While a pipeline is stopped, has given up, or rests after a manual sync, its Tables section no longer says a table is catching up (“applying the changes made since”), is being copied while the others wait, or is having a column’s values copied, and no longer says the pipeline is paused for a copy. Nothing moves then. Each table still shows its own state, kept for when the pipeline runs again, and the summary line says none is syncing before it counts them.
  • A pipeline stopped because its source’s history changed under it (a failover to a server that was behind, a restore) is told to accept the new history or re-sync every table, on the Alerts page and in the pipeline’s notice, never to fix the cause and start it again: starting it without accepting stops it again. Only a stop a person may accept is told so; one that cannot be accepted keeps the general words, and the worker’s own sentence under it says what to do.
  • API: a gave_up alert carries source_history (code, acceptable) on GET /v1/alerts and GET /v1/pipelines/{id}/alerts when the pipeline stopped for a changed source history; it is absent on every other give-up. For such a stop that may be accepted, the notice of GET /v1/pipelines/{id}, and of the answer to PUT /v1/pipelines/{id}/schedule, now says that starting it again without accepting the new history stops it again. A row of GET /v1/pipelines keeps the general notice: the list reads no stop.
  • A pipeline’s page no longer fails when the stop it recorded cannot be read: it shows the worker’s sentence and the general notice, without the stop’s facts, where it answered an error.
  • Saving a schedule on a pipeline that stopped no longer replaces the worker’s own explanation on its page with the shorter stored reason until a reload: the answer carries the worker’s sentence, as the page’s own read does.
  • Sync now on a pipeline stopped for a changed source history answers 409 pipeline_gave_up (the same code) naming the acceptance and the re-sync for a stop a person may accept, with details.source_history (code, acceptable) for any history stop; every other give-up keeps “read why on its page, fix it, and start it again” and no details.
  • A pipeline that gave up in the middle of its first copy is no longer said to be copying: its page, the Alerts page and the notification sweep no longer raise the warning “Syncing continues: it is copying the rows your table already held” beside “Syncing is blocked”, and its History tab no longer shows the “Backfilling: destination converging” banner while the pipeline is stopped, has given up, or rests after a manual sync. The rows copied so far stay on the table’s own row.
  • After Sync now is refused because the pipeline gave up, its page reads the pipeline again, so it shows that it gave up, the acceptance of a changed source history where there is one, and no Sync now, beside the refusal, where it kept saying “Running”.

2026-10-13 (IST) — A pipeline’s history shows who changed it

Section titled “2026-10-13 (IST) — A pipeline’s history shows who changed it”
  • GET /v1/pipelines/{id}/observations?include=changes merges in who changed the pipeline. Each change made through the app or the API (the audit log’s rows about this pipeline) is an entry of kind change with its action, actor, via, changes and reason, placed by the instant it was written; at one instant the pipeline’s own event comes first, and the pipeline’s events keep their sequence order. A change carries no address or user agent (an owner reads those in the audit log). Without include the history is unchanged.
  • New filters on the same route: kind= (repeatable; change selects the changes), actor= (a person’s user id, an API key’s id, or operator) and measurements=hide, which leaves out the once-a-minute resource_consumed and retention_observed rows. actor= or kind=change without include=changes is 422 changes_not_included, never an empty page.
  • A cursor continues only a request that asks the same way. A cursor from a request with include=changes sent without it, or the reverse, is 400 invalid_cursor. A merged cursor sent to the plain history used to be answered 500 observations_unavailable.
  • GET /v1/pipelines/{id}/runs/{run_id} answers one run or session exactly as the run history lists it, with shape beside it, so a link to one run reads the row the history showed. A run the 30-day window does not hold is 404 run_not_found (its events are still in the history); a pipeline with more history inside the window than one read covers is 500 run_lookup_truncated, never a 404.
  • GET /v1/pipelines/{id}/observations/export exports the history for one range, oldest first, streamed, as CSV (format=csv, the default: RFC 4180, UTF-8, \r\n) or NDJSON (format=ndjson), with Content-Disposition naming the pipeline and the range. Columns: occurred_at, kind, sequence, run_id, actor, detail (the worker’s own words, or a change’s action) and payload (the fields the history shows, as JSON). At most 31 days and 200,000 rows a request: more is 422 range_too_large, naming both. The history’s filters apply (include=changes, kind, actor, measurements); a CSV cell that a spreadsheet would run is prefixed with '. A member and a read API key may export.
  • GET /v1/overview is the account at a glance: pipelines by health (every word present), the alerts open now by severity, the balance and the billing mode, and the getting-started checklist (source_added, destination_added, pipeline_created, pipeline_started, first_rows_written, notification_address_set, teammate_invited), each step derived from the account’s rows when it is read and never stored. A member and a read API key may read it.
  • GET /v1/pipelines filters by health= (repeatable or comma-separated), source_id= and searches by name with q= (case-insensitive; % and _ are searched as themselves). Health is derived when it is read, so a request reads at most 1,000 pipelines for a health filter: when that runs out first, the page may be short or empty, carries a next_cursor, and says scan_budget_reached: true. An unknown health word is 422 unknown_health; text with a NUL character is 422 invalid_field.
  • Fixed: paging the pipelines list could skip a pipeline. The cursor joined the last row’s name to the next row’s creation time, so a page boundary between two pipelines whose names sorted against their age left the second one out of every page. The cursor now names the row the page ended on.
  • The API reference documents all of it: GET /v1/pipelines/{id}/observations/export, GET /v1/pipelines/{id}/runs/{run_id} and GET /v1/overview are new operations; the history’s page is typed as ObservationPage and the list’s as PipelineListPage (both were the untyped Page).
  • The history’s occurred_at is in UTC (Z), as documented. A server whose clock was set to another zone used to print that zone’s offset.
  • The audit log read with no to holds every row written before the read. to used to default to the server’s own clock, and a row the database had stamped a moment ahead of it was left out of the page and the CSV. An absent to is now no upper bound; a named to is unchanged, and the export’s audit_log.exported row records to only when one was named.
  • The overview reads in light mode: “Done” on the getting-started list and the paused line are words in the page’s text colour beside a green or amber mark, where the words themselves were green (2.06:1) and amber. On a phone, a history holding changes no longer scrolls sideways: a long address or action breaks inside itself, as an event’s detail already did.

2026-10-13 (IST) — What your account spent, day by day and pipeline by pipeline, and your wallet

Section titled “2026-10-13 (IST) — What your account spent, day by day and pipeline by pipeline, and your wallet”
  • New in the app: Usage and Billing, after Alerts in the navigation, for every person in the account. Usage shows one UTC month at a time: a chart of each day’s charges stacked by pipeline, each pipeline’s charged, credited-back and net amounts, which of the four states each day is in, what was not charged and why, any of the last 31 days hour by hour, and Export CSV. Billing shows your balance, how long it lasts at your recent spend, this month so far, what remains of your credit, and each month’s statement with every row’s balance after it, closed for good three days after the month ends (Export CSV too). A pipeline’s page has a Usage section with its days this month. The guide is Usage and billing: what your pipelines measured, what it cost, and your wallet.
  • New: GET /v1/usage/days — your usage per UTC day and pipeline, for up to 400 days at a time: each dimension’s quantity, what it was charged, what was credited back because a run ended in failure, and every quantity that was not charged with the reason it was not (a run that ended in failure, a repair we asked for, a window in which no table synced, a class the rate card in force that day prices at zero, a dimension it does not price, or a charge under one cent a day). Each day says which of four states it is in: open (today, an estimate), pending (still being measured or not yet billed), billed, or refused (billing it failed; it is retried, and you are never charged twice). The money is read from your ledger, never recomputed. A member or a read API key may call it.
  • New: GET /v1/usage/days.csv — the same range as CSV (at most 92 days and 250,000 rows), with \r\n line ends and spreadsheet formulas defused. 422 range_too_large names both limits.
  • New: GET /v1/usage/hours?day= (day required) — one of the last 31 UTC days, hour by hour (quantities only); 422 hours_out_of_range otherwise. New: GET /v1/usage/months — money per UTC month and pipeline, at most 24 months at a time.
  • New: GET /v1/wallet — your balance, whether new runs wait for credit, how many days the balance lasts at the average daily spend of the last seven closed days (averaged over the days that had spend, so a new account is not told it has seven times its runway), this month so far, and what remains of your credit by origin (top-ups, and credit granted by Reyansh). An owner also sees the saved payment method’s hint; a member or an API key is told only whether one is saved.
  • New: GET /v1/wallet/entries — your ledger, newest first in the order the entries were written, each with the balance after it. A page filtered by kind, from or to leaves rows out, so it carries no balance after each row.
  • New: GET /v1/wallet/statements/{month} (and GET /v1/wallet/statements.csv?month=) — a month’s statement: the opening balance, each top-up, grant and adjustment, one row per day of usage and one per day of refunds, and the closing balance, each with the balance after it. Once a month has ended and three days have passed, its statement is closed and never changes: an entry written later (a refund for a run that failed late, a payment whose notice arrived late) appears on the next statement, marked late, with its own day. 422 month_out_of_range for a month that has not begun.
  • Response enums (state, reason, classification, dimension, kind, billing_mode) are open: a newer release may add a value, and a client should show an unknown one as itself. GET /v1/usage is unchanged. The OpenAPI document (api/openapi.json) describes every new route, its query and its response.

2026-10-13 (IST) — A first sync stopped just before it saved its place starts again on its own

Section titled “2026-10-13 (IST) — A first sync stopped just before it saved its place starts again on its own”
  • A pipeline whose first sync was stopped after a table’s copy finished and before the sync saved its place, while another of its tables was parked at the start and has been resumed (or a table was added) since, now starts again by itself. Its next start used to refuse, at every start, with “the first run could not be settled before the tables you asked to copy are copied … This is a defect in the worker”, and the pipeline stayed stopped until someone stepped in. It now finishes the first sync where its copies began, copies the resumed or added table, and streams. The copy that finished before the stop is not done again, and every row arrives once.

2026-10-12 (IST) — A press only an owner may make is held for members

Section titled “2026-10-12 (IST) — A press only an owner may make is held for members”
  • Columns and filter, and the answer to another pipeline’s record: a change that makes a column clear again (an unblock, an unhash, clearing a column this pipeline syncs as it is, or keeping one held as it is where this pipeline protects it) is an owner’s. A member now sees the press held with the sentence that says so, instead of a press the server refuses with 403 owner_required.

2026-10-12 (IST) — Another account’s pipeline is never named

Section titled “2026-10-12 (IST) — Another account’s pipeline is never named”
  • shaping_record_of_another_pipeline on a pipeline’s feed names the other pipeline only when it is one of your account’s. A destination’s record can name a pipeline of another account writing the same schema; its id is then left out and the detail says "pipeline_elsewhere": true. The resume’s 409 answer_required says “a pipeline this account does not have” in the same case.

2026-10-12 (IST) — A request’s record is kept for a day, then deleted

Section titled “2026-10-12 (IST) — A request’s record is kept for a day, then deleted”
  • Every mutating request’s record (its Idempotency-Key, a fingerprint of its body, and its answer kept for a replay) is now deleted a day after the request, as the reference has always said (“kept for at least 24 hours”); before, nothing deleted them. A retry of a request more than a day old runs as a new request. A key left in flight by a write that failed (409 idempotency_key_in_flight on every retry) is freed the same way. (Corrected 2026-10-13 (IST), before release: only the records of requests whose body may carry a salt, a sample or a filter’s values are deleted; every other record is kept as before. See the entry above.)
  • A filter’s values are never kept as a plain hash of the request: the filter’s PUT, and a create’s or an add’s tables, fingerprint their body with a key of your account’s, as the salt’s routes do. A retry of a create sent just before this release still replays.

2026-10-12 (IST) — Columns and filters in the app, and the owner’s salt panel

Section titled “2026-10-12 (IST) — Columns and filters in the app, and the owner’s salt panel”
  • The pipeline page: Columns and filter, under each table of a PostgreSQL pipeline. Each column can be synced as it is, blocked or hashed; a change on a table that already holds rows opens a dialog that asks what happens to the values already there (set them to NULL, drop the column on Snowflake, keep them; for a hash or a sync, fill them from your database or leave them NULL), with the default preselected, the PostgreSQL DROP COLUMN statement shown rather than run, and what “cleared” means at each destination. The row filter is edited beside it: up to 10 conditions with the operators each column’s type takes, the confirmation a re-copy needs, and, on a PostgreSQL table kept live or in soft delete, keep or remove the rows that no longer match. A refused value names its condition, never the value.
  • The new-pipeline form reads a picked table’s columns (by testing the connection again for that table) and sets its columns and filter before its first copy, including the choice a filter needs on a table that is not REPLICA IDENTITY FULL.
  • A table stopped because another pipeline’s record disagrees is answered on its row: keep the columns as the destination holds them, or clear them and sync them as this pipeline is set to; for another pipeline’s row filter, confirm a copy again under this one’s. Each of the eleven shaping stops says what to do.
  • The destination page: the hash salt, for owners: reveal it (recorded), check the hash a value would get without revealing it, set it while no column has used it, and read its history.
  • The pipeline’s history tells shaping in words: a column’s change asked for and applied (a renamed column keeping its setting, values cleared because rows had arrived), a filter set or changed, what a filter left out, the rows a new filter removed or kept and why, and another pipeline’s record.
  • The guide: Blocking, hashing and filtering what a pipeline syncs.

2026-10-12 (IST) — A table’s columns and filter when it is created or added (the API)

Section titled “2026-10-12 (IST) — A table’s columns and filter when it is created or added (the API)”
  • POST /v1/pipelines and POST /v1/pipelines/{id}/tables: each entry of tables may now also carry columns (as PUT …/columns takes them: Sync, Block or Hash) and filter (as PUT …/filter takes it, with column_types, replica_identity, on_withheld_entry, acknowledge and rows_outside), so a table is shaped before its first row is copied. They are judged by those two routes’ own rules and refused with their codes, the table named in details.table; a refusal stores nothing. A table the pipeline never had holds no rows yet, so existing_rows is left out. A removed table asked back may still hold its rows, so it is judged as a table that has synced: existing_rows is required (422 existing_rows_required), a column going back to Sync from Block or Hash is an owner’s, a changed filter needs acknowledge and, on a PostgreSQL destination, rows_outside; its copy is the add itself. Shaping a table the pipeline already syncs through an add is 409 table_already_synced: use the two table routes.
  • POST /v1/pipelines/{id}/tables/{table_id}/resume answers another pipeline’s record. A table parked shaping_record_of_another_pipeline (its destination’s own record names columns another pipeline keeps otherwise) takes record_answer: keep_as_held makes this pipeline’s settings what the destination holds, clear_and_apply clears those values and syncs them as this pipeline is set to (a column left clear is an owner’s); 409 answer_required without one, 422 answer_not_offered for one the park does not take. When the record names another pipeline’s row filter, acknowledge: true (with rows_outside on a PostgreSQL destination’s filtered table) copies the table again under this pipeline’s filter, recorded as a re-copy.
  • The pipeline’s history tells another pipeline’s record (shaping_record_of_another_pipeline): which columns it holds and how, adopted when they agree with this pipeline’s settings, disputed when the table parks. A parked table’s remedy now says what fixes each shaping park.
  • A copy never writes a blocked or hashed key column: a table whose key a setting made before its key was known blocks or hashes stops before its first row (shaped_column_became_key), as a change already did.

2026-10-12 (IST) — A table’s row filter (the API)

Section titled “2026-10-12 (IST) — A table’s row filter (the API)”
  • PUT /v1/pipelines/{id}/tables/{table_id}/filter: set, change or remove (null) a table’s row filter, Fivetran’s shape: {"match": "all" | "any", "conditions": [{"column", "op", "value" | "values"}]}, 1 to 10 conditions, every literal a JSON string. On a table that holds none of the pipeline’s rows yet the filter is stored and its first copy applies it; on one that may hold rows a change copies the table again (acknowledge: true required), and on a PostgreSQL destination rows_outside says what happens to the rows already there that no longer match: keep, or delete (removed and counted, on a table kept in soft delete too). Changing or removing a filter is an owner’s (a full API key’s as owner power, told to every owner); creating one is a member’s. Literals are judged by the column’s type where the pipeline has read the table, else by column_types from the connection test’s catalogue_columns, and the pipeline judges every literal again when it starts. Refusals: 422 acknowledgment_required, rows_outside_required, rows_outside_not_applicable, filter_too_many_conditions, filter_type_not_supported, filter_operator_not_offered, filter_value_invalid (the condition and the reason, never the value), filter_column_blocked, filter_needs_full_identity, mode_not_composed; 404 column_not_found; 409 table_action_pending, copy_in_progress, table_removed. Told on the pipeline’s history as filter_changed, and in the audit log as table.filter_changed.
  • GET and PUT /v1/pipelines/{id}/tables/{table_id}/columns answer the table’s filter (wanted, applied, pending) and each column’s filter_type; a column setting on a table kept as history or append is 422 mode_not_composed until those modes compose with shaping.

2026-10-12 (IST) — The connection test answers one table’s columns (the create form’s shaping)

Section titled “2026-10-12 (IST) — The connection test answers one table’s columns (the create form’s shaping)”
  • POST /v1/connections/test takes catalogue_columns: {schema, name} (a PostgreSQL source): the answer’s catalogue.table_columns lists that table’s columns in order, each with its declared and base type, whether it is in the key, not_null, generated, whether the pipeline’s publication sent it (absent while no publication lists the table), may_withhold (a change can leave its value out under REPLICA IDENTITY DEFAULT), can_block and can_hash (every column but a key’s), and the row filter’s filter_type and filter_ops for it on this database; and the table’s replica_identity and server_encoding. A table that is not there, or that the role may not read, answers columns: [] with a why, and the rest of the test answers as before. Advice, as every mark of the listing is: the pipeline reads every fact again when it starts. A schema or name that is blank or holds a NUL is 422 invalid_field.

2026-10-12 (IST) — A destination’s hash salt, for its owners (the API)

Section titled “2026-10-12 (IST) — A destination’s hash salt, for its owners (the API)”
  • POST /v1/destinations/{id}/hash-salt/reveal (no body): the salt every pipeline writing the destination hashes with, its origin (generated or set_by_owner), whether a column has used it, the construction (Base64(SHA-256(UTF-8(text(value)) || UTF-8(salt))), NULL stays NULL) and the recipes that reproduce a hash in Snowflake and PostgreSQL. A destination with no salt yet is given one. A POST because every reveal is recorded in the name of whoever asked: a request another site’s page started is refused (403 cross_site_request). Never cached (Cache-Control: no-store) and never kept for a retry: a retry with the same key shows the salt again and records nothing twice.
  • PUT /v1/destinations/{id}/hash-salt with {"salt"}: your own salt (16 to 1,024 bytes, no NUL, neither $$ nor $s$, not ending in $ or $s), for example the one another tool hashed with, while no column has been hashed with the destination’s (409 hash_salt_in_use after; 422 hash_salt_invalid naming the reason, never the value). Answers its hint only.
  • POST /v1/destinations/{id}/hash-salt/preview with {"value"}: the hash that value would get, to check a recipe without reading the salt. At most 20 a minute per account (429 with Retry-After); its answer is never kept for a retry, which computes it again.
  • GET /v1/destinations/{id}/hash-salt/events: who generated, set, revealed, previewed or first used the salt, and when.
  • Owners only, and never an API key (403 owner_required, 403 api_key_not_allowed). Each reveal, set and preview is in the audit log: destination.hash_salt_revealed, destination.hash_salt_set, destination.hash_salt_previewed.

2026-10-12 (IST) — Block or hash a column of a table (the API)

Section titled “2026-10-12 (IST) — Block or hash a column of a table (the API)”
  • GET /v1/pipelines/{id}/tables/{table_id}/columns: a table’s columns, each with what the destination holds (applied: as_is, blocked or hashed), the setting you chose and whether it is still pending, whether it is a key column or used by the table’s filter, and which treatments it takes (can). A table the pipeline has not read yet lists only the columns you have set (columns_known false).
  • PUT /v1/pipelines/{id}/tables/{table_id}/columns with {"columns": [{"name", "treatment", "existing_rows"?}]}: Sync (as_is), Block (never delivered) or Hash (a salted SHA-256 of the value). On a table that may already hold this pipeline’s rows, existing_rows says what happens to the values there and is required (existing_rows_required); on one that holds none, leave it out. A setting is applied when the table next starts, never by the request. Refusals: column_is_key, column_in_filter (a column the filter uses cannot be blocked), column_not_found, existing_rows_required, existing_rows_not_offered (naming what is offered), table_removed, shaping_not_offered (a source that is not PostgreSQL).
  • Going back to Sync from Block or Hash is an owner’s, and never an API key’s, a full one included (403 owner_required, rule column_made_clear): it delivers what the block or the salt protected. A full key that clears a column’s values (null, drop_column) is using owner power, and every owner is told.
  • The first Hash into a destination makes its salt, sealed to that destination; every pipeline writing the destination shares it. The history shows columns_shaping_requested, and the audit log table.column_settings_changed.

2026-10-12 (IST) — A partition attached during a copy is copied by a user granted the partitioned table alone

Section titled “2026-10-12 (IST) — A partition attached during a copy is copied by a user granted the partitioned table alone”
  • A PostgreSQL source user granted SELECT on a partitioned table’s root alone now copies a partition attached while the copy runs, or attached while an interrupted copy waited to resume, rows and all. The copy read such a partition by its own name, which that user may not read, so it failed with the initial copy's lock failed (SQLSTATE 42501) and failed again at every restart, without saying what to do. Granting SELECT on each partition is no longer needed; a user that has it reads the partition as before, unless the partition has row-level security enabled (then it is read through the partitioned table: the same rows). The same goes for a partition the user holds SELECT on and still cannot read by its own name: one in a schema the user has no USAGE on, or one with row-level security enabled. Each is now read through the partitioned table.
  • What it costs. A list, range or default partition read this way costs what reading it by name costs. A hash partition read this way re-reads the other partitions’ keys for every window of the copy, so its extra time grows with the square of the table’s size (measured: four times the rows took ten to thirteen times the extra time). It is rare, and it never changes which rows arrive.

2026-10-12 (IST) — A purge is refused on a table waiting for you; a mixed-case table holds a second full re-sync off

Section titled “2026-10-12 (IST) — A purge is refused on a table waiting for you; a mixed-case table holds a second full re-sync off”
  • POST .../tables/{table_id}/purge-deleted on a table waiting for you is refused with 422 purge_table_waiting: a table whose waiting.reason is set and is not destination_busy (its publication, the source’s PostgreSQL version, a partition’s identity, the source’s room, or its key). The pipeline writes nothing of such a table, a purge included, until what it waits for is done, so the purge used to be accepted, told it took effect within a minute, and never ran. The refusal names what the table waits for and what to do; ask again once the table is copied. A table waiting for its first copy, or on a busy destination table, is written at a start, and its purge is accepted as before.
  • A purge asked again while one already waits on a parked table, or on a table waiting for you, is refused with the code a first ask there gets (422 purge_needs_resume, 422 purge_table_waiting), saying a purge already waits, what it waits for, and its cancel route. It was answered 200 with “within a minute, when the pipeline restarts”, which no start made true. Nothing changes either way.
  • A cancel of a waiting purge says a begun purge runs to its end for every table that is not parked, whatever the pipeline was asked to do: takes_effect said “now” for a stopped or given-up pipeline, whose worker could still be finishing the purge.
  • 409 resync_in_progress counts a table whose name is not plain lower case (public."User", as an ORM names a model’s table): such a table’s copy was never counted, so a second full re-sync was accepted while the first one copied it, and began that copy again.
  • In the app, Delete the rows marked deleted is not offered on a table waiting for you, and a purge asked before its table was found to wait says it runs once the table is copied. Soft delete’s confirmation on a PostgreSQL destination says the table is parked, for you to resume, when the pipeline’s role may not add its two columns (it said the table waits).

2026-10-12 (IST) — A change made while the pipeline’s publication was missing stops the pipeline and says how to fix it

Section titled “2026-10-12 (IST) — A change made while the pipeline’s publication was missing stops the pipeline and says how to fix it”
  • Fixed: when the pipeline’s publication did not exist on the source at the moment a change was made, PostgreSQL 17 refuses to send anything past that change, even once the publication is created again, and PostgreSQL 18 skips the change with only a warning. The pipeline used to say “a function or trigger refused the row” on 17 and restart into the same refusal, and on 18 it carried on without the change. Now both stop the pipeline (schema_stop_raised, not restarted) naming the publication, and say the way out: re-sync every table with new source names, which reads from a new replication slot and copies every table again. Nothing past the last saved position is acknowledged to the source. This most often meets a re-sync with new source names whose publication was not created.

2026-10-12 (IST) — A waiting purge can be cancelled; a table’s sync mode is offered by route and account

Section titled “2026-10-12 (IST) — A waiting purge can be cancelled; a table’s sync mode is offered by route and account”
  • New: DELETE /v1/pipelines/{id}/tables/{table_id}/purge-request cancels a purge of a table’s rows marked deleted that is waiting. The rows stay. When an API key cancels one, every owner of the account is told, as for the purge. 404 no_pending_purge when none waits. A purge the pipeline has already begun runs to its end; the answer’s takes_effect says so where one may have, and the table’s rows_purged then says what it removed. Audit action table.purge_request_cancelled.
  • POST .../tables/{table_id}/purge-deleted on a parked table is refused with 422 purge_needs_resume: a purge runs only for a table the pipeline writes, so it would wait for ever and hold the table’s resume. Resume the table first. A table’s pending_purge gains waits_for_resume (true while the table is parked: cancel the purge to resume it first).
  • A request refused by a waiting change of a table’s sync mode or a waiting purge (409 table_action_pending, and a full re-sync’s 409 request_pending) now names that request’s cancel route, because a parked table’s mode change and purge wait until it is resumed.
  • sync_modes on a destination card of GET /v1/connectors is now keyed by SOURCE kind: {"<source kind>": {default, offered, purge}}, for the account asking. A MySQL or Stripe pipeline into PostgreSQL writes every table live and runs no purge, so it is offered live alone and no purge: a change of a table’s mode, the pipeline’s default (PUT .../sync-mode) and a create’s sync_mode_default are refused there with 422 mode_fixed_by_source, and a purge with 422 purge_not_offered.
  • Soft delete into a PostgreSQL destination is not available yet (422 not_yet_available, on a table’s mode, the pipeline’s default and a create’s default), and is not in that destination’s sync_modes. The release before this one would delete such a table’s marked rows for real if it were rolled back to; the next release turns it on. Snowflake’s soft delete is unchanged.
  • A full re-sync’s copy_restarts names the running copy whatever it is: its door copies every table again from the first row, so a copy that would otherwise carry on from its last saved batch is begun again too (and a stopped pipeline’s interrupted copy, at its next start).
  • 409 resync_in_progress is read from the last full re-sync’s own tables: the tables its door asked to copy that have not finished since, named in details.tables. A table added later, waiting for its own copy, no longer refuses a second full re-sync, and neither does a table waiting for you (its waiting.reason set, a busy destination table apart, which tries again on its own): the full re-sync with a new slot that a table waiting for the source’s version is offered is accepted.
  • POST /v1/pipelines/{id}/tables is refused 409 request_pending while a full re-sync waits, as every other table request already was; and a full re-sync is refused while a removed table’s request to be added back waits.
  • Sync now on a manual pipeline at rest is refused as Start is (422 unsupported_kind, 422 unsupported_pairing, 409 destination_table_taken): those were answered 500 sync_unavailable.
  • A deleted pipeline’s source_cleanup names what a full re-sync left: previous_slot_name and previous_publication_name (absent when there is none), with the old slot’s check and drop statements after the current slot’s, and the old publication’s drop last.
  • New: GET /v1/pipelines/{id}/new-source-names draws a replication slot and publication name for a re-sync of every table that moves the pipeline to them, with statements (the publication, with the pipeline’s tables: run before you ask) and start_statements (the slot: right before the re-sync is applied). Nothing is stored; each call draws a new pair. It is refused where that re-sync would be (422 resync_not_supported, 409 request_pending, 409 resync_in_progress, 409 previous_slot_still_present), so nobody is told to create a slot for a request that cannot be made. The re-sync dialog’s Draw a new pair uses it and shows those statements before the press: a re-sync asked for a pair the app could not get, and said to create the slot only after the press. invalid_source_names and the slot_name_taken / publication_name_taken refusals of a re-sync now name it.
  • A guarded rotation of a PostgreSQL connection string is one connection check of the account’s limit (six a minute), however many probes it takes: it looks for each pipeline’s slot and publication in turn, so a source read by five or more pipelines, with nothing recorded and its current credential no longer connecting, was answered 429 rate_limited every time.
  • credential.rotated audit rows say which database a rotation recorded: identity_recorded, each destination or source with the identity recorded on it, and confirmed: true where your confirm asserted it was the same database.
  • A pipeline’s old_slot is the slot a re-sync renamed it away from, which may still exist: it is served from the moment the re-sync is applied until the pipeline reads the slot gone, so it was wrong to say it “still exists” (the page now says it may).

2026-10-11 (IST) — Each destination card names its sync modes; a new pipeline cannot take a name a re-sync asked for

Section titled “2026-10-11 (IST) — Each destination card names its sync modes; a new pipeline cannot take a name a re-sync asked for”
  • sync_modes {default, offered} on each destination card of GET /v1/connectors: the mode a table takes when nothing names one, and every mode a request may name (Snowflake: soft_delete by default; PostgreSQL: live by default; both offer soft_delete and live). The routes refuse exactly what this list leaves out.
  • POST /v1/pipelines with a slot_name and publication_name another pipeline of the account has asked a full re-sync to move to is refused with 409 source_names_in_use, as a pair another pipeline already holds was. Test the connection again to draw names.

2026-10-11 (IST) — An edit that restarts a pipeline says which copy it starts again

Section titled “2026-10-11 (IST) — An edit that restarts a pipeline says which copy it starts again”
  • copy_restarts (an array of table names, absent when empty) on the answer of every route that restarts a running pipeline: PUT /v1/pipelines/{id}/schedule, PUT .../discarded-rows, PUT .../change-policy (when it changed something), the table requests (recopy, remove, resume, and the others), POST .../tables, PUT .../tables/{table_id}/sync-mode, POST .../tables/{table_id}/purge-deleted, POST .../resync and, per pipeline, PATCH /v1/destinations/{id}. It names the table whose copy the restart starts again from its first row. A copy that keeps its place is not named: it continues from its last saved batch. Nothing is refused because of it.
  • copying on GET /v1/pipelines/{id} gains resumable (true when the running copy keeps its place if interrupted) and resumed_at_rows (where this attempt picked up, or null). rows_copied is never below where it resumed.

2026-10-11 (IST) — A re-sync’s old replication slot raises a warning until you drop it

Section titled “2026-10-11 (IST) — A re-sync’s old replication slot raises a warning until you drop it”
  • New alert kind old_slot_holds_log (a warning) on GET /v1/pipelines/{id}/alerts and GET /v1/alerts: a full re-sync gave the pipeline a new replication slot, and the old one is still on your source, keeping its log. It carries old_slot: {slot, statement}, the slot’s name and the statement that drops it, which is yours to run once the re-sync has settled; we never drop a slot. It stands while the pipeline last found the slot present and ends when it finds it gone.
  • New notification trigger old_slot_holds_log, on by default for email (as source_log_held is: a full disk stops your database) until you switch warnings yourself; a stop does not end it. The webhook’s details carry slot and statement.
  • An account’s alert page can now return up to 10 more alerts than limit asked for (it was 9), since one pipeline can raise one more kind at once.

2026-10-11 (IST) — A credential rotation cannot move a pipeline to another database

Section titled “2026-10-11 (IST) — A credential rotation cannot move a pipeline to another database”
  • POST /v1/credentials/{ref}/rotate of a connection string a PostgreSQL destination or source uses, while a pipeline uses it, now checks which database the new one reaches, by the server’s own identity (system_identifier and current_database()), never by the URL’s text: an alias of the same database (another host name, a provider’s new endpoint) is rotated to as before; another database is refused with 409 destination_would_move or 409 source_would_move, naming the pipelines and the identity it reaches. Nothing is rotated on a refusal.
  • The database an object is known by is the one recorded, else the one its pipelines’ last run told, else the one its current credential reaches now. When none of those can be read (the current credential no longer connects), 409 identity_unproven says which database the new one reaches and which of the pipelines’ objects are there; send the rotation again with "confirm": true to accept it, which is refused (409 destination_would_move) when one of them is missing. The identity is recorded with the rotation.
  • New error codes: 422 identity_check_failed (the new credential could not be checked against its server, with its words), 422 invalid_connection_string, 504 identity_check_timed_out, 503 identity_check_unavailable. A key-pair (Snowflake) credential is not guarded: its account and database are the destination’s settings.

2026-10-11 (IST) — Edit a Snowflake destination’s warehouse, role or user

Section titled “2026-10-11 (IST) — Edit a Snowflake destination’s warehouse, role or user”
  • PATCH /v1/destinations/{id}, the API’s first PATCH: {"settings": {"warehouse"?, "role"?, "user"?}, "credential"?}. Before anything is saved, a check runs as the new settings: it signs in, and asks whether the role owns every table the destination’s pipelines write and may create tables in their schemas. Saved, every pipeline writing there restarts onto it within a minute; the answer lists them (pipelines, each with takes_effect, the copy it is running as copying, and copy_restarts) and changed, empty when the settings sent were the ones it had. A copy that keeps its place (copying.resumable) pauses and carries on from its last saved batch; one that cannot begins again from its first row, and is the one copy_restarts names.
  • A change of user takes credential, the reference of the key-pair credential registered on the new user (upload or generate it first), in the same request. A new key for the same user is a rotation, as before (POST /v1/credentials/{ref}/rotate, or a pending key and Test and switch).
  • New error codes: 422 setting_not_editable (account, database, time_travel_days), 422 credential_required_with_user, 422 credential_only_with_user, 422 no_editable_settings (a PostgreSQL destination: rotate its credential), 409 key_rotation_pending, 422 destination_check_failed (with details.tables: what the role lacks, usage, privilege, ownership or create_table, and details.statements, the grants an administrator runs), 503 destination_check_unavailable, 504 destination_check_timed_out, 409 destination_changed. Nothing is saved on any refusal.
  • Owners only; an API key’s edit is owner power, told to every owner. Recorded in the audit log as destination.edited, and on each pipeline’s history as destination_edited.
  • CORS: Access-Control-Allow-Methods now lists every method the API routes (PUT, PATCH and DELETE beside GET and POST).

2026-10-11 (IST) — Re-sync tables or a whole pipeline, Sync now, and a table’s sync mode: soft delete or live; a purge of the rows marked deleted

Section titled “2026-10-11 (IST) — Re-sync tables or a whole pipeline, Sync now, and a table’s sync mode: soft delete or live; a purge of the rows marked deleted”
  • Re-sync: POST /v1/pipelines/{id}/resync ({"confirm": true}) copies every table not removed again (a full re-sync), starting the pipeline again from where its replication slot stands: the way back from a lost or recreated slot. With "tables": [...] it copies those tables only. A full re-sync may take a new slot_name and publication_name (a pair GET /v1/pipelines/{id}/new-source-names draws, 2026-10-12); the answer’s setup then carries the new ones to create and the old ones’ drop statements, yours to run once the re-sync has settled. New error codes: 422 confirm_required, 409 request_pending, 409 resync_in_progress, 422 names_need_full_resync, 422 invalid_source_names, 409 slot_name_taken, 409 publication_name_taken, 409 previous_slot_still_present, 422 resync_not_supported; 422 delete_not_applicable now also answers a delete asked of a soft_delete table (by the re-sync and by .../recopy).

  • Sync now: POST /v1/pipelines/{id}/sync writes everything the pipeline has received up to now without restarting it; effect says what it did (writing_held_changes, nothing_held, after_the_copy, started). 409 pipeline_stopped, 409 pipeline_gave_up.

  • GET /v1/pipelines/{id} gains sync_mode_default, resync (the last full re-sync, pending until applied), sync_now, old_slot (a slot a re-sync left on your source, with its drop statement) and copying (the copy running now). New history kinds resync_requested, resync_held, resync_applied, sync_requested, held_changes_written, old_slot_still_present; new audit actions pipeline.resync_requested, pipeline.sync_requested.

  • Each table is kept in a sync mode, shown as sync_mode on every table: soft_delete (a row deleted at your source stays in your destination, marked in _REYANSH_DELETED_AT; Snowflake’s default) or live (it is deleted; a PostgreSQL destination’s default). A table’s mode is recorded when it is added and never changes on its own.

  • New endpoints: PUT /v1/pipelines/{id}/tables/{table_id}/sync-mode ({"mode"}) asks for a table’s mode to change, applied when the pipeline next starts once the table is syncing, shown as the table’s pending_mode until then; DELETE /v1/pipelines/{id}/tables/{table_id}/sync-mode-request cancels it while it waits; POST /v1/pipelines/{id}/tables/{table_id}/purge-deleted ({"confirm": true}) deletes the rows a table holds marked deleted, shown as pending_purge, then rows_purged; PUT /v1/pipelines/{id}/sync-mode ({"default"}) sets the mode a table added later is kept in, and changes no existing table. Switching from soft delete to live keeps the rows already marked: purge them to remove them. POST /v1/pipelines takes sync_mode_default, recorded on each of its tables and on each table added later.

  • New error codes: 422 mode_not_offered (history and append are not offered yet), 404 no_pending_mode, 409 mode_change_in_progress, 422 confirm_required, 422 purge_not_applicable, and 409 request_pending on every table request while a re-sync of every table is pending. 409 table_action_pending now also names a waiting mode change or purge.

  • A full API key’s purge is owner power, told to every owner, as a copy that deletes is.

  • New history kinds: table_mode_change_requested, table_mode_changed, rows_purged. New audit actions: table.sync_mode_requested, table.sync_mode_request_cancelled, table.purge_requested, pipeline.sync_mode_default_changed.

In the app: a pipeline’s page has Sync now beside Start and Stop, and Re-sync every table (with Use a new replication slot and publication and, since 2026-10-12, Draw a new pair, which shows what to create on your source before you press). A table’s menu offers Re-sync (and, for a PostgreSQL live table, Re-sync and delete them), the table’s Sync mode with a change that says what it does before the second press, and Delete the rows marked deleted with Cancel the delete while it waits; ticking several tables offers one re-sync of them all. Each dialog says what the copy does by the table’s mode, when the table was last copied, that the copy is metered, and which running copy the press restarts or pauses. A Snowflake destination’s page has Change its settings (warehouse, role, or user with its key), whose refusal lists what the role lacks and the statements an administrator runs; replacing a PostgreSQL connection string says which database the new one reaches, and asks It is the same database: replace it where nothing could prove it.

2026-10-11 (IST) — A table’s last changes are delivered before a stop, a request or a copy can lose them

Section titled “2026-10-11 (IST) — A table’s last changes are delivered before a stop, a request or a copy can lose them”
  • A key change, then the table gone: the changes made to a table before its key changed now reach your destination even when the table is dropped, renamed away, replaced or taken out of the publication before it is copied again. Its row no longer offers a copy of a table that is not there.
  • Copy again or Remove on a table being read to its end (dropped, renamed away, replaced or out of the publication) waits until the table’s last changes are written, and is applied then. The history tells it: a new kind, table_request_held, “A request waits for a table’s last changes”.
  • A partition attached while the pipeline was not running is now told when it starts, as one attached while it runs is: copy the table again to include the rows the partition held.
  • A copy reads only the table the pipeline syncs: a table replaced under its name just before its copy is stopped as replaced, before any row, never copied as the old table. After Copy again of a replaced table, the old table’s last changes no longer stop it a second time.
  • No endpoint changed.

2026-10-11 (IST) — The pipeline page shows what Start, Stop and an accepted history leave, and a history stop’s alert names the acceptance

Section titled “2026-10-11 (IST) — The pipeline page shows what Start, Stop and an accepted history leave, and a history stop’s alert names the acceptance”
  • After Start, Stop or “Accept and start the pipeline”, the page now shows the pipeline exactly as the answer describes it. It used to keep any part of the page the answer no longer carried, so after an acceptance, or Start on a pipeline that had given up, it said “Starting” under “What the worker reported”, still telling you the pipeline had stopped and to accept the new history, until you reloaded. No API change: these answers already carried the whole pipeline.
  • Focus follows the press: after Start, Stop or an acceptance it moves to the pipeline’s state, which a screen reader reads out, and “Accept this history” moves it to the question it asks (Cancel gives it back). It used to fall to the top of the page.
  • A pipeline stopped because its source’s history changed now says so in its alert on the pipeline’s page, and that starting it without accepting stops it again: accept the new history there, which starts it, or delete the pipeline and create a new one. It said “Fix the cause, then start it again.” The account’s Alerts page keeps the give-up’s words, since an alert there does not say why the pipeline stopped.
  • Settings → Audit log, a row opened on a phone: a long change now wraps inside the table, and the page no longer scrolls sideways.

2026-10-11 (IST) — A kept type change says which dates a Snowflake timestamp column writes as NULL

Section titled “2026-10-11 (IST) — A kept type change says which dates a Snowflake timestamp column writes as NULL”

A column’s type narrows (type_narrowed) told every pipeline “The destination column already holds every value of the new type, so it was not changed.” On Snowflake that was false for one pair: a timestamp column changed to date at the source is kept as TIMESTAMP_NTZ, and that column writes a date before year 1 or after the year 294276 as NULL, with its value kept in _REYANSH_META (see “Values Snowflake cannot hold” in the Snowflake guide). Nothing about what is written changes; only the words do.

  • The pipeline’s history now says, for that pair: “The destination column was not changed: it holds every value of the new type except a date before year 1 or after the year 294276, which is written as NULL, with its value kept in _REYANSH_META.” Every other narrowing keeps the sentence it had.
  • A table waiting on a narrowing under Ask me now says what the destination column holds, with the same exception where it applies, in the pipeline’s words above the answers. The waiting line under it names the change alone (“Column c changed type at the source, from … to ….”): it no longer claims every value, which it could not know for this pair.
  • The policy editor’s “A column’s type narrows” names the exception.

2026-10-10 (IST) — The audit log also records change-policy edits, answers to waiting changes, an accepted source history and both phases of a key rotation

Section titled “2026-10-10 (IST) — The audit log also records change-policy edits, answers to waiting changes, an accepted source history and both phases of a key rotation”

Five more actions in the account’s audit log, each written in the same transaction as the change it records, as every row of the log is:

  • pipeline.change_policy_changed: a pipeline’s answers to schema changes were set (PUT /v1/pipelines/{id}/change-policy). The row shows each answer that changed, before and after, and which copy-again answers are confirmed.
  • table.change_policy_changed: one table’s own answers were set or cleared (PUT and DELETE /v1/pipelines/{id}/tables/{table_id}/change-policy).
  • table.change_decided: a resume answered the schema changes a table waited on. The row names each change by its id, with its kind and the answer given, beside the table.resumed row of the same request.
  • pipeline.source_history_accepted: a person accepted a changed source history, and the pipeline was started. The row holds the five facts that were accepted.
  • credential.pending_key_generated: the first step of a key pair’s rotation made its pending key. The switch to it is recorded as credential.rotated, as an uploaded rotation is. Neither row holds a key: only that it changed.

A write that changes nothing (the same policy again, clearing a table that has no answers of its own) records nothing, and a refused request records nothing.

Not in the audit log: what a pipeline does by its change policy without being asked, such as adding a table it found or applying a schema change. Those are in the pipeline’s own history; the audit log holds who set the policy that chose them.

In the OpenAPI document each of these operations now carries x-reyansh-audit, and GET /v1/audit-events?action=table. (or any prefix) filters to them. The guide, The audit log, lists every action.

2026-10-10 (IST) — An interrupted copy carries on from where it had got

Section titled “2026-10-10 (IST) — An interrupted copy carries on from where it had got”

New: the copy of a PostgreSQL table’s existing rows resumes after an interruption (part of #967). Until now a copy that was interrupted (you stopped the pipeline, it was restarted, a connection was lost, its worker failed) started again from the first row, however far it had got. It now carries on after the last rows your destination saved a place for: every batch on a PostgreSQL destination, about once a minute on Snowflake. A stop is taken between two batches, after the place is saved, so nothing is read again; after a failure at most the last batch (PostgreSQL) or about the last minute of rows (Snowflake) is read again and written over the same rows. A copy is shown once in your usage, with all its rows, however many attempts it took.

What you see. On the pipeline’s page, under History, a copy that carried on says “Copy resumed after an interruption, at {n} rows.”, and the count of rows copied goes on from there instead of starting at zero. A copy that had to start again from the first row says why: the table’s key or a column being copied changed at the source, the order of the table’s key changed at the source (its collation changed version), the destination table was dropped, replaced or emptied, the saved place could not be read back exactly, or the keys kept for a table copied again were lost. When the whole history is loaded, the page also says how often the copy was interrupted and since when.

A table whose copy cannot carry on is copied in one statement, as before, and says so from its first attempt: “If this copy is interrupted it starts again from the first row”. That is a table whose key index is not plain ascending (a DESC column, text_pattern_ops), whose key collation has changed version, which your database would not read in key order, whose key holds a value that does not read back exactly, or whose destination cannot keep the copy’s place.

New on the feed. GET /v1/pipelines/{id}/observations: snapshot_started may now carry copy (an id shared by every attempt of one table’s copy), resumed (rows_copied), restarted (reason) and not_resumable (reason); snapshot_completed carries copy. Each is absent when it does not apply and on older events. The restarted reasons written today are key_changed, columns_changed, target_changed, boundary_unreadable, keys_lost and key_order_changed; the not_resumable reasons are key_index_order, collation_version, plan, key_literal, progress_table and reconcile_keys. More may be added: read a word you do not know as its field. The OpenAPI document does not describe the feed’s rows, so it does not change.

What you may see in your destination. The copy keeps its place in your destination, never with us, because the place is a key value of one of your rows. On PostgreSQL that is a small table, _reyansh_copy_v1, in each schema the pipeline writes, created the first time a table is copied there (the role needs CREATE on the schema; without it the copy runs as before and cannot carry on); and, while a table is copied again, a table of the keys that copy wrote, _reyansh_recopy_ followed by 32 characters, dropped when the copy ends. On Snowflake it is _REYANSH_COPY in the pipeline’s _REYANSH_<SCHEMA> schema, written by one small statement about once a minute while a table is copied. Either progress table is safe to drop when no copy is running; a copy that was under way then starts again from its first row.

What changes on your source database. Nothing is created or changed on it. A copy that can carry on reads the table in key order through its key’s index, a slice at a time, and each slice takes the ACCESS SHARE lock only for as long as its rows take to be read, so an ALTER TABLE waits for one slice of the copy and no longer for the whole copy. The copy waits up to 60 seconds for that lock (the entry of 2026-10-08 (IST) below said 30), up to three times for a slice, then ends that run and tries again by itself. A slice that passes 1 GiB of text is ended by the pipeline’s own role (pg_cancel_backend on its own statement) and read on from its last whole row. As before, the pipeline keeps its place in your source’s change log from the moment a table’s copy begins until it ends, now across interruptions too.

A copy that keeps failing but carries on each time is not given up on (2026-10-11 (IST)). A pipeline whose worker keeps failing in the middle of a long copy used to be moved onto the slower retry schedule after five quick restarts and given up on after 14 days, while the copy advanced on every attempt. An attempt now counts as progress once the next one resumes further on, so such a pipeline keeps its quick restarts until the copy finishes. A worker that keeps failing before its copy saves anything (for example, on Snowflake, sooner than the minute between saves) is still retried on the slower schedule and given up on, as before, and each of its retry notices says it “has delivered nothing since the failure before”: rows it copies again from the first row are not new. A retry notice says the worker stopped “after delivering data” only when that attempt copied rows no earlier attempt of the copy had, and a pipeline given up on after such an attempt is told it “kept stopping for 14 days of automatic restarts without finishing its copy”, never that it delivered nothing.

A partition that leaves a table while it is copied is told (2026-10-11 (IST)). A partition detached or dropped from a partitioned table during its copy, or while the copy was interrupted, is told on the pipeline’s feed (partition_detached), in words that say which; the copy reads none of its other rows and carries on. Any of its rows the copy wrote before then stay in your destination, since PostgreSQL sends no delete when a partition leaves a table. Until now a partition attached during the copy and then dropped stopped that copy from ever finishing, and one detached was read on into the copy, with nothing said. And Copy again is refused while a table is being copied (copy_in_progress), a new pipeline’s first copy included.

In GET /v1/pipelines/{id}/tables (2026-10-11 (IST)), a table’s copy.started_at is when the copy began, not when its latest attempt did, and after a resume copy.rows_copied starts at the rows it resumed at instead of 0. And each reason a copy cannot carry on now has its own sentence on the pipeline’s page.

See A pipeline’s tables.

2026-10-10 (IST) — A replaced or unpublished table’s last changes arrive too, and a change that takes no answer says its way out

Section titled “2026-10-10 (IST) — A replaced or unpublished table’s last changes arrive too, and a change that takes no answer says its way out”

Part of the schema-change policy (the 2026-10-07 entry below), from the review of the entry below this one:

  • Fixed: a table dropped and created again, or taken out of the publication, could still lose its last changes. The entry below said every way a table ends was covered “also when the pipeline was stopped”; that was true of a dropped or renamed table only. A table replaced under its name, or one the publication no longer lists, is now read to its end as well: every change made to it before that point is delivered first, no row of the new table under that name is written into the old one’s destination table before the table is set aside (a resume, or a confirmed rule to copy a replaced table again, then copies the table that has the name), and its row says “Every change made to {table} before its name passed to another table reached the destination” or “… before it left the publication reached the destination”. In a running pipeline, rows the pipeline was holding when it met the replacement are delivered before the table is set aside (before, a resume copied the new table and those rows were gone). The same holds for a table renamed away and then written under its new name: the rows written under the old name arrive first, and the row says “Every change made to {table} before it was renamed reached the destination”.
  • A change that takes no answer. GET /v1/pipelines/{id}/tables can show an open change whose answers is []: a change no answer can be made to at this destination (a type change of a column the Snowflake table no longer has). Its table stops and cannot be resumed; the other tables carry on unless the pipeline is set to stop every table when one stops. parked.remedy, and the page, say so and name the way out: “Copy it again: every row is read again, keeping the rows your destination already has, and that copy is billed like any other work. Or remove it.” POST …/tables/{table_id}/resume answers 409 answer_required with “{table} cannot be resumed: it waits on a change no answer can be made to at this destination (…). Copy {table} again, or remove it.”, its details.changes naming those changes.
  • The New pipeline form’s history choice also names a renamed table. Under “Sync only changes from now on”, a table you pick that is later renamed at the source is a new table to the pipeline: it follows “When the source changes”, which by default copies it with its existing rows.
  • Three history sentences corrected. A column added with no values now ends “so there is nothing to copy” (it said “so nothing is copied”: if the source changes the table before the pipeline’s own check of it, the values are copied after all, and the history says that too). A column added to a table that is no longer at the source under its name says “the source has no table of that name to read”, which is also true of a renamed table. And a column added with a type the source has dropped, on a table the source has dropped too, no longer tells you to copy the table again from the source: it says the table is gone, and that its changes since the last delivery did not arrive.
  • The schema-changes guide says what Copy again does to a column whose type changed: kept where it already holds the source’s values, widened, or converted, whatever the type rules say.
  • Fixed before release: while a replaced table’s last changes were being delivered, the pipeline still asked the source about it by its name. That name is the new table’s, so a column the old table had just gained could be filled with the new table’s values, the new table’s columns could be added to the old table’s destination and shown in the history as changes of the old one, and a column the new table lacks could be dropped under “drop it”. A table whose last changes are being delivered is no longer read by its name by anything. A column it gained just before its end is added with the values the change log carried, and its history line says so: “Column {column} was added to {table} at the source before its name passed to another table (before it was dropped; before it was renamed; before it left the publication). It was added to the destination table with the values the change log carried, and no other value of it is copied into that table: the pipeline writes the last changes of {table} and then stops syncing it.”
  • Fixed before release: a column added to a table just before the table was dropped stopped the whole pipeline, at every restart, with “the checkpoint could not be made durable”. The column is added and the table’s last rows are delivered.
  • Fixed before release: a partitioned table that was dropped, renamed or replaced is no longer told that each of its partitions was detached, nor a table that took its name that its partitions were attached.
  • Known limit, in the schema-changes guide: a table whose key changes and that is then dropped before the pipeline has copied it again. Its changes since the pipeline’s last write do not arrive, and there is no table left to copy. The guide says what its row shows and what to do.
  • A table taken out of the publication and put back before the pipeline looked now stops, keeping its place, and says what may have happened. PostgreSQL does not send the changes made to a table while it is out of the publication. When a table’s entry is replaced by one with the same column list and row filter between two looks, the table stops: either it was out and put back, or its list or filter was changed and changed back in two statements, which the source’s catalogue cannot tell apart. Its row says both: if it was out, its changes while out did not arrive. Resume streams it on from its place (if you know it was never out); Copy again brings it back in line. A list set and set back while the pipeline runs is seen as it happens and stops nothing, including after a restart. Put back with a different list or filter, it syncs on as any list change does, and its history says its entry in the publication was replaced and that, if it was out in between, Copy again brings back what did not arrive.
  • A request made while the pipeline is starting is never applied before its table is read to its end: it waits for the start it causes. On Snowflake, a request held for a table’s last changes says when those changes cannot be read, instead of promising them.
  • A partition attach told while the pipeline runs is not told again when it restarts.

2026-10-10 (IST) — A dropped table’s last changes arrive, two migrations in one window never stop a pipeline, and Copy again changes a column’s type

Section titled “2026-10-10 (IST) — A dropped table’s last changes arrive, two migrations in one window never stop a pipeline, and Copy again changes a column’s type”

Part of the schema-change policy (the 2026-10-07 entry below), from a live end-to-end run against Snowflake:

  • Fixed: changes made to a table shortly before it was dropped could be lost. A table dropped, renamed, replaced or taken out of the publication was set aside on a once-a-minute check, before the pipeline had delivered what it was holding of it: with the default six-hour schedule, up to six hours of that table’s changes. Now every change made to it before that point is delivered first, also when the pipeline was stopped across the drop, and the table’s row then says “Every change made to {table} before it was dropped reached the destination.” Where the pipeline cannot read it to its end, the row says that its changes since the last delivery did not arrive.
  • Fixed: adding a column and changing its type in one schedule window could stop the whole pipeline, at every resume, with only an answer that could not be made. The type change is now judged after the column is added; a resume never stops on values written before the change; and a change no answer can make offers none, saying instead to copy the table again or remove it.
  • Copy again now changes a column’s type to one that holds the source’s values (Snowflake: widened in place, or converted as an automatic type change is), so it is the way out of a type change you did not answer. Before, on Snowflake it could stop the table again with “cannot hold the source’s values”.
  • A column added with no values is told so: “The source’s existing rows hold no value in it, so nothing is copied”, never “they are being copied, and the pipeline’s other tables wait”.
  • The New pipeline form no longer says a pipeline never copies a table on its own. Its history choice is about the tables you pick there; a table added to the publication later follows the change policy (by default added and copied with its existing rows), as the policy editor already said.

2026-10-09 (IST) — A column’s fill reads what the copy reads, waits for a busy source, and says what it waited for

Section titled “2026-10-09 (IST) — A column’s fill reads what the copy reads, waits for a busy source, and says what it waited for”

Part of the schema-change policy (the 2026-10-07 entry below), from its final review:

  • A fill opens as the initial copy now does. It locks the source table before it reads (the lock a SELECT takes), so an ALTER TABLE that rewrites the table cannot leave the read empty, and on a source that names synchronous standbys it waits until every transaction that had written there has ended, so it never writes a row’s older value over a newer one.
  • A fill the source makes wait is a stop the pipeline retries itself. A wait past 30 seconds (a lock another session holds on the table, or a transaction there that is still open or not yet confirmed by a synchronous standby) parks the table, keeping its place, with the new cause fill_busy in GET /v1/pipelines/{id}/tables (parked.cause), a remedy that names the source, and a sentence saying that it is tried again every five minutes while the pipeline runs. The other tables carry on unless the pipeline stops every table.
  • A fill that fails says so in a fill’s words, naming the column whose values were being copied, never “the initial copy could not be started”.
  • A column added and then widened while the pipeline was stopped is told once, as added. It was told added twice and then “narrowed”, and a pipeline set to ask about narrowings waited on that false question.
  • A Snowflake column whose type change stops part-way while the pipeline runs is named in the table’s row, which says that its values are in a column starting _REYANSH_OLD_ until the table is resumed.
  • “Stop every table” names the stops it cannot extend: a table whose copy at the start does not finish, a table whose place the replication slot was moved past, and any stop found at a start before the pipeline has saved its first place stop that table alone (GET /v1/change-policy, the editor, the guide).

2026-10-08 (IST) — A commit waiting for a synchronous standby is no longer missed by the initial copy

Section titled “2026-10-08 (IST) — A commit waiting for a synchronous standby is no longer missed by the initial copy”

Fixed: a row could be missing from a PostgreSQL table’s initial copy, silently, on a source with synchronous replication (synchronous_standby_names set) whose standby had stopped confirming commits, or under synchronous_commit = remote_apply with the standby’s replay held back. Such a commit is saved on your server but stays invisible until a standby confirms it, and the replication slot can already be past it: the copy did not see the row and the change stream would never send it.

What changes on your database: nothing is created or changed on it. On a primary that names synchronous standbys, the copy now first waits until every transaction that had written when it began has ended, by reading PostgreSQL’s lock table (pg_locks), which the pipeline’s role can already read. It needs no new privilege and no replication slot. A source with no synchronous standby, and a standby source, are unchanged.

New message on the pipeline’s history (worker_refused): “The initial copy of {table} was not started. This source names synchronous standbys … After {n} s one still had not: either a synchronous standby is not confirming commits (pg_stat_replication on the source shows its state), or a transaction is still open there (pg_stat_activity …, and pg_prepared_xacts a prepared one). Nothing was copied. It tries again by itself; if this keeps happening it stops trying, and this history says so.” Written when the wait reaches 30 seconds, on each attempt; your database’s own lock_timeout or statement_timeout does not shorten it.

2026-10-08 (IST) — A PostgreSQL table rewritten during its initial copy is copied whole

Section titled “2026-10-08 (IST) — A PostgreSQL table rewritten during its initial copy is copied whole”

Fixed: a table could be copied empty, silently. If a schema change that rewrites the table started in the moment between the copy’s preparation and its read of the table, the copy read no rows and reported itself complete, and every row that existed before the copy was missing at the destination. The changes that rewrite a table are ALTER TABLE … ALTER COLUMN … TYPE to a type that is not binary-compatible (integer to bigint, for instance), ADD COLUMN with a volatile default (clock_timestamp(), random(), gen_random_uuid()), a stored generated or identity column, and SET ACCESS METHOD. PostgreSQL documents that a table rewritten after a reader’s snapshot looks empty to that reader, and nothing in the change stream carries the rewrite.

What changes on your database. The copy takes the same ACCESS SHARE lock it always took, one statement earlier, before it reads: a rewrite either finishes before the copy reads the table or waits for the copy, as it already waited for the copy’s read. No new privilege is needed (the SELECT the copy already has). If another session keeps the table locked against reads (an ALTER TABLE, a VACUUM FULL, a LOCK TABLE … ACCESS EXCLUSIVE) for more than 30 seconds, the copy stops without having read anything and tries again by itself.

2026-10-08 (IST) — A Snowflake pipeline writes only into the database its destination names

Section titled “2026-10-08 (IST) — A Snowflake pipeline writes only into the database its destination names”

Fixed: a Snowflake pipeline whose database could not be found kept retrying, and was never told how to get its data back. Snowflake finds the destination’s database by its exact name, case included, and a name that finds nothing is not refused: the pipeline’s statements simply run with no database in use. The start’s first read of the destination then failed, and the pipeline was retried on the restart schedule as a destination that could not be reached. Re-running the setup script in the meantime (CREATE DATABASE IF NOT EXISTS) made an empty database of the same name, and the next retry resumed into it, without the rows copied before and without an error. Now every start first asks Snowflake which database it is in, before it reads or writes anything, and stops unless the answer is the destination’s database, exactly as named. It stops for you, once, and says what to do: rename the database back, UNDROP DATABASE, or grant the role USAGE on it, then resume, and never resume into a new, empty database of the same name. Every write session asks the same question again before it writes. The schema listing names the database too. The question needs no running warehouse, so it costs nothing.

2026-10-08 (IST) — Each start asks the destination whether a newer release shaped what it writes

Section titled “2026-10-08 (IST) — Each start asks the destination whether a newer release shaped what it writes”

New: before a pipeline starts, the worker reads one small table of its own in your destination (_REYANSH_SHAPING in the pipeline’s _REYANSH_<SCHEMA> schema on Snowflake, _reyansh_shaping_v1 beside _reyansh_rejected_v1 on PostgreSQL), to learn whether a column it writes is blocked or hashed, or a table filtered, by a newer release. Nothing writes that table yet, so today the answer is always “no such table”: on Snowflake it is asked with SHOW TABLES, which does not resume your warehouse, and on PostgreSQL with to_regclass. It is read only; the worker never changes it.

New refusal on the pipeline’s history (worker_refused): “Reyansh could not check how the columns of {destination} are kept ({class}). …” when that read gets no answer (it times out, the destination is unreachable or down). The pipeline does not start and nothing is written; it tries again by itself, and if this keeps happening it stops trying and the history says so. The sentence names the class of the failure (for example “it did not answer in time”), never the database’s own error text or a credential. A refused credential or a missing privilege is unchanged: the pipeline stops for you, in the words it always used (a refused password, a role that may not use the schema, a Snowflake key or role refused), and starts again when you start it.

2026-10-08 (IST) — A PostgreSQL destination has one writer per pipeline

Section titled “2026-10-08 (IST) — A PostgreSQL destination has one writer per pipeline”

Fixed: two workers of one pipeline could both write into a PostgreSQL destination (#912). When a deploy overlapped a running worker, or an old worker outlived its replacement, both could write, and a row the newer worker had updated or deleted could be put back by the older one’s copy, for good. Each pipeline’s writes into a PostgreSQL destination now go through one session that holds a PostgreSQL advisory lock for that pipeline, and every write transaction first proves that this same session still holds the lock, so a worker that is no longer the pipeline’s writer writes nothing. Each batch is now written in one transaction (a refused batch is written again row by row, as before), so a transaction_timeout set for the destination role must be longer than a batch takes: a batch it ends is refused naming 25P04, keeps nothing, and is restarted.

What you may see in your database: the pipeline’s session is named reyansh-worker <pipeline id> in pg_stat_activity, and holds one advisory lock while the pipeline runs.

New on the feed: destination_fence_taken_over when a worker of the pipeline held the lock for more than two minutes without letting go (a stopped process, a paused machine) and its session was ended so the pipeline could carry on, told once the lock was taken; and destination_fence_held when a session the pipeline may not end has held the lock for ten minutes: the pipeline wrote nothing, its worker stops, and it shows Retrying while it is started again on its retry schedule, carrying on at the first restart after the lock is let go; after 14 days of it, Broken.

Changed: a PostgreSQL destination behind a pooler that keeps session state between clients is refused, saying to connect directly or through a pooler in session mode that resets each session (PgBouncer’s default DISCARD ALL): PgBouncer in transaction mode at the first write that lands on another server connection, a pooler that resets sessions between transactions (server_reset_query_always = 1) at the first write, and session mode without a reset query at the start. On Neon use the host without -pooler; on Supabase, the direct connection. And a role that may not call pg_try_advisory_lock or read pg_locks is refused at the start, with the GRANT that fixes it. See A PostgreSQL destination.


2026-10-08 (IST) — The account’s audit log

Section titled “2026-10-08 (IST) — The account’s audit log”

New: every change to an account is recorded, in the same transaction as the change. Who made it (a person and their address at the time, an API key and its name, Reyansh operations, Reyansh staff, or Reyansh itself), how it came (app, api, operator, staff_console, system), what it changed, the before and after of each field (a secret only as “changed”, never its value), the request id, and the client address and user agent. A change and its record commit together or not at all.

  • Recorded: creating, deleting, starting and stopping a pipeline; its schedule, discarded-row answers, mute and alert thresholds; acknowledging what a deleted pipeline left; adding, removing, resuming and copying again a table; creating a source or a destination; creating and rotating a credential; a connection test that ran (and whether it passed); creating, changing, deleting, rotating and testing a notification channel; the account’s notification settings and their test; a resend; a person’s own notification choices; a top-up; signing in, switching account and signing out. Invitations, members and API keys keep their own trails and are read with the rest.
  • New: GET /v1/audit-events (owners; a read API key may pull it): the account’s log newest first, from all three trails (changes, people, keys), filtered by actor, action (a prefix: pipeline.), target, pipeline_id, from and to (366 days at most, 422 range_too_large), cursor-paged. A filter holding a NUL character or bytes that are not UTF-8 is 422 invalid_field naming it, on the page and the CSV alike. client_addr and user_agent are returned only to an owner signed in as a person, never to an API key, and are cleared 365 days after the row.
  • New: GET /v1/audit-events.csv: the same filters as CSV, at most 200,000 rows (422 range_too_large past it). The export is itself recorded (audit_log.exported) before any row is sent, and a cell beginning with =, +, -, @, a tab or a carriage return is prefixed with ' so a spreadsheet never runs it. A request another site’s page made is 403 cross_site_request (the export is recorded, so a link must not start one), and a failure after the first row breaks the download rather than ending it, so a short file never looks complete.
  • Every mutating operation in the API reference now says what it records: x-reyansh-audit is the list of actions, in_trail (people and keys), or not_account_scoped (requesting a sign-in link and previewing an invitation, which act before any account is known).
  • Reyansh staff now give a reason before opening an account (support, incident, billing or security_review, with an optional note), and the account’s log shows the view with the staff member’s name and reason.
  • A sign-out is now one transaction with its record: POST /v1/auth/logout answers 500 logout_failed if the record cannot be written, and the session is then still live; signing out again works.
  • POST /v1/connections/test answers 500 check_unrecorded when the test ran and its record could not be written; the answer is not given, and running it again is safe.
Section titled “2026-10-08 (IST) — The sign-in link’s token is in its fragment; the account’s small findings”

Changed: the sign-in link is /auth/verify#token=…. The token moved from the query into the URL fragment, as an invitation link’s already is: a fragment is never sent to a server, so the token reaches no access log, proxy or Referer, and the page removes it from the address bar as soon as it has read it. A ?token= link mailed before this release is still read until 2026-11-30 00:00 UTC, then refused; a link lives fifteen minutes, so none can be affected. POST /v1/auth/session is unchanged: the token is still posted in its body.

Changed: a role is changed only after a confirmation. Choosing a role in Settings → Members stages it; Change role opens a dialog naming the person and the role, and only its Yes changes it.

Fixed: a removed person’s row now leaves the members list as soon as the removal is made; the last owner’s Leave is disabled with its reason instead of being refused after a confirmation; a member who opens the Snowflake destination form directly is told only an owner can add a destination and is shown no field; an API key’s row button is “Revoke {name}…” and the dialog’s is “Yes, revoke {name}”, so two buttons no longer share one name; a declined invitation’s entry in GET /v1/membership-events names who declined (actor).


2026-10-08 (IST) — Snowflake: Time Travel days on a destination

Section titled “2026-10-08 (IST) — Snowflake: Time Travel days on a destination”

A Snowflake destination takes settings.time_travel_days, a whole number from 0 (Time Travel off) to 90: how many days Snowflake keeps the earlier versions of the tables its pipelines write. Left out, the account’s own retention is kept, as before. A string, a fraction or a value outside 0 to 90 is 422 invalid_settings, naming the field. It is chosen when the destination is created.

It is rolled out over two releases. This release reads the setting everywhere it is stored, and takes it only for an account it is offered to: elsewhere a create carrying it is 422 not_yet_available, and the form does not show the field (GET /v1/me answers time_travel_enabled). The next release offers it to every account.

It is applied as each pipeline starts: in a schema the pipeline alone writes (destination_schema_naming fivetran), as the schema’s default, so every table in it follows; in a shared schema, on each table the pipeline writes, and never on the schema, which may hold your own tables. An account that keeps fewer days refuses it (a Standard edition keeps at most 1 day), and so does a transient table or database above 1 day: the pipeline writes on, and its history says so with the new event time_travel_not_applied, naming the schema or table and what to do. It is tried again each time the pipeline starts.

2026-10-07 (IST) — A PostgreSQL destination is written to over TLS; an MD5 role streams

Section titled “2026-10-07 (IST) — A PostgreSQL destination is written to over TLS; an MD5 role streams”

Fixed: rows written into a PostgreSQL destination crossed the network unencrypted. The worker dialled a PostgreSQL destination without TLS whatever its connection string said, and a string saying sslmode=require could not connect at all. Every connection to a PostgreSQL destination now honours the connection string’s sslmode; one that names none means prefer, PostgreSQL’s own default: TLS when the server offers it, verifying nothing, and plaintext when it does not. As PostgreSQL’s prefer does, a server that refuses the TLS handshake, or refuses the connection over TLS before it asks for a password, is tried once more without TLS; never after a password was sent, and never under require, verify-ca or verify-full. A refusal is said of the destination, never of the source.

New: destination_tls on GET /v1/pipelines/{id}, on GET /v1/destinations/{id} and in the answer of POST /v1/connections/test: the sslmode in effect, whether the connection is encrypted and verified, the TLS version, and standing_warning, a message key, while it is below verify-full. Each session tells it on the feed as the event destination_tls, so a destination that is never tested again still shows how its rows travel. The warning is one message key per mode and state, so a connection that set sslmode=disable is told so, and none is told its server offers no TLS. The OpenAPI document describes it as the schema DestinationTLS, and the connection test’s warnings beside it.

Changed: a PostgreSQL destination’s connection string that sets something its connection does not apply (options, application_name, connect_timeout, keepalives and the like) is refused, naming the setting, rather than connecting without it. The user, password, database, sslmode and sslrootcert are read.

Fixed: a role that signs in with MD5 passed the connection test and then failed at the stream (#1076). MD5 now works at the stream too. PostgreSQL 18 deprecates MD5, so the connection test warns (warnings: auth_md5_deprecated) with how to move the role to SCRAM-SHA-256.

2026-10-07 (IST) — A pipeline no longer resumes past a source that failed over to a server that was behind, or was restored

Section titled “2026-10-07 (IST) — A pipeline no longer resumes past a source that failed over to a server that was behind, or was restored”

Fixed: a silent loss after a failover or a restore of a PostgreSQL source. A pipeline resumes from its last position, and PostgreSQL starts a logical stream at that position or the replication slot’s, whichever is later, skipping everything before it with no error. After a failover to a standby that had not received everything the old primary sent, or a restore to an earlier point, the new server’s changes below the pipeline’s position were skipped. Every start now compares the source’s system identifier and timeline with the ones the pipeline’s position was saved under, and:

  • continues when nothing can be skipped: the same server, or a new timeline that left the old one at or after the pipeline’s position (event source_failed_over), or a standby whose log has not reached the position yet, which waits (source_behind_checkpoint);
  • stops, before streaming anything, when the history changed under it: another server; a primary whose log ends before the position (restored); a new timeline that left the old one before it; a new timeline whose history cannot be read; a standby that followed its primary there and has not confirmed the position. The pipeline’s page says which, and what to do.

New: POST /v1/pipelines/{id}/source-history/accept. When the stop can be accepted (source_history.acceptable on GET /v1/pipelines/{id}), a member or an owner may accept it by sending exactly the stop’s five facts: the pipeline continues from its position, skipping the new timeline’s changes below it, and is started. Never an API key (403 api_key_not_allowed). 422 history_mismatch when the body is not the stop’s facts; 409 history_not_diverged when the pipeline is not stopped for a history that can be accepted. The page offers the same, with a confirmation.

New on GET /v1/pipelines/{id}: source_history, the stop’s facts, on a pipeline stopped for its source’s history.

New events: source_failed_over, source_behind_checkpoint, source_history_unverifiable (a source that does not report its identity, so a failover cannot be detected), and source_history_accepted, naming the person.

2026-10-07 (IST) — A deleted pipeline of many tables says how to set each table’s replica identity back

Section titled “2026-10-07 (IST) — A deleted pipeline of many tables says how to set each table’s replica identity back”

Fixed: a deleted pipeline’s page gave one table’s REPLICA IDENTITY statements for a pipeline of many. It showed “If you set this table to REPLICA IDENTITY FULL” with the statements for the pipeline’s first table, in public, whatever schema the tables were in, and every other table went unnamed. The page now gives one read-only query over every table the pipeline selected, a table removed earlier included: it lists which of them are REPLICA IDENTITY FULL now, which publications still send each, and, for each one no publication sends any more, prints the statement that sets it back, each name quoted. A table under DEFAULT or USING INDEX gets no statement. Its sentences, and those about the pipeline’s table being written or free, speak of one table or of many as the pipeline has.

New: deletion.source_cleanup.identity_reset on GET /v1/pipelines/{id} and a delete’s answer: tables and check. Like the rest of the clean-up, we never run it. The 409 pipeline_deleted message now says “To replicate its tables again”.

2026-10-07 (IST) — Deleting a pipeline names every table it wrote, removed ones included

Section titled “2026-10-07 (IST) — Deleting a pipeline names every table it wrote, removed ones included”

Fixed: the delete step and a deleted pipeline’s page named only the tables the pipeline synced at the time. A table removed from a pipeline keeps its rows in your destination, and the page said “the tables it wrote stay in your destination” without naming it, so a customer cleaning up after a delete could miss it. Both now name every table the pipeline wrote rows to, a table removed earlier included, in the pipeline’s order. A table removed before any copy of it began, or one still waiting for its first copy, wrote nothing and is not named; a pipeline that ran and saved no progress names every table it syncs, as tables it may have created.

New: written_tables on GET /v1/pipelines/{id}: every destination table the pipeline has written to, named as destination_tables names them, for a pipeline whose worker ran. destination_tables is unchanged (what it writes now), and a deleted pipeline’s deletion.kept_tables is now the same list as written_tables.

2026-10-07 (IST) — A copy we had to make twice is shown once in your usage

Section titled “2026-10-07 (IST) — A copy we had to make twice is shown once in your usage”

Fixed: a table’s copy that we had to make again was counted twice in your usage. If the worker stopped between finishing a table’s copy and saving that it had (a crash, or a newer worker taking over the pipeline), the next run copied the table again, and both copies were recorded as historical_load rows and bytes in GET /v1/usage. Now a copy is recorded once its save is recorded: the second copy we made is the one counted, and the first is shown as replay at zero. A copy you ask for again (Copy again, POST /v1/pipelines/{id}/tables/{table_id}/recopy) is a new copy and is counted again. A copy is now dated the moment its save was recorded, a few seconds after it finished for a table copied at a start, and after the last table for a pipeline’s first copy. Nothing you were charged changes: copied rows and bytes are not priced. Usage already recorded is not rewritten.

2026-10-07 (IST) — A misspelled field in a request body is refused, and named

Section titled “2026-10-07 (IST) — A misspelled field in a request body is refused, and named”

Fixed: a request that misspelled a field name was answered as if the field had not been sent. PUT /v1/pipelines/{id}/discarded-rows with {"record_in_destinaton": false} answered 200 and left the record on; a channel created with "pipelnes" was created for every pipeline; a schedule with "time_zone" ran in UTC. Every endpoint that reads a JSON body now refuses a field it does not take, at any depth (a misspelled schema inside tables too), with 422 unknown_field. The error’s details.field is the name as you sent it, and the message names it too. No field any endpoint takes has changed, and the app sends none it does not.

Changed: a body that is not JSON for the endpoint is 400 invalid_body everywhere. The endpoints for people, invitations, your notification choices, switching account, sign-in and API keys answered 422 invalid_body for a body that could not be read; they now answer 400, as every other endpoint always has. A field those endpoints do not take was 422 invalid_body and is now 422 unknown_field.

2026-10-07 (IST) — A table under row-level security is no longer copied as a subset

Section titled “2026-10-07 (IST) — A table under row-level security is no longer copied as a subset”

Fixed: a PostgreSQL table with row-level security could be copied with only some of its rows, and the first sync reported it whole. If the table’s policies apply to the role a pipeline reads the source as, a copy sees only the rows those policies show. Now such a table is not copied: it stops syncing on its own, the pipeline’s other tables carry on, and the table’s page names it, the role, and the statement to run on the source as a superuser, ALTER ROLE <role> BYPASSRLS;. Resume the table once that is done and it is copied in full. A policy that lets the role read every row does not do: the copy refuses any table whose policies apply to its role. A table already streaming is unaffected; its changes are not filtered.

Fixed: a partitioned table published without publish_via_partition_root was told to run a statement that fails. The table waits, as before, and its page now says to run ALTER PUBLICATION <publication> SET (publish_via_partition_root = true); (and to add the table only if the publication does not list it). Once the option is set, the running pipeline copies the table on its next check, with no restart.

Fixed: contradictory advice for a column named like one of ours. A source column whose name becomes _REYANSH_SYNCED_AT, _REYANSH_META or _REYANSH_DELETED_AT in Snowflake, left out by the publication, was reported as a column the pipeline needs, with advice to publish it, which is then refused as a reserved name. Such a column is no longer asked for: the name belongs to the destination’s own column, and the source’s is never synced.

Fixed: behind a connection pooler in transaction mode (PgBouncer), the initial copy could spell dates, numbers, binary values and intervals with the server’s own settings instead of ours, and left its settings on a server connection your other applications might then be given. Every setting the initial copy needs is now made inside the copy’s own transaction, and nothing the copy sets outlives it. This covers the initial copy only: two other connections a pipeline keeps to your database for its own catalogue reads still set a 30-second statement timeout for their whole session, and moving those into transactions too is still to come.

2026-10-07 (IST) — A change to a source table’s shape follows the pipeline’s change policy

Section titled “2026-10-07 (IST) — A change to a source table’s shape follows the pipeline’s change policy”

New: every pipeline has a schema-change policy, one answer per kind of change. A column added, dropped or renamed, a type widened, narrowed or changed, a key changed, a table replaced, truncated, found in the publication or gone from it, and a publication that sends less: each is answered by a rule, and the pipeline tells you what it did on the activity feed. A new pipeline takes the automatic preset (each rule’s default) unless you choose ask me about every change, which stops a table when the pipeline meets a change to it until you answer. A table can override most rules for itself.

A table copied again on its own needs your confirmation. The default answer to a changed key or a replaced table copies the table again, keeping the rows your destination has, but only once you confirm that answer; until then such a table waits for you. A confirmation is yours alone: a later change to that rule, or a preset, that does not confirm again removes it.

In the app: a table’s menu offers Ask me about every change to this table, which gives that table Ask me for every rule it may set for itself, and Use the pipeline’s policy, which clears its own rules. A table found in the publication under Tell me is listed under Tables found in the publication, with a button that adds it. A stopped table’s row now says what its stop means for the pipeline’s other tables as they are when you look, never as they were when it stopped, so it no longer says the other tables carry on while the pipeline is stopped. The note “Waiting while the existing values of column … are copied” is shown only on a table that is streaming or catching up, the ones that copy actually holds up.

A column’s existing values are never copied through a row-level security policy. When a policy on the source table applies to the role the pipeline reads as, copying an added column’s existing values would read only the rows the policy shows, so the table stops before any is read, and its row names the table, the role and the statement that fixes it (ALTER ROLE ... BYPASSRLS;), exactly as a table’s first copy does. Once it is run, resume the table and its values are copied.

Fixed: a source column named current_date, current_time, current_timestamp, current_user, localtime or localtimestamp could not be created in Snowflake. Snowflake refuses these six names in upper case, even quoted. Such a column now lands in lower case, quoted ("localtime"); every other column, CONSTRAINT included, stays upper case.

The guide: When a source table’s shape changes.

API:

  • GET /v1/change-policy: every rule, its answers with what each does, its default, whether a table may override it, and the two presets.
  • GET and PUT /v1/pipelines/{id}/change-policy: a pipeline’s rules (preset, rules, confirm). PUT and DELETE /v1/pipelines/{id}/tables/{table_id}/change-policy: a table’s overrides. Each write takes an Idempotency-Key; a changed rule takes effect when a running pipeline restarts onto it, within a minute, and an unchanged write restarts nothing. New refusals: 422 answer_not_offered, rule_not_per_table, unknown_rule, and change_policy_unsupported_source for a pipeline whose source is not PostgreSQL: only a PostgreSQL source follows a policy, and a MySQL source still stops when a table’s shape changes. Reading a policy and clearing a table’s overrides are still answered.
  • POST /v1/pipelines takes change_policy (preset, rules, confirm); left out, the pipeline has the automatic preset, unconfirmed.
  • GET /v1/pipelines/{id}/tables: each table gains pending_changes (each change it waits on, with its change_id and the answers it takes), columns_filling, left_out, source_note, rules (its overrides) and paused_for_fill (only on a table that is streaming or catching up); parked gains clause and waiting gains retry, both composed from the pipeline as it is when you look, so neither says “the other tables carry on” or “tries again on its own” about a pipeline that is stopped. parked.remedy now reads the cause. clause counts the tables that stopped with this one from the tables themselves, never from the pipeline’s rules, so it never says the other tables stopped when they kept syncing. parked also gains with_table, for a table that stopped because another did: that table and whether it is still parked, which is what decides whether resuming it brings this one back (it does not for a table whose place was let go, whose own resume copies it again).
  • POST /v1/pipelines/{id}/tables/{table_id}/resume takes answers, one per change the table waits on, by change_id. New refusals: 409 answer_required, 409 change_not_pending, 422 answer_not_offered, and 409 resume_pending for a resume sent again while the first is pending with other answers, naming each answer that is pending (the same answers, a part of them, or none still answer the pending resume, which records nothing new). Each names the changes in its message as the table shows them, by the column and what happened at the source and each answer by its button’s words, and carries details.changes: each change’s change_id, with the answer sent and the answers it takes for answer_not_offered, and the pending and requested answers for resume_pending.
  • A request on a table the pipeline does not have (remove, resume, copy again, and a table’s change policy) is refused 404 table_not_found, which was the general not_found: a missing table and a missing pipeline (404 pipeline_not_found) are told apart by their codes, and the app no longer says “That pipeline does not exist” of a table.
  • A table request on a pipeline that stopped and needs you now says it takes effect “when you start the pipeline again” (was “when the pipeline next starts”).
  • GET /v1/pipelines/{id}/found-tables: each table found in a PostgreSQL pipeline’s publication that it did not sync, and what the table_found rule did with it: added (copied, with its existing rows, when the pipeline next starts), not_added (with the reason, in the add’s own words) or notified. A table you removed from the pipeline is never added back by the policy.
  • Alerts and notifications gain three kinds: table_parked (an error: tables of a pipeline stopped and wait for you, sent two minutes after the newest one stopped, so one migration is one message naming them all; another table stopping meanwhile sends a new message naming every waiting table, while the same table stopped again, as the pipeline does every few minutes for a table whose destination table another session holds, is the same message; and for such a table “no table is waiting any more” is sent only once none has stopped for seven minutes), table_gone (a warning: a table dropped or renamed at the source) and schema_changed (a warning: the pipeline followed a change to a source table’s shape, standing for a day). An alert of the first two carries sentence_by_table, what each table met; schema_changed carries changes. Each pipeline, in the list too, carries tables_waiting_for_you.
  • The activity feed gains schema_change (each change and what was done: applied, kept, left_out, ignored, waiting, refused, reverted, or not_sent for a column a publication’s column list does not send), column_filled, table_found and table_found_outcome.

2026-10-07 (IST) — Snowflake key pairs: every format, a key we make for you, and a rotation that never drops a pipeline

Section titled “2026-10-07 (IST) — Snowflake key pairs: every format, a key we make for you, and a rotation that never drops a pipeline”

Every private key format a Snowflake key pair comes in is accepted, and decrypted when you save it. private_key now takes PKCS#1 (BEGIN RSA PRIVATE KEY, plain or under the legacy PEM encryption) as well as PKCS#8, and an encrypted PKCS#8 key under PBES2 with any HMAC PRF, HMAC-SHA1 included (the shape macOS’s built-in openssl, LibreSSL, writes), or under one of the six PKCS#12 schemes (RC4, two- and three-key 3DES, RC2). The key is decrypted once, with your passphrase, and stored sealed and unencrypted; the passphrase is not stored. A non-ASCII passphrase works whichever OpenSSL version encrypted the key. A key stored before this keeps working unchanged. The refusal pkcs1 no longer exists.

POST /v1/credentials can make the key for you: {"ref": ..., "generate": "rsa_2048"}. The private key is never shown, not even to you, and only the worker that writes for you is handed it; the answer’s new public_key field is the value to register on the Snowflake user with ALTER USER ... SET RSA_PUBLIC_KEY = '...', and the Snowflake form puts it into its setup script. Every key-pair credential now answers its public_key (a key stored before this release answers none). Any other generate value is 422 unsupported_key_scheme.

A key pair rotates in two phases, so no running pipeline is ever left signing with a key Snowflake no longer knows. POST /v1/credentials/{ref}/rotate with {"generate": "rsa_2048"} makes a pending key while the current one keeps signing; GET /v1/credentials/{ref} shows it as pending {fingerprint, public_key, created_at}. Register it as the user’s RSA_PUBLIC_KEY_2 (after checking RSA_PUBLIC_KEY_2_FP is empty), then rotate with {"promote": "<ref>-next"}: the pending key is tested on every Snowflake destination using the credential, and only if Snowflake accepts it is the credential switched (422 key_refused carries Snowflake’s words otherwise, and nothing changes). New refusals: 409 no_pending_key, 409 credential_not_in_use, 409 pending_key_changed. A key pair’s rotation, by upload or by promote, now restarts every pipeline using it at once, and the new pipelines_restarting field counts the running ones not yet on the new key; when it reaches 0, run ALTER USER ... SET RSA_PUBLIC_KEY = '<new key>' and ALTER USER ... UNSET RSA_PUBLIC_KEY_2, which retires the old key and leaves slot 2 free for the next rotation. A value credential’s rotation is unchanged.

References ending in -next are reserved for a pending key: creating a credential, a source or a destination, or a pipeline that names one is 422 credential_ref_reserved.

The guide, A Snowflake destination, lists every key shape taken and walks through a rotation step by step.

2026-10-06 (IST) — A table you add or resume before a pipeline’s first checkpoint is copied

Section titled “2026-10-06 (IST) — A table you add or resume before a pipeline’s first checkpoint is copied”

Fixed: a table you added, resumed after a park, or asked to copy again could be synced without its existing rows, when its pipeline had not yet saved its first checkpoint. A pipeline created to sync only changes from now on, and with a table of its own to stream, saved no checkpoint until it first delivered a change, which on a quiet database can take a long time; a pipeline whose first run stopped right after parking a table had none either. In that time the worker took every table waiting to be copied to be one of the pipeline’s own first tables, and applied that first answer to it: a table you added, or parked and resumed, then streamed its new changes while the rows already in it never arrived, with nothing reported. Now a table you add, resume or ask to copy again is copied before it streams, whatever the pipeline was first told and whether or not it has a checkpoint yet; the pipeline’s own first tables still follow that first answer.

How to tell whether a table was affected: you added it, resumed it or asked to copy it again on a pipeline that had not yet delivered its first change (or whose first run had just parked a table), or in the minutes just before this release was installed, and rows that were already in the source table at that moment are missing from your destination. Use Copy again on such a table: it is copied in full, and nothing else needs to change.

Also fixed: a pipeline started while its replication slot was still being created could be stopped for good, reporting a replication gap that never happened. Creating a logical replication slot waits for the transactions already running on your database, and until it finishes the slot has no position. Such a start now saves no checkpoint and is retried for about a minute. If the slot is still being created after that, the pipeline stops as failing to start; start it again once the slot exists, and it resumes, with nothing to repair.

Changed: a physical replication slot under a pipeline’s slot name now stops the pipeline at once, and says so. It used to be retried as if it were a slot still being created, then stopped after about a minute with no reason given. The pipeline’s history now names the slot as a physical one, with the two statements that replace it with a logical slot of the same name. If the pipeline has synced before, the changes made since its last checkpoint are in no logical slot, so after the slot is replaced its tables need a fresh copy, and the message says so.

2026-10-06 (IST) — A failed run is not charged

Section titled “2026-10-06 (IST) — A failed run is not charged”

Changed: a run that ends in failure is not charged, the whole run, whoever caused it. A run is one start of a pipeline’s worker. It is charged when it ends cleanly (you stopped it, a scheduled sync finished, or we restarted it for a deploy and it stopped cleanly) and while it runs; when it ends in failure, nothing it used is charged. A deploy that lands while a run is still starting or copying, or that has to kill a worker which does not stop in time, ends that run as a failure, so it is not charged either. The retry that succeeds is a new run and is charged once.

  • How it works on your wallet: usage is still debited day by day while a run is going, because the prepaid balance has to move as you use it. When a run turns out to have failed, its share of every day already debited is refunded to your balance, and a day debited after the failure is known is refunded in the same step, so your balance never moves for it. Until a refund lands (at the next hourly billing pass) a day debited while the run was still going counts against your balance as usual, so it can pause a wallet at zero for up to that hour. A refund is never more than the debit it returns, and rounds in your favour. A pause our charge caused is lifted when the refund leaves your balance above zero.
  • GET /v1/usage: a failed run’s usage today is reported under a new classification, failed_run, “not charged”, whatever kind of work it was. The other classifications are unchanged. The enum is a response value: a client that rejects an unknown classification must accept failed_run.
  • What it replaces: until now a failure against your own source (an expired credential, a vanished table) was billed as ordinary compute, and only a replay caused by our own crash was free. There is no longer any judgement of whose failure it was.
  • One case is still charged, stated rather than discovered: a run whose pipeline you stop or delete after the run’s first failure and before its automatic restart has reached our own systems, normally a second or two (the restart writes its first row before it contacts your source or destination, so a source that cannot be reached does not lengthen this). Nothing after it says the run is over, so it stays charged until the pipeline is started again, which frees it. A stop during any later wait (the retries a failing pipeline makes for up to 14 days) is covered.
  • Run history: a restart that never reaches your source (it is down, or refuses us) now appears as a run that confirmed nothing, because a run writes its first entry as soon as it starts, before it contacts your source. Before, such a restart left no trace.

2026-10-06 (IST) — Fixes from the second end-to-end walk-through

Section titled “2026-10-06 (IST) — Fixes from the second end-to-end walk-through”

Fixed: one large source transaction no longer stalls a pipeline. A transaction that changes hundreds of thousands of distinct rows (a bulk UPDATE) was folded by a search whose cost grew with the square of its size: the pipeline sat busy for many minutes per 100,000 rows, sent nothing, and could lose its replication connection. A bulk change of keys on a table with a large column the change log leaves out met a second search of the same kind, just before the first. Both are now linear in the transaction.

Fixed: what a table’s row says while it is copied. During a pipeline’s first copy, the table being copied showed “Waiting to be copied when the pipeline next starts” on a running pipeline. It now shows Copying, with the rows copied so far, and GET /v1/pipelines/{id}/tables and the pipeline’s tables_summary say copying for it. A waiting table on a running pipeline no longer says it waits for the next start: the pipeline copies it while it runs.

Fixed, in the app: before the connection test, the new-pipeline form no longer says a pipeline syncs one table; a webhook delivery that failed on its certificate now says so (“the receiver could not be reached, its certificate was not accepted, or it did not answer in time”) instead of “no answer from the receiver”; the skip link reads “Skip to the page’s content”.

2026-10-05 (IST) — An account has API keys

Section titled “2026-10-05 (IST) — An account has API keys”

Added: API keys, so a server can call the API without a person’s session (behind REYANSH_API_KEYS, off until switched on per account). An owner creates a key in Settings → API keys (POST /v1/api-keys), names it, chooses read (GET only) or full (every operation marked for keys), and an expiry or none. The key is shown once, in the response that created it; we keep only its SHA-256 and its last four characters. Send it as Authorization: Bearer <key>.

  • Every operation says whether a key may call it. The reference names both ways in (security: the session cookie, and apiKey where a key may), and x-reyansh-api-key is the narrowest key that may call it: read, full or never. Keys never manage keys, people or money, and a person’s own routes (/v1/me) are theirs: those answer a key 403 api_key_not_allowed. A read key’s write is 403 api_key_read_only.
  • Every 401 now carries WWW-Authenticate (Bearer realm="api", with error="invalid_token" when a key was presented), as RFC 9110 requires. A browser does not prompt for it.
  • New refusals: 400 authorization_invalid (two Authorization headers, or not Bearer <key>), 400 credentials_ambiguous (a session cookie and an Authorization header together), 401 authorization_scheme_unsupported (Basic, Token), 401 api_key_malformed, 401 api_key_invalid (unknown or revoked), 401 api_key_expired (details.expired_at), 403 api_keys_not_enabled, and 429 rate_limited for an address sending many keys that fail.
  • A key in a URL is refused, 400 api_key_in_url, whatever else the request carries, and so is any /v1 request over plain http://, 400 https_required: the key may have been recorded on the way, so roll it. If the key is live, the account’s owners are told.
  • GET /v1/me gains api_keys_enabled.
  • Added: GET /v1/account: which account the caller acts for, and for a key its id, name and access. Any caller may ask.
  • Added: the key routes (owners, signed in as people): GET /v1/api-keys (?state=all includes revoked and expired keys), GET /v1/api-keys/{id} (with built: the pipelines, sources, destinations and credentials the key made, and its owner-power changes), POST /v1/api-keys/{id}/roll (a new key with the same name and access; the old one keeps working overlap_hours, 0 to 720, default 24), DELETE /v1/api-keys/{id} (immediate), and GET /v1/api-key-events (the trail). At most 50 live keys per account (409 api_key_limit).
  • Limits: 600 requests a minute per key and 1,200 across an account’s keys, with RateLimit-* on every key response and 429 + Retry-After past them.
  • Every owner is told, at their own address, whatever their notification settings: a key created, rolled or revoked; a key using owner power (adding or changing a destination, rotating a destination’s credential, changing where notifications go, copying a pipeline’s table again with delete_rows_not_in_source: true: the first change at once, the rest at most hourly); a key seen in a URL or over plain http; a key expiring in 7 days, in 1 day, and expired; a rolled key still in use when it stopped.
  • What a key does is attributed to it: a pipeline, source, destination or credential it made names the key (created_by, written_by with kind: "api_key"), never the person who created the key.
  • Settings → API keys in the app: the keys, Create (the secret shown once, with Copy), Roll, Revoke (showing what the key built, with Stop beside each running pipeline), and the key activity. A member sees who to ask. The members removal dialog lists the person’s keys with Roll and Revoke.
  • Our edge never logs a key: a key in a request’s URL is replaced and every request header is dropped from the edge’s logs, and plain http:// to /v1 reaches the API to be refused instead of being redirected.
  • Your secret scanner can find a key: they start rsk_ and match rsk_[a-z2-7]{58}; treat them as opaque, at most 255 characters. The guide is API keys.

2026-10-04 (IST) — An account has people: owners and members

Section titled “2026-10-04 (IST) — An account has people: owners and members”

Added: roles, enforced on every endpoint. A person is an owner or a member of an account. A member operates the account’s pipelines: creates, starts, stops and deletes them, creates sources and credentials, and reads everything, usage included. An owner also administers the account: its people, its money (top-ups), where its data may go (destinations) and where its notifications go (settings and channels). Every operation in the API reference now says who may call it (x-reyansh-access: public, member or owner), and an owner-only operation answers a member with 403 owner_required (details.required, details.role).

  • Destinations are owners’: POST /v1/destinations is owner-only, as Fivetran’s Account Analyst “cannot create, edit, or delete destinations”. Members create pipelines into existing destinations by destination_id.
  • Two owner rules on member operations (x-reyansh-owner-when, and details.rule on the refusal): POST /v1/pipelines with the legacy destination credential form (it creates a destination object: destination_by_credential), and POST /v1/credentials/{ref}/rotate of a credential a destination uses (rotating it repoints the destination: destination_credential).
  • Added: GET /v1/me: who is signed in, the account this session acts for, their role in it, every account they belong to, and whether the account may send invitations yet (invitations_enabled).
  • Added: the account’s people. GET /v1/members lists them (every member may read it); GET /v1/members/{user_id} shows one person and everything they created (pipelines with their state, sources and destinations with the pipelines using them, the credentials whose current value they wrote, the people who joined through their invitations); PUT /v1/members/{user_id} changes a role; DELETE /v1/members/{user_id} removes a person and answers with the same lists; DELETE /v1/me/membership leaves; GET /v1/membership-events is the account’s trail. All but the list and leaving are owners’. An account keeps at least one owner (409 last_owner), nobody changes their own role (409 cannot_change_own_role), and removal ends the person’s sessions in the account at once and withdraws the invitations they sent. What a removed person made keeps running until you stop it: the answer lists it, and the credentials they wrote are the ones to rotate.
  • Added: invitations (owners), switched on per account by the operator while we prove the flow (403 invitations_not_enabled otherwise; an open invitation then reads paused, and withdrawing still works). POST /v1/invitations invites an address as owner or member; GET /v1/invitations lists them (state=open or all); POST /v1/invitations/{id}/resend sends a new link (the old one stops working; one send a minute, four in all); DELETE /v1/invitations/{id} withdraws one. An invitation lasts 7 days, one address has at most one open invitation per account (409 already_invited), an account sends at most 30 invitation emails a day (429 rate_limited with Retry-After) and holds at most 50 open ones. No answer ever carries the invitation’s link: it is in the email only. A send that failed is a 201 with delivery: not_sent; send it again.
  • Added: joining, and one person in several accounts. An invitation’s link only shows it (POST /v1/auth/invitations/preview); the invited person joins by signing in with the invited address and choosing it. POST /v1/auth/session answers a person with several accounts or an open invitation with 409 account_choice_required (details.accounts, details.invitations) and does not spend the link: send it again with account_id, invitation_id or decline_invitation_id. POST /v1/auth/switch moves a signed-in person to another of their accounts; the new session ends when the old one would have. account_ambiguous is retired. Signing in, joining or switching ends the session this browser held.
  • Added: a browser names the account it is acting on. DELETE /v1/me/membership, PUT /v1/members/{user_id} and DELETE /v1/members/{user_id} read an optional X-Reyansh-Account header; when it names another account than the session’s (another tab or window switched), the answer is 409 account_changed and nothing changes. Without the header they act on the session’s account, as before. The app sends it, re-reads the account before each of the three, and reloads every open tab when one of them switches account, signs in or signs out.
  • Changed: an undocumented path under /v1, or a wrong method on a documented one, is 404 not_found, outside the sign-in endpoints (/v1/auth/). A wrong method answered 405 before. The sign-in endpoints are served before there is a session, outside this check, and a wrong method there is still 405.
  • Changed: the sign-in endpoints (/v1/auth/*) accept a body only as application/json (415 unsupported_media_type otherwise; sign-out takes no body) and refuse a request from another site (403 cross_site_request: Sec-Fetch-Site: cross-site, or an Origin that is neither this site nor on the configured allowlist).
  • Changed: an Idempotency-Key belongs to the person who sent it. The same key sent by another person of the account is 422 idempotency_key_reuse, never the first person’s answer. A key used before this release still replays its own request.
  • Added: each person chooses their own email. PUT /v1/me/notifications (and notifications on GET /v1/me): which pipelines (none, created_by_me or all) and which severities, sent to the person’s own sign-in address. The default is the pipelines you create, errors on, warnings off. A pipeline made before people could be told apart has no creator, so created_by_me covers only new ones. Running out of credit goes to every owner, whatever they chose (none included), and never to members, and nobody gets the same email twice: a person whose address is the account’s notification address gets the account’s copy when the account’s switches send it, and their own when they do not.
  • Added: owners are told when an owner is added or removed (account_owner_added, account_owner_removed in What was sent), whatever their own choices and mutes. The notice is sent after the change commits, once, even if a deploy is running two dispatchers.
  • Changed: What was sent shows a person’s delivery (scope member:<user_id>, with recipient while they are a member). A delivery to someone who has since left is not sent, reads recipient_removed, and cannot be resent.
  • An account with no notification address takes it from an owner’s sign-in, never a member’s.
  • Added: written_by on GET /v1/credentials/{ref}: who wrote the credential’s current value (user_id, and email while they are a member), absent for a value written before people were recorded. Whoever wrote a credential knows it: check it before attaching a credential to a destination.

2026-10-04 (IST) — A PostgreSQL pipeline syncs many tables

Section titled “2026-10-04 (IST) — A PostgreSQL pipeline syncs many tables”

Added: tables on POST /v1/pipelines. A pipeline from a PostgreSQL source names its tables as {"schema": ..., "name": ...} pairs, up to 1,000, from as many schemas as you like. Each table lands in the destination schema its own source schema names (destination_schema_naming): with Fivetran naming sales.orders lands in <pipeline>_sales and public.customers in <pipeline>_public; with source naming in sales and public; and a Postgres destination writes each table in the schema of the same name. streams still works, each name read as a table in public, and a PostgreSQL source now takes several.

Added: setup on a PostgreSQL pipeline, in create’s answer and on GET /v1/pipelines/{id}: the statements that publish exactly its tables, and the slot to create just before Start. The publication is created WITH (publish_via_partition_root = true) and each table added with its own ALTER PUBLICATION ... ADD TABLE ONLY, so tables with different owners can each be added by their owner, and an inheritance parent never brings its children (whose own UPDATE and DELETE would otherwise need a replica identity). The connection test’s statements take the same shape, with a placeholder table. We never run them.

New refusals on create (422, yours to change): tables_and_streams (both lists sent), duplicate_table, invalid_table_name (blank, over 63 bytes, or holding a NUL, or a Snowflake reserved name), too_many_tables, destination_table_collision (two tables your destination would write as one, such as Orders and ORDERS into Snowflake) and destination_schema_collision (two source schemas it would write as one), each naming both, and tables_need_postgres.

Added: a pipeline’s tables. GET /v1/pipelines/{id}/tables lists them, by schema and name, each with its state (waiting, copying, catching_up, streaming, parked or removed), where it lands, its key, its latest copy, why it parked and what brings it back, and any request waiting to be applied. Four requests change one table, each applied by the pipeline when it next starts (a running pipeline restarts onto it within a minute; the answer’s takes_effect says which):

  • POST /v1/pipelines/{id}/tables adds tables to a PostgreSQL pipeline (a removed one is asked back), refused as create refuses its tables, and answers the statements that publish them;
  • DELETE /v1/pipelines/{id}/tables/{table_id} removes one (its rows stay in your destination; the last table is refused with last_table: delete the pipeline instead), and answers the optional statement that takes it out of the publication;
  • POST …/tables/{table_id}/resume resumes a parked table (not_parked otherwise);
  • POST …/tables/{table_id}/recopy copies it again, keeping the rows your destination has that the source no longer does, or, into a Postgres destination with {"delete_rows_not_in_source": true}, deleting them (delete_not_applicable into Snowflake, whose copy already marks them deleted); copy_in_progress and table_removed refuse it.

One request at a time per table: another while one is pending is table_action_pending, naming it; the same request again answers the table and records nothing. GET /v1/pipelines/{id} gains tables_summary, the tables counted by what they are doing.

Added: a pipeline we stopped is started again by us. If an older release of Reyansh ever runs a pipeline a newer release changed (our rollback), it refuses rather than guess, and the pipeline stops. When the newer release is back it is started again on its own, and its history says so (restarted_after_roll_forward). If another pipeline took one of its tables meanwhile, it is left stopped for you, and its history and its page say which table and which pipeline (restart_refused).

Added: the connection test lists the source’s tables. For a PostgreSQL source, POST /v1/connections/test answers catalogue: every table and partitioned table the source’s role may read (a partition is synced through its table and not listed on its own), up to 10,000, each with the key a pipeline would sync it by (primary_key, replica_identity or none, with why), whether it is partitioned and how many partitions it has, about how many rows it holds, its owner (who can add it to a publication), and whether the pipeline’s publication covers it already. catalogue_schema narrows it to one schema; catalogue.more says how many were left out. It also answers server_version_num.

Added: picking many tables, and a pipeline’s tables, in the app. The new-pipeline form lists every table your source’s role can read, with its key, its size, whether it is partitioned and its owner, and you tick as many as you like, by schema or one by one; it shows where each will land before you create the pipeline. The pipeline’s page shows the statements to run on your source, and a Tables section: each table’s state, why one stopped and how to bring it back, any change waiting for the next start, and Resume, Copy again, Remove and Add.

Added: a table added to a running pipeline is copied when the pipeline next starts. A table you add, add back, resume after a stop that let its place go, or copy again, waits until the pipeline’s publication lists it, then is copied before the pipeline resumes streaming: its existing rows first, then its changes, and the pipeline’s other tables pause while it copies and catch up after, losing nothing. Fivetran keeps the other tables syncing during such a copy; a later release of Reyansh will too. A table that cannot be copied yet says why on its row and in the pipeline’s history (table_waiting): the source does not publish it yet (with the statement that does), its PostgreSQL 17 release before 17.6 can lose an added table’s changes (upgrade to 17.6 or later, or create a new pipeline for the table), or copying it then would hold more of the source’s change log than it keeps for the pipeline’s slot. A finished copy is table_copied. GET /v1/pipelines/{id}/tables gains waiting.reason, and rows_not_in_source.removed (what a “copy again and delete” actually deleted, which can differ from the count you confirmed).

Added: a table copied again says which of your destination’s rows the source no longer has. When a table that synced before is copied again (you copy it again, add it back, or resume it after a stop that let its place go), the copy ends by finding the destination rows it did not write, and the pipeline’s history says how many (table_reconciled, with rows_not_in_source and removed). Into Snowflake they are marked deleted (_REYANSH_DELETED_AT), as Fivetran’s re-sync marks the rows it did not fetch again. Into a PostgreSQL destination they are kept and counted, because the table is yours and may hold rows you wrote, and deleted only when you copy again with {"delete_rows_not_in_source": true}. A count that could not be proven is said (not_counted), never shown as 0, and deletes nothing. Copying a table again into PostgreSQL counts in a temporary table, so the destination role needs TEMPORARY on its database (every role has it unless it was revoked); a role without it stops the pipeline with the GRANT to run.

Added: a waiting table is copied as soon as it can be, without a restart. A table waiting for its publication is copied within about a minute of the publication listing it, and one waiting for room in the source’s change log once the source has room, while the pipeline runs: the pipeline pauses its other tables, copies the table, and carries on, in the same run. Its history says so (pipeline_reentered, naming the tables).

Added: partitioned tables sync through their root. A partitioned table is one destination table, named after the root, holding every partition’s rows; the role needs SELECT on the root alone. A partition attached while the pipeline runs is told on its history (partition_attached): PostgreSQL does not send the rows it held when it was attached, so copy the table again to include them. A partition detached is told too (partition_detached); its rows stay in your destination. Every partition must carry the table’s key in its replica identity: one that does not keeps the table waiting, naming the partition and the statement to run.

Fixed: a table copied again after an earlier copy of it stopped part-way is reconciled. A copy that was parked after its first rows (a value your destination refused, say), or interrupted, and then resumed, used to be copied again with no check for rows your source had deleted meanwhile, which stayed in your destination as if in sync. It is now reconciled like any copy over rows the pipeline wrote: Snowflake marks them deleted, PostgreSQL counts them. And a table a crash left mid-copy whose name now names another table is parked, naming both, rather than copied beside the old rows.

Fixed: a restart while a table was parked “keeping its place” re-wrote the other tables. Every start re-sent the changes since the parked table’s place, and every other table wrote them again (converging, but costing your destination’s time and showing older values meanwhile). They are now skipped.

Fixed: a waiting table whose partition did not carry its key was checked only at the next start. It is checked about once a minute, as the guide says, and copied once every partition carries it.

Changed: a copy stops between batches when your source runs short of room for its log. On a source that limits the change log kept for the slot, a copy that has used half of that room stops, the table waits, the other tables catch up and free the log, and it is copied once more when there is room, instead of risking the slot of every table. Stopped a second time, the table is parked, naming the setting to raise (max_slot_wal_keep_size), rather than paused-and-retried for good.

Fixed: an ordinary table that other tables inherit from was copied with its children’s rows, which then never changed again in your destination, because the stream sends only the parent’s own changes. Its copy now reads the parent alone (ONLY), as its stream does.

Changed: a table with no key waits instead of stopping its start. It waits on its own (waiting.reason = key), naming the fix (a primary key, or a unique index made its replica identity), and the pipeline’s other tables sync; it is copied by itself within a few minutes of having one. On a pipeline created without copying existing rows, such a table found at the first start is parked instead, as before: Resume it, and it is copied once it has a key. See A pipeline’s tables.

Changed: a table you resume after its name came to belong to another table follows the new one. A table stopped because it was dropped and re-created, or another table was renamed into its place, is copied from the table that has the name now when you resume it, and pinned to it. A table that is streaming is still stopped by name, never followed silently.

Changed: one_stream_per_pipeline is now only for a MySQL or Stripe source, which still syncs one stream per pipeline.

Changed: the one-writer check (destination_table_taken, destination_schema_taken) judges each table in the schema it lands in. Two pipelines may write sales.orders and public.orders beside each other; a Fivetran-named schema stays written by one pipeline, in every schema it writes.

2026-10-04 (IST) — A session’s log retention is shown again

Section titled “2026-10-04 (IST) — A session’s log retention is shown again”

Fixed: retention_pressure on a streaming pipeline’s sessions (GET /v1/pipelines/{id}/runs) was always absent. The worker reports how much log your database holds for the pipeline as a measurement, and we read it as text, so it was dropped. It now reads held_bytes=<n> headroom_bytes=<n> (or headroom_bytes=unbounded when your database sets no limit), the worker’s own numbers, exact however large.

2026-10-04 (IST) — Settings → Webhooks and Slack, What was sent, and a pipeline’s mute

Section titled “2026-10-04 (IST) — Settings → Webhooks and Slack, What was sent, and a pipeline’s mute”

Added: Settings → Webhooks and Slack. Add a webhook or a Slack channel, choose what it hears, send it a test, switch it off and on, rotate a webhook’s secret or delete a channel. A webhook’s signing secret is generated in your browser and shown once, before you save: store it, tick “I have stored this secret”, then save. We never show it again.

Added: What was sent (from Settings and from Alerts): every notification of the last 30 days, where each went and whether it arrived, with Resend where it can be sent again.

Added: Settings → Notifications has “Send a test email” and “Choose per event”, where each event can follow its switch, always be emailed, or never be. Running out of credit and a channel we switched off are always emailed while an address is set, so PUT /v1/notification-settings refuses a choice for either with 422 invalid_field.

Added: on a pipeline’s page, mute its notifications for an hour, a day or until you unmute, and set its alert thresholds (how late is late, when the database’s log warning raises, and after how long without data to warn).

2026-10-04 (IST) — Webhooks and Slack, a notification history, test sends, and a pipeline’s mute and thresholds

Section titled “2026-10-04 (IST) — Webhooks and Slack, a notification history, test sends, and a pipeline’s mute and thresholds”

Added: notification channels. POST /v1/notification-channels adds a signed webhook or a Slack incoming webhook (at most 20 per account); GET, PUT and DELETE /v1/notification-channels/{id} read, replace and delete one. A channel has its own errors, warnings and recoveries switches, per-trigger overrides (triggers) and a pipeline filter (pipelines: "all" or a list of ids). It hears an episode only if it existed when the episode began.

  • The URL and the signing secret are never returned: responses carry url_hint, signing_secret_hint and signing_secret_id only. A webhook’s signing secret is generated by you (whsec_ and 24 to 64 random bytes in base64; the app generates one in your browser) and sent once. Every delivery is signed with it twice: Reyansh-Signature (t=…,v1=…) and the Standard Webhooks headers (webhook-id, webhook-timestamp, webhook-signature), so you can verify with either. Deliveries are at least once: dedupe on Reyansh-Webhook-Id. Slack has no dedupe, so a crash at the wrong moment can post a message twice.
  • The URL’s host is judged before it is saved: 422 url_refused for an address we will not send to, 422 url_unresolvable for a host that does not exist.
  • POST /v1/notification-channels/{id}/rotate-secret replaces a webhook’s secret; the old one keeps signing for overlap_hours (0 to 24, default 24). Sending the current secret again changes nothing. A different secret during an overlap is 409 rotation_in_progress unless drop_previous is true.
  • Retries and health: a failed delivery is retried at 5 s, 5 min, 30 min, 2 h, 5 h, 10 h, 14 h, 20 h and 24 h (each with some jitter), honouring Retry-After up to an hour, ten attempts in all. A receiver answering 410 is disabled at once; one failing for five days, after failing for 12 hours, is disabled as failing. You are emailed channel_disabled either way, and PUT with enabled: true switches it back on.

Added: POST /v1/notification-channels/{id}/test and POST /v1/notification-settings/test send a test of a trigger ({"trigger": …}, default new_error; the body may be left out) now and answer what happened: delivered, status, error (our words, never the receiver’s body) and latency_ms. A failed send is still 200: the test ran. Ten test emails and ten channel tests a minute per account, each its own limit.

Added: GET /v1/notifications, what you were told and where, newest first, for 30 days, each event with its delivery on every scope; filter by pipeline_id, scope, trigger or state. POST /v1/notifications/{event_id}/deliveries/{scope}/resend sends one again (only a finished delivery; a pending one is 409 delivery_in_progress; a stop email sent by the earlier delivery path is 409 resend_not_available; a kind this deployment never sends, such as email with no mail provider, is 503 not_configured). Each delivery says whether it can be resent (resendable) and, when not, why as a closed code (not_resendable_code: in_progress, legacy, channel_off, not_configured).

Added: GET /v1/notification-triggers, every condition a notification can be about, with its severity, default, wait and what ends it. GET and PUT /v1/notification-settings carry email’s per-trigger overrides as triggers (optional on PUT).

Added: a pipeline’s mute and alert thresholds. PUT /v1/pipelines/{id}/notifications ({"muted": true, "until": …}) mutes who is told, never the alerts; unmuting does not send what happened meanwhile, and a recovery of something you were already told about is still sent. GET and PUT /v1/pipelines/{id}/alert-thresholds set grace_minutes, source_log_percent, source_log_bytes and stall_minutes (null is the default); changing them does not restart the pipeline.

2026-10-04 (IST) — Email for every trigger, and one more when the problem is over

Section titled “2026-10-04 (IST) — Email for every trigger, and one more when the problem is over”

Changed: notification email now covers every condition that needs you, not only a stopped pipeline. Errors: a pipeline that stops and will not restart on its own, and one that keeps failing to start (from the second failed attempt). Warnings: a sync running 60 minutes past due, a pipeline that keeps stopping and restarting, rows your destination discarded, values changed to fit, no data moved for longer than the threshold you set, and your database holding a lot of log for a pipeline. Running out of credit is always emailed while an address is set, whatever the switches say: only you can add credit.

  • Warnings are emailed again when you turn them on. The switch had been hidden because nothing delivered a warning; Settings shows it again. The database-log warning is sent by default even with warnings off, until you switch warnings yourself: a full disk stops your own database.
  • A recovery email: when a problem you were emailed about is over, one more email says so (a sync completed, credit added, data moving again). It goes only where the first one went, and waits for it: when the first email or webhook is still being retried, the recovery follows once it is delivered, and is not sent at all if it never was. Turn it off with recoveries: false.
  • A broken pipeline you start again and again is emailed once until it recovers; the next stop after a recovery is a new email.
  • Nothing is ever resolved by an alert disappearing: one alert can hide another (out of credit hides a delay), and a restart of ours clears some for a moment, so each problem ends only on its own fact (a completed sync for a delay, an hour of stable running for a stop, and so on).
  • GET /v1/notification-settings carries recoveries (on unless switched off), and PUT accepts it as optional: a body without it keeps what is stored, so an older client cannot switch it off by omission.
  • Each email the new triggers send is retried after 1, 5 and 30 minutes and 2 hours, then given up; one recorded more than four days before it could be sent is not sent at all.

2026-10-04 (IST) — Two new alerts: your database holding a lot of log, and data that stops moving

Section titled “2026-10-04 (IST) — Two new alerts: your database holding a lot of log, and data that stops moving”

Added: source_log_held, a warning raised when your PostgreSQL database is holding a lot of its log (WAL) for a pipeline. A replication slot keeps log until the pipeline reads it, and we never drop your slot, so a slot that falls behind fills your database’s disk. The alert is raised when the newest measurement the pipeline reported holds at least half of the room the slot had (held plus what is left before the database invalidates it), or, when your database sets no limit (max_slot_wal_keep_size unset, which means the disk is the limit), at 20 GiB held. Both are our reasoned defaults, not measured ones, and each pipeline’s can be changed (a smaller percentage warns earlier). It is on by default.

  • It cannot see a pipeline that is stopped or given up: no worker runs, so nothing measures the slot while it grows. The pipeline’s page and our notifications say so.
  • GET /v1/pipelines/{id}/alerts and GET /v1/alerts carry source_log on it: held_bytes, headroom_bytes (absent when your database sets no limit), threshold_bytes and measured_at.

Added: no_data_moved, an opt-in warning raised when a running pipeline has applied no batch for longer than a threshold you set. It is off until a threshold is set. The time is counted from the newest batch, or from your last change to the pipeline (a start, for example) when that is later, and never from a restart of ours, so a deploy does not reset it. It is measured as a continuous duration: data 90 seconds old is 90 seconds old, whichever side of an hour it fell. It carries stall: since and threshold_seconds. A source with nothing to send looks exactly like this, which is why you choose the threshold; set it above how often your pipeline runs.

  • GET /v1/alerts: a page may now overshoot limit by up to 6 alerts (it said 4), because a pipeline can raise up to 7 at once.

2026-10-04 (IST) — Four more address ranges are refused when we connect where you say

Section titled “2026-10-04 (IST) — Four more address ranges are refused when we connect where you say”

Changed: the connection test and a pipeline’s start now also refuse four kinds of address that are not public destinations. 0.0.0.0/8 (only 0.0.0.0 itself was refused), 240.0.0.0/4 (reserved, including 255.255.255.255), and IPv6 addresses that carry an IPv4 address inside them, NAT64 (64:ff9b::/96) and 6to4 (2002::/16), which are now judged by the address they carry: 64:ff9b::a00:1 is refused as the private address 10.0.0.1 it is. A host you can reach from the internet is not affected. The refusal says the same one sentence as before and never names the address a name resolved to.

2026-10-04 (IST) — A pipeline that stops is emailed the first time it stops

Section titled “2026-10-04 (IST) — A pipeline that stops is emailed the first time it stops”

Fixed: a pipeline that stopped once was not emailed. The “Syncing is blocked” email waited for a pipeline to fail twice in a row. But a pipeline only stops after its automatic restarts have run out, and it stays stopped until you start it again, so a pipeline whose restarts ran out once, or that stopped itself to wait for you (for example over a schema change), sat stopped with no email. A busy pipeline was worse off: when many batches arrived between two stops, neither stop was emailed.

  • Now one email is sent when a pipeline stops and will not restart on its own, from the first stop, however busy the pipeline is, and one only until it recovers: a pipeline that stays stopped is emailed once, not once a minute.
  • The email says when it stopped, in UTC (“It stopped on 2026-10-04 07:12 UTC and will not resume on its own.”), instead of “The last 2 runs failed”.
  • On the deploy that brings this, a pipeline that stopped once earlier and was never emailed is emailed then, naming the time it stopped, because it is still stopped and nobody was told. The email settings at the moment it stopped still decide whether it is sent: a stop from a time when error email was off, or when no address was set, is not sent.
  • The link in the email now escapes the pipeline’s name, so a pipeline created before the name rule, whose name holds a character such as ?, # or /, links to its own page.
  • Pressing Start on a pipeline that stops again at once sends nothing more until it recovers; the next stop after a recovery is a new email. (Corrected 2026-10-04 (IST): this line first said one email for each stop, which the open-episode rule of the same pull request does not do.)
  • Settings → Notifications says so: “one email until it recovers: starting it again without a recovery sends nothing more, and the next stop after a recovery is a new one.”

2026-10-04 (IST) — A first sync of a large table no longer restarts every 30 seconds

Section titled “2026-10-04 (IST) — A first sync of a large table no longer restarts every 30 seconds”

Fixed: a PostgreSQL pipeline’s first copy of existing rows was cut off after 30 seconds and started again from the first row, for ever. Any table whose first copy took longer than that, because it is large or because the destination takes its time writing, never finished its first sync. The copy now runs for as long as it needs to; the short reads we make on your database before it (which table, which columns, where the replication slot stands) still give up after 30 seconds, so a lock held on your catalogue cannot keep a pipeline waiting for ever.

  • Nothing to do on your side. We set this per connection, so your server’s own statement_timeout is left as it is and does not have to be raised for us. The same goes for a transaction_timeout (PostgreSQL 17 and later) set on the role or database we connect as: it no longer ends the first copy part-way either.
  • While a first copy runs, it holds one open read on the table (a shared lock and a snapshot) for the whole copy. A schema change on that table, such as ALTER TABLE, waits until the copy finishes, and while it waits, every later query on that table waits behind it too: for the whole copy now, where the cut-off used to end that wait after 30 seconds. Make such a change before the first sync starts or after it has finished.

2026-10-04 (IST) — What you see before go-live: alerts, stops and restarts told truly

Section titled “2026-10-04 (IST) — What you see before go-live: alerts, stops and restarts told truly”
  • An alert whose report could not be read says so in more cases. A discard or fitted-value report that names no table, or a column with no name, was read as naming nothing; it now counts in unreadable_reports, as any report the server cannot read does. A discard alert across more than three tables now says “at least” its rows when one of its reports could not be read.
  • A stopped pipeline’s page no longer shows a stop from an earlier attempt as the reason. A pipeline that announced a stop, was then stopped and started by you (or restarted by one of our deploys) and gave up before its worker said anything new, showed the old stop. The page now shows only what the worker said during the attempt that gave up, and otherwise the give-up’s own reason.
  • A quiet session no longer reads “Nothing confirmed yet”. In a pipeline’s Sessions, a session that was asked to stop with nothing ready to write now says “Connected; nothing was ready to write when it was asked to stop” (a transaction still arriving at that moment is written by the next session); “Nothing confirmed yet” is kept for a session still running; any other session that wrote nothing says “Nothing confirmed”. API: GET /v1/pipelines/{id}/runs gains no_write on a session that confirmed no write (nothing_to_write, not_yet or none; absent when a write was confirmed). Treat a value you do not know as none.
  • A pipeline whose worker keeps stopping no longer reads healthy because it delivers a little each time. As Fivetran counts every sync that ends in failure, every stop now counts, whether or not data was written first. From the second stop in a row, each is in the pipeline’s history (launch_retrying, saying how the worker stopped; a worker killed outright, as the system’s out-of-memory killer does, is named), the health word is retrying, and a new alert, keeps_stopping, says so as a WARNING, because data still moves between the stops. It is restarted at once each time rather than on the retry schedule, though a worker that dies within a few seconds of every start is still given up after five restarts in 60 seconds, as any crash loop is; the word clears once a run has stayed up an hour or a sync completes. API: GET /v1/alerts and GET /v1/pipelines/{id}/alerts may now answer kind: keeps_stopping.
  • A stop that a restart cannot fix no longer blames your configuration. When the worker exits with code 2, the history’s give-up row and the pipeline’s reason said “the worker reported a configuration fault”. Code 2 also covers faults that are ours. It now says only what the code means: restarting cannot help, and a person must act on what the pipeline’s history says. Where the worker said why, the pipeline’s page still shows its own words.
  • A pipeline’s name must follow the rule the form states. Letters, numbers, dashes and underscores, from 1 to 63 characters. API: POST /v1/pipelines refuses any other id with 422 invalid_pipeline_name. A pipeline created before this keeps its name, and can still be read, started, stopped and deleted by it. The create form says the rule beside the field. GET /v1/destinations/{id}/schema-preview refuses such a pipeline_id the same way, so a name create would refuse is no longer previewed as free.
  • A pipeline’s page shows only the actions that apply. A running pipeline shows Stop, as the main button; a stopped one shows Start. A given-up pipeline, or one at rest after a manual sync, shows both, with Start first. (Start on a pipeline that is already running, through the API, changes nothing and restarts nothing.)
  • Notification email is on from your first sign-in. An account that has never saved its notification settings now gets the address its member signed in with, with errors on and warnings off, the first time a member signs in (as Fivetran enables notifications for an account by default). An account that saved its settings, including one that turned email off, keeps what it saved.
  • Where to reach us is shown. The app has a Support link in its header, and a pipeline’s page and its history show “To reach us, write to …” under a stop, a refusal and a give-up, whose own words can say “contact support”. The notification email ends with the same line.

2026-10-03 (IST) — A Snowflake pipeline that cannot load from files says so, and no batch outgrows the worker’s memory

Section titled “2026-10-03 (IST) — A Snowflake pipeline that cannot load from files says so, and no batch outgrows the worker’s memory”

New on the activity feed: bulk_load_paused, “Large batches written the slower way”. When a Snowflake pipeline stops loading its large batches from staged files and writes them by INSERT instead, the feed says so once, with the reason (a status and a code, never a value) and for how long. Every row is still written exactly as before; the slower way takes more of your warehouse’s time, which is why you are told. It is not a failure: no alert, no email.

  • Why, and for how long.
    • For the next 30 minutes, then files are tried again, after two large batches in a row could not use them: the stage’s storage refused the upload or did not answer it, Snowflake did not answer the upload’s sign-in or its request for the stage, refused either with an HTTP 429 or 5xx, or did not load the files as they were sent.
    • Until the pipeline next restarts, when files are tried again: Snowflake refused the upload’s sign-in or its request for the stage’s location in a way that does not pass by itself, or answered in a shape this version does not read.
    • For this account: its stage is in Google Cloud Storage or Microsoft Azure Blob Storage, or uses a storage endpoint, bucket, region, encryption cipher or key this version does not upload to. A restart does not change that, and the feed does not suggest one.
  • A single refusal that may pass (an HTTP 429 or 5xx) no longer turns loading from files off for days.
  • A load Snowflake refuses no longer restarts the pipeline. The batch is staged again by INSERT at once, and only that batch.
  • Files a refused upload left in the service user’s stage are removed at once, not when the pipeline next starts. Files are not swept for a pipeline you delete, a table you deselect, or a service user you replace: they are encrypted, a batch’s worth at most, and you can remove them with REMOVE @~/reyansh/ as that user.

Fixed: a wide table no longer takes the worker’s memory. A batch is now also bounded by what it holds in memory, 128 MiB, for every pipeline, Snowflake and PostgreSQL, the first copy and the stream alike. A table of many columns, or of many empty ones, was batched by its count of rows and the size of its values alone, and one batch of a 300-column table could need gigabytes; it is now cut into batches of a few thousand rows. Tables like the ones we measured are batched exactly as before. A PostgreSQL pipeline is affected only by rows larger than about 134 KB.

2026-10-03 (IST) — A report the server cannot read costs its own alert’s detail, and never a stop

Section titled “2026-10-03 (IST) — A report the server cannot read costs its own alert’s detail, and never a stop”

Fixed: a pipeline can always be stopped. One event row the server could not read (a values_fitted report whose fitted is not a list of column names, or a rows_discarded report whose rows is not a number) made POST /v1/pipelines/{id}/stop answer 500 with the pipeline still running, and so did start, PUT /v1/pipelines/{id}/schedule, PUT /v1/pipelines/{id}/discarded-rows and DELETE /v1/pipelines/{id}. None of them reads a report any more.

Fixed: GET /v1/pipelines, GET /v1/pipelines/{id} and GET /v1/alerts answer beside such a row. The pipelines list and a pipeline’s answer show nothing a report holds, and no longer read one. The account’s alert list answered 500 for every pipeline in the account; now only the alert the row belongs to is affected, and it says so.

New on rows_discarded and values_fitted alerts: unreadable_reports, how many of the reports of the last 24 hours the server could not read. The alert is still raised, and names such a report’s table when that much of it reads; that table has no count in rows_by_table, and the report’s columns are not in columns_by_table. Absent when every report was read.

Changed: a name longer than a source’s name can be is not shown. A report naming a column longer than 64 characters or 192 bytes (MySQL allows 64 characters, PostgreSQL 63 bytes), or a table longer than 129 characters or 385 bytes (a schema, a dot and a table), is counted in unreadable_reports instead of being echoed.

Which reports are parsed. The server fetches a pipeline’s newest 51 reports of each kind and parses only those among the newest 50 that are from the last 24 hours. Any other report adds no table, count or column and is never counted in unreadable_reports, whatever it holds; one from the last 24 hours past the newest 50 still sets tables_partial, as before.

In the app: a rows_discarded or values_fitted alert says how many of its reports from the last 24 hours could not be read, under the tables it names, so what it names is not shown as if it were all.

2026-10-03 (IST) — What a first pipeline into Snowflake says, corrected after walking it end to end

Section titled “2026-10-03 (IST) — What a first pipeline into Snowflake says, corrected after walking it end to end”

Fixed: a pipeline’s Sessions table splits no run in two. The initial copy’s events come before the run’s start; the copy was shown as a session “Started before the window” with its volume “Not known”, and the run as 0 rows. One session now carries the copy’s rows and its confirmed write (GET /v1/pipelines/{id}/runs).

Changed: a source or destination’s “Connection” says what it records: whether a test passed before it was saved (“Tested before it was saved” / “Not tested before it was saved”). A Snowflake destination is saved before it is tested, so it read “Never tested” after every test.

The new-pipeline form says a table must be in the public schema before you create the publication, and does not ask you to pick a table when none in the publication can be synced.

The new-pipeline form warns about a table with no usable key before you publish it: once a table is in a publication, PostgreSQL refuses every UPDATE and DELETE on it unless it has a replica identity. A DEFERRABLE primary key is not one, and needs REPLICA IDENTITY FULL first; a table with no primary key cannot be synced yet (its pipeline refuses to start). The form says what those ALTER TABLE statements cost: an ACCESS EXCLUSIVE lock on the table while they wait and run (it suggests SET lock_timeout = '5s'; first, so the statement gives up instead of queueing behind your traffic), and, under FULL, the whole old row written to the write-ahead log by every UPDATE and DELETE for as long as it stays. A deleted pipeline’s page and Deleting a pipeline give the statement that sets it back, apart from the clean-up the copy button copies, to run only after DROP PUBLICATION and never while any publication still sends the table: with a DEFERRABLE key, DEFAULT under a publication makes PostgreSQL refuse every UPDATE and DELETE.

The new-pipeline form’s test of a Snowflake destination says what it does there: it creates a schema named _REYANSH_check_… and drops it, and the form now shows the permission test’s answer and any test schema left behind, with the statement that drops it.

Fixed: a PostgreSQL source user with only REPLICATION and SELECT can start a pipeline. On PostgreSQL 18.6+ and 17.11+ every start read a setting (output_plugin_libraries) that such a user may not examine, and failed; the server enforces that setting itself, so it is no longer read as a refusal. The connection test now asks the start’s server-wide question before a table is picked, too.

Changed: a read of your source’s catalogue that your server refuses stops the pipeline and says why. A privilege the source user lacks, for example: the stop quotes PostgreSQL’s code and message and says what to grant, and the pipeline is not restarted, where before it was restarted five times and showed “exit code 1”.

The Snowflake destination guide lists the type each column lands in. A numeric with no precision lands as exact text (VARCHAR), and its NaN as the text NaN.

2026-10-03 (IST) — A large source transaction is delivered in full after a stop or a failure

Section titled “2026-10-03 (IST) — A large source transaction is delivered in full after a stop or a failure”

Fixed: silent data loss. A change made in one source transaction that a batch boundary fell inside (any transaction of two rows or more can be cut; one of more than 1,000 changes, the default batch, always is) was delivered only in part if the pipeline stopped, failed or lost its connection before the transaction’s last batch was written. A deploy stops every pipeline, so this needed nothing unusual. The pipeline then resumed after the whole transaction and never wrote the rest, and nothing reported it.

  • Now a transaction counts as delivered only once every row of it is written. A stop or a failure part way through leaves the pipeline’s position before the transaction, and the next run delivers all of it. Rows already written are written again, by key, as any replay is, so they are not duplicated.
  • A transaction larger than one batch is written in pieces, and appears in the pipeline’s activity as one batch when its last row is written.
  • Known limit. A transaction that takes longer to write than the pipeline runs between stops is written again from its start after each stop.
  • Fixed: a lost source connection is told as one. A PostgreSQL replication connection that the network or the server closed was reported as “unexpected message during connection startup … a bug on our side”, and during connection start-up it was not retried. It is now reported as a lost connection, and retried; nothing past the last saved position was acknowledged to the source, so nothing is lost.

Fixed: rows and bytes in your usage figures. A batch that began inside a transaction the batch before it had cut was counted as a repeat of rows already counted, so rows_delivered and bytes_moved read low under load. Every delivered row is now counted once. These figures are your receipt; you are billed for resources used, which this did not affect.

2026-10-02 (IST) — A delete records who made it, and a deleted pipeline says only what it can have left

Section titled “2026-10-02 (IST) — A delete records who made it, and a deleted pipeline says only what it can have left”

New on a deleted pipeline: deletion.deleted_by (user_id, email, request_id): who deleted it and in which request, recorded with the delete and never changed. deletion.source_cleanup.acknowledged_by is the same for the acknowledgement.

New on a pipeline: activity (worker_ran, progress_saved), source_kind and destination_kind, on the answers that carry destination_tables.

Changed: deletion.kept_tables and kept_working_schema are present only for a pipeline whose worker ran. A pipeline that never ran wrote nothing, and its answer no longer names tables it never created.

Changed: GET /v1/destinations/{id}/schema-preview answers taken with the code pipeline_exists for an id that is already a pipeline’s or was a deleted pipeline’s.

Changed: an id that is in use answers 409 pipeline_exists on create, whichever form the request took. A second create of an existing id by credential references answered 409 connector_object_exists; it now says the pipeline exists, and an id that belonged to a deleted pipeline says it is retired.

New: a pipeline that cannot have its first run says so in its notice. A stopped pipeline that has never saved progress and reads a source kind that is not offered for new work (Stripe and MySQL today) says which kind, why, and that nothing is wrong with the pipeline or its credentials. Starting it is still refused with 422 unsupported_kind.

Corrected: a refused test of a stored Postgres destination never relays the stored password, whatever its length. A password shorter than nine characters could be relayed if the database’s refusal echoed it. The refusal’s sentence is now replaced when it contains the password, in either spelling, or the whole stored string. The user, the host and the database name are still relayed: they are what the refusal is about.

In the app:

  • A deleted pipeline’s page says who deleted it and the reference of that request, and the same for the clean-up’s acknowledgement.
  • That page, and the step that deletes, say only what can have happened. For a pipeline that never ran they no longer say that tables were kept, that a working schema was left, or that a replication slot was read. Tables are named only for a pipeline that ran.
  • Both say that the pipeline’s source, destination and stored credentials stay in your account, and that there is no way to remove them yet.
  • A Snowflake pipeline’s page no longer asks the two destination questions, which do nothing there. It says what Snowflake does instead.
  • The new-pipeline form says “That pipeline name cannot be used” for a name that is in use or was a deleted pipeline’s. It said “Another pipeline already writes there”.
  • The pipelines list says “No pipelines yet” only for an account with none. With only deleted pipelines it says so and lists them.
  • A destination that does not exist is no longer reported as a pipeline that does not exist.

Corrected in the API reference: an Idempotency-Key belongs to one method and path (the same key on a different path is a different key, and that request runs); the three /v1/auth/* operations do not take the header; pipeline_id and kind are marked required on the two previews; secrets in request bodies are writeOnly; a key pair’s hint is its SHA256: fingerprint. To learn when a delete has finished, poll GET /v1/pipelines/{id}: a repeat under the same key replays the first answer.

2026-10-02 (IST) — A pipeline names the tables it writes, and a start or a stop answers with the whole pipeline

Section titled “2026-10-02 (IST) — A pipeline names the tables it writes, and a start or a stop answers with the whole pipeline”

New: destination_tables on a pipeline. The tables it writes, each named as its destination names it: for Snowflake, ANALYTICS.ORDERS_PUBLIC.ORDERS, where destination_schema holds the name as we store it (orders_public). It is the same spelling the schema preview shows before the create and a delete’s kept_tables shows after it. Present on GET /v1/pipelines/{id} and on the answers of a start, a stop, a delete, an acknowledgement and the discarded-rows setting; absent on a list and on the answers of a create and a schedule change.

Corrected: POST /v1/pipelines/{id}/start and /stop answered with an incomplete pipeline. The answer carried "source_id": "", "destination_id": "" and "schedule": {"kind": ""} for a pipeline that has all three. Both now answer with the pipeline exactly as GET /v1/pipelines/{id} reads it, in the same transaction as the change. If you read those three fields from a start or a stop answer, they are now right; nothing else in the answer changed.

In the app:

  • A pipeline’s page shows the tables it writes as your destination names them (“Writes to”), and so does a destination’s page for each pipeline that writes to it.
  • Creating a pipeline under a deleted pipeline’s name says the name belonged to a pipeline you deleted. It said “You already have a pipeline with that name”.
  • SQL shown for you to copy (the Snowflake setup script, the source setup, a deleted pipeline’s clean-up) reads left to right in a right-to-left page.

2026-10-02 (IST) — on_rejected_value says which destination reads it, and has a guide

Section titled “2026-10-02 (IST) — on_rejected_value says which destination reads it, and has a guide”

Corrected: the API’s description of on_rejected_value. No behaviour changed. New guide: Values your destination cannot take.

  • Only a PostgreSQL destination reads the answer, and the description now says so before it describes either answer. It said "stop": nothing is cut or NULLed and “every other refused value still stops the pipeline” of every destination.
  • A Snowflake destination does not read it. Under either answer it writes a value it cannot hold as NULL and keeps a note of the original in the row’s _REYANSH_META column, and writes no values_fitted event. Never in a key column, and a number too wide for its column is never rounded: such a row stops the pipeline until you act. The description’s last sentence says so.
  • The guide says what is cut, what is written as NULL and what never is, how each is told, what stop does and costs, and what a Snowflake destination does instead.
  • Corrected: the guide “Rows your destination discards” said a value your destination refuses stops the pipeline whatever its setting says. Since on_rejected_value took effect that is no longer so; it now points at the new guide.

2026-10-02 (IST) — The app offers the setting for a value your destination cannot take

Section titled “2026-10-02 (IST) — The app offers the setting for a value your destination cannot take”

New, in the app: on_rejected_value on the New pipeline form and on a pipeline’s page, below “Rows your destination discards”. The API has had it since 2026-10-01. It is read by a PostgreSQL destination.

  • “Change the value and keep syncing” is the default (continue): text too long for its varchar(n) or char(n) column is cut to the column’s length, and a value that is not a valid uuid or JSON is written as NULL where the column allows NULL. Never a key column. Each is reported on the pipeline’s history and in a warning.
  • “Stop the pipeline” (stop): nothing is cut or written as NULL, and the pipeline stops at a row holding a value the first answer would change, until you start it again. A refused value that answer would not change (in a key column, or needing NULL where the column does not allow it) is refused under either answer, and the pipeline restarts on its own until it gives up.
  • On a pipeline’s page, both settings are saved together, and only an answer you changed is sent.

2026-10-02 (IST) — The warning for a cut or NULLed value names the columns

Section titled “2026-10-02 (IST) — The warning for a cut or NULLed value names the columns”

Changed, in the app: the values_fitted warning names each table’s columns, and its sentence is corrected. No API change: columns_by_table has been on both alert endpoints since the warning shipped.

  • The warning names each table’s columns: “It happened on public.orders (columns doc and note)”. Up to five a table, then a count; and “possibly others” when the server could not read every report (tables_partial). With more than three tables it gives the number of tables, and the pipeline’s history names each.
  • The sentence no longer gives a reason. It said the values “were changed so it would take them”. That is not always true: a NULL may come from our own check on a json or jsonb column, and a json column might have taken that value. It now says the values “were not written to your destination as your source sent them: each was cut to the column’s length, or written as NULL”.

2026-10-02 (IST) — A cut or NULLed value is told in words on a pipeline’s history

Section titled “2026-10-02 (IST) — A cut or NULLed value is told in words on a pipeline’s history”

Changed, in the app: a values_fitted report on a pipeline’s history is now a titled notice. No API change.

  • The row is titled “Values cut or written as NULL” and says, for the table: how many values were not written as your source sent them, then one line per column with what was done (cut to the column’s length, or written as NULL), in how many rows, and why. A NULL from our own check on a json or jsonb column says so: that check is stricter than a json column, so the column itself might have taken the value. It ends with what the pipeline did next, when the report proves it. Until now the row showed the wire name and the raw fitted=[…] list.
  • Two more history rows have titles: “Not started: out of credit” and “CPU and memory measured”. Both showed their wire names.
  • Never a value. The app holds none: the report carries column names and counts.

2026-10-02 (IST) — A Snowflake pipeline whose role lacks a privilege stops and says the grant

Section titled “2026-10-02 (IST) — A Snowflake pipeline whose role lacks a privilege stops and says the grant”

Changed, for a pipeline that writes to Snowflake (not yet offered in the app: this is in place before it is).

  • When Snowflake refuses a statement because the pipeline’s role does not hold a privilege it needs (Snowflake code 003001, SQLSTATE 42501), the pipeline stops and tells you which grants it needs. Before, it was restarted again and again, and each restart could start your warehouse to meet the same refusal.
  • Refused when a table is created, before anything is written: the message names the grants on that schema (USAGE and CREATE TABLE on the schema the pipeline writes into).
  • Refused while the pipeline is writing: the message lists what the role needs. On a table it did not create or no longer owns: SELECT, INSERT, UPDATE and DELETE. On the destination’s own schema: USAGE, CREATE TABLE and CREATE SEQUENCE. And USAGE on the warehouse, the database and the schema it writes into.
  • Grant what is missing and resume. The pipeline starts again from its last checkpoint and writes by key, so nothing is written twice.

2026-10-02 (IST) — A Snowflake connection test checks what the role may create, by creating it

Section titled “2026-10-02 (IST) — A Snowflake connection test checks what the role may create, by creating it”

New in the connection test of a Snowflake destination: a permission test, and four new fields on the answer of POST /v1/connections/test. Until now the test read the key, the role, the warehouse and the database, and created nothing, so a role that may not create a schema passed the test and the pipeline stopped at its first run. Now, once those four are right, the test verifies the role’s privileges two ways.

  • By doing it. The test creates a schema named _REYANSH_check_<time>_<random> in the destination’s database, a table and a temporary table inside it, and drops the schema. This is what Fivetran’s setup test does. It runs only when you press Test connection, never on your source, and it does not start your warehouse.
  • By reading the grants. It also lists the grants on the database and on the role, the roles the role is granted, and PUBLIC.
  • permission_test says what the test found: verdict is permitted, refused or not_known, and detail is the sentence. not_known is a test that was not run, or that Snowflake did not answer: neither a pass nor a refusal, on an answer that is otherwise usable.
  • grants_listing says what the grants list: listed, not_listed or not_known. A listed grant is not a create that succeeds; the permission test is what counts.
  • A create that is refused refuses the test, and the message says which grant fixes it:
    • 003001: the role is not granted CREATE SCHEMA on the database;
    • 391918: no database is in use for the role. A role not granted USAGE on the database is refused earlier, at the database, and nothing is created;
    • 003540: the database is shared to your account from another one, and no schema can be created in it, whatever is granted.
  • privileges_disagree is present when the two say opposite things, and says why. The grants can list a privilege the role cannot use (a shared database; a grant made in the last minute), and a role can create through a grant the listing does not follow (to a user, or through a database role).
  • left_behind lists every test schema that may be in your database, each with the statement that drops it, on a usable answer and on a refusal alike: the test’s own when its drop was not confirmed; one an earlier test left that this role does not own, or whose drop was not confirmed; and one less than an hour old, which is never dropped, because another test may be using it. A later test drops a leftover the role owns once it is an hour old.
  • The test does not wait for Snowflake. A statement Snowflake does not answer is given up, the drop is still sent, and the answer says what was not learned. When your source has answered in the first ten seconds of a test, the answer comes by the twelfth. A slower source leaves Snowflake two seconds to answer, and one that takes thirteen seconds or more may end the test at its 15-second limit, as a 504. A source a little faster can too: the 15 seconds are counted from your request, and the source’s time from the moment the test starts, which is a little later. The permission test begins only in the first five seconds of a test. Its creates are given up at the eighth second, answered or not, and the drop of a schema it may have made is then sent with three seconds of its own, so the permission test is over by the eleventh second.
  • A test that ends with no answer says which schema to look for, and which never to drop. The 504 check_timed_out of a stored destination’s test, and its two 500 answers (check_unavailable, check_unreadable), say that a test schema may remain; how to list one (SHOW SCHEMAS IN DATABASE <your database> STARTS WITH '_REYANSH_check_', which compares by case and reads no wildcard); and that only a name that is _REYANSH_check_ with “check” in lower case, then digits, an underscore and eight characters from 0-9 and a-f is the test’s. A schema whose name goes on in upper case after _REYANSH_, such as _REYANSH_CHECKOUT, is a pipeline’s own: never drop it.
  • Those three answers say it in a field too: details.test_schema_may_remain is true. It is absent from every other answer, check_timed_out and check_unavailable included when the test ended before it started: nothing can have been created then. A client should act on the field, not on the code or the message.
  • The app says it as well. Below a stored Snowflake destination’s test that ended that way, it shows that a test schema may be in your database, the statement that lists it (with your database’s name, as you typed it), which names alone are the test’s, and that a schema such as _REYANSH_CHECKOUT is a pipeline’s own and is never to be dropped. Before, the app showed only its sentence for the code: a firewall for the 504, and “something went wrong at our end” for the 500s.
  • A test that ended before it started says so: details.test_not_started is true. That is the 504 check_timed_out and the 500 check_unavailable of a test our side could not prepare in time or could not start (our database, our key store), for a stored destination and a pair alike. Nothing reached either of your databases. The app now says that instead of pointing at a firewall.
  • A 504 check_timed_out no longer says “Neither database answered”. We cannot know which one did not: the test connects your source first and then your destination, so a test can run out of time after the source has answered. It says the test did not finish in time; for two connection strings it still names the usual cause, a firewall dropping a connection, without saying which; for a stored Snowflake destination it goes on to the test schema, as above. The app’s sentence for that 504 changed the same way.
  • A role name that does not exist (or is in the wrong case, or was typed with quotes) is now refused with its own message. Before, the test said the destination “could not be checked”.

2026-10-02 (IST) — Snowflake destinations are offered

Section titled “2026-10-02 (IST) — Snowflake destinations are offered”

The Snowflake destination’s card is live. You can create a Snowflake destination, test it, and create a Postgres pipeline that writes to it, in the app and over the API. New guides: A Snowflake destination and Deleting a pipeline.

  • POST /v1/destinations accepts kind: "snowflake" with settings (account, user, warehouse, database, and optionally role) and a credential_ref naming a key pair.
  • POST /v1/credentials accepts a key pair: private_key (PKCS#8 PEM), with passphrase when the key is encrypted. The answer’s hint is the key’s fingerprint, the value Snowflake shows as RSA_PUBLIC_KEY_FP. The key is never returned.
  • POST /v1/connections/test takes destination_id for a stored destination.
  • A Snowflake destination accepts a Postgres source only. Its card lists that in sources, and any other pairing is refused with 422 unsupported_pairing.
  • Each pipeline writes its own schema, named when the pipeline is created (destination_schema_naming: fivetran, the default, or source).
  • What stops a Snowflake pipeline today: any change to the source table’s columns, an added column included, and a TRUNCATE your publication publishes. The pipeline stops and says why; it does not guess. The guide lists every case.
  • In the app, the new-pipeline form picks a destination: one you have already set up (PostgreSQL or Snowflake), or a new PostgreSQL destination by connection string, as before. For a stored destination it shows the naming choice and the exact schema and table the pipeline will write before you create it, and says so when another pipeline already writes that table.
  • A destination has a page of its own: its settings, its key’s fingerprint, its connection test, and the pipelines that write to it.
  • For a Snowflake destination the form does not ask the two destination questions. A Snowflake destination never discards a row, and does not read the rejected-value answer: the form says what Snowflake does instead.

The Stripe source is no longer offered for new pipelines. Its card is withdrawn: POST /v1/sources with kind: "stripe" and a new pipeline naming an existing Stripe source are refused with 422 unsupported_kind, saying why. A Stripe pipeline that has already run keeps running and can be stopped and started. One that was created and never started is refused at its first start, as a withdrawn MySQL pipeline is. It is withdrawn until the Postgres to Snowflake pipeline is complete, and it returns after that. (This line first said “once its known gaps are closed”, which is not the condition; corrected 2026-10-02 (IST).)

2026-10-02 (IST) — A pipeline says what its schedule does, and you can edit it in the app

Section titled “2026-10-02 (IST) — A pipeline says what its schedule does, and you can edit it in the app”

A pipeline’s schedule has two new fields, effect and hold_seconds, on GET /v1/pipelines/{id}, on create, and on PUT /v1/pipelines/{id}/schedule.

  • effect is what the schedule does for that pipeline, which depends on its two ends:
    • runs: the source’s syncs end, and one runs at each of next_runs.
    • batch_hold: a Postgres source into Snowflake. The source is read continuously and never waits for the schedule. Each quiet batch is held for hold_seconds before it is written, so your warehouse wakes about once per run.
    • none: a Postgres source into Postgres. Changes are written as they arrive, and nothing reads the schedule.
  • hold_seconds is the shortest gap between two of the schedule’s runs in the week ahead, at most 24 hours, and six hours for a manual schedule.
  • New: GET /v1/schedule-preview answers what a schedule would be before you save it: the same schedule object, or problem, the sentence the setter would refuse it with. It stores nothing.
  • The app has a schedule editor, on the new-pipeline form and on the pipeline’s page, for a pipeline whose schedule does something. It shows the server’s own answer as you choose.

2026-10-02 (IST) — The API reference documents every request body

Section titled “2026-10-02 (IST) — The API reference documents every request body”

api/openapi.json now has a requestBody schema on every operation that reads one. Until now a body’s fields were described in a sentence of the operation’s summary, or not at all.

  • Twelve operations gained a body schema: creating a pipeline, a source, a destination and a credential; rotating a credential; the schedule; the discarded-rows setting; the connection test; the notification settings; a wallet top-up; and the two sign-in calls. Each schema is generated from the type the server reads the body into, so the two cannot drift.
  • SnowflakeSettings refuses a field it does not define (additionalProperties: false), because the server does. Every other body ignores an unknown field, and its schema says nothing else.
  • The Idempotency-Key header now says what it does on every mutating operation: required, replayed under the same key, refused with 422 idempotency_key_reuse for a different body.
  • Pipeline documents what it returns: schedule, source_id, destination_id and deletion were returned and not documented. historical_load was documented on Pipeline and never returned: it is something you send, and is now on the create body.
  • ConnectorObject documents settings, and GET /v1/pipelines documents its destination_id and include_deleted filters.

2026-10-02 (IST) — You can delete a pipeline

Section titled “2026-10-02 (IST) — You can delete a pipeline”

New: DELETE /v1/pipelines/{id}, and a Delete button on the pipeline’s page. Until now a pipeline could be stopped and never removed, and a stopped pipeline went on holding its destination table: no other pipeline could write it.

  • Deleting stops the pipeline first. It answers 200 with the pipeline once nothing of it is running, and 202 while a worker that was up is still finishing its batch (deletion.state is deleting, then deleted). You do not have to stop it yourself.
  • Your destination’s tables are kept. They are your data. The answer lists them in deletion.kept_tables. For a Snowflake destination it also names our working schema beside yours (deletion.kept_working_schema), which holds a fence table and staging tables.
  • Nothing on your source is touched. A Postgres pipeline leaves a replication slot and a publication on your database, and an unread slot holds write-ahead log until the disk fills. We never change anything on a source, so deletion.source_cleanup gives you the statements to run: one that shows what the slot holds, one that drops the slot, one that drops the publication. The app keeps showing them until you say you have dealt with them (POST /v1/pipelines/{id}/source-cleanup/acknowledge).
  • Its history is kept. GET /v1/pipelines/{id} still answers for a deleted pipeline, with deletion present, and so do its observations, runs and alerts. GET /v1/pipelines leaves it out unless you send include_deleted=true.
  • It is final. There is no restore. Start, stop, a schedule change and a setting change on a deleted pipeline answer 409 pipeline_deleted.
  • Its id is not reused. Creating a pipeline under a deleted pipeline’s id answers 409 pipeline_exists, saying so: its history is kept under that id.
  • Its table is free again once deletion.state is deleted. Until then, a second pipeline into the same table is refused with 422 destination_table_taken, saying the deleted pipeline is still stopping.
  • A deleted pipeline raises no alert and sends no email.
  • Repeating a delete changes nothing and answers the same way.

New: GET /v1/destinations/{id}/schema-preview. It answers where a pipeline would write in a destination before you create it: the schema, the table as the destination names it, which naming rules that destination offers, and whether another pipeline already writes there (taken). It uses the same naming rule POST /v1/pipelines uses, and stores nothing. Query: pipeline_id (required), stream, naming.

New: GET /v1/pipelines?destination_id=… lists only the pipelines that write to one destination.

Changed: POST /v1/connections/test tests a stored Postgres destination by destination_id. It used to answer 422 invalid_field and ask for the connection string again. A stored string is write-only, so it is now tested where it is: its host meets the same check a typed one does (422 host_not_allowed for a private address), and nothing of the stored string appears in the answer.

2026-10-02 (IST) — Large tables load into Snowflake from staged files

Section titled “2026-10-02 (IST) — Large tables load into Snowflake from staged files”

Faster and cheaper: a large batch into Snowflake is uploaded as files and loaded with COPY. A first copy of a table, and a busy stream, now reach Snowflake in batches of up to 32 MiB of values, and at most 128 MiB of memory (the entry above). Each is written as compressed, encrypted files in the stage of the user you gave us, loaded into our staging table, checked value for value against what we sent, and merged into your table as before. Measured on an X-Small warehouse: a gigabyte in about five and a half minutes for about a tenth of a credit, where the same rows took about fifty-five minutes and 1.4 credits. Small batches go as before.

  • Nothing to set up and nothing new to grant. The files live under reyansh/ in the service user’s own stage, are removed as soon as they are loaded, and anything a crashed run left is removed when the next one starts.
  • Your network must let the worker reach the stage’s storage as well as your account’s address. Today that is Amazon S3, for a Snowflake account on AWS. If the upload cannot be made, or your account is on Google Cloud or Azure, the batch is written the old way: slower, never different, and the activity feed says so (bulk_load_paused, the entry above).
  • A slow write no longer restarts a Postgres pipeline. While a batch is being written the worker keeps answering your database, which used to end the replication connection after wal_sender_timeout (60 seconds by default). It reports only what is already delivered.

2026-10-02 (IST) — A value that was cut or written as NULL raises a warning

Section titled “2026-10-02 (IST) — A value that was cut or written as NULL raises a warning”

New: a values_fitted warning, on the Alerts page and on both alert endpoints. A pipeline set to carry on when its destination would refuse a value (on_rejected_value: "continue", the default) cuts a too-long text value to its column’s length, or writes NULL where the column’s type would not take the value, and reports it on the pipeline’s history. Until now nothing pointed you there. Now the pipeline shows a warning for 24 hours after the newest such report.

  • GET /v1/alerts and GET /v1/pipelines/{id}/alerts have a new kind: values_fitted. severity is warning and blocks is false: the values were written, changed, and syncing continues. tables names the destination tables, newest report first, as it does for rows_discarded.
  • A new field, columns_by_table, names each of those tables’ columns whose values were changed, sorted. It is present on values_fitted only.
  • Names only. No row counts: each report on the pipeline’s history carries its own, with what was done to each column and why. No values: we do not hold them.
  • tables_partial: true means the same as on rows_discarded: more than 50 reports arrived in the 24 hours, so tables and columns_by_table may be missing some.
  • It clears on its own, 24 hours after the last report, and it sends no email.
  • Postgres destinations. They are the destinations that report these values today.
  • GET /v1/alerts: a page may now hold up to 4 more alerts than limit (it was 3), because one pipeline can raise one more alert at once. A page still never splits a pipeline’s alerts.
  • A client that does not know a kind can still place it: severity and blocks are sent with every alert.

2026-10-02 (IST) — A stopped pipeline’s page says why it stopped, in the stop’s own words

Section titled “2026-10-02 (IST) — A stopped pipeline’s page says why it stopped, in the stop’s own words”

observed_detail on GET /v1/pipelines/{id}, and the “What the worker reported” panel that shows it, now carry a mid-run stop’s own sentence. When a pipeline stopped for you to act (a key it could not follow, a value or a row your destination refused while the pipeline is set to stop), the page showed “the worker reported a configuration fault (exit 2); restarting cannot fix it and a human must change something”, and the sentence naming the table, the column and what to change was only on the activity feed. The page now shows that sentence.

  • Nothing about the field’s shape changes. It is still free text for a person, still sent only for gave_up, and still falls back to the supervisor’s summary when the worker said nothing.
  • A stop the pipeline got past is not shown. If it ran again, or began copying your table again, after a stop and gave up later for another reason, the page shows that later reason. A stop it meets again every time is still shown.
  • Changing a stopped pipeline’s settings does not take the sentence away. A schedule change, a stop, or a changed answer for discarded rows or rejected values leaves it on the page. Starting the pipeline does: the page then says it is starting.
  • Known: a stop that is restarted rather than left waiting can be replaced by the supervisor’s summary when the last restarts fail for another reason before they reach it again. The sentence stays on the activity feed.
  • Known, and it can show the wrong sentence: after a stop that is restarted, if the pipeline is stopped and started again while it waits to retry (by you, or by a restart of our own service) and that next start fails before the pipeline runs, the page can show the earlier stop where it should show why the start failed. Before this change the page showed the supervisor’s summary there. Tracked as issue 1249.
  • The pipeline list is unchanged: it shows the stored summary, as before.

2026-10-01 (IST) — A Snowflake destination takes no schema

Section titled “2026-10-01 (IST) — A Snowflake destination takes no schema”

Nothing you can send today is answered differently. Snowflake destinations are not offered yet.

  • A Snowflake destination will have no schema of its own. Each pipeline writes its own schema, named when the pipeline is created (destination_schema, in the entries below). So a schema in a Snowflake destination’s settings is refused on create: 422 invalid_settings, saying it is chosen per pipeline.
  • A stored destination’s settings are shown without one, on GET /v1/destinations and GET /v1/destinations/{id}.

2026-10-01 (IST) — A stop that needs you is titled “Stopped, action required”

Section titled “2026-10-01 (IST) — A stop that needs you is titled “Stopped, action required””

The activity feed’s title for a pipeline that stopped and waits for you has changed. It read “Schema change needs attention” for every such stop, including ones that were not schema changes: a key that arrived NULL, a value or a row your destination refused while the pipeline is set to stop, a publication that no longer covers the table. The sentence under the title was right and is unchanged; the title is now true of all of them.

  • The event’s wire name is unchanged: schema_stop_raised on GET /v1/pipelines/{id}/observations. Nothing an API client reads has moved.
  • The sentence still says which stop it was and what to change.

2026-10-01 (IST) — destination_checked says what was not checked

Section titled “2026-10-01 (IST) — destination_checked says what was not checked”

Nothing you can send today is answered differently. This is about Snowflake destinations, which are not offered yet.

  • destination_checked on POST /v1/connections/test is described more exactly in the API reference. It is false whenever the destination’s tables were not checked: when no stream was given, as before, and when the test had no schema to look in because the pipeline that will write it has not been created yet. No answer changes for a Postgres destination.
  • A connection test of a stored Snowflake destination checks its key, its role, its warehouse and its database, and says the destination’s tables were not checked, whatever stream it was given. Each pipeline writes its own schema, named when the pipeline is created (destination_schema, in the entries below), so a destination has no schema to test before its first pipeline exists.

2026-10-01 (IST) — Your Postgres destination keeps a record of what it did not take: _reyansh_rejected_v1

Section titled “2026-10-01 (IST) — Your Postgres destination keeps a record of what it did not take: _reyansh_rejected_v1”

New: a table in YOUR destination, _reyansh_rejected_v1, in the schema your pipeline writes. For each pipeline it holds the key of every row your destination accepted and did not keep (key_columns, key_values, reason = 'discarded'), and the original of every value cut or written as NULL so its column would take it (column_name, original_value, reason truncated or nulled), with table_name, source_position, run_id and detected_at. Query it like any table: SELECT * FROM _reyansh_rejected_v1 WHERE table_name = 'orders'.

  • Those keys and values stay in your database. Reyansh stores only names and counts, and never reads, alters or deletes the table.
  • A rows_discarded or values_fitted entry now says where its record is: record_table, and not_recorded with the reason when the record could not be written.
  • It is created the first time there is something to record. The role Reyansh connects as needs CREATE on the schema, or INSERT on a table you create yourself. With neither, your pipeline keeps syncing exactly as before: each such entry says the record was not kept and gives the GRANT (or the CREATE TABLE) to run, and once you run it the next one is recorded.
  • On by default. To turn it off for a pipeline, send {"record_in_destination": false} to PUT /v1/pipelines/{id}/discarded-rows. Nothing is then written or created, and what is not recorded while it is off cannot be recovered later.
  • When the record cannot be written for a reason that passes by itself (a lock on that table, a timeout, a lost connection), your pipeline does not move past that batch: it restarts and writes the batch and its record again. Only a reason that stays until something is changed (a missing privilege, the table altered, a rule of your own on it) lets it carry on unrecorded.
  • A row written again after a restart is recorded once. So is a first copy that failed and ran again: it is filed under your Postgres source’s slot position, which a failed copy leaves where it was. A copy from another position records what it loses again, with its own run_id.

Postgres destinations only. The page with the table’s definition is not written yet (#1081, K3).

2026-10-01 (IST) — A schema named from a pipeline’s id is written by that pipeline alone

Section titled “2026-10-01 (IST) — A schema named from a pipeline’s id is written by that pipeline alone”

New error: 422 destination_schema_taken from POST /v1/pipelines and POST /v1/pipelines/{id}/start. With fivetran naming a pipeline writes a schema named from its id, and that schema is its own. A pipeline is refused when another pipeline in your workspace already writes its schema in the same Snowflake database, or through the same stored Postgres destination or the same Postgres credential reference, and either of the two is fivetran-named, whatever tables they write. The message names the other pipeline and the schema.

  • The usual cause is two ids that normalise to one name. col-a, col_a, COL.A and col a all name col_a_public. The second is refused: give it another id. Nothing is suffixed for you, because a suffix would name a schema nobody chose.
  • source-named pipelines still share a schema, as do pipelines created before schemas were named per pipeline. Those are judged per table, with destination_table_taken as before.
  • Pipelines that already exist are asked when they are next started. If two of yours hold the same fivetran-named schema, neither starts while the other counts, and each is told the other’s id. A pipeline’s schema is never renamed, so the way out is a new pipeline under another id.
  • Only your workspace is compared, and a pipeline the supervisor gave up on does not count.

Snowflake destinations are not offered yet, and every Postgres pipeline writes public, so no pipeline you have is affected.

2026-10-01 (IST) — A Postgres table is written by one pipeline, through one destination

Section titled “2026-10-01 (IST) — A Postgres table is written by one pipeline, through one destination”

New for Postgres: 422 destination_table_taken from POST /v1/pipelines and POST /v1/pipelines/{id}/start. Until now only Snowflake pipelines were asked. A pipeline that would write a table another pipeline in your workspace already writes through the same stored destination, or through the same credential reference, is refused, and the message names that pipeline and the table. Two pipelines writing one table overwrite each other’s rows.

  • What is refused: two pipelines writing one table through the same stored destination (one destination_id), or through the same credential reference (one destination, or two stored destinations made on one credential). One credential reference is one database.
  • What is not refused yet: two pipelines made with the app’s create form. The form stores a credential of its own for every pipeline, so two pipelines it makes never share a credential reference, even when both credentials point at one database and both pipelines write one table. Both are created, both start, and each overwrites the other’s rows. Comparing them waits for the database fingerprint, which is not built yet. Until it is, give every table of a database one pipeline yourself.
  • There is no way to free a table yet, and we would rather say so. A pipeline holds its table whether it is running or stopped, because a stopped pipeline still owns the rows it wrote. The API cannot delete a pipeline yet. So once a pipeline writes a table, no other pipeline can be created or started for that table through that credential, even after you stop the first one for good. Until delete exists, the pipeline that holds a table is the one to start again. The one exception is a pipeline the supervisor gave up on (below).
  • Two existing pipelines that already write one table can each block the other. If both were created before this change, starting either is refused while the other exists and has not been given up on. Nothing is stopped: a running pipeline keeps running. The way out is to delete one of the two, which the API cannot do yet.
  • One Snowflake account spelt two ways is one account. Snowflake accepts - in place of _ in an account name (myorg-my_account and myorg-my-account), and two Snowflake destinations that differ only in that spelling are now compared as the same account.
  • Names are compared exactly, as PostgreSQL compares a quoted name: Orders and orders are two tables. Two pipelines that write two tables of public are the ordinary case, and fine.
  • A running pipeline keeps running. It is asked the next time it is started. A pipeline the supervisor gave up on does not count until then.
  • Only your workspace is compared.

2026-10-01 (IST) — destination_table_taken judges the schema each pipeline writes

Section titled “2026-10-01 (IST) — destination_table_taken judges the schema each pipeline writes”

Changed: the one-writer rule for a Snowflake table compares each pipeline’s own destination_schema, the schema its rows land in, and no longer the schema setting of the destination it goes through.

  • Two pipelines that write the same schema of the same database are refused the same table, whichever destinations they go through and whatever those destinations’ schema settings say.
  • Two pipelines with schemas of their own may each write a table called orders through one destination: they are two tables.
  • POST /v1/pipelines and POST /v1/pipelines/{id}/start both ask. A pipeline created before this change is asked when it is next started, by the schema it already holds.

Snowflake destinations are not offered yet, so no pipeline you have is affected.

2026-10-01 (IST) — A destination schema name we cannot create is refused, naming the rule

Section titled “2026-10-01 (IST) — A destination schema name we cannot create is refused, naming the rule”

Added: 422 invalid_destination_schema on POST /v1/pipelines. A pipeline whose destination schema would have a name we cannot create is refused, the message names the rule and the name, and nothing is created:

  • a name beginning pg_ (PostgreSQL keeps those) or _reyansh_ (ours), and information_schema;
  • with source naming, a name too long for the destination, or one that begins or ends with whitespace.

Choose another pipeline id, or the other naming. Snowflake is not offered yet and a pipeline into Postgres writes public, so no request reaches this today.

2026-10-01 (IST) — A pipeline shows the schema it writes in its destination, and how it was named

Section titled “2026-10-01 (IST) — A pipeline shows the schema it writes in its destination, and how it was named”

Added: destination_schema_naming (fivetran, source or legacy) and destination_schema on every response that returns a pipeline. Both are stored when the pipeline is created and never change, so every response says what the pipeline writes, read from its row.

  • A pipeline into Postgres reads legacy and public: it writes where it always wrote. So does every pipeline created before today.
  • legacy is only ever read: sent to POST /v1/pipelines it is 422 invalid_field.
  • Snowflake is not offered yet. When it is, a pipeline into Snowflake reads the schema of its own that it was created with; Snowflake folds the name to upper case.

2026-10-01 (IST) — The schema a pipeline writes in its destination is named once, when it is created

Section titled “2026-10-01 (IST) — The schema a pipeline writes in its destination is named once, when it is created”

Added: POST /v1/pipelines takes destination_schema_naming as an optional field. A pipeline writes one schema in its destination. That schema is now named when the pipeline is created and never renamed.

  • Nothing changes for a pipeline into Postgres, the only destination offered today: it keeps writing the schema public. The choice is not offered there yet, so a request that sends destination_schema_naming is refused with 422 unsupported_destination_schema_naming and nothing is created. Leave the field out.
  • Snowflake is not offered yet. When it is, a pipeline into Snowflake writes a schema of its own. fivetran, the default, names it <pipeline id>_<source schema>: lower-cased, every character outside a-z, 0-9 and _ replaced by _, a leading digit given a _ in front, and a name over 63 bytes cut to 54 and ended with _ and 8 hex digits of a hash. source uses the source schema’s name exactly.
  • A value that is neither choice is 422 invalid_field.

2026-10-01 (IST) — A pipeline set to stop on a rejected value now stops and says which column

Section titled “2026-10-01 (IST) — A pipeline set to stop on a rejected value now stops and says which column”

Fixed, for a Postgres destination whose pipeline answers on_rejected_value = stop. A row the destination refuses that holds a value continue would cut or NULL now stops the pipeline until you start it again. Before, it was restarted on its own, backing off, until given up, and nothing said which value it was.

  • The stop names the table, each such column and the reason (too_long or not_a_value), never the value, and what you can do, each followed by a start: change the column so it takes the value (for a too_long one, a longer length or the type text), switch to continue, or correct the value in the source. It is a schema_stop_raised event, or worker_refused while existing rows are copied.
  • That includes a json or jsonb value holding a \u0000 escape, which continue writes as NULL from this release (the entry of this date below): under stop it stops the pipeline, naming its column as not_a_value and PostgreSQL’s error code for it, 22P05.
  • Nothing is cut or NULLed, and nothing is saved past the row, so the next start sends it again.
  • The row is not retried, so it may hold something else the destination refuses. That shows only afterwards, as PostgreSQL’s own refusal.
  • A refused row holding no such value is unchanged under both answers. The on_rejected_value description in the API reference says the same.

2026-10-01 (IST) — A pipeline is created with its answer to a refused value and its record switch

Section titled “2026-10-01 (IST) — A pipeline is created with its answer to a refused value and its record switch”

Added: POST /v1/pipelines takes on_rejected_value and record_in_destination as optional fields. Leave either out for its default, continue and true. An unknown on_rejected_value is 422 invalid_field, and nothing is stored. What each answer does today is in the entry below: record_in_destination is recorded now and acted on from a later release.

2026-10-01 (IST) — A pipeline shows what it does with a value your destination refuses, and whether it keeps a record there

Section titled “2026-10-01 (IST) — A pipeline shows what it does with a value your destination refuses, and whether it keeps a record there”

Added: on_rejected_value (continue or stop) and record_in_destination (true or false) on every response that returns a pipeline. Existing pipelines read continue and true.

  • PUT /v1/pipelines/{id}/discarded-rows sets any of its three answers. At least one is required (422 missing_field) and one left out keeps its answer, so a client sending only on_discarded_row sees no change. An unknown on_rejected_value is 422 invalid_field. A changed answer bumps version, and a running pipeline restarts onto it on its own.
  • continue is 2026-09-30’s behaviour (a too-long text cut, a bad uuid or JSON value NULLed, into a Postgres destination). Under stop nothing is cut or NULLed: the pipeline stops at the value and is restarted on its own, backing off, until given up; that stop is not yet reported as a rejected value.
  • record_in_destination is recorded now and acted on from a later release. The table in your destination that will hold discarded rows’ keys and the originals of changed values does not exist yet, so nothing is written under either answer.
  • The OpenAPI Pipeline schema lists on_discarded_row, on_rejected_value and record_in_destination as required, because every response carries all three.
  • One caveat for retries: a request replayed with the same idempotency key within its window returns the response stored before this release, which may lack the two new fields.

2026-10-01 (IST) — A pipeline whose stored settings cannot be read stops at once, and says why

Section titled “2026-10-01 (IST) — A pipeline whose stored settings cannot be read stops at once, and says why”

Fixed: when a pipeline’s stored configuration could not be read back as a pipeline (one of its answers carrying a value this release does not know, for example), the worker treated it as our database blinking. It was restarted a few times in a quarter of a minute, then stopped with “5 restarts in 60s reached the restart intensity” and no word of the cause. It now stops at once, and the pipeline’s feed says what could not be read, naming the pipeline and the value, and that the fault is ours: it asks you to contact support rather than re-save the pipeline. A read of the configuration that merely failed, because our database was briefly unavailable, is still restarted as before. The stop is still headed “a configuration fault”, which is untrue of this one (it is ours); correcting that heading is its own change.

2026-10-01 (IST) — A JSON value holding a \u0000 escape is written as NULL, as the entry of 2026-09-30 said

Section titled “2026-10-01 (IST) — A JSON value holding a \u0000 escape is written as NULL, as the entry of 2026-09-30 said”

Fixed, for a Postgres destination whose pipeline answers on_rejected_value = continue (the default): a json or jsonb value holding a \u0000 escape was not written as NULL. PostgreSQL refuses that value with its own error code (22P05), not the one it gives every other JSON value it will not parse (22P02), and the pipeline acted only on the second. So the row was refused and the pipeline restarted, backing off, until given up, with nothing naming the column, although the entry of 2026-09-30 says a JSON value PostgreSQL would not parse is written as NULL.

  • This changes what continue does for that value. It is now written as NULL where the column allows NULL, and the pipeline carries on. It is on the feed as values_fitted with not_a_value and nulled, like any other, and never carries the value.
  • In a json column that NULL is our check’s, not your value’s, and is marked our_cast: the pipeline writes a json column through jsonb, and a json column would have stored the escape.
  • Nothing else changes on a destination database whose encoding is UTF-8. In a NOT NULL column the value still stops the pipeline. A refusal that is not about a value (a lock not granted in time, a constraint) is still PostgreSQL’s own refusal and is still restarted, whatever else the row holds.
  • On a destination whose encoding is not UTF-8 (LATIN1, WIN1252), two more values change. There 22P05 is also PostgreSQL’s code for any character the encoding cannot hold. A too-long text value whose unwritable character is in the part that is cut off is now written cut, and a value that is not JSON and holds such a character is now written NULL, each reported as values_fitted. Every other value holding such a character is still PostgreSQL’s own refusal: it is neither NULLed nor explained yet (#1222).