Changelog: October 2026
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
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: 0stops 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’sstateinGET /v1/api-keysandGET /v1/api-keys/{id}, so the list never calls a keyactivethat authentication already refuses, or the reverse. - A key’s
last_used_atis 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
historyandappendin 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.asidenames 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.reasonhistory_copy_lock, and after the third try in a rowparked.causehistory_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), soappendwas refused on it with422 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
historyorappendon a table parkedkeyless_mode_not_offeredwith nothing written in that mode is applied at the pipeline’s next start, while the table is parked (pending_mode.waits_for_streamingisfalsefor it, and itspending_modenames noaside: none is kept), in place, with no table kept aside; its422 confirm_requiredand 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 parkedkeyless_mode_not_offeredis freed, and itsparked.remedynow 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
historyorappendyet: asking for either on a table the pipeline has read with no primary key answers422 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 forsoft_deleteorliveis 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
historyorappend: asking for either, on a table or as the pipeline’s default, answers422 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 toquery_basedis already refused while a table is kept so). historyandappendare offered onPUT /v1/pipelines/{id}/tables/{table_id}/sync-mode, the pipeline’s default (PUT /v1/pipelines/{id}/sync-mode),POST /v1/pipelinesandGET /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 answer422 not_yet_available(they were422 mode_not_offered). Available to every account from the next release.- A change of a table’s shape needs
confirm: true(422 confirm_requiredotherwise, saying what happens and naming the table its old rows are kept in): out ofhistoryorappend, intoappend, and intohistoryat 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 (betweensoft_deleteandlive, and from either tohistoryat Snowflake) needs no confirm, as before. table_mode_change_requestedandtable_mode_changedcarryaside_tablefor 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 refused409 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_deleteanddeleteanswers 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_refusednames what blocks it (reason:granteeormanaged_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.reasonhistory_standby): a history table’s first copy is never read from a standby, and it was toldkeyless_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_rewroteortype_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 anumeric(12,4), a longercharacter 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 (anumeric(10,2)column givennumeric(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 astype_change_rewroteand 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_deleteand inlive, 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-checkandPUT /v1/pipelines/{id}/tables/{table_id}/missing-rows; the create fieldsdelete_check,delete_check_confirmedanddelete_check_large(a body naming one is refused as an unknown field); the table fieldsmissing_rows,delete_check,delete_checked_at,delete_check_failures,delete_check_large,delete_check_heldandrows_found_deleted; the codesdelete_check_unconfirmed,delete_check_not_applicableanddelete_check_large_not_applicable; the alert and notificationdelete_check_failing; the audit actionstable.missing_rows_changedandtable.delete_check_changed; and the history kindsdeletes_counted,keys_missing_in_destination,key_compare_mismatch,delete_check_held,delete_check_failed,delete_check_found_emptyandwitness_missing.query_readno longer carriesdeleted, and its sentence is “table: N rows changed since the last sync.” (api/openapi.jsonregenerated.) - 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_modedescription 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, reasonattached).
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’sproviderstep failsaurora_unconfirmedwith the same sentence as theserverstep, 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 holdsaurora_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_rewroteby 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 (
textmadevarchar; an integer madenumericornumeric(p,0); an integer or anumericmadetextorvarchar; anumeric(p,s)madenumeric; atimeortimetzgiven 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: anumericgiven fewer digits at the same scale now copies it again, and atimestamp(6)ortimestamptz(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, causetable_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_restartedis 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_catalogonly (search_pathset 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
numericwith no declared precision, or wider than 38 digits, lands.settings.wide_numeric_asonPOST /v1/destinationsisVARCHAR(the default when absent: exact text, as before) orNUMBER(38,<s>)for a scalesfrom 0 to 37. Under a number, in a table synced by a key, a value with more digits than the type holds is written asNULL, its exact original kept in the row’s_REYANSH_METAunderdoes_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 asNULL. 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 declarednumeric(p,s)lands asNUMBER(p,s)as before, and a column a table already holds as a narrowerNUMBERkeeps that type: a value too wide for it stops the pipeline, as without the setting. Offered only to accountsGET /v1/memarkswide_numeric_enabled; others are refused422 not_yet_available. Chosen at create:PATCHanswers422 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’sparked.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_daysonPOST /v1/destinationswere offered only to some accounts; the others were refused422 not_yet_availableand 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’stime_travel_enabledistruefor 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)totimestamp(3), anumericgiven 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 ... TYPEstatement: 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 plainrecopy, which deletes only rows outside a row filter you changed answeringdelete), and asoft_deletetable 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
varcharlengthened or madetext, an integer widened, anumericgiven more digits at the same scale, a timestamp given a finer precision, an integer ornumericmade text. The full list is in When a source table’s shape changes. GET /v1/pipelines/{id}/tablesnames 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}/resumeon such a table at a PostgreSQL destination records the copy it is, shown as the table’spending_action:recopyfor a column outside the key or on asoft_deletetable; for a column of the key (causetype_change_rewrote_key) on a table keptliveit is refused, 409copy_choice_required, whatever the table’s row filter, naming the two copies (POST .../recopy, with or withoutdelete_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 theirCHECKs 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 inpg_catalogonly, and a resumable copy compares key values: for a key column of typecitextthat comparison becametext’s, while the rows still came incitext’s order, so under aCorPOSIXcollation (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; forltreethe 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 acitextpart in its key was copied since 2026-10-25 (IST), copy it again from the table’s page. - The replication stream checks its
search_pathbefore 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 ofpg_catalogon 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, aVACUUM FULL, aTRUNCATE). It let go for any session queued on the table, so anANALYZEqueued 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}/rotateanswers422 ssh_tunnel_in_credentialwhenvalueis 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, throughPATCH /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
valueis 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’supdate_methodon 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/pipelinesacceptsdelete_checkfor 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, oroff, which leaves deleted rows in your destination and needsdelete_check_confirmed: true(422 delete_check_unconfirmedwithout 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, orremove): 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 keptliveonly (422 delete_check_large_not_applicablefor any other). - A pipeline that reads your database’s change log refuses all three (
422 delete_check_not_applicable); a word outside the lists is422 invalid_field. - A table’s
delete_checknow shows the pipeline’s default when the table has no answer of its own (it showedevery_sync). Setting onlylarge, or answering a held removal, throughPUT /v1/pipelines/{id}/tables/{table_id}/delete-checkleaves 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}/runsgains the outcomestopped: 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=stoppedfinds them.- A stopped query-based sync now tells
sync.endedwithstatus: stoppedand the stop’s reason; before, it told nosync.endedat 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-checksets 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, oroff, which leaves deleted rows in your destination and needsconfirm: true,422 delete_check_unconfirmedwithout it);large, for a table keptlivein Snowflake, what a check that would remove more than half of the table and more than 1,000 rows does (ask, the default, orremove;422 delete_check_large_not_applicablefor any other table); andanswer_heldwithheld_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) orkeep(nothing removed; asked again only when more rows are gone).409 delete_check_nothing_heldwhen nothing waits,409 delete_check_held_changedwhen the waiting count is no longer the one you were shown;422 delete_check_not_applicablefor a pipeline that reads your database’s change log. Settings, written at once and read at the table’s next sync: nothing restarts. Audited astable.delete_check_changed.- Every table gains
delete_check,delete_checked_at,delete_check_failures,delete_check_largeanddelete_check_held(rows,since,answer,answered_rows): null on a table of a pipeline that reads your database’s change log, anddelete_check_largenull unless the table is keptlivein Snowflake. - And its last read:
last_read_at,rows_changed,rows_found_deleted,rows_rereadandreread_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,
MERGEand 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 keptliveremoves them, except rows already marked deleted, which stay until you purge them. - A large removal waits for you. When a
livetable 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_deletetable’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 withsynchronous_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 intables, onGET /v1/pipelines/{id}/alertsandGET /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 carriestables.
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-rowssets 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 needsconfirm: trueevery time (422 missing_rows_unconfirmedwithout 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 astable.missing_rows_changed, before and after.422 missing_rows_not_applicablefor a table of a pipeline that reads your database’s change log, which delivers every delete and reports no missing rows;422 invalid_fieldfor any other answer;409 table_removed.- Every table gains
missing_rows: the answer on a query-based pipeline’s table,nullelsewhere. 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
VARCHARthe destination creates holds 16,777,216 characters and aBINARY8,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 asNULL. The row’s_REYANSH_METAsays 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_METAalways 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_METApast 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, withoriginal_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
NULLin 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_FENCEtable 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_FENCEis deleted, unless the table was created after_REYANSH_FENCEand 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 saysdestination_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 anUPDATEmoves a row into it, PostgreSQL sends that row as a new row, and underREPLICA IDENTITY DEFAULTorREPLICA IDENTITY USING INDEXit leaves out any large value the update did not change (a longtext,byteaorjsonbvalue 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 withbinlog_row_image = MINIMALcould do the same for anINSERTthat 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 FULLwhere PostgreSQL allows it; underFULLPostgreSQL 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 DEFAULTorUSING 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, whateversearch_pathyour 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 withsearch_path_unpinned, and a running pipeline stops and says so. Connect it to the server directly, or have the pooler pass theoptionsstartup 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’sserverstep 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, avector) 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_catalogwith its schema (public.money3,public.mood), whateversearch_pathyour 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 exampleSELECT pg_catalog.pg_drop_replication_slot('<slot>');). Before, a role allowed to create functions in yourpublicschema (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 inpublic, checkpublicfor functions named like PostgreSQL’s (\df public.pg_*,\df public.format) and revokeCREATE ON SCHEMA public FROM PUBLIC. - The webhook body of
old_slot_holds_logcarries 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_slotslisting 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_slotsand 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
serverstep 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
DOstatement that, run on a 17+ primary, creates the slot withfailover => 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 => trueon a 17+ primary, without it elsewhere. - The connection test reports the slot’s failover facts. The replication slot step of
POST /v1/connections/testgainsdetails.slotwithfailoverandsynced(frompg_replication_slots, each absent before 17), for a slot it found, beside an emptydetails.chain:chainstays 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 whosesynchronized_standby_slotsis empty (or, before 17, thepg_failover_slotsextension loaded with an emptystandby_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’ssync_replication_slots,hot_standby_feedback,primary_slot_nameanddbname,pg_failover_slotsfor 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 => trueeverywhere, 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
40001or40P01) used to restart the pipeline with nothing said. It now stops (worker_refused), naming the table, the standby’smax_standby_streaming_delayand the remedies; started again after the change, the copy carries on from the last part it saved. The settings step’sstandby_delay_shortwarning 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-keysgenerates the account an Ed25519 SSH key. We keep the private half sealed and never show it; the answer is the public key, itsSHA256:fingerprint and theauthorized_keysline. At most five keys that are not retired (409 ssh_key_limit).GET /v1/ssh-keyslists 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-lineis the line to paste on a bastion for that key:restrict,port-forwarding,permitopen="db:5432" ssh-ed25519 AAAA... <comment>, onepermitopenfor 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_hostanddatabase_hostmust be a host name of letters, digits, hyphens and dots, or a bare IP address, the rule a source’s host follows; anything else is422 invalid_host(withdetails.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}/retiredeletes 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
connectiongainsconnect:{"method": "ssh_tunnel", "ssh": {"host", "port", "user", "key_id", "host_key"}}.host_keyis the bastion’s host key you approve: aSHA256:fingerprint asssh-keygen -lprints it, or whatssh-keyscanprints, 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 referencessh-key:is reserved (credential_ref_reserved). - The connection test’s
sshstep opens the tunnel and a channel to the database. With no host key approved it failshost_key_approval_neededand hands backdetails.host_key({"algorithm", "sha256"}) beside an emptydetails.chain([]:chainstays required on/v1, as on theslotline), the key the bastion presents: compare it withssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pubon the bastion, then send<algorithm> <sha256>asconnection.connect.ssh.host_key. A different key than the approved one failshost_key_changedwith 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/megainsssh_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 withworker_refusedand itstunnelfacts (source_host_key_changedwith 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 answers422 ssh_tunnel_not_enabledwithout 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_deletethose 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. Inlive, 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 withsource_history.codesource_timeline_unverifiedandacceptable: true. Continue it on the pipeline’s page, or withPOST /v1/pipelines/{id}/source-history/acceptand the stop’s facts: it carries on from where it last read and skips nothing. Re-sync instead if the move lost transactions. source_historygainsquery_positionfor 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
REPLICATIONwhose 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 asource_failed_overevent. 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
REPLICATIONcannot 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/testtakesupdate_methodandtables. Withupdate_method: query_basedthe source is signed in to as an ordinary user (noREPLICATIONneeded), itssettings,publicationandslotsteps areskipped(query_based), nosetupis answered, and nine steps check what reading tables by queries needs:query_privileges(the lock andxmineach sync takes, with theGRANTthat 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) andlocks.tablesnames the tables to probe (at most 1,000); without it the pickedstreamis 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_untestednaming the step that failed (details.step, every step indetails.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 gainsstopped_runs, besidefailed_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 instopped_runsand never infailed_runs. Neither is charged; nothing about the money changed. Today’s stopped runs were alreadystopped_runentries ofnot_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 gainsmethods, each with itsname(logical_replication,query_based),completion,first_runandposition_dialect. A pipeline reads by one method, and these are that method’s facts.- Deprecated: the card’s own
completion,first_runandposition_dialect. They are itslogical_replicationmethod’s, and stay until 2027-10-25: every answer carriesDeprecation(@1792886400, 2026-10-25) andSunset(Mon, 25 Oct 2027 00:00:00 GMT). Readmethodsinstead.
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/pipelinestakesupdate_method:logical_replication(left out means this: the source’s log through a replication slot and a publication) orquery_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, sohistorical_loadleft out is recordedrequested, and refusesdeclined(422historical_load_needs_logical_replication), slot names (422source_names_need_logical_replication) and ahistoryorappenddefault mode (422mode_needs_logical_replication). A method the source does not offer is 422update_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}/resynctakesupdate_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,setupnames 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 byGET /v1/pipelines/{id}/new-source-namesis required andsetupcreates it. New refusals: 422method_switch_needs_full_resync, 422method_switch_needs_source_names, 409method_switch_blocked_by_mode.GET /v1/schedule-previewtakesupdate_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}/synchas a fiftheffect,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_busywithRetry-After, or504 identity_provider_slow, instead of429or “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 codesso_client_refusedfor 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/usagereports 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 fromfailed_run, because a stop is not a failure. The classification set was already documented as open.GET /v1/usage/daysreports today’s stopped syncs asnot_chargedentries with the reasonstopped_run, besidefailed_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
429at the callback is replaced by the page above. Every unauthenticated route’s work now takes its reservation as a parameter of a type onlyinternal/admissioncan 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
429withRetry-Afterpast 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
429with 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 carriessession_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/switchfrom 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 answered403 not_a_memberfor 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 resultgrant_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(withRetry-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_owneronPUT /v1/members/{user_id},DELETE /v1/members/{user_id}andDELETE /v1/me/membership(it was409 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/modeanswers the same code when another owner’s change took the last one (it answered500). Every database refusal the API words is now chosen by the name of the constraint that raised it; one nobody worded is a500. PUT /v1/sso/mode‘s answer gainspeople_signed_out: the distinct people a switch to required signed out (one person in two browsers is twosessions_revokedand 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/domainsgainsneeds_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_linkedinGET /v1/membersis an owner’s: answered to an owner, omitted for a member.- The different-identity notice names whose link refused the sign-in (
sso.identity_mismatchgainslinked_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).
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)
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’sconnection_id(now a string), the link chooser’s and the refusals’sso_connection_id, and the owner’sGET /v1/sso(id). The sequential id is in no answer: a number where the id goes is400 invalid_connection.POST /v1/auth/sso/discovernames 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 inX-Reyansh-Accountis409 account_changed).GET /v1/members(and a member’s detail) gainsso_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_revokedin the answer and onsso.version_applied), and a sign-in the old provider answered that completes after the change issso_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’saccountslists 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 toldsso_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.
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)
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/completeandPOST /v1/auth/sso/confirm, when they sign the person in (outcome: signed_in), now also answeraddress(the address now signed in),domains(the account’s verified domains) andhost(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 withokta,entra,googleoroidc(another provider); SAML is422 sso_protocol_unavailableuntil it is available;409 sso_existswhen 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 is502 idp_discovery_failed. Leaveclient_secretout to keep the current one (422 client_secret_requiredwhen 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/teststarts 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_versionbefore a draft is saved.POST /v1/sso/draft/applymakes 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/draftdiscards the draft (404 sso_no_draftwhen there is none); the live version is unchanged.GET /v1/ssoreads 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/ssodeletes 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_appliedandsso.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_expiringin 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
publicationstep said “make it withCREATE PUBLICATION ... FOR TABLE <the table you picked>;”. A publication made that way sends the table’sUPDATEandDELETE, so for a table with no primary key and noREPLICA IDENTITY FULLyour database would then refuse everyUPDATEandDELETEof 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,DEFAULTorNOTHING, 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_modedescription and thePUT /v1/pipelines/{id}/sync-modesummary: 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’sUPDATEandDELETEeven 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 (anACCESS EXCLUSIVElock 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.reasonkeyless_new_rowsandPipelineTable.modenew_rows_onlyare 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-policyand the pipeline’s change policy page), and the API’s descriptions of a table’ssync_modeand ofPUT /v1/pipelines/{id}/sync-modenow 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/v1like/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 inREYANSH_STATUS_TOKEN(minted on the box bybootstrap-secrets.sh); unset, every/internal/path answers404.- 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_dumpandpg_dumpall --roles-onlycarry, 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 inpg_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), whichrelease.shnow 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.shstarts it wherever its weekly timer is on). backup-postgres.shnow fails when asked to upload with noawsCLI, instead of keeping the dump locally and exiting 0.
2026-10-20 (IST) — Small fixes
Section titled “2026-10-20 (IST) — Small fixes”- 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_modeand ofPUT /v1/pipelines/{id}/sync-modesay 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_availablefor 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_ATis 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.removedalready carried the marked number; its description now says it can be fewer thancount. -
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_sourceand422 purge_not_offeredanswers 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 is422 invalid_domain, and a domain the account already has is409 domain_exists.POST /v1/sso/domains/{domain}/checklooks the record up now: found, the domain is verified (again, when it had lapsed).409 domain_record_not_foundwhen it is not there yet;502 dns_unavailablewhen the lookup did not answer.GET /v1/sso/domainslists 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), besidesso.domain_added,sso.domain_verifiedandsso.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-onoff,allowedorrequired, 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_changedandsso.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 faultupstreamwhen the provider refused or could not be reached. A sign-in whose account turned single sign-on off meanwhile issso_turned_off. POST /v1/auth/sso/start’s “confirm first” is409 sso_confirm_required(it wasconfirm_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), not404. - The remembered browser’s cookie is set only once the sign-in has committed.
2026-10-19 (IST) — Single sign-on: an owner can unlink a person’s identity (not yet released)
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_foundwhen the person has none in the account,404 sso_not_set_upwhen the account has no single sign-on. The audit log recordssso.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}toownerends 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;0when 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_changedrow 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_deniedrow recordshost, 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
500when it races a person joining the account: the change is retried once, as the join already was. GET /v1/membership-eventsdocumentsmember_joined_by_sso, the kind a person joining through single sign-on writes, and Settings, Members names it (“… joined through single sign-on”).
2026-10-19 (IST) — Single sign-on: discovery, the link’s page and the start (not yet released)
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 verifieddomains(a lapsed one withverified_until), thediscoverable_domains, the identity provider’shostthe browser will go to, and whether this browser isrememberedor holds anopen_request_unanswered. Never the account’s name or the IdP’s label.404 sso_not_foundfor a connection that cannot be started;400 invalid_connectionfor 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_ssobinding cookie (SameSite=Lax, ten minutes) and answersredirect_url, the identity provider’s sign-in URL.400 one_of_requiredunless exactly one ofconnection_idandemail;409 confirm_requiredforby: rememberedfrom a browser that is not remembered;422 return_tofor a destination that is not a page of this app;404 sso_not_found;409 sso_misconfigured(withdetails.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, answers303 /auth/sso#attempt=<code>(the code in the fragment, forPOST /v1/auth/sso/complete), or303 /auth/sso#error=sso_attempt_invalidfor 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_knowncookie 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 verifieddomains, the identity provider’shostthe sign-in went through, theaddressthe code was sent to,owner_invitation, andthis_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,
429withRetry-Afterpast it): 30 a minute forPOST /v1/auth/sso/complete, and 30 a minute shared byPOST /v1/auth/sso/confirm,/confirm/denyand/confirm/describe. - The OpenAPI document’s
x-reyansh-auditnames a POST that only readsreads: the invitation preview (wasnot_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_confirmcookie. It answers200withoutcome: 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’sinvitation_endedsays why. Refusals:403 sso_wrong_browser(no confirmation cookie),403 sso_code_wrongwithdetails.remaining(the fifth wrong code ends the confirmation),410 sso_code_expired(expired, used, denied or ended: sign in again),410 invitation_endedwithdetails.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_expiredfor a link that can no longer be used, which changes nothing.code_sentanswers also carryreturn_to, for the page to go to once the code is entered.- The audit log gains
sso.link_deniedandsso.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_requiredwithdetails.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 answers403 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 carrydetails.sso_connection_id,details.domains(the account’s verified domains) anddetails.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 anssoobject:connection_id,required, andlink_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 is403 sso_requiredand the link is NOT spent; for its recovery owners it signs in, and the audit log’ssession.signed_insaysrecovery: true.POST /v1/auth/switchanswers409 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 assession.switchedwithrecovery: 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_deletetoliveno 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, asPUT /v1/pipelines/{id}/tables/{table_id}/sync-modesays, but a row whose key your source inserts or updates again is now written unmarked (_reyansh_deleted_atcleared), 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 UPDATEtrigger that skips or rewrites an update which changes only_reyansh_deleted_atused 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 INSTEADrule (which PostgreSQL refuses such a delete under) or aBEFORE DELETEtrigger 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 aBEFORE DELETEtrigger 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 aslog_parameter_max_length_on_errorchanges 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). Astatement_timeoutof 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
healthywith 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_timeoutcancels a statement and never ends a connection. It now names the server’sidle_session_timeoutandidle_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
retryingand sent aretryingnotification, 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 withoutFORCE 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 isUSING (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_atand_reyansh_synced_atare 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,ONLYboth times, with a column list of its other columns and its row filter kept (the publication’s other tables are not touched); or, on aFOR ALL TABLESorFOR TABLES IN SCHEMApublication 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_discardedreport undercontinuenow 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
livetable, 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_sourcein the API now carriesremoved_as(markedorremoved), and thetable_reconciledevent 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
liveis no longer told its rows are kept or “marked deleted”: its copy deletes the rows your source no longer has, as any table keptlivedoes 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, withrows_outside(keep,delete, ornullwhere none is asked);nullwhen none waits. What a copy will do with the rows that filter leaves out is said from it. delete_rows_not_in_sourceis refused (422 delete_not_applicable) for every table whose copy does not keep those rows, byPOST .../tables/{table_id}/recopyandPOST .../resyncalike, 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_outsidedescription) 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_applicableanswers, where it named only Snowflake and a table kept in soft delete. tables[].rows_not_in_source.countgainsnot_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), withremovedsaying what it removed or marked.not_countednow 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[].keyis 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_sourcecounts only the rows inside the filter, and the rows outside it are told asrows_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 waskeep. Re-sync and delete them (recopywithdelete_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.countisnot_counted,removedsays 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 .../recopywithdelete_rows_not_in_sourceis 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_ssobinding cookie. It answers200withoutcome:signed_in(the session cookie is set and the binding cookie cleared;return_tosays 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_confirmcookie is set) ortested(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_endedwithdetails.reason,429 sso_confirmations_exhaustedwithRetry-After, and403naming 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_testedandsso.remembered_identity_changed;session.signed_inrecordsmethod: "sso"for a single sign-on; the people trail gainsmember.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 tablerow_hash;noneis 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, insoft_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 forPOST .../resyncand.../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}/columnstakes it with noexisting_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_rowssays 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_sourceandremoved, 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, andtable_reconciledin 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’scolumnswhen 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 with409 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: fillis 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 (causekeyless_shaping_change, nothing written): withdraw the change (2026-10-17 (IST): any member can, see the entry above), then resume it. rows_outsideis 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 FULLprinted a statement that could make your source refuse the table’sUPDATEandDELETE. Since 2026-10-02 (IST) a filter on a table that is notREPLICA 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 runALTER 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 everyUPDATEandDELETEof 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 itONLYboth 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.statementon a table stopped for one of those three causes (empty for every other stop),whole_rows_statementon a table’s columns (GET /v1/pipelines/{id}/tables/{table_id}/columns) and on the create form’s read of a table’s columns, anddetails.statementon the422 filter_needs_full_identityrefusal 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
UPDATEandDELETEare 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/sourcestakes the connection itself:connection, its fields (host, port, database, user, password, TLS mode and trust, an uploaded CA), orconnection_url, a pastedpostgres://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. Sendingcredential_reffor a source still works and is deprecated: the response carriesDeprecationandSunset(twelve months).GET /v1/sources/{id}shows the connection, the password as its****last4hint, andstanding_warningsfor every TLS mode belowverify-fullfor 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’schannel_binding = preferdoes: a middleman who terminates the TLS can no longer relay the sign-in, which matters most underrequire, where nothing verifies the certificate.connection.tls.channel_binding(disable,prefer,require; a pasted URL’schannel_bindingis read, as Neon’s carryrequire) chooses;requirerefuses 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 forprefer. - 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
rejectline, 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 missingCONNECTgrant and a missingREPLICATIONattribute 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 gainssteps): 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, eachpassed,warning,failed,skippedornot_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 withoutREPLICATIONno 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.usableandrefusalread 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
resolvestep failing withtimed_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 is504 check_timed_outwith faultours, never a firewall of yours. The source can now beconnection(its fields),connection_url(a pasted URL, read by the parserPOST /v1/sourcesuses), orsource_id(a stored source) with optionalconnection_changes, which obey the samesecret_requiredrule asPATCH; the destination is optional for a PostgreSQL source. The answer carriessource_tls, and theresolvestep leads the worker’s. - A test of a pasted
connection_urlshows what the URL was read as: the answer’sconnectionholds its fields, the password as its****last4hint, on every answer of such a test (aresolvefailure 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 = approvedwithconnection.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, andprivate_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 acertline orclientcert=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 withclientcert=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
tlsstep failsapproval_neededwhen no authority this connection trusts signed the server’s certificate, and hands back the chain the server presented, leaf first, underdetails.chain(PresentedCertificate: subject, issuer, SHA-256, dates, whether it is a certificate authority and signed itself, therolean approval of it takes, and the onerecommended: the root when the server sent one, which survives its renewals, otherwise its own certificate). Send that certificate’scertificate_pemasconnection.tls.approved_pemand test again.name_mismatchnames what the certificate lists and offersverify-ca;expirednames the date;certificate_changednames the certificate the server presents instead of the one you approved, with its chain. A PostgreSQL destination’s certificate refusals staycertificate_rejected. - A pipeline whose source stops presenting the certificate you approved stops, and says which one it saw.
Its
worker_refusedcarriescertificate:source_certificate_changedwith the approved and the presented certificate’s SHA-256, orsource_certificate_untrustedwith 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
connectionshowsexpiry: every certificate whose end its pipelines watch (the client certificate, each uploaded CA certificate and the approved certificate, each with its subject, SHA-256 andnot_after); a server certificate under a CA is not watched, because its CA renews it. A running pipeline tellssource_certificate_expiringon 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 kindsource_certificate_expiring(a warning) onGET /v1/pipelines/{id}/alertsandGET /v1/alerts, withcertificates(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 triggersource_certificate_expiring, on by default for email: told once at 30 days and once more at 7, and its webhook body’sdetails.certificatesnames each one.GET /v1/alertsmay 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(withverify-caorverify-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 carriesdetails.recommended_trust: "aws_rds"and recommends no certificate (a pinned RDS certificate would stop at the next rotation). Uploading Amazon’s bundle asca_pemis answered withuse_aws_rdsrather than a size refusal; one RDS root uploaded alone is still a CA like any other. GET /v1/trustlists every certificate your account approved for a source (TrustedCertificate: the source,kindtls_certificate, itsrole, 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, orverify-fullfromverify-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 is404 trust_not_foundand changes nothing. In the audit log assource.trust_revoked.GET /v1/networksays where this service connects from:published, theregion, 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: falsealone 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’sresolvestep withipv6_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}/rotateanswers409 use_source_patchfor 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-trustandPOST /v1/credentials/{ref}/rotateeach 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 answers409 source_changed(a source) or409 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-cais 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-cawithtrust = systemis422 verify_ca_needs_a_ca(fieldconnection.tls.mode); a pastedconnection_urlwithsslmode=verify-cais422 url_not_understoodnamingsslmode(a URL cannot carry a CA);verify-cawith an uploaded CA, an approved certificate oraws_rdsis unchanged. The worker refuses the pair too, for a source and for a PostgreSQL destination’s URL, and so does the MySQL source’sREYANSH_SOURCE_SSLMODE=verify-cawith no CA. A revocation underverify-caresealsverify-fullwith the system’s store (shown in the answer, and thesource.trust_revokedaudit 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 suggestsverify-ca: connect by a name the certificate lists.- ⚠ UPGRADE NOTE: a stored connection string with
sslmode=verify-caand no CA of its own now stops. Until this release a source’s or a PostgreSQL destination’s connection string withsslmode=verify-caand nosslrootcertran 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 readsverify-caasverify-full, saves the TLS choice you make, and its audit row namestls.modeas 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_namesay, has its connection string replaced instead, since its page answers such an edit with409); a destination’s connection string is replaced with one that sayssslmode=verify-full. The same now holds for every TLS parameter a pipeline’s worker refuses in a connection string (an unknownsslmodeorchannel_binding,sslrootcertnaming a file,sslrootcert=systembelowverify-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=systemwas “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 with422 value_not_carriable(more than 96 KiB is refused, the cap a source saved field by field already had, whose refusalconnection_too_largenow 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/testanswers422 value_not_carriablepast 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/credentialsand its rotation store apostgres://orpostgresql://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}answersconnection_unread: truefor 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 with409 source_url_not_understood, says to create a new source instead, and still warns about a connection in the clear, from the URL’s ownsslmode. 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
faultand never as a failure of ours. A source whose connection is changed by someone else while an edit or a revocation is tested answers409 source_changedand 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/mesayssource_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), and422 source_fields_unavailablenames 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}’sconnectionandstanding_warnings).- The OpenAPI document (
api/openapi.json) describesPATCH /v1/sources/{id}, theconnectionandconnection_urlrequest fields and theconnectionandstanding_warningsresponse fields, and the connection test’sconnection,connection_url,source_idandconnection_changesrequest fields and itssteps(CheckStep, with itsdetails) andsource_tls(SourceTLS) response fields, andPresentedCertificate.
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) andlow_balance_minorfor the low-balance warning,monthly_budget_minor, andbudget_action:notify, orstop_new_runs. Every field is required, an amount isnullfor none, and the change is in the audit log aswallet.alerts_changed.GET /v1/walletreturns them asalerts, withalerts.budget_reachedwhile a budget that stops new runs is reached, andbilling_modeis 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(inGET /v1/walletand the PUT’s answer) says how many of the account’s running pipelines a budget set tostop_new_runswould 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_bysays 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 inGET /v1/wallet(alerts.held_by), the PUT’s answer,GET /v1/overview(spend.held_by), the start’s409 budget_reached(details.held_by) and every billing webhook’sdetails, and the Billing page and the overview say it in one sentence.GET /v1/overview’sspend.billing_modeis documented asprepaidorpostpaid, as it has answered since the mode in force became readable.held_by,spend.billing_modeand a pipeline’shealthare open sets (x-extensible-enumin 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 theout_of_credithealth 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 readdelayed(“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_creditstill leads when the account is out of credit too; a pipeline that streams continuously never readsbudget_reached. The pipeline list’shealthfilter 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_bynow 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/testwithout_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_bynames every way each billing notice ends (GET /v1/notification-triggers, and the notifications guide in the same words).out_of_creditsaid “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_balancethe balance lasting long enough and above the amount, or the account becoming invoiced monthly;spend_thresholdthe next UTC month, the budget removed, or a higher step;budget_reachedevery 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_reachednames 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
detailscarrycontinuous_pipelines, withcontinuous_pipelines_truncatedwhen the list was cut andcontinuous_pipelines_partialwhen 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/dayssays which amounts are read from the ledger (2026-10-17 (IST)):charged_minor,refunded_minorand a failed run’scredited_minorare,net_minoris the first less the second, andestimated_minor,amount_minor_decimalandpending_minorare 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 (
eventsonPOSTandPUT /v1/notification-channels):sync.startedandsync.ended,table.copied,table.parked,schema.changed,connection_test.succeededand.failed, and every action of the audit log (pipeline.created,pipeline.schedule_changed,api_key.created,member.removed, …), by exact type, bynoun.*, 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’sevents_sincesays from when each pattern is sent, andevents_pipelines_sincefrom when each pipeline is). Slack channels take no events (422 events_not_for_slack); a type that is not one is422 unknown_event_type, naming it. GET /v1/notification-event-typeslists 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 onid, and order a pipeline’s events bysequence(increasing, with gaps). POST /v1/notification-channels/{id}/testtakesevent_typeand sends a sample of that event, marked"test": true.GET /v1/notificationstakesphase(repeatable:raised,resolved,test,occurred). Events are listed only whenphase=occurredis asked for, or whentriggernames an event type (then its events and tests), so the default page is unchanged for every existing client; an event’salert_idisnull. A phase a trigger never has (trigger=sync.ended&phase=raised) is422 phase_not_for_trigger, never an empty page.- An item’s
phaseinGET /v1/notificationsis an open set (x-extensible-enumin the API reference, ashealth,held_byandbilling_modeare), andoccurredand a nullalert_idreach only a client that asks for events (phase=occurred, or atriggerthat 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_POOLsets 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:partialorfailed, the last one with the reason) and on the webhook alike: each is told its ownsync.ended(failed; the last one, the attempt whose worker process started last, with the reason, also when it died before itssync.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 orduration_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 toldsync.ended(failed, no reason) then, so that event’screated_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 (partialwhen 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_disabledemail tells an owner to do. - A webhook disabled for failing says whether the deliveries that failed were events (
failed_onin thechannel_disabledbody:events,alertsorboth).
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 underREPLICA IDENTITY FULLare 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 itONLYboth times, with its column list as it is now and yourWHEREclause, 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, whoseUPDATEandDELETEyour database then refuses when it has no primary key. Every re-add now saysONLY. - 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’sUPDATEandDELETEwhile 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 FULLand 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 itsUPDATEandDELETE; 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 FULLsays it then sends every column, the ones the list left out included; and every text advisingpublish_via_partition_rootsays 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 EXCLUSIVElock and builds an index. - Fixed: a table an earlier release left waiting
keywas told to add a primary key, on its row, in the refusal of a purge asked of it, and in the API’s description ofwaiting.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 waitskeyany 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_rooton 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_rootprints 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 aDEFERRABLEprimary key needsREPLICA IDENTITY FULLfirst; your database still refuses UPDATE and DELETE underFULLwhile 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 nameREPLICA IDENTITY FULLas 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
UPDATEandDELETEafter 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
streamingonce it has caught up, even when your source database writes nothing more. Since v0.1.53 it could readcatching upfor 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_rootoption, shown for a partitioned table waitingroot_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 ofwaiting, 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 FULLnames 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’ssource_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_rootoption 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’swaiting.statementturns 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 whoseADD TABLEthe 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 FULLnow 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, aDEFAULTidentity with no primary key, aDEFERRABLEprimary 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 ofwaiting.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 FULLand publishes it now refuses, changing nothing, whereFULLitself 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 underpublish_generated_columns = stored). Before, such a table, or a partition that kept its own primary key beside a generated column, was givenFULLand 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 TABLEnames 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 DEFAULTwhere a primary key is there to use, the key re-createdNOT DEFERRABLE,FULLonly 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 printedREPLICA IDENTITY DEFAULTfor 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 stayedFULL. - 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
publishkinds, a row filter, a column list), a column list underFULL, 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 underREPLICA 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.statementsis now ONEDOblock, 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 everyUPDATEandDELETEof 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 aFULLthat gave up on its lock left theADD TABLEafter 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 runSET lock_timeoutfirst. 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.statementforkeyless_publicationis now that one statement (it was empty), and forkeyless_unchecked_writesandkeyless_root_identityit gives the table and each of its partitionsFULL. The pipeline’s history, a park for a table that left its publication, and a purge’s refusal no longer carry anADD TABLEof 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 noONLY, so an inheritance parent brought its children, published with no identity.- What
REPLICA IDENTITY FULLcosts 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.reasongainskeyless_new_rowsandkeyless_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 waitskeyless_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”, underpublication. 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, waitskeyless_publication, and its row serves the one statement that keeps its writes working (the entry above).TableWaiting.statementis the publication’sADD TABLEonly forpublication, 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 noREPLICA IDENTITY FULL, the statement adding it to the publication makes PostgreSQL refuse everyUPDATEandDELETEof 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.statementsgive a table the pipeline read with no usable keyREPLICA IDENTITY FULLwherever 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 theADD TABLEalone, which makes PostgreSQL refuse everyUPDATEandDELETEof 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 whatFULLcosts, 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.reasongains 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) andkeyless_root_identity(a partition sends whole old rows while the table does not). The app names each, with its remedy.TableWaiting.statementis the statement that lifts the wait, where one does: forkeyless_unchecked_writesandkeyless_root_identity, the one that gives the table and each of its partitionsREPLICA IDENTITY FULL(or changes nothing and says why, where your database would still refuse its UPDATE and DELETE), and empty forkeyless_standbyandcopy_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_lockis tried again by the pipeline on its own:TableWaiting.retrysays 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.sourceis documented as what it is: the replica identity’s letter (d,i,f) as the pipeline recorded it, orrow_hashfor a table with no primary key. The document listedprimary_key,replica_identityandnone, 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_monetaryand 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_unusableand 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 everyINSERT,UPDATE,DELETE,MERGEandCOPY FROMtakes, orACCESS EXCLUSIVE, whichTRUNCATEtakes), usually for milliseconds. A reader, aSERIALIZABLEreader, 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_activityandpg_prepared_xactson 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, withoutpg_read_all_stats, is waited on exactly as a superuser would be. (Before, a source role withoutpg_read_all_statscould 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 TABLEwaiting 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) throughpg_publication_tables, which opens every table the publication lists. With anALTER TABLEof 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, isopen, notnone. 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 isnoneas 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 arefailed_runs, one object per run. Each hasrun_id,refund(credited,pending,refusedornothing_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(forpending, what the refund rule still owes it, which the refund pass writes) andusage. 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’sfailed_runsunder the samerun_id: count eachpipeline_idandrun_idonce to tell a range. The refund pass credits an account in one transaction, so while any failed run of the account isrefused, on any day, it credits none of the account’s runs, and apendingamount waits for that correction too. Closed days’failed_runentries ofnot_charged, and that array’sruns,refundandpending_minorfields, are gone; today’s failed runs are stillfailed_runentries ofnot_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’screditadds up tobalance_minor. It gainsfailed_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), andother_minor, the rest of the balance, which is negative when usage was charged while no top-up or grant had credit left. Before,creditheld 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_minoronGET /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}answersstatus: "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 answeredopen, 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.statusisopen,closedornone, 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_startedwith a newrestartedreason,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
tothat holds exactly 200,000 rows no longer drops its oldest row.GET /v1/audit-events.csvrecords 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.csvandGET /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=…withkind=changealone, or withactor=, is422 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
fromis not before itstois told “from must be before to.” onGET /v1/audit-events,GET /v1/audit-events.csvandGET /v1/pipelines/{id}/observations/export, where it read “from is before to.” (the same422 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’sfailed_runentry carriesrefundandpending_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.refundsays which:credited(amount_minorwas credited back),pending(pending_minoris still to be credited back),refused(the credit could not be worked out automatically; the charge stands until we correct it) ornothing_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
runscounts the runs itsrefundstate is about: forpendingandrefusedthe runs still owed a credit; forcreditedthe runs credited back, and any other run on a credited line (a run the credit’s cap left nothing is free too); fornothing_chargedthe 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. retryingis now served for apendingday 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/entriesand the statement: a top-up’s card hint is an owner’s, as onGET /v1/wallet. A member or an API key reads the same rows withoutinstrument_hint(null on a statement row; absent on a ledger row).- The statement CSV of a month still open ends with a
balance_so_farrow, dated the day its balance is of; only a closed month’s ends withclosing_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:refundandpending_minoronUsageNotCharged,retryingfor apendingday, and whoseinstrument_hinta 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_startedwithrestarted: 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 sameIdempotency-Key. It is now kept for a day, then deleted, like the filter’s ownPUT(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 refused409 credential_exists, a channel’s create makes a second channel, a rotation runs again (ageneratemakes 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_changedno longer saysIdempotent-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 gainsheld. 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 isheld: it is notpendingand 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.appliedsays 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/revealandPOST …/hash-salt/preview: a retry with the sameIdempotency-Keystill 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 refused409 hash_salt_changedand 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_upalert carriessource_history(code,acceptable) onGET /v1/alertsandGET /v1/pipelines/{id}/alertswhen the pipeline stopped for a changed source history; it is absent on every other give-up. For such a stop that may be accepted, thenoticeofGET /v1/pipelines/{id}, and of the answer toPUT /v1/pipelines/{id}/schedule, now says that starting it again without accepting the new history stops it again. A row ofGET /v1/pipelineskeeps 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, withdetails.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=changesmerges 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 kindchangewith itsaction,actor,via,changesandreason, 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). Withoutincludethe history is unchanged.- New filters on the same route:
kind=(repeatable;changeselects the changes),actor=(a person’s user id, an API key’s id, oroperator) andmeasurements=hide, which leaves out the once-a-minuteresource_consumedandretention_observedrows.actor=orkind=changewithoutinclude=changesis422 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=changessent without it, or the reverse, is400 invalid_cursor. A merged cursor sent to the plain history used to be answered500 observations_unavailable. GET /v1/pipelines/{id}/runs/{run_id}answers one run or session exactly as the run history lists it, withshapebeside it, so a link to one run reads the row the history showed. A run the 30-day window does not hold is404 run_not_found(its events are still in the history); a pipeline with more history inside the window than one read covers is500 run_lookup_truncated, never a 404.GET /v1/pipelines/{id}/observations/exportexports the history for one range, oldest first, streamed, as CSV (format=csv, the default: RFC 4180, UTF-8,\r\n) or NDJSON (format=ndjson), withContent-Dispositionnaming the pipeline and the range. Columns:occurred_at,kind,sequence,run_id,actor,detail(the worker’s own words, or a change’s action) andpayload(the fields the history shows, as JSON). At most 31 days and 200,000 rows a request: more is422 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/overviewis 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/pipelinesfilters byhealth=(repeatable or comma-separated),source_id=and searches by name withq=(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 anext_cursor, and saysscan_budget_reached: true. An unknown health word is422 unknown_health; text with a NUL character is422 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}andGET /v1/overvieware new operations; the history’s page is typed asObservationPageand the list’s asPipelineListPage(both were the untypedPage). - The history’s
occurred_atis 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
toholds every row written before the read.toused 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 absenttois now no upper bound; a namedtois unchanged, and the export’saudit_log.exportedrow recordstoonly 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, orrefused(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\nline ends and spreadsheet formulas defused.422 range_too_largenames both limits. - New:
GET /v1/usage/hours?day=(dayrequired) — one of the last 31 UTC days, hour by hour (quantities only);422 hours_out_of_rangeotherwise. 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 bykind,fromortoleaves rows out, so it carries no balance after each row. - New:
GET /v1/wallet/statements/{month}(andGET /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_rangefor 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/usageis 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_pipelineon 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’s409 answer_requiredsays “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_flighton 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’stables, 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 COLUMNstatement 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/pipelinesandPOST /v1/pipelines/{id}/tables: each entry oftablesmay now also carrycolumns(asPUT …/columnstakes them: Sync, Block or Hash) andfilter(asPUT …/filtertakes it, withcolumn_types,replica_identity,on_withheld_entry,acknowledgeandrows_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 indetails.table; a refusal stores nothing. A table the pipeline never had holds no rows yet, soexisting_rowsis left out. A removed table asked back may still hold its rows, so it is judged as a table that has synced:existing_rowsis required (422 existing_rows_required), a column going back to Sync from Block or Hash is an owner’s, a changed filter needsacknowledgeand, on a PostgreSQL destination,rows_outside; its copy is the add itself. Shaping a table the pipeline already syncs through an add is409 table_already_synced: use the two table routes.POST /v1/pipelines/{id}/tables/{table_id}/resumeanswers another pipeline’s record. A table parkedshaping_record_of_another_pipeline(its destination’s own record names columns another pipeline keeps otherwise) takesrecord_answer:keep_as_heldmakes this pipeline’s settings what the destination holds,clear_and_applyclears those values and syncs them as this pipeline is set to (a column left clear is an owner’s);409 answer_requiredwithout one,422 answer_not_offeredfor one the park does not take. When the record names another pipeline’s row filter,acknowledge: true(withrows_outsideon 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,adoptedwhen they agree with this pipeline’s settings,disputedwhen 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: truerequired), and on a PostgreSQL destinationrows_outsidesays what happens to the rows already there that no longer match:keep, ordelete(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 bycolumn_typesfrom the connection test’scatalogue_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 asfilter_changed, and in the audit log astable.filter_changed.GETandPUT /v1/pipelines/{id}/tables/{table_id}/columnsanswer the table’sfilter(wanted, applied, pending) and each column’sfilter_type; a column setting on a table kept ashistoryorappendis422 mode_not_composeduntil 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/testtakescatalogue_columns: {schema, name}(a PostgreSQL source): the answer’scatalogue.table_columnslists 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 publicationsentit (absent while no publication lists the table),may_withhold(a change can leave its value out under REPLICA IDENTITY DEFAULT),can_blockandcan_hash(every column but a key’s), and the row filter’sfilter_typeandfilter_opsfor it on this database; and the table’sreplica_identityandserver_encoding. A table that is not there, or that the role may not read, answerscolumns: []with awhy, 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 is422 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, itsorigin(generatedorset_by_owner), whether a column hasusedit, the construction (Base64(SHA-256(UTF-8(text(value)) || UTF-8(salt))), NULL stays NULL) and therecipesthat 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-saltwith{"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_useafter;422 hash_salt_invalidnaming the reason, never the value). Answers its hint only.POST /v1/destinations/{id}/hash-salt/previewwith{"value"}: the hash that value would get, to check a recipe without reading the salt. At most 20 a minute per account (429withRetry-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,blockedorhashed), the setting you chose and whether it is stillpending, 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_knownfalse).PUT /v1/pipelines/{id}/tables/{table_id}/columnswith{"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_rowssays 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, rulecolumn_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 logtable.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
SELECTon 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 withthe initial copy's lock failed (SQLSTATE 42501)and failed again at every restart, without saying what to do. GrantingSELECTon 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 holdsSELECTon and still cannot read by its own name: one in a schema the user has noUSAGEon, 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-deletedon a table waiting for you is refused with422 purge_table_waiting: a table whosewaiting.reasonis set and is notdestination_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 answered200with “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_effectsaid “now” for a stopped or given-up pipeline, whose worker could still be finishing the purge. 409 resync_in_progresscounts 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-requestcancels 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_purgewhen none waits. A purge the pipeline has already begun runs to its end; the answer’stakes_effectsays so where one may have, and the table’srows_purgedthen says what it removed. Audit actiontable.purge_request_cancelled. POST .../tables/{table_id}/purge-deletedon a parked table is refused with422 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’spending_purgegainswaits_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’s409 request_pending) now names that request’s cancel route, because a parked table’s mode change and purge wait until it is resumed. sync_modeson a destination card ofGET /v1/connectorsis now keyed by SOURCE kind:{"<source kind>": {default, offered, purge}}, for the account asking. A MySQL or Stripe pipeline into PostgreSQL writes every tableliveand runs no purge, so it is offeredlivealone and no purge: a change of a table’s mode, the pipeline’s default (PUT .../sync-mode) and a create’ssync_mode_defaultare refused there with422 mode_fixed_by_source, and a purge with422 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’ssync_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_restartsnames 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_progressis read from the last full re-sync’s own tables: the tables its door asked to copy that have not finished since, named indetails.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 (itswaiting.reasonset, 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}/tablesis refused409 request_pendingwhile 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 answered500 sync_unavailable. - A deleted pipeline’s
source_cleanupnames what a full re-sync left:previous_slot_nameandprevious_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-namesdraws a replication slot and publication name for a re-sync of every table that moves the pipeline to them, withstatements(the publication, with the pipeline’s tables: run before you ask) andstart_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_namesand theslot_name_taken/publication_name_takenrefusals 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_limitedevery time. credential.rotatedaudit rows say which database a rotation recorded:identity_recorded, each destination or source with the identity recorded on it, andconfirmed: truewhere yourconfirmasserted it was the same database.- A pipeline’s
old_slotis 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 ofGET /v1/connectors: the mode a table takes when nothing names one, and every mode a request may name (Snowflake:soft_deleteby default; PostgreSQL:liveby default; both offersoft_deleteandlive). The routes refuse exactly what this list leaves out.POST /v1/pipelineswith aslot_nameandpublication_nameanother pipeline of the account has asked a full re-sync to move to is refused with409 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 .../resyncand, 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.copyingonGET /v1/pipelines/{id}gainsresumable(true when the running copy keeps its place if interrupted) andresumed_at_rows(where this attempt picked up, or null).rows_copiedis 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) onGET /v1/pipelines/{id}/alertsandGET /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 carriesold_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 (assource_log_heldis: a full disk stops your database) until you switch warnings yourself; a stop does not end it. The webhook’sdetailscarryslotandstatement. - An account’s alert page can now return up to 10 more alerts than
limitasked 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}/rotateof 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_identifierandcurrent_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 with409 destination_would_moveor409 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_unprovensays which database the new one reaches and which of the pipelines’ objects are there; send the rotation again with"confirm": trueto 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 firstPATCH:{"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 withtakes_effect, the copy it is running ascopying, andcopy_restarts) andchanged, 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 onecopy_restartsnames.- A change of
usertakescredential, 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(withdetails.tables: what the role lacks,usage,privilege,ownershiporcreate_table, anddetails.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 asdestination_edited. - CORS:
Access-Control-Allow-Methodsnow lists every method the API routes (PUT,PATCHandDELETEbesideGETandPOST).
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 newslot_nameandpublication_name(a pairGET /v1/pipelines/{id}/new-source-namesdraws, 2026-10-12); the answer’ssetupthen 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_applicablenow also answers a delete asked of asoft_deletetable (by the re-sync and by.../recopy). -
Sync now:
POST /v1/pipelines/{id}/syncwrites everything the pipeline has received up to now without restarting it;effectsays what it did (writing_held_changes,nothing_held,after_the_copy,started).409 pipeline_stopped,409 pipeline_gave_up. -
GET /v1/pipelines/{id}gainssync_mode_default,resync(the last full re-sync,pendinguntil applied),sync_now,old_slot(a slot a re-sync left on your source, with its drop statement) andcopying(the copy running now). New history kindsresync_requested,resync_held,resync_applied,sync_requested,held_changes_written,old_slot_still_present; new audit actionspipeline.resync_requested,pipeline.sync_requested. -
Each table is kept in a sync mode, shown as
sync_modeon every table:soft_delete(a row deleted at your source stays in your destination, marked in_REYANSH_DELETED_AT; Snowflake’s default) orlive(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’spending_modeuntil then;DELETE /v1/pipelines/{id}/tables/{table_id}/sync-mode-requestcancels it while it waits;POST /v1/pipelines/{id}/tables/{table_id}/purge-deleted({"confirm": true}) deletes the rows a table holds marked deleted, shown aspending_purge, thenrows_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/pipelinestakessync_mode_default, recorded on each of its tables and on each table added later. -
New error codes:
422 mode_not_offered(historyandappendare not offered yet),404 no_pending_mode,409 mode_change_in_progress,422 confirm_required,422 purge_not_applicable, and409 request_pendingon every table request while a re-sync of every table is pending.409 table_action_pendingnow 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 (PUTandDELETE /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 thetable.resumedrow 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 ascredential.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}/tablescan show an open change whoseanswersis[]: 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}/resumeanswers 409answer_requiredwith “{table} cannot be resumed: it waits on a change no answer can be made to at this destination (…). Copy {table} again, or remove it.”, itsdetails.changesnaming 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
SELECTtakes), so anALTER TABLEthat 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_busyinGET /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 byactor,action(a prefix:pipeline.),target,pipeline_id,fromandto(366 days at most,422 range_too_large), cursor-paged. A filter holding a NUL character or bytes that are not UTF-8 is422 invalid_fieldnaming it, on the page and the CSV alike.client_addranduser_agentare 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_largepast 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 is403 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-auditis the list of actions,in_trail(people and keys), ornot_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,billingorsecurity_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/logoutanswers500 logout_failedif the record cannot be written, and the session is then still live; signing out again works. POST /v1/connections/testanswers500 check_unrecordedwhen the test ran and its record could not be written; the answer is not given, and running it again is safe.
2026-10-08 (IST) — The sign-in link’s token is in its fragment; the account’s small findings
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.GETandPUT /v1/pipelines/{id}/change-policy: a pipeline’s rules (preset,rules,confirm).PUTandDELETE /v1/pipelines/{id}/tables/{table_id}/change-policy: a table’s overrides. Each write takes anIdempotency-Key; a changed rule takes effect when a running pipeline restarts onto it, within a minute, and an unchanged write restarts nothing. New refusals: 422answer_not_offered,rule_not_per_table,unknown_rule, andchange_policy_unsupported_sourcefor 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/pipelinestakeschange_policy(preset,rules,confirm); left out, the pipeline has the automatic preset, unconfirmed.GET /v1/pipelines/{id}/tables: each table gainspending_changes(each change it waits on, with itschange_idand the answers it takes),columns_filling,left_out,source_note,rules(its overrides) andpaused_for_fill(only on a table that is streaming or catching up);parkedgainsclauseandwaitinggainsretry, 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.remedynow reads the cause.clausecounts 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.parkedalso gainswith_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}/resumetakesanswers, one per change the table waits on, bychange_id. New refusals: 409answer_required, 409change_not_pending, 422answer_not_offered, and 409resume_pendingfor 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 itsmessageas the table shows them, by the column and what happened at the source and each answer by its button’s words, and carriesdetails.changes: each change’schange_id, with theanswersent and theanswersit takes foranswer_not_offered, and thependingandrequestedanswers forresume_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 generalnot_found: a missing table and a missing pipeline (404pipeline_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 thetable_foundrule 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) ornotified. 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) andschema_changed(a warning: the pipeline followed a change to a source table’s shape, standing for a day). An alert of the first two carriessentence_by_table, what each table met;schema_changedcarrieschanges. Each pipeline, in the list too, carriestables_waiting_for_you. - The activity feed gains
schema_change(each change and what was done:applied,kept,left_out,ignored,waiting,refused,reverted, ornot_sentfor a column a publication’s column list does not send),column_filled,table_foundandtable_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 unknownclassificationmust acceptfailed_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: thesessioncookie, andapiKeywhere a key may), andx-reyansh-api-keyis the narrowest key that may call it:read,fullornever. Keys never manage keys, people or money, and a person’s own routes (/v1/me) are theirs: those answer a key403 api_key_not_allowed. A read key’s write is403 api_key_read_only. - Every
401now carriesWWW-Authenticate(Bearer realm="api", witherror="invalid_token"when a key was presented), as RFC 9110 requires. A browser does not prompt for it. - New refusals:
400 authorization_invalid(twoAuthorizationheaders, or notBearer <key>),400 credentials_ambiguous(a session cookie and anAuthorizationheader 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, and429 rate_limitedfor 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/v1request over plainhttp://,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/megainsapi_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=allincludes revoked and expired keys),GET /v1/api-keys/{id}(withbuilt: 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 workingoverlap_hours, 0 to 720, default 24),DELETE /v1/api-keys/{id}(immediate), andGET /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 and429+Retry-Afterpast 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 plainhttp; 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_bywithkind: "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/v1reaches the API to be refused instead of being redirected. - Your secret scanner can find a key: they start
rsk_and matchrsk_[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/destinationsis owner-only, as Fivetran’s Account Analyst “cannot create, edit, or delete destinations”. Members create pipelines into existing destinations bydestination_id. - Two owner rules on member operations (
x-reyansh-owner-when, anddetails.ruleon the refusal):POST /v1/pipelineswith the legacydestinationcredential form (it creates a destination object:destination_by_credential), andPOST /v1/credentials/{ref}/rotateof 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/memberslists 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/membershipleaves;GET /v1/membership-eventsis 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_enabledotherwise; an open invitation then readspaused, and withdrawing still works).POST /v1/invitationsinvites an address asownerormember;GET /v1/invitationslists them (state=openorall);POST /v1/invitations/{id}/resendsends 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_limitedwithRetry-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 a201withdelivery: 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/sessionanswers a person with several accounts or an open invitation with409 account_choice_required(details.accounts,details.invitations) and does not spend the link: send it again withaccount_id,invitation_idordecline_invitation_id.POST /v1/auth/switchmoves a signed-in person to another of their accounts; the new session ends when the old one would have.account_ambiguousis 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}andDELETE /v1/members/{user_id}read an optionalX-Reyansh-Accountheader; when it names another account than the session’s (another tab or window switched), the answer is409 account_changedand 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, is404 not_found, outside the sign-in endpoints (/v1/auth/). A wrong method answered405before. The sign-in endpoints are served before there is a session, outside this check, and a wrong method there is still405. - Changed: the sign-in endpoints (
/v1/auth/*) accept a body only asapplication/json(415 unsupported_media_typeotherwise; sign-out takes no body) and refuse a request from another site (403 cross_site_request:Sec-Fetch-Site: cross-site, or anOriginthat is neither this site nor on the configured allowlist). - Changed: an
Idempotency-Keybelongs to the person who sent it. The same key sent by another person of the account is422 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(andnotificationsonGET /v1/me): which pipelines (none,created_by_meorall) 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, socreated_by_mecovers only new ones. Running out of credit goes to every owner, whatever they chose (noneincluded), 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_removedin 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 (
scopemember:<user_id>, withrecipientwhile they are a member). A delivery to someone who has since left is not sent, readsrecipient_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_byonGET /v1/credentials/{ref}: who wrote the credential’s current value (user_id, andemailwhile 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}/tablesadds 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 withlast_table: delete the pipeline instead), and answers the optional statement that takes it out of the publication;POST …/tables/{table_id}/resumeresumes a parked table (not_parkedotherwise);POST …/tables/{table_id}/recopycopies 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_applicableinto Snowflake, whose copy already marks them deleted);copy_in_progressandtable_removedrefuse 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_hintandsigning_secret_idonly. 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 onReyansh-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_refusedfor an address we will not send to,422 url_unresolvablefor a host that does not exist. POST /v1/notification-channels/{id}/rotate-secretreplaces a webhook’s secret; the old one keeps signing foroverlap_hours(0 to 24, default 24). Sending the current secret again changes nothing. A different secret during an overlap is409 rotation_in_progressunlessdrop_previousis 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-Afterup 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 emailedchannel_disabledeither way, andPUTwithenabled: trueswitches 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-settingscarriesrecoveries(on unless switched off), andPUTaccepts 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}/alertsandGET /v1/alertscarrysource_logon it:held_bytes,headroom_bytes(absent when your database sets no limit),threshold_bytesandmeasured_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 overshootlimitby 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_timeoutis left as it is and does not have to be raised for us. The same goes for atransaction_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}/runsgainsno_writeon a session that confirmed no write (nothing_to_write,not_yetornone; absent when a write was confirmed). Treat a value you do not know asnone. - 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 isretrying, 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/alertsandGET /v1/pipelines/{id}/alertsmay now answerkind: 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/pipelinesrefuses any otheridwith422 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-previewrefuses such apipeline_idthe 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 NULLedand “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_METAcolumn, and writes novalues_fittedevent. 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
stopdoes 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_valuetook 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 itsvarchar(n)orchar(n)column is cut to the column’s length, and a value that is not a validuuidor 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
jsonorjsonbcolumn, and ajsoncolumn 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
jsonorjsonbcolumn says so: that check is stricter than ajsoncolumn, 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 rawfitted=[…]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, SQLSTATE42501), 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 (
USAGEandCREATE TABLEon 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,UPDATEandDELETE. On the destination’s own schema:USAGE,CREATE TABLEandCREATE SEQUENCE. AndUSAGEon 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_testsays what the test found:verdictispermitted,refusedornot_known, anddetailis the sentence.not_knownis 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_listingsays what the grants list:listed,not_listedornot_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 grantedCREATE SCHEMAon the database;391918: no database is in use for the role. A role not grantedUSAGEon 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_disagreeis 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_behindlists 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_outof a stored destination’s test, and its two500answers (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_remainistrue. It is absent from every other answer,check_timed_outandcheck_unavailableincluded 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 themessage. - 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_CHECKOUTis a pipeline’s own and is never to be dropped. Before, the app showed only its sentence for the code: a firewall for the504, and “something went wrong at our end” for the500s. - A test that ended before it started says so:
details.test_not_startedistrue. That is the504 check_timed_outand the500 check_unavailableof 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_outno 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 that504changed 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/destinationsacceptskind: "snowflake"withsettings(account,user,warehouse,database, and optionallyrole) and acredential_refnaming a key pair.POST /v1/credentialsaccepts a key pair:private_key(PKCS#8 PEM), withpassphrasewhen the key is encrypted. The answer’shintis the key’s fingerprint, the value Snowflake shows asRSA_PUBLIC_KEY_FP. The key is never returned.POST /v1/connections/testtakesdestination_idfor a stored destination.- A Snowflake destination accepts a Postgres source only. Its card lists that in
sources, and any other pairing is refused with422 unsupported_pairing. - Each pipeline writes its own schema, named when the pipeline is created
(
destination_schema_naming:fivetran, the default, orsource). - What stops a Snowflake pipeline today: any change to the source table’s columns, an added
column included, and a
TRUNCATEyour 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.
effectis what the schedule does for that pipeline, which depends on its two ends:runs: the source’s syncs end, and one runs at each ofnext_runs.batch_hold: a Postgres source into Snowflake. The source is read continuously and never waits for the schedule. Each quiet batch is held forhold_secondsbefore 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_secondsis the shortest gap between two of the schedule’s runs in the week ahead, at most 24 hours, and six hours for amanualschedule.- New:
GET /v1/schedule-previewanswers what a schedule would be before you save it: the samescheduleobject, orproblem, 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.
SnowflakeSettingsrefuses 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-Keyheader now says what it does on every mutating operation: required, replayed under the same key, refused with422 idempotency_key_reusefor a different body. Pipelinedocuments what it returns:schedule,source_id,destination_idanddeletionwere returned and not documented.historical_loadwas documented onPipelineand never returned: it is something you send, and is now on the create body.ConnectorObjectdocumentssettings, andGET /v1/pipelinesdocuments itsdestination_idandinclude_deletedfilters.
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
200with the pipeline once nothing of it is running, and202while a worker that was up is still finishing its batch (deletion.stateisdeleting, thendeleted). 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_cleanupgives 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, withdeletionpresent, and so do its observations, runs and alerts.GET /v1/pipelinesleaves it out unless you sendinclude_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.stateisdeleted. Until then, a second pipeline into the same table is refused with422 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/alertsandGET /v1/pipelines/{id}/alertshave a newkind:values_fitted.severityiswarningandblocksisfalse: the values were written, changed, and syncing continues.tablesnames the destination tables, newest report first, as it does forrows_discarded.- A new field,
columns_by_table, names each of those tables’ columns whose values were changed, sorted. It is present onvalues_fittedonly. - 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: truemeans the same as onrows_discarded: more than 50 reports arrived in the 24 hours, sotablesandcolumns_by_tablemay 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 thanlimit(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
kindcan still place it:severityandblocksare 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 aschemain a Snowflake destination’ssettingsis refused on create:422 invalid_settings, saying it is chosen per pipeline. - A stored destination’s
settingsare shown without one, onGET /v1/destinationsandGET /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_raisedonGET /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_checkedonPOST /v1/connections/testis described more exactly in the API reference. It is false whenever the destination’s tables were not checked: when nostreamwas 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
streamit 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_discardedorvalues_fittedentry now says where its record is:record_table, andnot_recordedwith 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
CREATEon the schema, orINSERTon 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 theGRANT(or theCREATE 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}toPUT /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.Aandcol aall namecol_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, withdestination_table_takenas 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 (onedestination, 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_accountandmyorg-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:
Ordersandordersare two tables. Two pipelines that write two tables ofpublicare 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’
schemasettings say. - Two pipelines with schemas of their own may each write a table called
ordersthrough one destination: they are two tables. POST /v1/pipelinesandPOST /v1/pipelines/{id}/startboth 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), andinformation_schema; - with
sourcenaming, 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
legacyandpublic: it writes where it always wrote. So does every pipeline created before today. legacyis only ever read: sent toPOST /v1/pipelinesit is422 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 sendsdestination_schema_namingis refused with422 unsupported_destination_schema_namingand 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 outsidea-z,0-9and_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.sourceuses 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_longornot_a_value), never the value, and what you can do, each followed by a start: change the column so it takes the value (for atoo_longone, a longer length or the typetext), switch tocontinue, or correct the value in the source. It is aschema_stop_raisedevent, orworker_refusedwhile existing rows are copied. - That includes a
jsonorjsonbvalue holding a\u0000escape, whichcontinuewrites as NULL from this release (the entry of this date below): understopit stops the pipeline, naming its column asnot_a_valueand 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_valuedescription 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-rowssets any of its three answers. At least one is required (422 missing_field) and one left out keeps its answer, so a client sending onlyon_discarded_rowsees no change. An unknownon_rejected_valueis422 invalid_field. A changed answer bumpsversion, and a running pipeline restarts onto it on its own.continueis 2026-09-30’s behaviour (a too-long text cut, a baduuidor JSON value NULLed, into a Postgres destination). Understopnothing 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_destinationis 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
Pipelineschema listson_discarded_row,on_rejected_valueandrecord_in_destinationas 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
continuedoes for that value. It is now written as NULL where the column allows NULL, and the pipeline carries on. It is on the feed asvalues_fittedwithnot_a_valueandnulled, like any other, and never carries the value. - In a
jsoncolumn that NULL is our check’s, not your value’s, and is markedour_cast: the pipeline writes ajsoncolumn throughjsonb, and ajsoncolumn would have stored the escape. - Nothing else changes on a destination database whose encoding is UTF-8. In a
NOT NULLcolumn 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
22P05is 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 asvalues_fitted. Every other value holding such a character is still PostgreSQL’s own refusal: it is neither NULLed nor explained yet (#1222).