Skip to content

Changelog: November 2026

Section titled “2026-11-20 (IST) — Long pipeline names wrap, a destination’s page no longer jumps, and an emailed link’s lost answer says what to do”
  • The Pipelines list wraps a long pipeline name on a wide screen too, so a name at the 63-character limit never pushes the list sideways or its pins out of sight.
  • A destination’s page draws its pipelines once your role is known, so a member’s line about the hashing salt no longer pushes them down after the page appears. Until then it says it is loading your account, where they will be.
  • Signing in, or answering an invitation, from an emailed link when the service’s answer did not arrive: the message says it may have gone through, that the page cannot show whether it did, and to request a new link and open it. It used to say only to try again, though the link may already have been used.

2026-11-20 (IST) — A change whose answer was lost may have been done, an agent source’s edit, a name already holding a connection string, and a menu that stays on the screen

Section titled “2026-11-20 (IST) — A change whose answer was lost may have been done, an agent source’s edit, a name already holding a connection string, and a menu that stays on the screen”
  • When the service’s answer to a change did not arrive (a save, a delete, a start or a stop, an approval), the message says the change may have been done, and what to do from that page. Where the page shows the change, it says to reload the page to see whether it was before you press again. Where pressing again is safe, because the page kept what makes it so (the history export, a notification channel, an API key, a new destination, a new pipeline, an SSH key made from a source’s tunnel settings), it says to press again without changing anything: nothing is done twice. There, a request still being handled says to wait a moment and press it again, not to reload. Elsewhere it says what you can do, such as looking for a new source in Sources. It used to say only to try again, so a delete the service had done met “Deleted” on the next press. An error page from a proxy in front of the service is read the same way. A page that could not be read because of one says the service did not answer just now, and to try again in a moment.
  • A new Postgres or Snowflake destination whose save’s answer did not arrive says it may have been saved, and pressing Save again without changing anything finishes it: the destination, its connection string or its key pair are never made twice. The Postgres form used to say the destination was not saved, and pressing again asked for another name. Closing the form, or leaving the setup, then says what may have been stored or saved, never that nothing was.
  • The history export, while a pipeline’s answer did not arrive, says “At least” of the pipelines that exist.
  • Signing out, when its answer did not arrive and the service then answers that your session has ended, finishes signing out in this browser, as Sign out does: your Shortcuts here are cleared and you go to the sign-in page.
  • Editing a source reached through a proxy agent says it connects through that agent, with its SSH key, and that only the API points it at another agent or key. It used to show Directly chosen. Saving it keeps the agent, as before.
  • A new Postgres destination whose name already holds a connection string (an earlier save that did not finish, or another destination) says so and asks for another name. It used to speak of a pipeline.
  • A pipeline’s More actions on a phone stays on the screen when Sync now finishes while the menu is open.
  • Proxy agents: a waiting agent’s token is said to have expired once it has, even on a page left open.
  • Settings › Network and security says, above both panes, that a key or an agent a source still uses cannot be retired or deleted.
  • Shortcuts: the guide says that Sign out and Leave clear every Shortcuts list in this browser, every account’s and every person’s.

2026-11-20 (IST) — A sign-out that may not have finished is said, Leave clears Shortcuts, focus stays put on Network and security, and a source’s proxy agent is shown

Section titled “2026-11-20 (IST) — A sign-out that may not have finished is said, Leave clears Shortcuts, focus stays put on Network and security, and a source’s proxy agent is shown”
  • A sign-out that may not have finished is said where you pressed Sign out, and you stay on the same page: nothing is cleared, and your other tabs are not signed out, until it goes through. It used to send you to the sign-in page while your session could still work. Once the service answers that your session has ended, signing out finishes here. A session that had already ended signs out as before.
  • Leave clears this browser’s Shortcuts, as Sign out does. A Leave whose answer did not arrive puts keyboard focus on the message that says so.
  • When this browser refuses to keep pins once, Shortcuts keeps them in the page until you reload, as it says, and no longer writes over the pins it had kept. Its empty list no longer says a pin is kept in this browser.
  • The Snowflake destination form: pressing Save destination again opens Time Travel, wide numerics and text if you had closed it over a field it refuses, and puts you on that field.
  • Settings › Network and security: Check again and Load more keep keyboard focus while they read, and say they are reading. When an answer removes the button you pressed (the last page, or an approval, a deletion or a retirement that answered after you closed its question), focus moves to the line that says what happened.
  • In the icon rail, the Shortcuts menu reads your pipelines as two labelled groups, Pinned and Recent.
  • A source reached through a proxy agent shows the agent and its SSH key on its page, and says that only the API points it at another agent or key.
  • The history export no longer links a member to API keys, which only owners open: it says an owner creates read keys.
  • A pipeline’s page names the change bookmark wherever it names your database’s replication slot, and no longer says “worker”.

2026-11-20 (IST) — The app on a phone: page headers, Members, key files and a pipeline’s More actions fit the screen

Section titled “2026-11-20 (IST) — The app on a phone: page headers, Members, key files and a pipeline’s More actions fit the screen”
  • A page header’s buttons go to the next line, below the title, when beside it they would leave the title less than about 12rem, so the title is no longer squeezed to a few letters a line. On Sources, a source’s page and Channels the two buttons used to run off a 320 px phone’s screen.
  • Members on a phone: each member is a block of its own (the address, then the role, then the buttons), and the buttons and the role select are a finger’s height (up to 768 px). From 640 px it is the table.
  • A pipeline’s More actions (where Sync now is on a phone) opens on the screen. It used to open past the screen’s left edge. A menu open while the screen’s width changes (a phone turned) closes; open it again.
  • Choose a key file (a Snowflake destination) and a source’s client key file fit a phone’s width.

2026-11-19 (IST) — Retire an SSH key and approve a proxy agent from the app, Shortcuts, the Overview’s open problems, and the Pipelines list’s source and destination filters

Section titled “2026-11-19 (IST) — Retire an SSH key and approve a proxy agent from the app, Shortcuts, the Overview’s open problems, and the Pipelines list’s source and destination filters”
  • Settings › Network and security has two panes: Addresses and keys (as before) and Proxy agents. Each of the account’s active SSH keys has Retire, for every role, after a question that says the key’s private half is deleted for good; a key a source still uses, through an SSH tunnel or a proxy agent, is not retired, and the sources are named. Proxy agents lists the account’s agents with their state, version and key, and offers Approve this key (the question shows the fingerprint it sends) and Delete (a source still reaching its database through the agent is named, and nothing is deleted), with Check again. Agents are still created with the API.
  • Shortcuts: a Pin on each row of the Pipelines list keeps that pipeline in the sidebar’s Shortcuts, with Recent below the pins: up to five pipelines you opened recently, newest first, never a pinned one. Both lists are kept in this browser, for you in this account, and signing out with Sign out clears them from this browser.
  • The Overview lists its open problems: the first five open alerts, errors first, each with its pipeline, and See all with the account’s own count. The month’s heading says it is the UTC month, on the Overview and on Billing, and the balance is in the account’s own currency.
  • The Pipelines list filters by source and destination with two selects, by name, in place of the removable chips; a filter set by Show in Pipelines is kept as its own choice even when the list does not hold it.
  • Usage and the Audit log link the history export where the account’s API keys are on, each with a line saying what its CSV downloads and what the export copies; the export page says so in place of its form where they are not.
  • Smaller: one link at a time, of the sidebar, tabs or panes, is announced as the current page; a source’s Revoke and a member sent back from a destination’s Hashing salt land focus on the question or the sentence that says why; Add a source waits for the account before drawing what its flags decide, and its settings open over a refused tunnel choice; closing Destinations › Add a destination’s PostgreSQL form after its connection string was stored asks first; a webhook sent nothing says so once.
  • No API changed. The app now reads the open alerts on the Overview and the sources’ and destinations’ names on the Pipelines list when each opens, as the Alerts, Sources and Destinations pages already did.

2026-11-18 (IST) — Sources, destinations, the overview, alerts, usage and settings on the new pages

Section titled “2026-11-18 (IST) — Sources, destinations, the overview, alerts, usage and settings on the new pages”
  • Settings › Network and security is new, for every role: the addresses we connect from, the account’s SSH keys (read-only; shown when SSH tunnels are on for the account) and the approved certificates, which moved there from the Sources list. Each approval now says who approved it and when. Settings › Delivery history is the delivery history’s own Settings address; the emailed /notifications still opens it.
  • Destinations › Add a destination is a chooser: PostgreSQL (its connection string, saved and then tested on its page when you ask) or Snowflake (the form you know). A destination named new is refused before anything is stored, in both forms, since /destinations/new is the chooser’s address.
  • A destination’s page has panes, each with its own address: Overview, Test, Settings, Key rotation and Hashing salt (/destinations/{id}/test, /settings, /key-rotation, /hashing-salt). A member sees Key rotation only while a rotation is in progress, and no Hashing salt pane: its address leads back to the destination with one sentence.
  • Members, API keys and single sign-on have panes too: Members › People, Invitations and Recent changes, with Invite a member in the header (owners); API keys › Keys and Recent changes; Single sign-on › Connection, Domains, Who signs in and Delete. A member’s Members page now says that owners invite members.
  • The Overview adds this month’s billed charges, refunds and net (the figures Billing shows), and a line counting deleted pipelines whose clean-up on their source is not done yet. Alerts are grouped into Errors and Warnings. The Pipelines list shows the health first and the state beside it, and can be filtered to one source or one destination (Show in Pipelines on a source’s or destination’s page).
  • A source’s page has its Test and Edit in its header, its facts in one card, and its approved certificates and the pipelines reading it as tables; the Sources list says where each source connects. Add a source asks where your database is hosted, keeps its less common settings behind Show all settings, and shows the host’s setup guide beside the form on a wide screen.
  • Settings’ pages take a header with the page’s one action, and lists with a header row: the per-event email choices are a table (Event · Emailed), the channels are rows under Name · Kind · Sends · State, and the audit log’s filters are one row. While the app is still asking who you are, no button a page holds back from members can be pressed: each waits until the app knows.
  • Words: a replication slot is called the pipeline’s change bookmark (replication slot), a Snowflake key’s second place its second key position, and an SSH bastion a jump server (bastion). The sidebar’s account block moves at most once while it loads, and a run’s page is titled by its pipeline rather than its id.
  • Light mode is redrawn on the deeper of its two surfaces, with the sidebar and cards on the lighter one.
  • No API changed.

2026-11-17 (IST) — The volume forecast: a view is named as a view, a promotion before a restart is seen, and a large catalogue is read at the cost of the tables named

Section titled “2026-11-17 (IST) — The volume forecast: a view is named as a view, a promotion before a restart is seen, and a large catalogue is read at the cost of the tables named”
  • A name in catalogue_forecast that holds a view, a materialized view, a foreign table or another kind of relation is answered why: not_a_table, with kind (view, materialized_view, foreign_table, other), where it was not_found. A query-based pipeline syncs a view or a materialized view picked with its key columns, so the forecast no longer calls one missing. No figure is given for it: what a view moves is what its query returns at each sync, which the source’s statistics do not record. The total is not given while the list names one, as for any name that was not read.
  • promoted_since_counting_began is now also given when the window began at or before the server last started and the server replayed a change since it started: such a server was in recovery from that start until its promotion, counting nothing, whatever the age of the last change it replayed. A standby restarted while its primary was quiet, then promoted, read low unannounced before. A window that began after the server started, over a recovery whose last replayed change is older than the window (the log’s counters of a server restored to an earlier point and promoted), is still not seen; the API and guide say so.
  • The forecast no longer reads pg_stat_all_tables, a view that aggregates every relation of the database before one is used. The tables’ figures cost the same however many tables the database holds, and the partial-reset check runs only when the database has recorded a reset, stopping at the first relation that shows one. Every figure is unchanged: the live suite reads the old and new statements in one statistics snapshot and compares them.

2026-11-17 (IST) — Data freshness: a proof keeps its own server’s clock, and a kept threshold’s life is said

Section titled “2026-11-17 (IST) — Data freshness: a proof keeps its own server’s clock, and a kept threshold’s life is said”
  • “Current as of” stays right across a failover or a source re-pointed at another host. The proof that your destination holds everything committed by a moment is now moved onto our clock by the clock of the server that proved it. Before, for the few minutes after such a change, it was moved by the new server’s clock: a new server whose clock was minutes fast read minutes staler than it was (and could raise data_stale), one running slow read fresher than anything proved. The skew freshness.source_clock_ahead_seconds states is still the newest reading’s.
  • A freshness threshold kept after a full re-sync switched a pipeline to queries (it does nothing there) is now said to last only until the pipeline’s notifications are next saved, which clears it, and to apply again if a re-sync switches the pipeline back to logical replication before that save. Nothing changed in how it behaves; the guide now says both.

2026-11-17 (IST) — The slot watch names the SSH bastion or proxy agent that would not forward its read

Section titled “2026-11-17 (IST) — The slot watch names the SSH bastion or proxy agent that would not forward its read”
  • Two new unmeasured.reason words on source_log_unmeasured, for a database reached through an SSH bastion or a proxy agent whose refusal to forward our slot watch’s read used to be reported as rejected, the word for your database turning the read down:
    • bastion_forwarding_refused: the SSH bastion would not forward the read to your database. Check its AllowTcpForwarding, and the permitopen on our key’s line in authorized_keys (or sshd’s PermitOpen): it must allow the database’s host and port as the source’s connection names them. The source’s setup test shows the line.
    • agent_forwarding_refused: the proxy agent’s allow list (REYANSH_AGENT_ALLOW) does not admit the database’s host and port, so the agent did not connect to your database. Add them to the agent’s allow list. Both carry last_attempt_at and keep the last measurement, and are raised even when the slot was never measured, as rejected is. The email, Slack and webhook messages and the pipeline’s page say the same. A database reached directly is never given either word.
  • rejected stays for your database’s own refusal (its sign-in, the connection’s settings or its certificate), and through a bastion or an agent for what that hop refused other than forwarding (our key, its host key). Its description in the API now names the bastion or agent too, as its message already did.
  • A failure on our side is now refused, never rejected or unreachable: a fault in our SSH client, our relay refusing our own ticket, a protocol error of ours, or a sign-in method we do not support used to be reported as your database (or its bastion or agent) turning the read down, or as unreachable. The pipeline’s page now shows a line for refused saying it was not your database.

2026-11-17 (IST) — The pipeline page: a lost slot offers Start, one press syncs a pipeline at rest

Section titled “2026-11-17 (IST) — The pipeline page: a lost slot offers Start, one press syncs a pipeline at rest”
  • A paused pipeline whose replication slot our slot watch found lost offers Start, not Resume: what it saved names a place in a log your database no longer keeps, so it cannot pick up where it stopped.
  • A pipeline at rest after its sync offers one press that syncs it, Sync again, beside the word “Synced”; Sync now, which did the same thing there, is not drawn beside it (nor in More).
  • Pause always says what it does: a pipeline with no replication slot and no copy running is told that once it has stopped nothing is read or written until it is started again. On Overview, the slot watch’s sentence is said once, in the region.
  • Smaller: a table’s drawer opened again after Escape no longer shows a Remove pressed once; focus stays in the drawer after Verify; the worker’s report can be scrolled by keyboard on a phone; “About this pipeline” is not drawn over an empty list; the arrow from a table to where it lands points the reading way in a right-to-left page.

2026-11-17 (IST) — The id new is reserved for sources, destinations and pipelines

Section titled “2026-11-17 (IST) — The id new is reserved for sources, destinations and pipelines”
  • POST /v1/sources, POST /v1/destinations and POST /v1/pipelines refuse the id new, in any case, with 422 id_reserved (fault customer), before anything is read or stored, and GET /v1/destinations/{id}/schema-preview refuses it as a pipeline_id in the same words. The id is kept for the app’s pages that add one, whose addresses begin /sources/new, /destinations/new and /pipelines/new: a source or a pipeline stored with it had a page nobody could open, its address opening the page that adds one. Any other id that merely contains the word (news, new-db) is unchanged.
  • Asked of a new id only (at create, and by the schema preview of a pipeline not yet created). An object created with the id new before this change keeps it, and every endpoint still finds it by its id.

2026-11-17 (IST) — History tables on PostgreSQL: a statement timeout while checking what was written stops that table

Section titled “2026-11-17 (IST) — History tables on PostgreSQL: a statement timeout while checking what was written stops that table”
  • When your destination’s statement_timeout cancels the check a history table’s write makes of what it wrote, that table now stops and waits for you, told as the statement timeout it was (with the value in force), and the pipeline’s other tables keep syncing unless “When one table stops” says to stop every table. Before, it was told as a refusal of a table of Reyansh’s own and the whole pipeline restarted into the same timeout. This is how every other statement on your table is already answered.
  • The guide Rows your destination discards now says that a BEFORE INSERT trigger that changes a key column of a history table is reported as a discarded row (the version is in the table under the key the trigger gave it), and that a trigger skipping the pipeline’s update of a version it already wrote (a large transaction written in more than one batch, or a batch written again after a restart) is not detected. Neither behaviour changed.
  • A MySQL or Stripe pipeline now stops for you when its table would have stopped, and no longer restarts. These pipelines sync one table, which cannot stop alone. Before, a value your destination refused, a row it discarded with the pipeline set to stop, or a refusal of the destination table stopped the table and then ended the run as a fault on our side, which restarted into the same row again and again. Now the pipeline stops, is told once in the history (“Stopped, action required”, for a refused value “Stopped: your destination refused a value”, in words naming the column and why), and waits: change what the words name, then start the pipeline again. A platform-history pipeline does the same for a discarded row or a refusal of its table, but a value refused from the platform history export is ours, so there the pipeline still restarts and its history says to contact us (unchanged).
  • A NUL character (U+0000) in a text value no longer stops a MySQL, Stripe or platform history pipeline set to “continue”. PostgreSQL text cannot hold one, so the NUL is removed before the row is sent, the rest of the value is written as your source sent it, and the change is reported like any other changed value: on values_fitted, reason nul_character, action nul_removed. The record in your destination keeps the original whole: its reason is nul_removed and original_value holds the original’s bytes in PostgreSQL’s hex form (\x...), which decode(substr(original_value, 3), 'hex') reads back exactly. A key is never changed, so a NUL in a key column still stops the pipeline. Under “stop”, a MySQL or Stripe pipeline’s stop now says what gets past it: set the pipeline to “continue”, then start it again. It used to say to strip the NUL at the source or map the column to bytea; neither works, because the pipeline reads the same change again and PostgreSQL refuses the NUL in a bytea column’s text too. From the platform history export a refused value is ours, so under “stop” that pipeline restarts and its history says to contact us, as before. The history row for changed values is now titled “Values changed when written” (it was “Values cut or written as NULL”, untrue of a NUL removed), and its warning and notifications name every change one report may hold.

2026-11-17 (IST) — MySQL sources: text in every character set we read, and binary columns, arrive as MySQL holds them

Section titled “2026-11-17 (IST) — MySQL sources: text in every character set we read, and binary columns, arrive as MySQL holds them”
  • A latin1 text value now arrives as the same text. Every VARCHAR and TEXT value was read as UTF-8 whatever its column’s character set, and anything that did not fit was replaced with �: an accented latin1 letter or a € arrived as �. Each value is now read in its column’s own character set: utf8mb4, utf8mb3, latin1 (MySQL’s, which is Windows cp1252) and ascii.
  • A binary column (BINARY, VARBINARY, BLOB of every size) now arrives as its bytes, unchanged, rather than as text with every byte that was not valid UTF-8 replaced. BINARY(n) arrives n bytes long, as MySQL returns it. Make its destination column bytea. A PostgreSQL text column judges the bytes as text: valid UTF-8 is written as that text; valid UTF-8 apart from NUL bytes (a BINARY(n) holding fewer than n bytes is padded with them) is written with each NUL removed under “Change the value and keep syncing”, reported and recorded whole as a NUL in text is, and stops the pipeline under “Stop the table” or in a key; bytes that are not UTF-8 stop the pipeline under either answer. A MySQL pipeline syncs one table, so it stops without restarting, its history naming the column. The stop’s words give the ways out that work, never the answer the pipeline already has: bytea then a start, and, for NULs under “Stop the table” only, “Change the value and keep syncing”. The refusal’s words for bytes that are not UTF-8 say bytea only, for every source, and no longer offer to “fix the encoding at the source”, which the change read again from where the pipeline stopped does not get past.
  • CHAR, ENUM and SET columns are read as what they are. A CHAR column was read as an ENUM, and a CHAR or SET before an ENUM could give the ENUM another column’s labels; an ENUM of more than 255 labels read a later label as an earlier one. A SET now arrives as its labels joined by commas, as MySQL returns it, and an ENUM holding no label (what a server outside its strict mode stores for a value that is not a label) arrives as the empty string, as MySQL returns it, where it was refused and the pipeline restarted into it.
  • A text, ENUM or SET column in any other character set (cp1251, utf16, gbk…) now stops the pipeline at the first change to its table, instead of being written with � in place of what it could not read. The pipeline does not restart on its own, and its history says once which table, column and character set (event schema_stop_raised, cause source_setup). Starting it again, or a new pipeline for the table, meets the same change, because the binary log keeps it as written: convert the column at your source, let the server drop the binary log files written before the conversion (its own binlog_expire_logs_seconds does, at its next start or FLUSH BINARY LOGS), then delete the pipeline and create a new one. PURGE BINARY LOGS drops them sooner, but they are then gone for every replica, point-in-time recovery and other reader of the server that has not read them: the stop’s words and the guide say what to check first. See A MySQL source’s text and binary columns, which has the steps and a query listing such columns.
  • Rows written before this release keep the values they were written with: a MySQL pipeline copies nothing, so they are corrected when the row changes at your source, or from your own copy of the table.
  • The guides are now a documentation site, with search, a sidebar for the guides and one for the API and Terraform, and a page per topic you can link to. Nothing in the API changes.
  • Every error code the API answers has its own page, at the address each error’s docs field already carries: the HTTP status and fault it is answered with where those are fixed, and the words the app shows for it.
  • Reference pages generated from the product itself: every step and message of the connection test, in the app’s words; every setting a new pipeline takes, with the request that changes it afterwards; and this changelog, by month.

2026-11-17 (IST) — A pipeline’s page: a header, what you must see, and five tabs

Section titled “2026-11-17 (IST) — A pipeline’s page: a header, what you must see, and five tabs”
  • A pipeline’s page is no longer one long page. Its header shows the pipeline’s health, its state, how current your destination is (on Overview it is under About this pipeline instead), and its buttons. Below it, everything you must see whatever tab is open (the notice, open alerts, an unverified TLS connection, a stop and its cause, the copy in progress, statements still to run) sits above the tabs: whole on Overview, one line each elsewhere. The tabs are Overview, Schema, History, Usage and Settings, each with its own address; Settings has one pane per section (General, Schedule, Schema changes, Data handling, Notifications and when to warn me, Source setup, Re-sync, Danger zone), showing only the panes the pipeline has.
  • Pause asks first. For a PostgreSQL pipeline that reads its database’s change log, it says what the pipeline’s change bookmark does while it is paused: as a fact once the pipeline has run and its alerts were read, as a condition when that is not known (a pipeline never started, alerts that could not be read, a pipeline that gave up), and in the slot watch’s own words when it has found the bookmark lost. A pipeline with no change bookmark (a query pipeline, any source that is not PostgreSQL) is told nothing about one. A copy running when Pause is pressed is said by whether it keeps its place. The buttons say what they do: Pause, Resume, Start again, Sync again, Start. More holds Copy id and Delete pipeline… (and Sync now on a phone).
  • Schema lists the tables in a grid grouped by schema, with each table’s state and how its changes land. A table’s name opens its drawer: what it waits for, its actions, Verify row counts, and its columns, each with Sync, Block and Hash shown side by side. A pipeline that reads by queries says once that row counts are not verified there, instead of offering a check every table would refuse.

2026-11-17 (IST) — Every dialog: pressed again right after it closed, it opens

Section titled “2026-11-17 (IST) — Every dialog: pressed again right after it closed, it opens”
  • A button that opens a dialog could do nothing when pressed again straight after that dialog was closed (with Cancel, Done, Escape or a press outside it) while the page was busy, and the press had to be made again. This was fixed for a table’s columns on Choose data the same day; it is now fixed for every dialog in the app: Search (Ctrl K), the phone menu, deleting a channel, creating, rolling and revoking an API key, removing, unlinking and changing the role of a member, the single sign-on confirmations, leaving a new pipeline, the setup guide, all steps, and the hand-off sheet. A key made, rolled or revoked in a dialog closed that way is listed at once.

2026-11-17 (IST) — New pipeline: a table opened again right after its columns were closed opens

Section titled “2026-11-17 (IST) — New pipeline: a table opened again right after its columns were closed opens”
  • On Choose data, pressing a table’s name again straight after closing its columns (Escape or Done) could do nothing when the page was busy, and the press had to be made again. Every such press now opens the table’s columns.

2026-11-16 (IST) — Proxy agents (preview): the slot watch reads a database reached through an agent, through the agent

Section titled “2026-11-16 (IST) — Proxy agents (preview): the slot watch reads a database reached through an agent, through the agent”
  • A PostgreSQL source reached through a proxy agent now has its replication slot read by our slot watch, through the agent (this replaces the 2026-11-15 entry below, where such a database was not read). The read is the same one-query, read-only read as for any other source, with its own relay ticket bound to that one process; the database’s host is judged by the agent’s allow list, not by us. Such a pipeline now gets source_log_held, source_slot_invalidating and source_slot_lost from the watch like any other.
  • New unmeasured.reason agent_offline on source_log_unmeasured: the agent was not connected, did not answer our relay, or its key was not approved, when the watch came to read the slot, so no connection to the database was tried. Never unreachable: our relay says why it could not carry the read, and the watch reads that rather than the worker’s own word for it. last_attempt_at is when the watch came; the last measurement is kept. It is raised even when the slot was never measured, as unreachable is.
  • agent_preview now means proxy agents are off where the pipeline runs (the only place a read through an agent is not attempted); its message is unchanged.
  • rejected’s message now names the SSH bastion or proxy agent a database is reached through as a possible refuser (“what it allows”), as well as the database’s sign-in, settings or certificate.
  • refused’s message no longer blames the saved connection alone: the slot was not read because the pipeline’s saved connection is one we would not use, or because a fault on our side stopped the read, and the watch tries again on its next pass.

2026-11-16 (IST) — SSH tunnels: a bastion’s host key or signature that cannot be read is told as the bastion’s, and retried

Section titled “2026-11-16 (IST) — SSH tunnels: a bastion’s host key or signature that cannot be read is told as the bastion’s, and retried”
  • A bastion that sends, during the key exchange, a host key, a signature or another key-exchange message that cannot be read is now told so, and retried. For example a host key cut short, a host certificate nested deeper than the SSH library accepts, or bytes left over after a signature. The step reads ssh_handshake_failed (“The SSH handshake with the bastion … did not complete: its host key, its signature over the key exchange, or another key-exchange message from it could not be read; if this persists, check the bastion’s host keys, and that nothing between this service and the bastion alters the connection. The pipeline will retry.”). Before, it was told as ssh_failed, “a bug on our side”, and the pipeline stopped. Such a run is free, as every failed run is. A signature that can be read and does not verify is unchanged: a failed integrity check, and the pipeline stops, because that is what a device altering the connection produces.
  • Nothing was ever trusted on such bytes: the host key is judged only after it is read and its signature verified.

2026-11-16 (IST) — A run whose worker stopped without finishing it is ended, told, and free

Section titled “2026-11-16 (IST) — A run whose worker stopped without finishing it is ended, told, and free”
  • When a pipeline’s worker process is killed (the system’s out-of-memory killer ends a process with SIGKILL), crashes, or stops on an error it cannot continue past, it writes nothing about its run. Until now that run read running in the pipeline’s run history for ever (a session read “nothing confirmed yet”), no sync.ended was sent for it, and its usage stayed charged until the next run began. Now, once we see the worker stop, we end that run (before restarting it, and also when you stop the pipeline after it stopped), under its own run_id, with a sentence saying how the worker stopped (its exit code, or the signal): the run history shows it ended (outcome: failed, or partial when it moved rows; a session’s no_write: none with that sentence as its detail); its sync.ended is sent, status: failed, with that sentence as its reason; and it is not charged, the whole run, as every failed run is not. The pipeline’s feed shows it as Stopped unexpectedly (worker_exited), with reason and exit_code or signal in its detail; the rows after it say whether the pipeline then restarted (it is not when you stop or delete it first).
  • A run that said how it ended itself (it finished, was asked to stop, or refused to start) is never ended a second time, and no notification email is sent for a single restart: when the restarts are given up on, the give-up is told as before.
  • Not covered: a worker that stopped together with our service (nothing saw it stop), and one that stopped before this change. Those read as before, until the pipeline’s next give-up ends them.

2026-11-15 (IST) — Proxy agents (preview): the slot watch does not read a database reached through an agent, and says so

Section titled “2026-11-15 (IST) — Proxy agents (preview): the slot watch does not read a database reached through an agent, and says so”
  • A PostgreSQL source reached through a proxy agent is not read by our slot watch while agents are in preview. The watch (which measures a stopped pipeline’s replication slot every ten minutes) reads only databases it reaches directly; reading through the agent is planned for the agent’s general release. Such a pipeline therefore never gets source_slot_invalidating or source_slot_lost from the watch, and when its own last measurement is no longer current, source_log_unmeasured carries the new unmeasured.reason agent_preview (and its message says the database is reached through a proxy agent), never unreachable: no read was tried. The source_agent_offline notice keeps naming the slot’s last measured size. Proxy agents are off by default.

2026-11-15 (IST) — SSH tunnels: a bastion that breaks the SSH protocol is retried, and a crafted host key can no longer stop the worker

Section titled “2026-11-15 (IST) — SSH tunnels: a bastion that breaks the SSH protocol is retried, and a crafted host key can no longer stop the worker”
  • A bastion that breaks the SSH protocol during the key exchange is now told as the bastion’s, and retried. For example a key exchange message that is too short, or a key exchange value outside the agreed group. The step reads ssh_unreachable (“The SSH session with the bastion … ended: the bastion sent an SSH message the protocol does not allow at that point, and the session was closed on it”), and the pipeline reconnects and resumes from its last saved position, as for any other session that ended. Before, it was told as ssh_failed, “a bug on our side”, and the pipeline stopped. Such a run is free, as every failed run is.
  • The SSH library is updated (russh 0.65.1). A host key built as a certificate nested thousands of levels deep, sent before the bastion’s key is checked, could exhaust the worker’s stack and stop every pipeline it runs; it is now refused at the ninth level, and only that connection fails. Nothing could be read or changed through it, and no host key was ever trusted by it. The update also bounds a bastion’s EXT_INFO messages and refuses a channel whose peer declares a zero maximum packet size, which used to stall it for good.

2026-11-15 (IST) — The overview: deleted pipelines still owing a source clean-up, and this month’s charges so far

Section titled “2026-11-15 (IST) — The overview: deleted pipelines still owing a source clean-up, and this month’s charges so far”
  • New field pipelines.deleted_owing_source_cleanup on GET /v1/overview: how many deleted pipelines have a deletion.source_cleanup (the replication slot and publication a PostgreSQL pipeline leaves on your source) that nobody has marked as dealt with (POST /v1/pipelines/{id}/source-cleanup/acknowledge). It is the number of entries GET /v1/pipelines?include_deleted=true shows with a source_cleanup and no acknowledged_at, and it is never in pipelines.total. We never read your source to check, so 0 means none is waiting to be marked as dealt with, not that the source was looked at.
  • New fields spend.currency and spend.month_to_date on GET /v1/overview: this UTC month’s charges so far, by the day the usage happened: month (YYYY-MM), starts_at and ends_at (the usage days it covers, in UTC), and charged_minor, refunded_minor (refunds of runs that did not finish, for the month’s usage days: a refund written this month for an earlier month’s usage counts in that month’s figure, never this one’s; on the statements it is that month’s while its statement is open, and once that statement has closed it is on the next statement, marked late, with its usage day) and net_minor. They are GET /v1/wallet‘s month_to_date, read from the ledger the same way, in either billing mode. They are what was charged, never an estimate: 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. Today’s estimate is GET /v1/usage/days’ estimated_minor, as before.
  • GET /v1/overview now reads in one snapshot, so its balance and its month’s charges describe the same instant.

2026-11-15 (IST) — A run that started again after a full re-sync’s door says it started

Section titled “2026-11-15 (IST) — A run that started again after a full re-sync’s door says it started”
  • When a full re-sync you asked for meets a stop at a pipeline’s start (its replication slot recreated or lost, or the source’s history changed), the re-sync is applied there and the pipeline starts again in the same process. That run now opens with run_started, as every other run does, telling both servers’ identities. It used to open with pipeline_reentered alone, so the product read it as a run that never began: after a run that had stopped and been restarted, the pipeline’s page said Retrying with the keeps_stopping warning for as long as the run stayed up and delivered, the keeps_stopping notification never resolved, no sync.started event was sent, the run history showed the run’s start as unknown, and a credential retry streak before it kept counting. All of those now read the run as started.
  • pipeline_reentered keeps its meaning: the run started again, in the same process and the same run, to copy a table that became ready. It now always follows a run_started of the same run.

2026-11-15 (IST) — A volume forecast before a PostgreSQL pipeline exists, with no price

Section titled “2026-11-15 (IST) — A volume forecast before a PostgreSQL pipeline exists, with no price”
  • POST /v1/connections/test takes catalogue_forecast: up to 1,000 tables, by schema and name, each once (an empty list, a blank or NUL name, a table named twice, more than 1,000, or names together too long to hand the test are refused 422 invalid_field before anything connects; the same length rule now refuses a query-based test’s tables in words, where it was answered as our failure). For a PostgreSQL source the answer’s catalogue.forecast gives, per table, its bytes on disk at the source with and without its indexes, its estimated rows, and the changes PostgreSQL counted since the database’s counters began (attempted ones, rolled-back included: an upper figure), with a per-day average over that window; plus a total and the whole server’s write-ahead log per day. Everything is read from the source’s own statistics: nothing is scanned or counted on your tables. Guide: How much a pipeline will move, before you create it.
  • No price. No figure in it is money.
  • Unknown is absent, never 0, and says why: rows_why: never_analyzed | estimate_is_stale (an estimate of 0 over a table with pages, which is how PostgreSQL 13 and earlier say never analysed); why: not_found | not_readable; a per-day rate only over a recorded window of at least a day (changes.why: counting_start_not_recorded, window_shorter_than_a_day, standby, counts_off, promoted_since_counting_began, partial_reset: resetting one table’s statistics moves the whole database’s start, and when any table still shows an older vacuum or analyse time no rate is stated), and none for a table whose own times show its counters began before the window (changes_why: counters_older_than_window). A total only when every named table was read.
  • A forecast that was not read says so, catalogue.forecast.why: not_read with its sqlstate, timed_out, or not_answered; the rest of the test’s answer, its catalogue included, stands.

2026-11-15 (IST) — A new pipeline is set up one step at a time

Section titled “2026-11-15 (IST) — A new pipeline is set up one step at a time”
  • New pipeline is now a guided setup, one question at a time, with a list of the steps beside it (on a phone, “Step N of M” and All steps): Source, Connection check, Destination, Pipeline check, Choose data, Sync settings, Review and create, then, for a pipeline that reads the change log, Prepare your database and Start. A saved source skips Connection check. Back keeps every answer. Changing an answer clears only what depended on it (another source needs another test, for example), and the steps after it are walked through again before Create pipeline. The tables picked stay for as long as the source, and how it is read, are the same: another connection string (even to the same database), another saved source or another way of reading it lists its own tables, and its first test picks that listing’s tables afresh, which Choose data and Review and create then say. A Block, a Hash or a row filter you chose is never removed by a test or by any other change: only your own press changes it (choosing again, its Clear, or Clear the column choices). One made on another listing (another database, or this one given another way or read the other way) is listed on Choose data and on Review and create, and drawn as it is in its table’s columns (a row filter with its match, all or any, and every condition), where it cannot be changed until you keep it or clear it. Keep these choices here applies it to the source on screen; while its table is in this create, Create pipeline waits until you keep it or clear it, and one whose table is not in this create is listed and kept, with nothing of it sent. Typing the same connection string again keeps everything. After a refused Create pipeline, a connection string the attempt stored is used again rather than asked for, and when a new test does need it, the same string keeps the picks. Every option the one-page form had is still there.
  • Step 1 takes the source three ways: Use a saved source, Paste a connection URL (as before), or Enter the details field by field (saved as a source when you continue from a passing test). A saved source whose saving reported a passing test skips step 2; one saved untested is tested there. For a source set up here you may choose where the database is hosted (Neon, Supabase, Amazon RDS or Aurora, Google Cloud SQL, Azure Database for PostgreSQL, or a PostgreSQL server of your own); the setup guide and step 8 then speak of that host. It is optional, and no request carries it, so choosing it after a test passed keeps the test; where you enter the details, Amazon RDS or Aurora chooses Amazon’s RDS certificates to verify the server in place of the system’s trust store, and the step says which trust is chosen, and that an RDS Proxy endpoint presents an AWS Certificate Manager certificate instead.
  • Step 2 tests the source on its own before you choose where the data goes, and says what to do about the one thing that failed, with Read by queries instead where reading by queries is offered; for a saved source, a link to its own page where that page offers an edit (opening it leaves the setup). For a host this deployment’s test does not reach, it says the pipeline starts only if this deployment’s operator lets your account reach private addresses, and, where your account can use one, that an SSH tunnel through a jump server (bastion) you run reaches a database inside your network. The test signs in and reads your database’s settings and its list of tables; it writes nothing there.
  • Step 3 adds a new Snowflake or PostgreSQL destination without leaving the setup (owners). For a PostgreSQL destination it says that each table must exist there first. A source given by a pasted URL may take a new PostgreSQL destination’s connection string as before; once a refused Create pipeline has saved that source in your account, it takes a saved destination, or one added here.
  • Step 5 lists every table with its key, its estimated rows and its columns. When at most 1,000 tables can be synced, every one of them is picked to begin with; above that none is, and the step says why. Press a table’s name to choose, column by column, Sync, Block or Hash. After Test again, the choices stay, and every table in this create holding a Block, a Hash or a row filter applied to this source has its columns read again by itself, at most four a minute (an account may test its connections six times a minute); Create pipeline waits for that read, so a choice is sent only for a column the source has now, and never for a column the source now reads as a key. Choose data and Review and create list every choice this create cannot carry yet, with why and the press that moves it: where the test cannot reach a host and the table name is typed instead (clear it, or give a host this service can reach and test again: the choice is kept through the test); where a test’s answer did not list the table’s columns (test again on step 4, or clear it); where it was made on another listing (Keep these choices here, or clear it); a column the table’s columns, as read under this test, do not have, or have as its key (clear it, on the list or in the table’s columns). Each has its own Clear, the list has Clear the column choices, and what a press did is said where focus lands, once it has happened.
  • Step 6 asks first about rows already in the tables, the one question with no safe default, then shows the schedule where it does something (into Snowflake, how often changes are written; and, for a pipeline that reads by queries, into any destination, how often it syncs); rows your destination discards, values it cannot take and When the source changes are under More settings, each at its default.
  • Step 7 says in one sentence what will be copied (from which source into which destination, how many tables, and the answer about existing rows), and, for a PostgreSQL destination, that each table must exist there first, with a column for each column synced (a hashed column as text of at least 44 characters).
  • Steps 8 and 9 show the statements to run and where to run them for your host, each with Copy, and a check of your database; step 8’s can be sent to your database admin (Send to your admin). Start can be pressed once the check finds the published tables (publication) and the change bookmark (replication slot). Step 8 does not show a missing change bookmark as a problem, because step 9 has you make it right before you start, and neither check tests the destination.
  • Pressing Continue before a step is complete says what is still needed and moves to it. Cancel asks first, naming anything the setup has already stored in your account, and so does closing or reloading the page while something is entered; a link to another page of the app, or the browser’s Back to one, does not ask.
  • From a pasted URL, the same answers make the same create requests as before. What is new is the source’s test on its own at step 2, and, at steps 8 and 9, the check of your database, which names no destination.

2026-11-14 (IST) — PostgreSQL destination: a role that cannot read PostgreSQL’s catalogue is told which, and the grant

Section titled “2026-11-14 (IST) — PostgreSQL destination: a role that cannot read PostgreSQL’s catalogue is told which, and the grant”
  • Before it writes to a table, the pipeline asks PostgreSQL’s catalogue about the table as it is now: its row security, its rules, and (since this version) whether its key still keeps every row apart. If the role the pipeline writes as has had SELECT on one of those catalogues revoked, the table stops before anything is written, and its message names the catalogue (for example pg_catalog.pg_attribute) and gives the statement that brings it back: GRANT SELECT ON pg_catalog.pg_attribute TO "your_role";, then resume the table. Such a stop used to show only PostgreSQL’s “permission denied” and suggest contacting us.
  • The pipeline never writes to a table whose catalogue it cannot read: without it, it cannot tell whether two keys your source keeps apart would become one row.

2026-11-14 (IST) — Snowflake on Google Cloud and Azure: large batches now really load from files, run against live accounts

Section titled “2026-11-14 (IST) — Snowflake on Google Cloud and Azure: large batches now really load from files, run against live accounts”
  • Snowflake destination: large batches (a first copy, a busy stream) on an account hosted on Google Cloud or Azure now load from files in the service user’s stage, as on AWS. This has now been run end to end against a live Snowflake account on each cloud: every table loaded from files and compared identical, value for value, with the same rows written by INSERT.
  • What happened before this version, said plainly. The 2026-11-09 entry below shipped the route without a live run on those clouds, and it did not work there: Snowflake on Google Cloud refused the upload’s request, and on Azure we refused the stage location Snowflake answered (its shape differs from AWS’s). As designed, every large batch was then written by INSERT: every row was right, at more warehouse time, and the pipeline’s history said so once a session as Large batches written the slower way, “… until the pipeline next restarts, when loading from files is tried again”, followed by the cause: on Azure “Snowflake’s answer about the stage was not in a shape this version reads”, on Google Cloud “Snowflake refused the request for the stage’s location (HTTP 200, code 091032)”. A restart did try again, and met the same cause. From this version that line should no longer appear for these causes; if it does, the cause it gives is a new one.
  • Nothing to grant or change on your side. If you run Reyansh yourself, the pipeline machines must still reach *.googleapis.com (Google Cloud) or *.blob.core.windows.net (Azure) over HTTPS.

2026-11-14 (IST) — PostgreSQL destination: a key given a case-insensitive collation while a pipeline runs stops that table before it merges rows

Section titled “2026-11-14 (IST) — PostgreSQL destination: a key given a case-insensitive collation while a pipeline runs stops that table before it merges rows”
  • A destination key column (or the unique index it is written by) changed to a non-deterministic collation, or to a type the pipeline does not write such as citext, while the pipeline is running now pauses that table before its next write. A collation is told with the same message and fix the pipeline’s start gives (give the key a deterministic collation, COLLATE "C" or any other, then resume the table); a type, with the type the column had and the statement that changes it back. A key changed to a NARROWER type pauses the table the same way (text to char(3), numeric to numeric(10,0), timestamptz to date), because it can make two keys one. Only these widenings keep syncing: a larger integer type, a longer varchar or text, a numeric keeping at least its digits, a timestamp keeping at least its fractional digits. Any other change of a key’s type pauses the table too, even one that keeps every key (an integer to numeric), because the pipeline has not proven it does. Until now these were found only at the next start, and rows written in between could merge: two keys your source keeps apart, such as abc and ABC, became one row with no error. Every other table of the pipeline keeps syncing.
  • A statement of the pipeline’s on your table that your own statement_timeout cancels is told with the timeout’s value, now also for a schema change’s ALTER, a column’s fill and a retried write; and a destination table dropped while a schema change runs on it is now recognised as gone, so once you make it again its resume copies it, as for a table dropped at any other moment.

2026-11-14 (IST) — A PostgreSQL destination must be a UTF8 database

Section titled “2026-11-14 (IST) — A PostgreSQL destination must be a UTF8 database”
  • A PostgreSQL destination whose database is not UTF8 (LATIN1, WIN1252, SQL_ASCII or any other) is now refused before anything is written to it. Its test (Run the test on the destination’s page, POST /v1/destinations/{id}/test, and the pipeline form’s test) fails the destination_permissions step with the code encoding_not_utf8, naming the encoding; a pipeline writing to it does not start, and its activity feed says why (worker_refused). A database in another encoding refuses any character it cannot hold (PostgreSQL error 22P05) whatever the column, so a pipeline into one wrote some rows and stopped at the first CJK character or emoji, and the record of what was cut could lose a whole batch. A database’s encoding is fixed when it is created, and a destination a pipeline uses cannot be moved to another database, so the way out is a UTF8 database under the same name: stop the pipeline, rename the old database away and create a UTF8 one under its name (the refusal gives the two statements, to run one at a time, as the database’s owner with CREATEDB or a superuser). What brings the earlier rows back depends on the source: a PostgreSQL source’s tables stop as new and are copied again when resumed, priced as copy work as a re-sync is; a MySQL, Stripe or history-export pipeline does not send them again, so copy the pipeline’s own tables across from the renamed database (pg_dump --data-only -t ...) before starting, or, for Stripe or the history export, create a new pipeline, which reads each stream from its beginning (Stripe: the objects it still holds, and events only for its last 30 days). Keep the renamed database until the new one holds what you need: no copy brings back a history-mode table’s earlier versions or rows deleted at the source. See A PostgreSQL destination. Fivetran asks the same of a PostgreSQL database it reads.
  • A pipeline already writing to such a database stops at its next start, with that sentence; nothing is written to it then. A UTF8 destination is unchanged: its destination_permissions step is still skipped. The pipeline form’s test says the same for every source, MySQL, Stripe and the history export included.
  • The way out the entry below gives for a stop on the database’s encoding (“correct the value at your source, then re-sync the table”) is replaced by the same one, in the stop and the table’s words, the on_rejected_value API help and the values guide: a re-sync would meet the start’s refusal.

2026-11-14 (IST) — The words for a refused value or a discarded row say the table stops, as it does

Section titled “2026-11-14 (IST) — The words for a refused value or a discarded row say the table stops, as it does”

Since 2026-11-07 a value your destination cannot take stops only the table that holds it, and a row your destination discards under stop has stopped only its table for longer. Several surfaces still said such a row stops the whole pipeline, or that it is “restarted on its own, backing off, until it is given up”. Neither was true. They now say what happens:

  • API reference: the on_rejected_value and on_discarded_row descriptions (on POST /v1/pipelines, the pipeline view and PUT /v1/pipelines/{id}/discarded-rows), and the 422 message for an unknown on_discarded_row. A refused row stops the table that holds it, under either answer, and the pipeline’s other tables keep syncing, unless the pipeline’s when_a_table_stops rule says to stop every table. The stop is table_parked on the activity feed, with the cause value_refused for a value refused under stop; change the column, or choose continue, then resume the table. A refusal that passes by itself (a lock not granted in time, a timeout, a lost connection) restarts the pipeline. A pipeline that has not saved its place yet (a new one that skipped the copy, at its first batch) still stops whole, until you start it again. At a Snowflake destination, a key it cannot hold, or a number too wide for its NUMBER column, stops the table that holds it.
  • The pipeline page and the create form: the help under “Values your destination cannot take” and “Rows your destination discards” now says the general rule (the table that holds the row stops) and that some cases stop every table, stop the whole pipeline or restart it instead, naming the guide that lists them. The answer is labelled “Stop the table (or every table, per When one table stops)”.
  • A column’s fill that stops again for a value the destination cannot take: at a PostgreSQL destination, change the destination column or correct the value at your source, then resume the table. “Re-sync the table instead” is the way out at a Snowflake destination only, for a number too wide for its wide-numeric setting: at PostgreSQL a re-sync copies the same value into the same column and stops the table again.
  • Guides: Rows your destination discards said a stop, and a row refused for another reason, stopped the pipeline; the Snowflake destination guide said the same of a key it cannot hold and of a number too wide for a narrower NUMBER.
  • A table stopped for a value refused under stop (cause value_refused) is now told its way back in its own words: change each named column so it takes the value (a longer length or text for a too_long value, text for a not_a_value one), or choose continue, then resume the table. It was told no way out, and its words said nothing after the row was written and no progress was saved, which the pipeline’s other tables made untrue; they now speak of the table’s own rows and progress.
  • A destination database whose encoding is not UTF-8 (LATIN1, for example) refuses a character it cannot hold (PostgreSQL error 22P05) in a column of any type or length. Such a stop now names the database’s encoding and no longer offers “a longer length or the type text”, which could not help: correct the value at your source, then re-sync the table. A not_a_value stop names text where it said “another type”. The encoding is never named for a row that holds any jsonb value (whose escapes PostgreSQL refuses with the same code in any database), nor in a SQL_ASCII one: there the column’s way out is the true one.
  • What does not stop only its table, said in the API reference and the guides: a refusal that passes by itself (a lock not granted in time, a timeout, a lost connection), a timestamp your source sends in a form other than ISO, and a value refused from the platform history export each restart the pipeline; a pipeline that has not saved its place yet stops whole at its first batch; a table stopped while it is copied stops alone, whatever When one table stops says. The cost of a waiting table is said per source: a PostgreSQL source keeps its WAL, a MySQL source keeps its binlog only by its own retention, and others hold nothing.
  • The answer’s label reads “Stop the table (or every table, per When one table stops)” where it read “Stop the pipeline”, on both questions and in both guides.
  • A table kept in history or append is said to change no value: at a PostgreSQL destination its rows are written as versions or log rows without the value check, so a value its column refuses stops that table under either answer, as the destination’s own refusal, and a row the destination discards there is not reported. Said in the API reference, the app’s help and both guides.

Nothing changed in what a pipeline does; only what it says.


2026-11-14 (IST) — Notifications: a pipeline’s spend spike

Section titled “2026-11-14 (IST) — Notifications: a pipeline’s spend spike”
  • A new notification, spend_spike (a warning about one pipeline): its metered spend on a UTC day is 3 times or more the median of the 7 days before it, and at least $1.00 above that median. Metered is the usage the meter measured, priced at the rate card in force that day, leaving out runs that had already ended in failure; it is not the bill, and a run of that day that fails later makes the day cost less. One notice per spike; it ends on a later whole week after the spike in which every day is under 3 times the median the notice named (the week before the spike), so a spend that stays high, even some days a week, is one notice and is never called over. A day must also be above every day of its week, so a weekly job is not told; each check judges the last 3 closed days; a week in which the rate card changed is not judged. It changes nothing on the pipeline.
  • Emailed by default until you move the warnings switch, like source_log_held; the per-event choice and a pipeline’s mute stop it. It is listed by GET /v1/notification-triggers.
  • Its webhook body’s details carry day, currency, metered_minor, median_minor, multiple and baseline_days on the raise; started_at is the start of the day measured.

2026-11-14 (IST) — A row your destination lacks comes back whole when its large value did not change

Section titled “2026-11-14 (IST) — A row your destination lacks comes back whole when its large value did not change”
  • An update of a row your destination does not hold, that leaves a large value unchanged, now arrives with that value. PostgreSQL does not resend a large value an update did not change (under the default replica identity). A row your destination already holds keeps it, as before; a row it does NOT hold (deleted there, never copied because the initial copy was declined, or in a table created again) used to be written with that column empty (NULL), at a Snowflake or a PostgreSQL destination, with nothing said. Now the worker asks your destination which rows it lacks, reads only those from your source (the same read-only, fenced read a key change already uses), and writes them whole. A PostgreSQL column declared NOT NULL no longer pauses the table for such a row.
  • If the row is no longer at your source when it is read (deleted there since), nothing is written for it and nothing pauses: the row is in neither your source nor your destination, and any later change to it arrives as usual.
  • Under REPLICA IDENTITY FULL PostgreSQL still leaves an unchanged large value out of the update’s new row, but carries it in the old row: such a row is completed from it, with nothing read and nothing paused.
  • The feed says so. “Large values read from your source” now also counts these rows (withheld_values_read’s updates_read and updates_deleted, each omitted when zero), in a sentence of their own.

2026-11-14 (IST) — The schedule preview estimates the Snowflake warehouse credits a schedule causes

Section titled “2026-11-14 (IST) — The schedule preview estimates the Snowflake warehouse credits a schedule causes”
  • GET /v1/schedule-preview takes destination_id: a stored destination, read in the caller’s account (an id the account does not hold is 404 not_found). Its kind is read from the stored destination; a destination_kind sent beside it is not read.
  • For a Snowflake destination whose schedule wakes the warehouse on a timetable (a stream’s batch hold, or a query pipeline’s runs), the answer carries warehouse_estimate: the warehouse credits a day, as a RANGE (credits_per_day_low / _high) and in billed seconds, with its basis (the warehouse’s size, generation, AUTO_SUSPEND, clusters and region, read by a worker without waking it; the hold; the write time assumed; the rates and the date of Snowflake’s Service Consumption Table they come from). Credits, never money: your credit price is your contract. shared_warning is always true: on a warehouse that also runs other work, this pipeline adds at most this much. With pipeline_id, writes forced by that pipeline’s measured volume are counted (volume_counted).
  • When the estimate was asked for and cannot be made, warehouse_estimate_unknown says why (rate_limited, warehouse_unread with the reason, unavailable, manual), and no figure is shown. The warehouse read shares the connection test’s limit of six a minute per account and is kept ten minutes per destination (a failed read one minute; an edit of the destination is read afresh at once).
  • (Same day, after review) For a stream the figure is “up to”: it assumes a change in every hold, and its low end is the figure if changes arrive every hold, never a daily floor. A query pipeline is estimated from its real due times over the year ahead (basis.runs_in_window, basis.window_days), so a weekly or monthly schedule is no longer read as daily or as manual; one with no run in that year is beyond_window. may_add_cluster says the high end is not a ceiling on a warehouse that may start more clusters. A warehouse kind the rule does not describe (an interactive warehouse) is kind_not_estimated, with no figure. Compute credits only: cloud-services credits are not counted.
  • (Same day, second review) A query pipeline’s credits a day are an AVERAGE over the window, so the answer also carries per_run_seconds_high and per_run_credits_high, what one run may bill. Every credit figure is rounded to four significant digits, so a small figure is never sent as 0; billed_seconds_per_day_low and _high are now numbers to four significant digits too (they were whole seconds, and a yearly run’s fraction of a second a day read 0).

2026-11-14 (IST) — The app: two pages that said something untrue

Section titled “2026-11-14 (IST) — The app: two pages that said something untrue”
  • Settings › API keys and Settings › Single sign-on said “Loading…” for ever when the app could not read who is signed in (GET /v1/me failed). They now say it failed, with the request id support needs, under the page’s heading. Reloading the page asks again.
  • A Snowflake destination’s page no longer offers a member the key rotation’s buttons. The API has always refused them to a member (403 owner_required, since rotating a credential a destination uses repoints where the account’s data goes). A member still reads a rotation an owner has started: the new key’s fingerprint, the statements to run in Snowflake, and how many pipelines are still restarting, which the page keeps asking; where the buttons were, they read “Only an owner can test and switch to the new key.” Nothing changes for an owner, and no API changed.

2026-11-14 (IST) — PostgreSQL: a table kept in history or append follows the value and discarded-row settings

Section titled “2026-11-14 (IST) — PostgreSQL: a table kept in history or append follows the value and discarded-row settings”
  • Values your destination cannot take (on_rejected_value) now applies to a table kept in history or append as to every other table. Under continue (the default), text longer than its varchar(n) or char(n) column is cut to n characters and a value that is not a valid uuid or JSON is written as NULL where the column allows NULL, told as values_fitted. Before, the server’s refusal stopped the table. Under stop, the table stops naming each column and the reason (value_refused), as other tables do.
  • Rows your destination discards (on_discarded_row) now applies to them too: a version or a row your destination’s trigger skips is told as rows_discarded and recorded by its key, and under stop the table stops on it. Before, such a row was counted as written and nobody was told.
  • Both hold for the stream and for a table’s copy, on every PostgreSQL destination a table kept in history was written to before (15 and later; append on any), not only 17 and 18. Snowflake destinations are unchanged: a value Snowflake cannot hold is still written NULL with a note in the row, and in a table kept in history or append that note is not yet reported in the pipeline’s history (the guides now say so).
  • The discards guide now says what is not detected in a table kept in history: a trigger that skips the pipeline’s own update or delete of an earlier version.
  • The note of 2026-11-14 (IST) (“The words for a refused value or a discarded row say the table stops”) that a table kept in history or append changes no value and reports no discard is no longer true, and its sentence is gone from the app’s hints, the API’s help and both guides.
Section titled “2026-11-14 (IST) — Every error’s docs link is absolute”
  • The docs member of every API error envelope is now an absolute URL on our documentation site, https://<docs host>/api/errors/<code>, as the API design has always shown it. Until now it was a relative path, /api/errors/<code>, which a client resolves against the API’s own address, where there is no such page. The code it names is unchanged, so a client keying on code sees no difference.
  • The documentation site’s pages for each code are still being written; until they are live, the link is correct but may not open yet. It starts working when they do, with nothing to change on your side.
  • Self-hosted: a release binary already carries the docs address and needs no setting. A control plane built from source refuses to start until REYANSH_DOCS_DOMAIN names the docs host (a host name, no https://); an operator whose docs live elsewhere sets it to override the built-in one.

2026-11-14 (IST) — A paused or stopped pipeline’s replication slot is watched, and every log figure says when it was measured

Section titled “2026-11-14 (IST) — A paused or stopped pipeline’s replication slot is watched, and every log figure says when it was measured”
  • source_log_held now says when its figure was measured. Its source_log carries measured_by (pipeline, measured by the pipeline as it streamed, or watch, read by our slot watch) and current. When current is false the figure was measured at measured_at and not since: before, a stopped pipeline’s last running figure was shown as if it were current. Email, Slack and webhook bodies say the same (measured_at, measured_by, current in a webhook’s details).
  • The log alerts are raised for a paused pipeline too. A paused pipeline’s slot keeps your database’s log until it runs again, and with PostgreSQL’s default max_slot_wal_keep_size = -1 nothing lets go of it. Every other alert of a paused pipeline stays silent, as before.
  • We read a stopped pipeline’s slot about every 10 minutes, read-only, through the pipeline’s own connection, from where its worker runs: a paused, given-up or out-of-credit pipeline’s held log is measured rather than frozen. We also read a running pipeline’s slot when its own measurement is not current (a long copy, a pipeline that keeps restarting), and never one that has never been started. Nothing is created, advanced or dropped on your database.
  • New warning source_log_unmeasured (alert and notification trigger, on for email by default, sent once it has stood 30 minutes): we cannot tell how much log your database holds for the pipeline now, because the newest measurement is no longer current and was below the threshold, or our watch could not reach your database. unmeasured.reason says which (not_watched, unreachable, rejected, unmeasurable, refused): rejected is your database turning our read down (its sign-in, the connection’s settings or its certificate), never told as “could not reach”. A stale figure is never read as safe, and “could not reach” is never shown as “0 held”.
  • New warning source_slot_invalidating (alert and notification trigger, on for email by default), PostgreSQL 18: with idle_replication_slot_timeout set, your database will invalidate the unread slot at its first checkpoint after source_log.invalidates_at, and the pipeline’s tables must then be copied again. Told whatever the slot holds, since the setting is there to keep slots small. A synced slot left on a promoted primary is predicted too, as PostgreSQL invalidates it there. source_log_held carries the same invalidates_at when it is up.
  • New warning source_slot_lost (alert and notification trigger, on for email by default): our watch found the slot invalidated by your database, or gone after we had measured it, so the changes made since the pipeline last read it cannot be streamed. slot_lost carries outcome and found_at. Told when our watch finds it, rather than at the pipeline’s next start.
  • PostgreSQL 10 to 12: the setup test’s slot step no longer fails on max_slot_wal_keep_size, a setting those servers do not have, and our watch finds their slot without measuring it (unmeasurable, the major named).
  • The setup test’s slot step reports both settings on details.slot: max_slot_wal_keep_size_bytes (-1 is no limit) and idle_replication_slot_timeout_secs (0 is off; absent before PostgreSQL 18).
  • api/openapi.json: both alert operations describe the two log alerts, and the setup test’s details.slot documents the two settings.
  • Not watched: a deleted pipeline (an alert is about a pipeline you can act on; its deletion told you the slot stays and how to drop it).

2026-11-14 (IST) — Proxy agents: reach a database that has no public address (in progress, off by default)

Section titled “2026-11-14 (IST) — Proxy agents: reach a database that has no public address (in progress, off by default)”

The first half of the “proxy agent” (Fivetran’s Proxy Agent): a small program you run beside your database, which connects out to us on port 443, so you open no inbound port. Served only where REYANSH_AGENT_RELAY is on; off, POST /v1/agents is 422 method_not_offered and nothing can connect.

  • GET /v1/agents: the account’s agents, each with its state (awaiting_enrollment, connected, offline, deleted), its key’s SHA256: fingerprint and key_state (pending_approval or approved), and what it last reported (version, address, the targets its own configuration allows). Members; read and full API keys.
  • POST /v1/agents {name}: creates one. The answer carries the enrollment token once (rae_ and 58 characters, single use, 24 hours; a replay of the same request answers null in its place) and the environment to start the agent with. At most 10 an account (409 agent_limit). Members only: API keys never (it mints a secret).
  • POST /v1/agents/{id}/approve {fingerprint}: approves the key the agent enrolled, naming its fingerprint; until then nothing is routed to it. 409 agent_key_changed when a different key is waiting, 409 agent_nothing_to_approve when none is. Members only: API keys never (the comparison is the defence).
  • DELETE /v1/agents/{id}: burns its key and token, closes its connection, keeps its record. Members; full API keys.
  • New error codes: method_not_offered, agent_limit, agent_not_found, agent_key_changed, agent_nothing_to_approve. New audit actions: agent.created, agent.key_approved, agent.deleted.
  • A PostgreSQL source reached through an agent: connection.connect.method agent with connection.connect.agent {id, key_id} on POST /v1/sources, PATCH /v1/sources/{id} and POST /v1/connections/test; the source’s host and port are dialled by the agent, as your network resolves them. The display shows it as connection.agent {id, key_id}. Saved only where agents are served (422 method_not_offered) and field by field (source_fields_unavailable); the agent must be this account’s and not deleted (agent_not_found, agent_deleted), the key not retired (ssh_key_not_found, ssh_key_retired). A test through an agent that cannot carry it now answers 422 agent_offline or agent_awaiting_approval, dialling nothing.
  • DELETE /v1/agents/{id} is 409 agent_in_use while a source reaches its database through the agent, naming the sources; POST /v1/ssh-keys/{id}/retire counts those sources as uses of their key (409 ssh_key_in_use).
  • New error codes: agent_deleted, agent_in_use, agent_offline, agent_awaiting_approval.
  • A pipeline whose agent is not connected, or whose key is not approved, waits: health is awaiting_connection (a new word in its open set, ranked just below retrying), status stays what was asked (running), nothing is restarted or given up for it, and it starts again by itself once the agent can carry it.
  • A relay ticket is now bound to the worker process it was minted for, at that process’s start.
  • source_agent_offline: a pipeline that has waited five minutes for its agent raises an error alert and a notification to the account’s channels; it resolves (“the proxy agent is back”) when the pipeline starts again.
  • A wait is on the pipeline’s feed and keeps its restart count: a new feed kind, pipeline_awaiting_connection (“Waiting for the proxy agent”), with reason, attempt and waited_at. When the agent returns, the pipeline’s restarts and its 14 days of automatic restarts carry on from where they stood, and the days spent waiting are not counted in the 14. A run that was open when the wait began is ended there, as a failed run (not charged).
  • source_agent_offline now says how much log the waiting pipelines’ databases were keeping when a run last measured it, before the wait; with nothing measured it states no size.
  • Not yet: re-keying, and the agent’s release images. Until then the relay starts only with REYANSH_AGENT_RELAY_PREVIEW set (an operator setting; customers see nothing of it).

2026-11-14 (IST) — How current your destination is: “current as of”, and a data_stale alert

Section titled “2026-11-14 (IST) — How current your destination is: “current as of”, and a data_stale alert”
  • GET /v1/pipelines/{id} carries freshness for a PostgreSQL source (the only kind that reports its clock; a MySQL pipeline has none, rather than “not measured” for ever): caught_up_as_of (when, on our clock, the destination is known to hold everything your source had committed), behind_by_seconds, source_clock_ahead_seconds (your source’s clock measured against ours, and removed from every figure), hold_seconds and held_by_design (a Snowflake pipeline’s schedule holds changes by design, and that is said, never called behind, and only while the pipeline runs with nothing wrong: a paused, broken or retrying pipeline is never “held”), and threshold_minutes. Before the first measurement measured is false and the figures are null, never 0. A quiet source is current: about once a minute the pipeline reads your source’s end of log and its clock (clock_timestamp()), and once replication has passed that point with everything written, the destination is proved current as of then. A large transaction still being read, or a backlog after a restart, is not current until it is written. A worker restart keeps the last proof (the control plane reads the newest proof among the newest five readings), so a deploy no longer makes a quiet pipeline read as of its last change. On a standby source every figure is to the last commit the standby replayed, by the primary’s clock (measured_on_standby): a lagging or paused standby reads behind, and so does a quiet primary.
  • GET /v1/pipelines/{id}/tables: each table carries caught_up_as_of and behind_by_seconds, its pipeline’s while the table is streaming, null otherwise. The pipeline’s figure covers its streaming tables only.
  • PUT /v1/pipelines/{id}/alert-thresholds takes freshness_minutes (5 to 10080, null is off), returned by the GET with freshness_measured; on a pipeline whose source does not report its clock it is refused, 422 freshness_not_measured. A threshold set before a full re-sync switched a pipeline to queries is kept but inert (freshness_measured: false), and the app’s form sends null for it, so the pipeline’s other thresholds still save. A data_stale notification measured on a standby says so, in the email and in the webhook’s details.measured_on_standby (false on a primary). The PUT replaces every threshold, as before: send freshness_minutes to keep it.
  • A new alert and notification trigger, data_stale (a warning, opt-in): the destination’s data is at least the pipeline’s batch hold plus freshness_minutes behind. Raised only for a pipeline that streams, is running and is otherwise healthy, so it never stands beside sync_delayed (a scheduled run late, for a source whose runs end). Once per episode; it ends when newer evidence shows the data within 80% of the threshold beyond the hold, or the threshold is removed. Its alert carries stale (caught_up_as_of, behind_by_seconds, hold_seconds, threshold_seconds), and its webhook body the same in details.
  • A pipeline whose schedule holds nothing (every pipeline except a PostgreSQL source into Snowflake) and whose source sends a steady trickle (never quiet for half a second) is now written at least every 5 seconds, whatever its source and destination, always a whole transaction at a time. Before, such a trickle waited for the batch size bound (1,000 changes into PostgreSQL), minutes behind. A Snowflake pipeline’s schedule hold is unchanged, and a warehouse already awake for a steady stream is not woken more often.

2026-11-14 (IST) — Verify a table’s row counts, source against destination

Section titled “2026-11-14 (IST) — Verify a table’s row counts, source against destination”
  • New: POST /v1/pipelines/{id}/tables/{table_id}/verify (and Verify row counts on a table) asks the running pipeline to count the table at both ends. The answer is matches, differs (only on three checks, at least 30 seconds apart, that the table did not change during), inconclusive (with why) or not_applicable (a table with no primary key, one kept in history or append, or one the publication does not send whole). Counts only: rows marked deleted are not counted, the destination’s distinct keys are, and rows your destination discarded or a re-copy kept are netted and said, never reported as missing.
  • It never restarts the pipeline and never holds another request of the table. Each source count is one read-only statement of at most 60 seconds (never a long snapshot); at Snowflake the count runs in a warehouse wake the pipeline already makes. The answer’s cost says this before it runs.
  • New table fields pending_verify and last_verify; new feed event table_verified; new audit action table.verify_requested. A pipeline that reads by queries answers 409 verify_not_offered.
  • While a count runs the pipeline writes nothing, so each count is held to at most 2 minutes at either end and is stopped by the database itself (PostgreSQL’s statement timeout, Snowflake’s statement timeout), never left running; the pipeline counts at most once between two of its writes while it has changes to write, and tables asked together take turns. A table your database estimates at more than three billion rows is not counted (inconclusive, source_too_large), and a request is answered within a day of when it was asked, whatever restarts. Rows your destination reported discarding are counted as they stand at each check, and the table shows them beside the verdict.

2026-11-10 (IST) — Snowflake: every account may choose to trim text values

Section titled “2026-11-10 (IST) — Snowflake: every account may choose to trim text values”
  • settings.trim_whitespace on POST /v1/destinations is no longer refused 422 not_yet_available: every account may choose it, and GET /v1/me’s trim_whitespace_enabled is always true (kept, so a client reading it keeps working). What it does is unchanged (the 2026-11-09 entry “Snowflake: every account chooses where wide numerics land, and text values can be trimmed”): off by default, the spaces and tabs at each end of a non-key text value removed when on, chosen at create.
  • The guide now says what it does to a table kept in history or as a log of changes: each version and each row is trimmed alike and its key kept exactly; an update that changes only a value’s edge spaces is still a version, holding the same text as the one before; a re-sync never writes a version for it.

2026-11-09 (IST) — History mode and append-only: offered to every account

Section titled “2026-11-09 (IST) — History mode and append-only: offered to every account”
  • Every account may keep a table in history mode or append-only, at a Snowflake or a PostgreSQL destination, for a PostgreSQL source read from its change log: the table’s mode menu offers both, GET /v1/connectors lists them, and PUT /v1/pipelines/{id}/tables/{table_id}/sync-mode (or a pipeline’s default) naming history or append is taken. Nothing about an existing pipeline changes until you pick a mode for a table: a table keeps the mode it has, and a table added without one is kept in the pipeline’s default mode (the destination’s, soft delete at Snowflake and live at PostgreSQL, unless you set one), as before. A deployment’s operator can still switch the two modes off; then a request for either answers 422 not_yet_available, and a table already kept so goes on being written so.

2026-11-09 (IST) — A query-based pipeline syncs a view or a materialized view you pick, with its key columns

Section titled “2026-11-09 (IST) — A query-based pipeline syncs a view or a materialized view you pick, with its key columns”
  • New field key_columns on a table of POST /v1/pipelines and POST /v1/pipelines/{id}/tables: for a view or a materialized view picked for a query-based pipeline, the columns that identify one of its rows. Each sync reads the view whole, in one snapshot, and writes its rows by that key; the rows gone from it since the last sync are marked deleted (Snowflake, or a PostgreSQL table kept soft_delete) or counted and kept (a PostgreSQL table kept live). What it costs: each sync runs the view twice in one snapshot (the key check, then the read), holds a share lock on every table it reads for the read’s length, and copies it whole; its rows are metered as copy work at every sync. A view whose rows can differ between two reads of the same data (TABLESAMPLE, LIMIT, OFFSET, DISTINCT ON, a window function, a volatile function) is parked view_not_syncable. A table picked with key_columns is synced by its own key, and its source_note says the named key is not used. Refused with 422 invalid_field on a pipeline that reads the source’s log, or when empty, blank or repeated. Fixed once named.
  • New field view_key on each table of GET /v1/pipelines/{id}/tables: the key named for a view; null for a table.
  • New park causes for a picked view, each naming what is wrong and never a value, nothing of the view written in that sync: view_key_null (a row with no value in a key column), view_key_not_unique (two rows share a key), view_key_missing (a key column the view no longer has), view_key_not_comparable (a key column of a type with no equality, such as json), view_not_syncable (the view reads a materialized view or a foreign table, or calls a volatile function or a function defined in your database).
  • A view picked with no key, or for a pipeline that reads the source’s log, still parks not_a_table; its words now say how a view is synced. The app’s table list still picks tables only: a view is picked through the API.

2026-11-09 (IST) — A Terraform provider: credentials, sources, destinations and pipelines as code (not yet in the public registry)

Section titled “2026-11-09 (IST) — A Terraform provider: credentials, sources, destinations and pipelines as code (not yet in the public registry)”
  • Four resources over the public API, applied by Terraform or OpenTofu 1.11 or later: reyansh_credential, reyansh_source (PostgreSQL), reyansh_destination (PostgreSQL and Snowflake) and reyansh_pipeline (its tables, schedule, what it does with rows and values the destination does not take, and whether it runs). Every resource imports by its id. A data source, reyansh_egress_addresses, gives the addresses to allow in a database’s firewall. Guide: Terraform: sources, destinations and pipelines as code.
  • Secrets are write-only: a connection string, private key or password is sent to the API and kept in no plan and no state file; raise its _wo_version (or set one for the first time) to send a new one.
  • A field the API keeps fixed (a pipeline’s source, a source’s database) changed under the same id is refused at plan, naming the field, rather than replaced: a pipeline’s id is never reused after a delete, so a replace would delete the pipeline and then fail to create its successor. Give the object a new id to replace it.
  • Destroy deletes a pipeline (its destination tables kept; the source statements that remove its slot and publication printed for you to run) and keeps a source, destination or credential in the account, saying so, because no API route deletes one yet.
  • Not yet published to the registry, so not yet installable: publishing needs a registry namespace and a signing key, which are being set up. The guide describes it as it will ship. People, invitations, API keys and money are not manageable by Terraform, by rule.

2026-11-09 (IST) — A table whose destination table is gone is told what its copy brings back

Section titled “2026-11-09 (IST) — A table whose destination table is gone is told what its copy brings back”
  • A table stopped because its PostgreSQL destination table is gone now says that its resume copies every row your source holds now, and that what only the dropped table held went with it: rows your source no longer has (kept marked deleted in soft delete), and a history table’s earlier versions or an append-only table’s change rows. It used to say that every row of it is written again. The tables guide says the same.
  • A Snowflake table stopped because its key may have been written as a number (the wide numeric setting) says that dropping it, instead of renaming it aside, also loses a history table’s earlier versions and an append-only table’s change rows.

2026-11-09 (IST) — Large batches load from files on Snowflake accounts on Google Cloud and Azure

Section titled “2026-11-09 (IST) — Large batches load from files on Snowflake accounts on Google Cloud and Azure”
  • Snowflake destination: an account hosted on Google Cloud or Azure now tries to load its large batches (a first copy, a busy stream) from compressed, encrypted files in the service user’s stage, as an account on AWS has since v0.1.48. Until now those accounts wrote every large batch by INSERT, correctly but with far more warehouse time, and the pipeline’s history said so once as Large batches written the slower way, “for this account”.
  • Not yet run against a live account on Google Cloud or Azure. The upload is built from Snowflake’s own drivers, which send the files straight to the stage’s own storage (Google Cloud Storage or Azure Blob Storage); no storage of ours is involved, and nothing new needs granting. If Snowflake or its storage answers differently from what the drivers expect, the batch is written by INSERT instead, every row exactly as before, and the history says so as it does today.
  • If you run Reyansh yourself, the pipeline machines must reach *.googleapis.com (Google Cloud) or *.blob.core.windows.net (Azure) over HTTPS, as they already reach S3 for an account on AWS.

2026-11-09 (IST) — Snowflake: every account chooses where wide numerics land, and text values can be trimmed (behind a flag)

Section titled “2026-11-09 (IST) — Snowflake: every account chooses where wide numerics land, and text values can be trimmed (behind a flag)”
  • Wide numerics, every account. settings.wide_numeric_as on POST /v1/destinations is no longer refused 422 not_yet_available: every account may choose NUMBER(38,s) for a numeric with no precision, or wider than 38 digits, and GET /v1/me’s wide_numeric_enabled is always true (kept, so a client reading it keeps working). Nothing else about the setting changes: chosen at create, PATCH answers 422 setting_not_editable.
  • New: settings.trim_whitespace (Airbyte’s “Trim Whitespace from String Fields”). true removes the spaces and tabs at the start and end of each value of a string column that is not a key (text, varchar, char(n), name, citext, uuid, an enum; the column view says trimmed for it), exactly the characters Snowflake’s own TRIM_SPACE removes (recorded): a line break, a no-break space and the spaces between words are kept, and a value of only spaces and tabs becomes the empty string, never NULL. Key columns, a value kept as the source’s text for another reason (a wide numeric, money, interval, xml), JSON, arrays, binary and typed columns are never trimmed. Off, or left out, every text value lands byte for byte, as before. Chosen at create: PATCH answers 422 setting_not_editable. Offered to an account once GET /v1/me says trim_whitespace_enabled; until then POST /v1/destinations answers 422 not_yet_available for the field, false included, because this release is the first that reads it.
  • The app: the Snowflake destination form shows Trim spaces and tabs from text values to such an account, and the destination’s page says whether its text values are trimmed. The guide’s Trimming text values says what is removed and why.

2026-11-09 (IST) — A lock timeout, statement timeout or deadlock at a PostgreSQL destination is told in PostgreSQL’s own words

Section titled “2026-11-09 (IST) — A lock timeout, statement timeout or deadlock at a PostgreSQL destination is told in PostgreSQL’s own words”
  • PostgreSQL destination: when a write waited on a row another session had not committed yet and then met a lock timeout, a statement timeout or a deadlock (or a statement timeout fired inside your trigger), the report read “the server refused the statement (the server’s message is withheld: it can quote a row’s values)”. It now says PostgreSQL’s own words, such as 55P03: canceling statement due to lock timeout or 40P01: deadlock detected, which are fixed strings and never hold a value. What the pipeline does with them is unchanged. A value your column cannot read (a JSON document it cannot parse, a character the database’s encoding cannot hold) is told by its own sentence and never as “a function or trigger”; only your trigger’s own RAISE is.

2026-11-09 (IST) — A Snowflake account given as its locator is compared with its orgname-accountname

Section titled “2026-11-09 (IST) — A Snowflake account given as its locator is compared with its orgname-accountname”
  • Snowflake destination: a pipeline whose table another pipeline already writes is refused with 422 destination_table_taken (or destination_schema_taken for a Fivetran-named schema) when one of the two destinations names the Snowflake account by its legacy locator (xy12345) and the other by orgname-accountname, and both name the same database. Until now the two spellings were two accounts to the check, so both pipelines were created and both wrote the table, overwriting each other’s rows every batch.
  • Which locator is which account only Snowflake knows, so a locator is counted as the same account as every orgname-accountname of the same database. Two different accounts with one database, schema and table name, one of them given by locator, are refused too. The message says why, and what that case can do: a pipeline created through the locator is created through orgname-accountname instead (SELECT CURRENT_ORGANIZATION_NAME() || '-' || CURRENT_ACCOUNT_NAME() shows it); a pipeline created beside a locator-named one names its own account by its locator (SELECT CURRENT_ACCOUNT()), or the other pipeline is deleted and, once its worker has stopped, replaced by a new one through orgname-accountname; a table added to an existing pipeline goes through a new pipeline; a pipeline refused at its start is deleted first (its destination tables are kept), then a new pipeline is created for its tables, since a pipeline’s destination is fixed. Two different locators are two accounts. Pipelines in different workspaces are still never compared.
  • Pipelines that already exist: two that already write one table this way keep running; the next start of either is refused, naming the other, with the same code. The control plane counts such pairs in its log at every boot.

2026-11-09 (IST) — A table that references itself is copied whatever order its key sorts its rows in

Section titled “2026-11-09 (IST) — A table that references itself is copied whatever order its key sorts its rows in”
  • PostgreSQL destination: a table is copied in the order of its key, up to 1,000 rows to a batch. When a foreign key of yours on the destination table referenced the table itself (employees.manager_id REFERENCES employees (id), a category tree), a row whose key sorted before the key of the row it references was refused, and the table stopped at its copy; resuming met the same rows every time. Such a batch is now written in one transaction, every row first without its references to the table and then as it is, so a child before its parent, a chain written backwards, or a cycle is written. A table with a trigger of yours, or whose reference another key cascades from on update, is never written this way; the rows and bytes counted are the batch’s own, once.
  • What one batch cannot hold still stops the table, now told what to do: a reference to a row in a later batch (common in a large table whose key sorts at random, such as a UUID), or a referencing column declared NOT NULL. The words name the foreign key and give the statements: save its definition, drop it while the table is copied, resume, and add it back. A foreign key that refuses a streaming table’s changes is told the lasting remedy instead (declare it ON DELETE CASCADE as your source’s is, or DEFERRABLE INITIALLY DEFERRED), never a copy’s order. A foreign key from one table of the pipeline onto another stops the pipeline at its start, as before. See Foreign keys of yours.

2026-11-09 (IST) — A unique constraint or foreign key of yours no longer stops a batch your source applied

Section titled “2026-11-09 (IST) — A unique constraint or foreign key of yours no longer stops a batch your source applied”
  • PostgreSQL destination: a batch is written one write per row as the row ends up, which is not always the order your source made its changes in. A UNIQUE constraint or unique index besides the key, an EXCLUDE constraint, or a foreign key between rows of the same table could refuse that order where your source’s own order passed (a value moving from one row to another in the batch, a child written before the parent inserted with it), and the table stopped; resuming met the same batch every time. Such a batch is now written again, in one transaction, in your source’s order, and the table stops only if that is refused too, with PostgreSQL’s words as before. Every other batch is written as before, and a batch is counted the same whichever order wrote it. A foreign key from one table of the pipeline to another is not covered. Snowflake does not enforce these constraints, so a Snowflake destination was never affected.

2026-11-09 (IST) — An update that leaves a large value unchanged no longer stops a PostgreSQL destination column declared NOT NULL

Section titled “2026-11-09 (IST) — An update that leaves a large value unchanged no longer stops a PostgreSQL destination column declared NOT NULL”
  • PostgreSQL destination: under a source table’s default settings, PostgreSQL leaves a large (out-of-line) value out of an update that does not change it. Reyansh kept the destination’s value, but where the destination table declared that column NOT NULL (a table made from the source’s own definition does), the write was refused although the row was there: the table paused, and every resume met the same refusal, so it never moved again. Such an update is now written as an update of the row the destination holds, and the column keeps its value. If the destination does not hold the row at all (it was removed there, or never copied), the value cannot be written, so the table is paused, told with the column’s name; resuming it copies the table again, which brings the row whole, and that copy is not charged. The statement the table’s page shows, run on the source, stops this from happening again.
  • One change to your own triggers, on these updates only: a trigger of yours that runs BEFORE INSERT no longer runs for such an update of a row your table holds, because that write is now an update: your BEFORE UPDATE and AFTER UPDATE triggers run instead. So a BEFORE INSERT trigger that rewrites a value (upper-casing a name, say) no longer rewrites it on these updates, and one that returns NULL to skip writes no longer skips them. It still runs for a new row, and for an update that carries every value. A statement-level UPDATE trigger runs twice for each such update.
  • A table whose rows are filtered and whose key is char(n) no longer pauses on an update of a row your destination holds that left a large value out: the row is found as the table stores it (the padding PostgreSQL sends kept on both sides), and written.

2026-11-09 (IST) — A history table whose key is shorter than its fixed-width column keeps a current version of each row

Section titled “2026-11-09 (IST) — A history table whose key is shorter than its fixed-width column keeps a current version of each row”
  • PostgreSQL destination, tables kept in history: in a table whose key included a fixed-width text column (char(n)), a row whose key value was SHORTER than the column’s width (which PostgreSQL stores padded with spaces) never had a version made current. Every version the copy or the stream wrote for it was left with no start, no end and not marked current, and its delete closed nothing, while the table showed as streaming with no error. A key that fills the column’s width (abcde in a char(5), a two-letter code in a char(2)) was not affected. Each row now has exactly one current version, every earlier one is closed where the next begins, and a delete closes the row’s version. Re-syncing an affected table restores its current versions; versions written before this change keep no start or end. History tables are offered only to the accounts they are enabled for.

2026-11-09 (IST) — Two pipelines on one PostgreSQL database are compared, whichever credentials they were saved with

Section titled “2026-11-09 (IST) — Two pipelines on one PostgreSQL database are compared, whichever credentials they were saved with”
  • PostgreSQL destination: a pipeline whose table another pipeline already writes is refused with 422 destination_table_taken when the two reach the same database through different saved credentials, as the app’s form makes them (a credential of its own for each pipeline). Until now only two pipelines through one destination, or two destinations on one saved credential, were compared, so two pipelines the form made on one database were both created and both started, and overwrote each other’s rows. The message says that the two credentials differ and both connect to the same database.
  • “The same database” is the same host, port, database name and user in the two connection URLs: the host’s ASCII case aside, an IP address in any of its spellings, and port 5432 when none is given. The password and sslmode play no part. The user does, because a pooler such as Supabase’s serves many projects at one host, port and database name and tells them apart by the user. Not recognised as one database (so two pipelines through them are not refused): two users of it, an IP address and a DNS name, a CNAME, a connection pooler or proxy in front of it, a trailing dot. Give every destination for one database the same host name and user.
  • Pipelines that already exist: two that already write one table this way keep running; the next start of either is refused, naming the other, with the same code. Credentials saved before this release are compared once the control plane has restarted on it.
  • No field, endpoint or request changes. The comparison never opens a credential, and nothing it stores is returned by the API. See A PostgreSQL destination.

2026-11-09 (IST) — A delete your PostgreSQL destination did not apply is reported, never taken as done

Section titled “2026-11-09 (IST) — A delete your PostgreSQL destination did not apply is reported, never taken as done”
  • PostgreSQL destination: a delete that a BEFORE DELETE trigger or an ON DELETE DO INSTEAD NOTHING rule on the destination table skips reports 0 rows, exactly what a delete of a row that is already gone reports, and the pipeline took it as done while the row stayed in your destination. Now a delete that reports 0 has its key looked up: a row still there is reported as a discarded row (rows_discarded, in words that say the row is still in your destination), recorded in _reyansh_rejected_v1 with the reason not_deleted, and handled by the pipeline’s discarded-row setting (keep syncing, or stop the table). A delete of a row already gone is accepted, as before. On a table with a DO INSTEAD rule on DELETE, every delete is looked up, because its count then describes what the rule did. On a table with no rule on DELETE, a delete stays one statement, a replayed one included. See Rows your destination discards.

2026-11-08 (IST) — A refused write to a history or append table no longer restarts the pipeline

Section titled “2026-11-08 (IST) — A refused write to a history or append table no longer restarts the pipeline”
  • PostgreSQL destination, tables kept in history or as an append log: when the destination refused a write to such a table (a CHECK it breaks, a permission, the table dropped), the pipeline parked that table and then stopped and restarted itself, because the refused transaction was left open on the connection the next table used; every other table waited for the restart. It now ends the refused transaction at once, so the other tables go on. (A history or append table DROPPED at the destination already parked so that resuming it copies it again; that is now pinned by a test.) History and append tables are offered only to the accounts they are enabled for.

2026-11-08 (IST) — A PostgreSQL destination key under a case-insensitive collation stops its table before a row is written

Section titled “2026-11-08 (IST) — A PostgreSQL destination key under a case-insensitive collation stops its table before a row is written”
  • PostgreSQL destination: a table whose key column, or the unique index on its key, compares under a non-deterministic collation (one that ignores case or accents) now stops at its start, before anything is written: parked destination_table_unusable on a pipeline that copies it, and the start stopped where the source sends only new changes. The words name the table, the column, the collation and the statement that fixes it (ALTER TABLE ... ALTER COLUMN ... TYPE <its type> COLLATE "C", or recreating the index without its COLLATE). Before this, such a key took abc and ABC as one row: the second was written as an update of the first, a delete of one deleted both, and every write reported success. A table kept in history is asked the same; one kept as an append log, and a collation on a column that is not part of the key, are not. The connection check (--check, the pipeline’s preflight) reports it too. Your table’s key: guides/postgresql-destination.md.

2026-11-08 (IST) — A PostgreSQL json column keeps a PostgreSQL source’s document exactly as sent

Section titled “2026-11-08 (IST) — A PostgreSQL json column keeps a PostgreSQL source’s document exactly as sent”
  • PostgreSQL destination, json columns: a value is written as json, so the column stores the text it is given, unchanged. From a PostgreSQL source (the copy and the stream) that is the source’s own text, byte for byte: its spacing, its key order and a repeated key. It used to be written through jsonb, which reordered the keys, kept only the last of a repeated key, re-spelt numbers and changed the spacing, silently.
  • From a REST source the JSON is not the API’s own text, before and after this release: a field declared json is read and written again as compact JSON before it reaches your destination, with its keys sorted, its spacing dropped, a repeated key’s last value kept, and an escaped ordinary character written as the character. A json column now stores that text as it arrives. (A MySQL source’s JSON column type is not one this release reads.)
  • And a json column now stores what jsonb refuses: a \u0000 escape, an unpaired surrogate escape, and a number beyond numeric’s range. Under on_rejected_value = continue the two escapes used to be written NULL in a json column (reported as values_fitted, not_a_value, marked our_cast); under stop they stopped the pipeline; the number was refused under either answer. A jsonb column is unchanged: it still normalises a document, writes those two escapes as NULL under continue, and refuses that number as before.
  • Rows already written are not rewritten. A json value written before this release keeps jsonb’s spelling ({"a": 1}) until its row is written again. A value written as NULL before this release stays NULL until its row changes at the source or the table is copied again (Copy again on the table, or a re-sync), which writes it as the source now holds it. While record_in_destination was on (the default), each original is in the table _reyansh_rejected_v1 in the schema the pipeline writes.
  • A stop on a rejected value is classed as your column’s in every case (on_rejected_value = stop): it was “undetermined” when a json column was in the row, because our cast could have been what refused it. No values_fitted report marks a NULL our_cast any more; reports written before this keep the mark.
  • The column view: a json source column into a json column now says exact (it said json_rewrites) from the pipeline’s next start. A Snowflake destination is unchanged: a JSON value lands in VARIANT, parsed.
  • API reference: the on_rejected_value description says this.

2026-11-07 (IST) — A copy that ended with its table’s stop is no longer shown as running

Section titled “2026-11-07 (IST) — A copy that ended with its table’s stop is no longer shown as running”
  • GET /v1/pipelines/{id}’s copying no longer names a table whose copy stopped because the table stopped on its own (it is parked, with its reason on the tables page). Before, such a copy was answered as running for good, and Sync now said the changes the pipeline holds would be written “as soon as the copy finishes”, of a copy that never would. Resuming the table starts its copy again, and copying names it again while it runs.

2026-11-07 (IST) — A PostgreSQL destination writes an unconstrained numeric’s infinities

Section titled “2026-11-07 (IST) — A PostgreSQL destination writes an unconstrained numeric’s infinities”
  • Infinity and -Infinity in an unconstrained numeric column are now written to a PostgreSQL destination, which has held them since PostgreSQL 14. Before, the pipeline refused the value as “not a valid numeric” at every start, restarted, and gave up, stopping every table of the pipeline for one value. A numeric column with a declared precision refuses an infinity, as PostgreSQL itself does, and NaN is written into both, as before.

2026-11-07 (IST) — One value your destination cannot take stops its table, never the whole pipeline

Section titled “2026-11-07 (IST) — One value your destination cannot take stops its table, never the whole pipeline”
  • A value no setting can write now stops only the table that holds it, at both destinations, and the pipeline’s other tables keep syncing (unless the pipeline is set to stop every table when one table stops). At PostgreSQL: a number wider than its numeric(p,s) or integer column keeps, text holding a NUL, a key the column would store as another key. At Snowflake: a key Snowflake cannot hold (an infinite date, a numeric NaN), and a number too wide for a declared NUMBER(p,s). Before, such a value stopped every table of the pipeline: at PostgreSQL after five quick restarts that met it again, and a PostgreSQL source kept its change log for every table meanwhile.
  • The stopped table is told its way back, on the history (“A table stopped syncing”) and in its alert: the column and why, never the value. Change the destination column so it holds the value, then Resume the table, which writes its changes from where it stopped; or, where no column can hold it, correct the value at your source and Re-sync the table. While it waits, a source the pipeline reads through its change log keeps that log from where the table stopped, as for any table that keeps its place.
  • What is billed: a pipeline that stops one table for a value no longer fails, so its run is billed for what it moves, as any run is; a table copied again after you fix it is billed as copy work, as any re-sync, and the table’s remedy says so. A run that fails is still free.
  • What still stops the pipeline: a timestamp your source sends in a form other than PostgreSQL’s ISO one (its DateStyle setting, every table’s), or with a UTC offset other than zero for a timestamp column (its TimeZone setting, every table’s); a value Snowflake refuses for a reason on our side; and a value refused from the platform history export, our own source, which is a fault on our side: the pipeline restarts, and a run that fails is free.
  • A pipeline with no saved place yet (a new one that skips the copy, in its very first batch) still stops for such a value, now for you, without restarting into it. See Values your destination cannot take.

2026-11-07 (IST) — The history export stops, and says so, when retention removed events it had not read

Section titled “2026-11-07 (IST) — The history export stops, and says so, when retention removed events it had not read”
  • API, GET /v1/exports/events: a resumed read (since above 0) never steps past a removed row. Its rows are served only while they follow on without a gap, and a page stops at a gap with a next_cursor; when the very next row after the reader’s position was removed by the history’s retention, the read is refused with 410 history_removed. details carries pipeline_id, after_sequence (the reader’s position), missing_from, missing_through, removed_rows, next_sequence (the first row kept after the hole), resume_since (where to go on) and swept_before. It used to serve the rows that were left, and a reader’s saved value stepped past the hole without knowing. To go on with every row that is kept, read again with since set to resume_since (the last removed sequence), or from the beginning without since; never with since set to next_sequence, a row you do not hold. A read without since is never refused. No other stream changes: runs is served for its 30-day window as before, and the other streams are not removed by retention.
  • History export pipelines: an events pipeline that meets this stops for a person, titled “Stopped: history was removed before this export read it”, with the export’s sentence (which pipeline, how many rows, up to where) and the way on: a new export pipeline for the stream, from the same source into the same table, reads every pipeline’s history from what is kept. Starting the stopped one again stops it again. The guide has a section, “When history was removed before the export read it”.
  • Why: so that the history’s retention (a run’s per-batch rows and measurements may be removed once it has been over for 31 days) can run beside the export without the export ever missing rows silently. An export that syncs at least once every 30 days (the daily default does) never meets this.

2026-11-07 (IST) — A view is told as a view, with the tables it reads, when a pipeline starts or reads the change log

Section titled “2026-11-07 (IST) — A view is told as a view, with the tables it reads, when a pipeline starts or reads the change log”
  • A view, a materialized view or a foreign table under a name a pipeline syncs is now named as what it is at the start of every sync, by queries or by the change log, to PostgreSQL or Snowflake; in the check a pipeline reading the change log makes of its tables while it runs; and in the words of a request held for the table. The commonest case is a table renamed with a view left under its old name: the table stops at its next sync (table_replaced, its place let go) in words that say a view took its name and name the table the view reads, which is the one to add. Before, it was “a different table … another table was renamed into its place”, and a pipeline reading by queries could follow the view into a refusal of the whole pipeline.
  • A view picked for a pipeline through the API stops at the start with a cause of its own, not_a_table, saying it is a view and what it reads, with the way back “remove it, and add the tables its sentence names”. It is alerted as a stopped table that waits for you, never as a table dropped or renamed, so the rule for a table gone from the source does not stop the others with it: the rest of the pipeline syncs, unless the pipeline is set to stop every table when any one stops. Before, a pipeline reading the change log waited for the view to be added to the publication, which PostgreSQL refuses for a view, and one reading by queries refused the whole pipeline. The test’s tables step fails with not_a_table for it, by either method (table_missing for a name nothing holds, which said no_key).
  • A view that calls a function of your own or names a foreign table is never told it “reads no table”: its words say we cannot follow what that reads.
  • Views are still not synced, as at Fivetran; see the guide.

2026-11-07 (IST) — A destination table made again is found at the next start, and copied again when you resume it

Section titled “2026-11-07 (IST) — A destination table made again is found at the next start, and copied again when you resume it”
  • A destination table made again is now found, at both destinations, on every kind of pipeline. The pipeline records which table it writes each of your tables into (at PostgreSQL the table’s identity in the catalogue and the identifier of the server it lives on, at Snowflake the instant it was created), every copy records the table it fills, and every start compares. A table dropped and made again, another table put under its name, Snowflake’s CREATE OR REPLACE TABLE, a clone or a swap into its place stops with its place let go and nothing written to it; resuming it copies the source into the table as it is now. Before, the pipeline found a table there and wrote on into it from where it had reached, every earlier row missing from it, with no error. This replaces the entry below that said such a table is not found.
  • One rule: after any restore or move of your destination, ask for Copy again on every table. Some of them cannot be found: a backup or snapshot restored, a point-in-time recovery, a promoted replica or a Snowflake UNDROP keeps every table’s identity, so the pipeline goes on from where it had reached and the rows written after the copy’s moment are missing. At PostgreSQL a copy on another server (a dump restored, a logical copy) is usually found, and so is an upgrade to a new major version (made with pg_upgrade, which managed services use too), which keeps every row but gives the server a new identifier: every table that was syncing stops, and each resume copies it again. Emptying a table keeps it the same table: ask for Copy again after emptying one.
  • Found at the next start, not between two writes. A table replaced while the pipeline runs is written on until the pipeline next starts (a restart, an update of the service, a resume), which then stops it. If you replace a destination table yourself, ask for Copy again on it straight away.
  • A stop that was told and not saved is no longer a way to lose rows. If the pipeline told you a table stopped because its destination table was gone, and its own record of that stop did not survive (the machine it ran on failed in between), the table you made again as told is found at the next start, rather than written on into.
  • A MySQL, Stripe or history export pipeline (they copy nothing) whose destination table is another one than it last wrote into stops once and says so: nothing more is needed if you put the table back from your own copy; otherwise the earlier rows are missing, and for a history export a new export pipeline of the stream reads again the ones the export still serves. Started again, it continues into the table as it is now. The history export’s pipelines stream, read whole at every sync, is filled again by the next sync and never stopped for it. At PostgreSQL a destination upgraded to a new major version stops each of them once the same way, and nothing more is needed.
  • A PostgreSQL destination role that may not call pg_control_system() (every role may, unless it was revoked) stops the pipeline at its start, told, with the statement that gives it back: GRANT EXECUTE ON FUNCTION pg_catalog.pg_control_system() TO <your role>;. Nothing is written until it can be read. The destination guide lists it with the role’s other needs.
  • A table nobody touched, in a destination nobody moved, is never stopped by this. It costs no extra statement at Snowflake for a table already syncing, and a metadata listing (no warehouse) before each copy: two for a table copied at a start, the start’s own after it makes the table and the copy’s. At PostgreSQL it is one catalogue read per table at each start and one before each copy.

2026-11-07 (IST) — A Snowflake pipeline made while an earlier writer’s first load was still queued waits for it

Section titled “2026-11-07 (IST) — A Snowflake pipeline made while an earlier writer’s first load was still queued waits for it”
  • A Snowflake pipeline whose destination table is empty while its working schema holds rows an earlier writer staged for that table now waits once before its first write there (about an hour per target schema, told as it begins: Waiting for earlier statements to end, naming the staged rows). Staged rows are looked for where each kind of table loads them: the table’s staging table, and the copy stages a first load of a table with no primary key is staged in, whatever the table’s key is now and however the account stores identifiers. The case is a pipeline deleted, or stopped for good, while Snowflake still had its first load queued, and a new one made over the same tables: before, the empty destination table read as one nobody had written, the new pipeline copied at once, and the queued load could then put the deleted pipeline’s older rows over the new copy, saying nothing. A writer that stopped after staging rows, whether or not it had applied them, leaves the same rows, so such a start may wait once with nothing queued.

2026-11-07 (IST) — A Snowflake pipeline made over another writer’s tables waits for that writer’s last statements

Section titled “2026-11-07 (IST) — A Snowflake pipeline made over another writer’s tables waits for that writer’s last statements”
  • A Snowflake pipeline that starts writing a target schema over tables already holding rows it did not write now always waits once, before its first write there, for any statement an earlier writer may still have queued in Snowflake (at most about an hour, told as it begins: Waiting for earlier statements to end). The commonest case is a pipeline you make over the tables of one you deleted: a pipeline stopped while Snowflake had a statement of it queued can be ended before that statement runs, and the statement then runs later. Before, when the working schema’s record of who writes each table was older than these tables (an earlier pipeline into the same schema had made it), the new pipeline did not wait, and such a statement could write the deleted pipeline’s older values over rows the new one had just copied, saying nothing. Its history names what Snowflake’s record showed: rows that the record of who writes the table, older than the table, names no writer for. A running pipeline that adds a table already holding another writer’s rows to a schema it already writes waited once before this change too, at the start that adds it; its history now says the table may have been added over another writer’s rows, where it said only that a row of that record had been deleted. The wait is per target schema: a pipeline whose tables are in several schemas that each owe one waits for each in turn, about an hour apiece. A pipeline that makes its own tables, or finds them empty with nothing staged for them, does not wait, and a pipeline that has written its tables before does not wait again.

2026-11-07 (IST) — The history export’s page shows the statements its tables need, and says why its button waits

Section titled “2026-11-07 (IST) — The history export’s page shows the statements its tables need, and says why its button waits”
  • The statements that create the export’s tables are on its page (under the notes, “The statements that create the tables”), the guide’s own, one CREATE TABLE per stream. The page had said to create them “with the columns the export guide lists”, and no page linked the guide.
  • The page’s button says why it cannot be pressed yet from the first look (a name, a read key, a destination, a stream), not only once a name was typed, and no longer offers to “Create 0 export pipelines” with no stream picked.
  • A platform source’s own page says what it reads, that its key is never shown, and how to replace the key (POST /v1/credentials/{ref}/rotate, then start each export pipeline it stopped). It said its connection was shown field by field “only for PostgreSQL”.

2026-11-07 (IST) — The light theme has its own lines, and the API key page’s usage line is readable in it

Section titled “2026-11-07 (IST) — The light theme has its own lines, and the API key page’s usage line is readable in it”
  • In the light theme, the API key page’s usage line is dark text on a light background, readable at last: it sat on the dark theme’s background colour, because the light theme set two of its four surface colours and the other two fell back to the dark ones. It now sits on the page’s own background in both themes.
  • The light theme’s neutral lines are a mid brown, at least 3:1 against the light backgrounds: the borders of inputs, buttons and cards, the row dividers, the header rule and the settings tab bar, in the app and in the staff console. They were the dark theme’s near black. A step marked skipped or not run in a connection test shows in the same brown.

2026-11-07 (IST) — The sync modes guide says what is offered now, and what a table that lost its key needs

Section titled “2026-11-07 (IST) — The sync modes guide says what is offered now, and what a table that lost its key needs”
  • Soft delete into PostgreSQL is offered to every account, as it has been since 2026-10-13; the sync modes guide still said it was not available yet and would come with the next release. It no longer does.
  • History and append-only are offered to the accounts they are available to (GET /v1/connectors says which modes your account is offered); the guide’s “from the next release … every account” is removed until that is so.
  • A table kept in history or append-only that lost its primary key after rows of it were written is told, in the guide as on its own row, that a request for soft delete or live waits until it syncs again, which it does not without a key: give it its primary key back at your source, then resume it. The guide had offered soft delete or live to every such table.

2026-11-07 (IST) — The history export’s page makes nothing twice when an answer is lost

Section titled “2026-11-07 (IST) — The history export’s page makes nothing twice when an answer is lost”
  • App, “Export your history”: when a create’s answer never arrives (the connection drops after the server made the source or a pipeline), pressing again sends the same request under the same idempotency key, so the server answers with what it made and the page carries on. It used to send a new key: the source’s retry was refused as 409 already_exists with words that sent you to make a second source holding the same key, and a pipeline’s as 409 pipeline_exists on every press. An answer from the server (a refusal included) still makes the next press a new request.

2026-11-07 (IST) — The history export runs as pipelines: pick the streams, a read key and a PostgreSQL destination

Section titled “2026-11-07 (IST) — The history export runs as pipelines: pick the streams, a read key and a PostgreSQL destination”
  • New source kind platform (card live): this account’s own /v1/exports, copied into a PostgreSQL destination you own by an ordinary pipeline. A pipeline syncs ONE stream, so an export of all six streams is six pipelines; the app’s Sources page makes them together (“Export your history”). Into Snowflake it is refused in this release (the Snowflake card lists postgres alone).
  • POST /v1/sources takes api_key for a platform source, and a platform source takes nothing else: a READ API key of this same account, checked before it is stored, sealed into the source’s own credential and never returned (the source shows its credential_ref; the credential, its hint). 422 invalid_api_key for a value that is not a key of this platform, or one revoked, expired or of another account (one answer for all four); 422 api_key_not_read for a full key, since the export only reads; 422 invalid_field for api_key on any other kind, and for a platform source sent credential_ref, connection or connection_url.
  • POST /v1/credentials/{ref}/rotate on a credential a platform source uses takes only a live READ key of this same account, the check the source’s create makes: 422 invalid_api_key (one answer for a value that is not a key of this platform, or one revoked, expired or of another account), 422 api_key_not_read for a full key, 503 api_keys_unavailable where keys cannot be checked. A refused rotation stores nothing.
  • A refused read key says so: an export pipeline whose key was revoked, rolled or has expired (the export answers 401) stops with a sentence naming the key and the remedy: POST /v1/credentials/{ref}/rotate with a new READ key, then start each export pipeline again (Start on its page, or POST /v1/pipelines/{id}/start), where it said only the HTTP status. A 403 (API keys not enabled for the account) says the key is not at fault. The guide’s “When the key stops working” says the same.
  • GET /v1/connectors: a source card whose streams its connector declares lists them in streams (the platform card’s six, in their order).
  • POST /v1/pipelines from a platform source names one of those streams (422 unknown_stream otherwise, naming them), and syncs every 24 hours when no schedule is sent (every other source keeps the six-hour default).
  • Billed as resources used, like any pipeline: each export run’s compute and memory are metered as that run’s, and a run that fails is free, as for every pipeline; its rows and bytes are measured and shown, never priced. (A REST source’s pipeline used to stop being metered at its second batch, which also held back its account’s daily charges; it is now counted by its run.)
  • Before the first sync, create each stream’s table in the destination’s public schema with the columns Exporting your account’s history into your own destination lists: a PostgreSQL destination is not created for you, and a missing table stops its pipeline, naming the table.
  • An export pipeline whose destination table was dropped after it wrote rows stops at its next start, and says what is true of the export: the export still holds the rows. A pipelines table (read whole at every sync) gets every row again from the next sync once you make it again and start the pipeline. For the other streams the pipeline reads on from where it stopped, so the table made again would miss the rows from before; to have them all again, delete the pipeline, make the table again and create a new export pipeline for the stream under a new id: a new pipeline reads the export from its start, as far back as the export keeps the stream.

2026-11-07 (IST) — Pagination cursors are signed with a secret key; cursors issued before this release stop working once

Section titled “2026-11-07 (IST) — Pagination cursors are signed with a secret key; cursors issued before this release stop working once”
  • A security fix: every list’s next_cursor is now signed with a key only the deployment holds. Cursors were always meant to be unforgeable (a cursor you did not receive from us is refused with 400 invalid_cursor), but the control plane signed them with an empty key, so anybody who had read one cursor could build another the API would accept, and one list, a destination’s hash salt history (GET /v1/destinations/{id}/hash-salt/events), handed out a bare event id that any number could stand in for.
  • What a forged cursor could do. It could not reach another account: every list is read under the signed-in account’s own row-level security, and a cursor only supplies a position inside it. Within your own account it could choose where a page started. On the wallet ledger (GET /v1/wallet/entries without filters) it could also choose the balance the next page’s balance_after_minor figures are counted down from, so the caller who sent it could be shown wrong running balances on the pages after the first. No ledger entry, balance or charge was changed by it: the figures are computed for the response and stored nowhere.
  • A cursor you were holding when this release was deployed answers 400 invalid_cursor once. It was signed with the old empty key, or, for the hash salt history, was a bare event id. Start the list again from its first page (no cursor parameter) and page on from there; the cursors you receive from now on keep working. The hash salt history’s cursor is now opaque like every other: a client must pass back the next_cursor it was given, never build one. Nothing else about any list changed.
  • For a self-hosted deployment: REYANSH_CURSOR_SECRET is a new required setting. At least 32 characters; the control plane refuses to start without it and names it (exit 78). bootstrap-secrets.sh mints one of 64 hex characters and keeps it across re-runs, and release.sh mints it on a box set up before it existed. Changing it later is a rotation: every cursor issued before the change answers 400 invalid_cursor once, as above.

2026-11-07 (IST) — A destination table found dropped is copied again when you resume it, never caught up into

Section titled “2026-11-07 (IST) — A destination table found dropped is copied again when you resume it, never caught up into”
  • A table whose destination table the pipeline finds dropped now stops with its place let go, at both destinations, on every kind of pipeline that copies: at PostgreSQL when a start reads it or the pipeline next writes to it, at Snowflake when the pipeline next starts or you resume the table (a write that meets it first can stop the table with its place kept: resume it without making the table again, and that start lets its place go). Resuming it then copies it again, so every row comes back. At PostgreSQL, make the table again first; at Snowflake, resume it and the copy makes it. Before, a PostgreSQL table whose destination table was dropped stopped saying that resuming would write its changes from where it was and lose none: after the table was made again, the resume caught up from that place into an empty table, and every row from before it was missing. At Snowflake the pipeline made the dropped table again, empty, and synced on into it, with the same result and no stop at all.
  • What is not found: a table dropped and made again before the pipeline looks. Dropped and made again while the pipeline is stopped, or between two of its writes, or replaced by Snowflake’s CREATE OR REPLACE TABLE, it is a table, and the pipeline writes on into it from where it had reached, every earlier row missing. After making a destination table again yourself, ask for Copy again on that table.
  • A MySQL or Stripe pipeline (they copy nothing) stops when its destination table is gone, and now says that a table made again empty would be given only the changes from where it stopped, and how to keep the earlier rows: put the table back from your own copy of it.
  • The words of a table found gone are its own. At PostgreSQL, a table dropped while the pipeline writes to it is told it is not in the destination’s catalogue any more, and to make it again, then resume; it was told to contact us. At Snowflake, a target that is not listed is told it is not there any more, or that the pipeline’s role can no longer see it.
  • A PostgreSQL table stopped because its destination table lacks part of its mode’s shape says what a table built beside it and swapped in would keep: none of its rows, every earlier version or log row staying in the table swapped out. Giving the table what it lacks, in place, is offered first.

2026-11-06 (IST) — Query-based pipelines: offered to every account

Section titled “2026-11-06 (IST) — Query-based pipelines: offered to every account”
  • Query-based capture is offered to every account. GET /v1/me answers query_capture_enabled: true, the new pipeline form asks how to read a PostgreSQL source, and POST /v1/pipelines or a re-sync naming update_method query_based is taken. Reading the log stays the default and recommended method: a pipeline created without choosing reads the log, and nothing about an existing pipeline changes unless you re-sync it to another method.
  • A source column named like one of the destination’s own columns stops only its table, at the start, before anything changes. On a query-based pipeline, a source column named _reyansh_deleted_at or _reyansh_synced_at (in Snowflake, any spelling of its own names) stops its table before the destination table is changed, saying which column and how to block or rename it; the other tables sync on. PUT /v1/pipelines/{id}/tables/{table}/columns now takes blocked for such a column even before the pipeline has read it, so blocking it and resuming the table syncs the table without it.
  • A sync that copied one table and then failed on another is told as a failure at each retry. A query-based pipeline used to record such a copy as progress before it was saved, so a failure that keeps coming back was retried without ever being told.

2026-11-06 (IST) — A table kept in history mode or append-only is told only what is true of it

Section titled “2026-11-06 (IST) — A table kept in history mode or append-only is told only what is true of it”

Every sentence a table kept in history mode or append-only can meet was read against what the pipeline does, before the two modes are offered to every account. These changed:

  • A history or append-only table that loses its primary key at the source is stopped for its mode, with the remedy that works: give it a primary key, then resume it. It was told to drop its destination table and resume, which would have destroyed its versions and stopped it again. While nothing of it is written yet, keeping it in soft delete or live mode instead is offered too; once rows are kept in its mode, that request is said to wait until the table syncs again.
  • A PostgreSQL history or append-only table whose destination table lost part of its shape after it synced is told to give the table what it lacks, in place, and that resuming it catches up from where it stopped. It was told to build a new table beside it and swap it in, which a resume never copies into.
  • A destination column named under _reyansh_ in a PostgreSQL history or append-only table stops the pipeline naming the column, with the rename as its remedy. It said the pipeline would try again and to contact us.
  • At a Snowflake destination, a source column whose name a history or append-only table keeps for its own stops the table so that resuming it copies it again under the column’s new name, and the remedy says to rename the column first. Resuming it kept the stop.
  • A PostgreSQL table stopped for its mode’s statements shows the remedy for its own case (a history or append table’s shape, or a change of shape), not soft delete’s two columns.
  • The history and append-only help names the truncate rules as the page does (Keep its rows, Ask me); a mode refused, and a purge refused for a history or append-only table, are worded as what they are.
  • A Snowflake history table asked to switch by a defect of ours is restarted, never told that its destination needs a change.

2026-11-06 (IST) — A stop on a rejected value says when the pipeline’s json handling may be what refused the row

Section titled “2026-11-06 (IST) — A stop on a rejected value says when the pipeline’s json handling may be what refused the row”
  • A PostgreSQL pipeline set to stop on a rejected value now says so when a json column of the row may be what the destination refused, including a column the stop does not name. The pipeline writes json and jsonb columns through jsonb, which refuses a \u0000 escape and an unpaired surrogate escape that a json column stores. A NOT NULL or key json column holding one is never named by the stop, which names only the columns it could cut or empty, so the stop named another column’s value and left that out: changing the named column alone would not have cleared it. The stop’s message now adds that the pipeline writes json columns through jsonb, which also refuses those escapes, whenever a json column of the row holds a value jsonb refuses.

2026-11-06 (IST) — A column kept as text says why, by its type

Section titled “2026-11-06 (IST) — A column kept as text says why, by its type”
  • Snowflake, a fix for corrupted values: an array of box, PostGIS geometry or geography (or any type whose elements PostgreSQL separates by something other than a comma) was split on commas. A box[] landed cut inside each box, and two geometries landed as one string. Each array is now split by its element type’s own delimiter, read from your database’s catalogue. If a pipeline synced such an array into Snowflake, re-sync that table (the table’s Re-sync) so its rows are written again correctly.

  • PostgreSQL destination: the pipeline’s column view now says how each column lands: exactly, converted into the type your table declares, or as your database’s own text (where you declared text for, say, an interval). A json column says it is rewritten: PostgreSQL’s jsonb keeps one of a repeated key and reorders the keys.

  • Both destinations: a table’s column view had no line for its columns until the pipeline’s next start when the table was first copied. The line is now written as the copy finishes.

  • Snowflake: a column with no exact Snowflake type still lands as your database’s own text, and the pipeline’s column view now says which kind it is and what that means: an interval (months, days and seconds kept apart), money (formatted by your database’s lc_monetary, so $1,234.11 and 1.234,11 € are the same value), a network address, a geometric shape, PostGIS (hex EWKB with its SRID), XML, a composite, or a time with a time zone. A numeric kept as text says its NaN and infinities are kept as that text.

  • Snowflake, a fix: an array whose elements have no exact Snowflake type (money[], an array of a composite) was described as “converted into your table’s own type”. It is JSON whose elements are each your database’s own text, and the column view now says so.

  • API: GET /v1/pipelines/{id}/tables/{table_id}/columns returns these as each column’s landing word (interval_as_text, money_as_text, network_as_text, geometric_as_text, spatial_as_text, xml_as_text, composite_as_text, json_elements_as_text), and the API document now lists every word landing can carry. A client should show its own fallback for a word it does not know.

  • PostgreSQL destination, a fix: a column your table declares as a type the destination does not write (interval, money, inet, xml, a geometry, a composite, an array, time) stopped the table saying the column did not exist and to add it. It now says the column has a type this destination does not write, names the types it does, and says to declare the column text, which keeps each value exactly as your source sends it.

2026-11-06 (IST) — A destination is tested on its own, with no source

Section titled “2026-11-06 (IST) — A destination is tested on its own, with no source”
  • New: POST /v1/destinations/{id}/test runs a stored destination’s setup test with no source. No body; an Idempotency-Key is required, as on every mutating call. It runs the destination steps the connection test runs (destination_reach, destination_tls, destination_sign_in, destination_permissions, destination_table), each passed, warning, failed, unanswered, skipped or not_run, in the same words; a PostgreSQL destination’s are led by resolve, the lookup of its host. A Snowflake destination’s test runs its permission test, which creates a schema named _REYANSH_check_<time>_<random> and drops it, and the answer carries permission_test, grants_listing, privileges_disagree and left_behind as the connection test’s does. The answer (DestinationTest) has no field for a source. It shares the connection test’s limit of six a minute per account, its 504 check_timed_out, 500 check_unavailable and 500 check_unreadable answers and their details, and it records a connection.tested event.
  • The destination page’s Test asks for nothing. It used to ask for a source’s connection string, with its password, and a pipeline name, to test a destination that needs neither. It now runs the destination’s own test and shows each step, for a Snowflake and a PostgreSQL destination alike.
  • A step can now read unanswered (CheckStep.status, in the connection test and the destination’s own test): it ran and got no answer. A Snowflake destination’s destination_permissions reads unanswered when its permission test’s create went unanswered, or the test could not begin; it used to read passed. It always says why, it is never a pass, and it refuses nothing: the answer stays usable, as the permission test’s not_known does.
  • The destination page never says a test passed when it did not hear back: a test whose permission test gave no answer says so, and a pass says how many of its steps were skipped (a PostgreSQL destination’s permissions and table, a Snowflake one’s table) because no pipeline has picked a table yet.
  • The audit row of a destination’s own test says so: connection.tested gains tested (connection or destination), and its kind is the destination’s for the destination’s own test. A test whose step got no answer is recorded with outcome unanswered, never passed, so it raises connection_test.failed, never connection_test.succeeded.

2026-11-06 (IST) — A stop that needs you is titled by what stopped it

Section titled “2026-11-06 (IST) — A stop that needs you is titled by what stopped it”

The activity feed now says why a pipeline stopped and waits for you. Every such stop read “Stopped, action required”, which was true and named nothing: a Snowflake key revoked mid-run, a destination table already holding duplicate keys and a row whose key arrived NULL all looked alike until you read the sentence. Each now has its own title, for example “Stopped: your destination refused our access”, “Stopped: rows already in your destination stop the write” and “Stopped: a row’s key could not be read”. The sentence under the title is unchanged.

  • schema_stop_raised carries cause on GET /v1/pipelines/{id}/observations: a stable code for what stopped the pipeline, one of schema_change, truncated, key_unreadable, value_withheld, value_refused, rows_discarded, destination_access, destination_name, destination_setup, destination_rows, source_key, shaping, publication, keyless_change, source_setup, source_access, source_history, source_identity and table_replaced. New codes may be added; read an unknown one as “a stop that needs you”. A stop recorded before today has no cause, and keeps the title “Stopped, action required”.
  • table_parked and tables_parked_together now show their cause (the stable code a table was stopped for), and table_parked its held, tables_parked_together its session (the destination schema the tables share). The pipeline has recorded them since tables could stop one at a time; the feed left them out.
  • Nothing was renamed or removed. The event’s name is still schema_stop_raised, and every field it had is where it was. Emails, Slack messages and webhooks are unchanged: the stop’s email already says “syncing is blocked”, which is true of every stop.

2026-11-06 (IST) — A PostgreSQL key change that leaves a large value unchanged is read from the source

Section titled “2026-11-06 (IST) — A PostgreSQL key change that leaves a large value unchanged is read from the source”
  • An UPDATE that changes a row’s primary key while leaving a large (TOAST) value alone no longer stops the pipeline. Under REPLICA IDENTITY DEFAULT such a change carries no value for that column, and the pipeline used to stop at it. It now reads the value from your database, at the row’s new key, in one short read-only transaction that waits until the change is visible there, and writes the row whole. The history shows each read, with the table and the columns, never a value. The same read fills a row that moved into a publication’s row filter, which used to pause its table until it was copied again.
  • When the row is gone by the time it is read (a later change deleted it or moved it again), the row is never written with the value empty. Where the same batch also removes the new key and the destination table is kept live, the old key’s delete is written, which is what the whole row would have come to. Anywhere else that delete alone could lose a row, so only that table stops, saying why, and the others carry on: resuming it copies it again.
  • A read that cannot be right stops only its table, in its own words: the column or the table was dropped after the change, or the table’s name now belongs to another table (resuming copies it again), or the pipeline’s role may not read it, or a row security policy applies to that role (grant what it lacks, then resume). The pipeline stops only when its own replication slot is the synchronous standby the change’s commit waits for. A large batch’s read is bounded per statement, so its length never stops it. See A change to a row’s primary key.
  • The setup check’s advice for a table under REPLICA IDENTITY DEFAULT says so: it no longer says the pipeline stops at such a key change.

2026-11-06 (IST) — A busy Snowflake service user no longer stalls its pipelines at every restart

Section titled “2026-11-06 (IST) — A busy Snowflake service user no longer stalls its pipelines at every restart”
  • A Snowflake pipeline whose service user runs many statements starts again at once after a restart or a deploy. Before it writes, a pipeline reads Snowflake’s query history to rule out an earlier attempt’s statement still running. That reading counted every statement the user ran in the last 75 minutes and refused to go on at 10,000 of them, so a user running more than about two statements a second (one pipeline with many busy tables was enough) could not start for up to 75 minutes. The reading now covers one minute: Snowflake lists a statement still running or queued however long ago it began (recorded), so nothing it could see before is missed, and the limit is now more than 160 statements a second.
  • destination_table_taken on POST /v1/pipelines and POST /v1/pipelines/{id}/start now says how a Snowflake account is compared: by its identifier as written, so one account given as orgname-accountname on one destination and as its legacy locator (xy12345) on another is not recognised as one. The Snowflake guide says to give every destination on one account the same orgname-accountname. Behaviour is unchanged; the description used to say “the same account” without that limit.

2026-11-06 (IST) — A pipeline’s rows and bytes, table by table

Section titled “2026-11-06 (IST) — A pipeline’s rows and bytes, table by table”
  • New: GET /v1/usage/tables?pipeline_id=&from=&to= (members and read keys). One pipeline’s rows and bytes for each table it wrote over a range of UTC days (at most 400; 422 range_too_large beyond, or past 2,000 tables), by classification: normal (synced as it changed) and historical_load (copied). Each table’s figures are what the destination confirmed for that table, so they add up to the pipeline’s own rows and bytes in /v1/usage/days. What the pipeline measured without a per-table count (before per-table counts began, or by a release without them) is not_split, and split_since is the first day it has any, so the tables and not_split always add up. 422 missing_field without a pipeline_id.
  • A drill-down, never a price: rows and bytes are not priced, and compute (cpu and memory) is measured per pipeline and never divided by table, because one sync’s compute serves every table at once.
  • The pipeline’s Usage section shows the month’s tables, largest first, with what was copied apart from what was synced, and says from when per-table counts exist.

2026-11-06 (IST) — A type change stopped by your own clustering key says so

Section titled “2026-11-06 (IST) — A type change stopped by your own clustering key says so”
  • A Snowflake table whose column type change is stopped by a clustering key you set now names the cause. Snowflake does not rename a column that is part of a clustering key, and a type change it cannot make in place is applied by renaming. The table’s history now says the column is part of the table’s clustering key and gives the statement that frees it (ALTER TABLE … DROP CLUSTERING KEY), then resume, then set the key again; it used to read as a refusal with no reason. A pipeline still never sets or drops a clustering key itself.
  • A schema change the destination stopped itself is told in its own words. A change of a column’s type that could not go on (for the reason above, or because converting would have changed values) used to be told as “unexpected Snowflake response” and as a refusal of a statement the pipeline needs “before it can write”; it now says what stopped it. Any other refused setup statement names the step it was for, and one that timed out, was cancelled or got no answer says it did not complete rather than that Snowflake refused it. The statement it gives to free a column of your clustering key names the database too.

2026-11-06 (IST) — Time Travel days for every account, and an account’s minimum retention is told

Section titled “2026-11-06 (IST) — Time Travel days for every account, and an account’s minimum retention is told”
  • Every account can set a Snowflake destination’s Time Travel (days) when it creates the destination. POST /v1/destinations no longer answers 422 not_yet_available for settings.time_travel_days; GET /v1/me’s time_travel_enabled is now always true (kept for clients that read it).
  • When Snowflake keeps more days than the destination’s setting, the pipeline’s history says how many days it keeps for which schema or table (time_travel_not_applied), each time the pipeline starts, and names what can do that: the account’s minimum retention (MIN_DATA_RETENTION_TIME_IN_DAYS) or a stream on the table.
  • The form and the guide say Time Travel days are billed: Snowflake charges storage for the earlier versions it keeps.

2026-11-06 (IST) — How long a pipeline’s history is kept, stated; swept_before on the history

Section titled “2026-11-06 (IST) — How long a pipeline’s history is kept, stated; swept_before on the history”
  • The history now states how long it keeps events. Every event is kept for at least 31 days. Once a run has been over for 31 days, its per-batch rows (batch_applied) and its measurements (resource_consumed, retention_observed) may be removed, except the pipeline’s newest of each kind. The rows, bytes, CPU and memory they recorded stay in Usage; the source log readings (retention_observed) are not kept elsewhere. Every other event (starts, stops, errors, schema changes, copies and changes people made) is kept. The sentence is in the descriptions of GET /v1/pipelines/{id}/observations, its export, GET /v1/pipelines/{id}/runs and GET /v1/pipelines/{id}/runs/{run_id}, and in the guide.
  • GET /v1/pipelines/{id}/observations answers swept_before (RFC 3339, optional) once anything of the pipeline has been removed: runs that ended before it keep every event but those. Additive: a client that reads data and next_cursor is unchanged. A row’s sequence is never reused, so a gap in the sequence is a removed row.
  • Nothing is removed yet. The removal ships switched off and is turned on separately; the run history (the last 30 days) never loses a row, and a failed or still-running run keeps its rows longer.

2026-11-06 (IST) — The platform export: your account’s history, oldest first, for your own destination

Section titled “2026-11-06 (IST) — The platform export: your account’s history, oldest first, for your own destination”
  • New: GET /v1/exports/{stream}, six read routes a read API key may call: GET /v1/exports/pipelines, /v1/exports/events, /v1/exports/runs, /v1/exports/usage_days, /v1/exports/wallet_entries and /v1/exports/audit_events (an owner’s, as the audit log is; never an address or a user agent). Each serves rows oldest first, in an order a program can resume from with since (inclusive) without missing a row, paged by next_cursor; runs is the exception: each page is one read of the run history, every run of it whose changed_sequence (the position of its latest change: a row of its own, its closer, or a later give-up that ended it) is at or after since, in no promised order. events, runs and usage_days are read one pipeline at a time (pipeline_id is required): their order holds within a pipeline. The rows are the ones the history, the run list, usage, the ledger and the audit log already serve, never recomputed. How to read them so that nothing is missed: Exporting your account’s history into your own destination.
  • The words a column holds are the reference’s words: usage_days’ dimension is cpu, memory, rows_delivered, bytes_moved, egress_internet or storage (as GET /v1/usage/days says it; an open set), and pipelines’ update_method is logical_replication or query_based. Filter on these exactly.
  • Refusals: 422 invalid_field for a missing pipeline_id, a negative or non-integer since, or a since on pipelines (read whole every time); 404 pipeline_not_found for a pipeline that is not the account’s; 400 invalid_cursor for a cursor issued for another stream or another pipeline.

2026-11-05 (IST) — A pipeline being restarted sends one “retrying” notification, not one per attempt

Section titled “2026-11-05 (IST) — A pipeline being restarted sends one “retrying” notification, not one per attempt”
  • A pipeline whose restarted attempts are each refused with a reason now raises its retrying notification once. Every such attempt used to close the notification with “taken over by a stop … will not resume on its own”, sent to webhooks and Slack while the pipeline was being restarted, and raise it again with a new email. It now stays open until the pipeline recovers, is stopped, or stops being retried.

2026-11-04 (IST) — A pipeline whose restarts keep failing before they run reads “retrying” throughout

Section titled “2026-11-04 (IST) — A pipeline whose restarts keep failing before they run reads “retrying” throughout”
  • A pipeline that is being restarted reads retrying, with its alert, until a restart actually runs. Each restarted attempt records a few facts as it starts (how its destination connection is encrypted, a wait for another worker’s lock on the destination), and any of them ended the retrying word: a pipeline whose every attempt stopped before it ran (a destination that began a session and then answered nothing, say) read healthy, with no words, for most of each attempt, and its retrying alert was resolved and raised again at every attempt. It now stays retrying, showing what the newest attempt was told, until an attempt reaches its run, starts a copy, or the pipeline stops retrying.

2026-11-03 (IST) — Retried pipelines and account switching: retry times are the database’s, and a signed-out session cannot be switched

Section titled “2026-11-03 (IST) — Retried pipelines and account switching: retry times are the database’s, and a signed-out session cannot be switched”
  • A retrying pipeline’s “next attempt at”, and the 14 days after which it stops retrying, are kept on the database’s clock. They were stamped by the clock of whichever server made the attempt, and read back by another after a restart, so a server whose clock was off moved them by as much; an attempt made while our database was not answering was stamped by that server’s clock even after it came back. Every retry is now stamped by the database when it is recorded, from how long ago it happened, so the time shown and the 14 days are the same whichever server records or reads them.
  • Switching accounts from a session that was signed out in the meantime no longer signs you in to the other account. Signing out in another tab, or being removed, while a switch was in flight left the switch issuing a new session; it now answers as a session that has ended.
  • The schedule preview reads the server’s clock; a saved pipeline’s next runs read the database’s. The two can differ by the server’s drift, a few seconds at a run boundary, never a different schedule.

2026-11-03 (IST) — MySQL sources over TLS connect instead of stopping the worker

Section titled “2026-11-03 (IST) — MySQL sources over TLS connect instead of stopping the worker”
  • A MySQL source over TLS is now connected and checked by the sslmode it asked for. Before, the worker stopped on its first connection to such a source, before a row moved, and the setup form’s connection test answered with an error from us rather than its report. verify-full is the default, so this was every MySQL source that did not choose disable. Now require connects encrypted without checking the server’s certificate, and verify-full connects when the server’s certificate chains to a public certificate authority and names the server, and is refused by name when it does not. The fault was ours, in how the worker chose its TLS library at start-up, and never in the source’s settings.
  • No CA of your own can be supplied for a MySQL source yet (issue #1286). So verify-ca, which checks the server’s certificate against a CA you supply, is refused with that reason, and verify-full refuses a server whose certificate a public certificate authority did not sign, a self-signed one among them.
  • The connection test’s retryable for a MySQL source is now false when trying again unchanged cannot pass: a certificate that does not verify, an sslmode that cannot be honoured, and any error the server answered with, a wrong password among them. It stays true when the server did not answer at all, and when the server answered but a catalogue query then failed. It said true for every connection failure before, disable included. Its detail no longer begins “could not reach the server” unless nothing answered.
  • Nothing else changes for a MySQL source on disable, for PostgreSQL sources, or for Stripe and Snowflake: their connections are made exactly as before.
Section titled “2026-11-03 (IST) — Billing and sign-in: a day is billed only once the database has closed it, and sessions, sign-in links and invitations expire on the database’s clock”
  • A day’s usage is billed only after that day has ended by the database’s clock. Usage belongs to the day the database recorded it in, and the billing job used to judge “the day has ended” by its own process’s clock. A process running ahead of the database could bill a day while the database was still recording usage into it, and that last part of the day was then never charged; a process running behind billed late. Billing now judges every day, its pauses, its budget month and its bonus ladder by the database’s clock.
  • Sessions, sign-in links and invitations start and expire on the database’s clock. A session or a sign-in link lasts exactly its lifetime from when the database issued it, whichever server checks it, and an invitation reads “expired” in the members list, on its own page and at sign-in at the same instant.
  • A pipeline’s health, its alerts and its run history are judged by the database’s clock. “Late”, “stalled” and an alert’s age compare stored times with now; they are now compared with the database’s now, so a server whose clock drifts cannot call a healthy pipeline late or a late one healthy.

2026-11-03 (IST) — Notifications: a queued notification is sent on the database’s clock, whatever the clock of the process that sends it

Section titled “2026-11-03 (IST) — Notifications: a queued notification is sent on the database’s clock, whatever the clock of the process that sends it”
  • A notification queued for delivery is claimed as soon as it is due by the database’s clock. The queue stamps each delivery with the database’s time and the dispatcher compared that with its own process’s clock, so a process whose clock ran behind the database’s held every new notification back for the difference, and its leases and retries were measured on a clock the database did not keep. Every instant the dispatcher stores or compares is now the database’s.
  • A test notification’s event is dated by the database too, like every other event in the notification history.

2026-11-03 (IST) — Query-based pipelines: offered to an account once the operator switches them on

Section titled “2026-11-03 (IST) — Query-based pipelines: offered to an account once the operator switches them on”
  • Creating a query-based pipeline, or switching one to queries, is switched on per account (REYANSH_QUERY_CAPTURE, off until the operator turns it on). While it is off, POST /v1/pipelines with update_method query_based and POST /v1/pipelines/{id}/resync naming query_based answer 422 not_yet_available, and nothing is created or recorded; a pipeline that reads the log is created and re-synced as before. GET /v1/me says which with query_capture_enabled, and the new-pipeline form offers the choice of method only when it is true.
  • A partitioned table’s first sync after its copy reads nothing again however old its partitions are. A partition attached long before the copy (more than about two billion transactions earlier) was read whole again by that sync, every row told changed; it is now read from where the copy left it, like the rest.
  • A re-sync after your source changed a column’s type never rounds a value into the old column. On a query-based pipeline into PostgreSQL, a copy whose destination column cannot hold every value of the new type now waits for it, nothing copied, its sentence naming the statement that changes the column, as a pipeline reading the log does.

2026-11-01 (IST) — Single sign-on: a sign-in that waited its whole turn is always told so

Section titled “2026-11-01 (IST) — Single sign-on: a sign-in that waited its whole turn is always told so”
  • A sign-in whose wait for its turn ran out at the very moment it was being checked is now told what held it: “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), as every other sign-in that waited that long is. Before, one such sign-in in a busy minute could be told “Single sign-on is not working at our end right now” (#error=sso_unavailable), which was not true: nothing had failed.
  • The same holds if our own store failed in that same moment: the sign-in had waited its whole turn either way, so it is told to try again in N seconds rather than that single sign-on is not working, and the failure itself is still written to our logs, now as sso_callback_cut with the request’s id. A store failure while a sign-in still has time left is told “not working at our end” and logged, as before.

2026-11-01 (IST) — Self-hosted: seed-credential refuses a database role that bypasses row-level security

Section titled “2026-11-01 (IST) — Self-hosted: seed-credential refuses a database role that bypasses row-level security”
  • seed-credential now exits 2, writing nothing, when REYANSH_METADATA_URL connects as a superuser, a role with BYPASSRLS, a login that can become one, or a role a policy grants every account’s rows (such as reyansh_signin). It names the role and which of these it is, and says to connect as reyansh_app, the role the control plane itself already requires. As such a role, a -rotate could replace the credential another account keeps under the same reference, and say it had stored yours. Use the REYANSH_METADATA_URL from the control plane’s own environment file; nothing changes for an installation that already does.