Changelog: September 2026
2026-09-30 (IST) — A rate-limited 429 is no longer replayed to a retry with the same key
Section titled “2026-09-30 (IST) — A rate-limited 429 is no longer replayed to a retry with the same key”Fixed: retrying a 429 rate_limited or 429 provider_unavailable with the same
Idempotency-Key now executes the request. Before, the idempotency layer stored the refusal
and answered every later request carrying that key with it, for the key’s lifetime and without
its Retry-After header, so a client that waited as told and retried with the same key could
never succeed. These answers mean “not done, come back later”, so the key is now released and
the next attempt runs, with whatever body it carries.
Unchanged: every other answer is replayed, including a 4xx refusal and any 5xx. A 5xx
is indeterminate (the request may have acted), so retrying it with the same key returns the
same answer rather than risking a second effect. This matches Stripe’s documented behaviour.
(The app is unaffected: it uses a new key for every request.)
2026-09-30 (IST) — A Postgres source that writes nothing no longer restarts its pipeline
Section titled “2026-09-30 (IST) — A Postgres source that writes nothing no longer restarts its pipeline”Fixed: a pipeline whose Postgres source wrote no WAL for about a minute and a half lost its replication connection with “timed out after 90s during the read phase of connecting to the source database”, and restarted. A quiet source is healthy; the worker now asks the source to answer while it is quiet, so the connection stays up however long the source says nothing.
2026-09-30 (IST) — A Postgres source’s existing rows are copied a thousand at a time
Section titled “2026-09-30 (IST) — A Postgres source’s existing rows are copied a thousand at a time”Fixed: a pipeline’s first copy of a Postgres table wrote its rows to the destination one batch per row, because the source sends them one message per row. It now writes up to 1,000 rows, or 16 MiB, per batch. The copy is the same rows in the same order. Into Snowflake, where each batch is staged and merged once, it is much faster; a Postgres destination still writes a statement per row within the batch, so the change there is smaller.
2026-09-30 (IST) — A value your Postgres table would refuse is cut or written as NULL, and told
Section titled “2026-09-30 (IST) — A value your Postgres table would refuse is cut or written as NULL, and told”Changed, for a Postgres destination whose pipeline answers on_rejected_value = continue (the
default): a text value longer than its varchar(n) or char(n) column is cut to the column’s
length, as Fivetran cuts a too-long string, and a uuid or JSON value PostgreSQL would not parse
is written as NULL where the column allows NULL. The pipeline carries on. Until now either
stopped the pipeline. A value is changed only after your database refused it as sent, so a
column you widen takes the whole value from then on.
- Every change is on the feed as
values_fitted: the table, each column’s name, why (too_longornot_a_value), what was done (truncatedornulled) and how many rows. It never carries a value. - A key is never changed, a
NOT NULLcolumn is never NULLed, and understopnothing is changed: those values stop the pipeline, as before. - A NULL in a
jsoncolumn may be our check’s, not your value’s: it is markedour_cast.
2026-09-30 (IST) — A pipeline the supervisor gave up on steps aside from its table
Section titled “2026-09-30 (IST) — A pipeline the supervisor gave up on steps aside from its table”Changed: destination_table_taken no longer counts a pipeline the supervisor gave up on, so a
new pipeline may take over its Snowflake table. That is the remedy the worker itself names when it
stops a pipeline for good. Starting the given-up pipeline again is asked the same question:
POST /v1/pipelines/{id}/start answers 422 destination_table_taken, naming the pipeline that now
writes the table, and records nothing.
2026-09-30 (IST) — A Snowflake table is written by one pipeline
Section titled “2026-09-30 (IST) — A Snowflake table is written by one pipeline”New error: 422 destination_table_taken from POST /v1/pipelines. When another pipeline
in your workspace already writes the
Snowflake table a stream would land in, the request is refused, and the message names that
pipeline and the table. Two pipelines writing one table would overwrite each other’s rows.
- The table is identified by where it lands: account, database, schema and table, with the
names folded to upper case as Snowflake folds unquoted names. Two destinations configured at the
same schema therefore share its tables, and
Ordersandordersare one table. Two databases whose names differ only by case are treated as one: a refusal you can see, rather than a double write you cannot. - Only your workspace is compared. A pipeline in another workspace writing the same Snowflake table is not seen.
- Snowflake is not yet offered. Postgres destinations are not checked yet (#1133).
2026-09-30 (IST) — A pairing the destination does not accept is refused up front
Section titled “2026-09-30 (IST) — A pairing the destination does not accept is refused up front”New error: 422 unsupported_pairing. A pipeline reading a source into a destination whose
card does not list that source’s kind in sources is refused at POST /v1/pipelines,
POST /v1/pipelines/{id}/start and POST /v1/connections/test, with a message naming both
kinds, rather than being created and then failing when it starts. A start is refused whether or
not the pipeline has run before, and nothing is stored or recorded by a refused request.
2026-09-30 (IST) — A destination card lists the sources it accepts
Section titled “2026-09-30 (IST) — A destination card lists the sources it accepts”New: a destination card in GET /v1/connectors may carry sources, the source kinds a
pipeline may read into it; a card without it accepts every source. The Snowflake card lists
["postgres"] (Snowflake is not yet offered).
2026-09-30 (IST) — A value refused before it is sent is described by its shape
Section titled “2026-09-30 (IST) — A value refused before it is sent is described by its shape”Fixed: a value we refuse before sending it to PostgreSQL (a number too wide for its column, a
timestamp in another DateStyle) was quoted in the error, up to 60 characters of it. It is
now described by its shape, with every letter and digit masked: 07/27/2026 10:00 reads
99/99/9{4} 99:99, and a long run is written by its length. The shape still tells you what is wrong; the value stays in your systems.
2026-09-29 (IST) — A refused value is described, never repeated
Section titled “2026-09-29 (IST) — A refused value is described, never repeated”Fixed: an error about a value your destination refused could repeat the value itself. When
PostgreSQL refuses a value (for example, text that is not a valid uuid), its message quotes that
value. Your data never belongs in our logs or on your activity feed, so that message is now
replaced by its SQLSTATE and a sentence of ours, such as 22P02: a value is not valid input for its column's type. Messages that name only tables, columns, constraints or privileges are
unchanged.
2026-09-29 (IST) — Choose in the app whether a discarded row stops a pipeline
Section titled “2026-09-29 (IST) — Choose in the app whether a discarded row stops a pipeline”New in the app: “Rows your destination discards”, on the New pipeline form and on each pipeline’s page. Choose Keep syncing (the default, preselected) or Stop the pipeline for a row your destination accepts and does not keep, without an error. Each choice says what it costs: with Stop, nothing after the row is marked as synced, and while the pipeline is stopped your source keeps its change log for it. On a pipeline’s page, Save sends a changed answer and a running pipeline restarts onto it on its own. Guide: Rows your destination discards.
2026-09-29 (IST) — A pipeline that stops at start-up is not stopped for good unless we could tell you why
Section titled “2026-09-29 (IST) — A pipeline that stops at start-up is not stopped for good unless we could tell you why”Fixed: a pipeline that refused to start could stop for good with nothing on its activity feed when the note explaining the refusal could not be saved. It is now retried until the note is saved, and only then stops.
2026-09-29 (IST) — A pipeline set to stop stops on a discarded row
Section titled “2026-09-29 (IST) — A pipeline set to stop stops on a discarded row”A pipeline whose on_discarded_row is stop now stops on a row your destination discards.
The row is reported first and nothing after it is marked as synced, in the initial copy and the
stream alike, so once your destination keeps the row, starting the pipeline again writes it.
2026-09-29 (IST) — A source that asks for an authentication method we do not support stops and says so
Section titled “2026-09-29 (IST) — A source that asks for an authentication method we do not support stops and says so”Fixed: a Postgres source whose pg_hba.conf asks our user for GSSAPI, SSPI or SCM
authentication was retried until the pipeline gave up, with nothing but restart notices on its
activity feed. The pipeline now stops at once and its feed names the method and says to allow
scram-sha-256 for that user instead.
2026-09-29 (IST) — A pipeline’s discarded-row answer can be changed
Section titled “2026-09-29 (IST) — A pipeline’s discarded-row answer can be changed”New: PUT /v1/pipelines/{id}/discarded-rows with {"on_discarded_row": "stop"} or
"continue" changes what a pipeline does with a row your destination discards (see the entry
below). It needs an Idempotency-Key, like every write, and responds with the pipeline. A
running pipeline restarts onto a changed answer on its own; sending the answer it already has
changes nothing and restarts nothing. Any other value is refused with 422 invalid_field, and
a body without on_discarded_row with 422 missing_field. A field left out of the body is left
as it is, so settings added to this endpoint later will not change what an existing request
does.
2026-09-29 (IST) — A pipeline says what to do with a row your destination discards
Section titled “2026-09-29 (IST) — A pipeline says what to do with a row your destination discards”Added: on_discarded_row on a pipeline, continue or stop, for a row your destination
accepts and does not keep (a trigger or rule that discards it). continue reports the row on
the activity feed and in an alert and keeps replicating. stop reports it and stops the
pipeline until you start it again. Every discarded row is reported either way.
POST /v1/pipelinestakes it as an optional field. Leave it out forcontinue.GET /v1/pipelinesandGET /v1/pipelines/{id}return it on every pipeline, and so does every other response that returns a pipeline. Existing pipelines readcontinue, which is what they already do.- Any other value is refused with
422 invalid_field.
stop is recorded and shown from today.
Corrected 2026-09-29 (IST): this entry said a pipeline set to
stopwould keep replicating until a later worker release. That release is the entry “A pipeline set tostopstops on a discarded row”:stopnow stops.
2026-09-29 (IST) — A schema change met during a pipeline’s first copy is shown on its activity feed
Section titled “2026-09-29 (IST) — A schema change met during a pipeline’s first copy is shown on its activity feed”Fixed: when your destination table changed in a way that needs your decision while a pipeline was copying its existing rows, the pipeline was retried with nothing on its activity feed saying why. It now shows the same “Schema change needs attention” entry it shows once the pipeline is streaming. And a fault of ours met during the first copy is now retried, as it is while streaming, rather than stopping the pipeline as though your configuration were wrong.
2026-09-29 (IST) — A source that is briefly unreachable as a pipeline starts is retried, not stopped
Section titled “2026-09-29 (IST) — A source that is briefly unreachable as a pipeline starts is retried, not stopped”Fixed: a Postgres source that went away while a pipeline was checking where to resume stopped the pipeline for good, reported as a configuration fault that a restart could not fix. It is now retried like any other unreachable source at start-up, and the pipeline resumes once the source is back. A resume the source genuinely cannot serve (a replication gap, a slot that was invalidated or dropped) still stops the pipeline and says why on its activity feed, because choosing how to recover from it is your decision. So does a source that refuses the check, such as a user without permission to read its replication slots, since only you can grant it.
2026-09-29 (IST) — The rows_discarded alert says how many rows each table lost
Section titled “2026-09-29 (IST) — The rows_discarded alert says how many rows each table lost”Added: rows_by_table on a rows_discarded alert (GET /v1/alerts,
GET /v1/pipelines/{id}/alerts): for each table in tables, how many rows your destination did
not keep in the last 24 hours. A row reported twice, because a restart replayed the batch or
re-ran the initial copy, is counted once. When tables_partial is true every count is a lower
bound, and the app says “at least”. A table can be in tables with no count: its source’s
positions cannot be ordered (MySQL today), so a replay cannot be told apart and we show no number
rather than a guess. The Alerts page and the pipeline banner show each table’s count.
2026-09-29 (IST) — The initial copy carries on through a row your destination discards
Section titled “2026-09-29 (IST) — The initial copy carries on through a row your destination discards”Changed: a row that a trigger or rule on your Postgres destination table discards during the
initial copy no longer stops the pipeline. The copy reports it on the activity feed as a
rows_discarded entry, as it does for streamed changes, finishes, and the pipeline goes on to
stream. The copy’s row count is the rows your destination kept. Each copy entry carries a
copy_chunk number, which, with the entry’s run, identifies it. The same rows can be reported
more than once, each time under a different run: when a pipeline restarts before its copy is
saved it copies again, and a worker being replaced can finish a copy that is then not saved.
If you total these entries, count those of one run only: the latest run in which a
snapshot_completed entry is followed by a checkpoint_advanced entry, which is the run whose
copy was saved. If no run has both, count the run with the latest snapshot_completed. The
feed can be filtered by run_id. Entries from any other run describe rows that were copied
again. This replaces the earlier behaviour in the entry below, where the copy stopped on a
discarded row. A copy that falls short by rows nobody reported still stops. That can only
happen through a defect on our side, since every row your destination was sent is accounted
for, so its message now says so, says the pipeline will not be retried automatically, and asks
you to report it before starting the pipeline again. A copy entry on the feed no longer shows
from_cursor and to_cursor as null; it leaves them out.
2026-09-29 (IST) — A discarded row is told in plain words, and raises a rows_discarded warning
Section titled “2026-09-29 (IST) — A discarded row is told in plain words, and raises a rows_discarded warning”New alert kind: rows_discarded, a warning (severity: "warning", blocks: false) on
GET /v1/pipelines/{id}/alerts and GET /v1/alerts. It is raised while your destination has
discarded rows in the last 24 hours (the newest rows_discarded entry on the pipeline’s feed is
less than 24 hours old), and it clears on its own a day after the last one. It does not change
the pipeline’s health: the pipeline carried on. A paused pipeline raises no alerts, this one
included. It sends no email yet.
It names the tables: tables lists the destination tables that discarded rows in the last
24 hours, newest first, each once, and tables_partial: true says the list may be missing some
older ones (a pipeline discarding on every batch). Both appear on rows_discarded only. The
Alerts page names up to three tables and counts beyond that. The row count is on each feed entry,
not yet on the alert.
The feed tells each rows_discarded entry as a sentence: how many rows, the table, the
likely cause (a trigger or rule on the table that skips rows), the key columns that identify
them, and whether the pipeline or the initial copy carried on.
GET /v1/alerts may now return up to 3 alerts more than limit (it was 2), because one
pipeline can raise one more kind at once.
2026-09-29 (IST) — A row your Postgres destination discards is shown on the feed, and the pipeline carries on
Section titled “2026-09-29 (IST) — A row your Postgres destination discards is shown on the feed, and the pipeline carries on”Changed: when a trigger or rule on a Postgres destination table discards a row, the pipeline
now reports it and keeps replicating. Until now it stopped on that batch. The activity feed
shows a rows_discarded entry naming the table, how many rows were not kept, the key columns
that identify them, and the likely cause. The pipeline continues with the next change. Rows the
destination discarded are not counted as rows delivered, and their data is not counted in data
moved.
This applies to changes streamed after the initial copy. During the initial copy a discarded
row still stops the pipeline, as before, with the same explanation and next step; the feed
now also shows a rows_discarded entry for it, saying the copy stopped. Carrying on during the
copy comes in a following release. If a pipeline stops and restarts between reporting a discard
and recording its progress, the same discard can be reported twice, and the second report can
cover a wider range of positions than the first. If you total these entries, count a streamed
entry only when its from_cursor is past the to_cursor of the last entry you counted. An
entry from the initial copy has no positions and describes one attempt at the copy. A setting to
make a pipeline stop on a discarded row instead of continuing comes later.
2026-09-28 (IST) — A replication slot moved during the initial copy is refused, naming both positions
Section titled “2026-09-28 (IST) — A replication slot moved during the initial copy is refused, naming both positions”Fixed: a replication slot moved by someone else during the initial copy now stops the pipeline
instead of silently skipping changes, whether or not the pipeline restarts. The pipeline reads
the slot’s position before the copy starts and compares it again before streaming. If the slot
was advanced in the meantime (for example with pg_replication_slot_advance, to relieve WAL
pressure on a long copy), the changes committed between the two positions can no longer be
read, so the pipeline stops. Its automatic restart then refuses to continue, names both positions
on the activity feed, and does not repeat the copy.
2026-09-28 (IST) — A restart after the initial copy no longer copies the table again
Section titled “2026-09-28 (IST) — A restart after the initial copy no longer copies the table again”Fixed: a Postgres pipeline restarted after its initial copy resumes where the copy left off, instead of copying the whole table again. The copy of a table’s existing rows wrote no resume point, so until the table’s first change after the copy reached the destination, every restart (a deploy, a crash, a moved worker) read the pipeline as never synced and copied the table from the start: hours of load on the source database, compute billed for it, and the replication slot holding the source’s log all the while. A completed copy now records where its changes are replayed from, and a restart resumes from there.
The resume point is the replication slot’s position read before the copy started.
Not yet covered: a replication slot moved by someone else during the copy (for example with
pg_replication_slot_advance, to relieve WAL pressure on a long copy). The changes committed
between the two positions are still skipped, as before, unless the pipeline happens to restart
within the first seconds after its copy. A check that stops the pipeline and names both
positions is coming in the next change.
A copy interrupted part-way still starts again from the beginning; resuming a copy part-way is separate work.
2026-09-28 (IST) — A replication slot the server has invalidated is refused before any copy, naming why
Section titled “2026-09-28 (IST) — A replication slot the server has invalidated is refused before any copy, naming why”Fixed: a replication slot the server has invalidated is now refused before any copy, naming
why, instead of re-copying on every restart. Postgres invalidates a slot when it removes the
log the slot was holding (the slot fell further behind than max_slot_wal_keep_size), when the
slot sat unused past idle_replication_slot_timeout (PostgreSQL 18), or, on a standby, when rows
or wal_level it needed are gone. An invalidated slot can never stream again. The pipeline read
its last confirmed position, which survives invalidation, and carried on: a first run copied the
whole table and then failed to stream, reported as a server problem that would be retried, and
every retry copied the table again.
The pipeline now stops before it copies or streams anything, and stays stopped rather than being
restarted into the same slot. The activity feed names the slot, gives the server’s reason in
plain words (its invalidation_reason: wal_removed, idle_timeout, rows_removed or
wal_level_insufficient), and says what to do. It names the setting to change first (raise
max_slot_wal_keep_size or idle_replication_slot_timeout, restore wal_level = logical, or
keep a standby’s hot_standby_feedback on), because a new slot under the same limit is
invalidated again during the next initial copy. Then it gives the statements that recreate the
slot, and asks for a re-sync with a fresh copy, because the changes the old slot was holding
cannot be read.
A first run is also refused, before copying, when its slot has already fallen further behind
than max_slot_wal_keep_size allows (wal_status unreserved): the source would discard the
log at its next checkpoint, during the copy. Raise the setting, or recreate the slot just before
starting. Retention monitoring treats an invalidated slot the same way, including one invalidated by
idle_timeout, which previously still reported the WAL it held as an ordinary reading.
Not covered: a slot invalidated in the moment between this check and the stream starting. It fails when streaming starts, as before, and the next start refuses it by name. On a first run that costs one extra initial copy.
2026-09-28 (IST) — A Postgres destination no longer reports a row as written when a trigger on your table discarded it
Section titled “2026-09-28 (IST) — A Postgres destination no longer reports a row as written when a trigger on your table discarded it”Fixed: a row that a trigger on your Postgres destination table discards is no longer counted as
written. A BEFORE INSERT or BEFORE UPDATE trigger that returns NULL tells Postgres to skip
the row, and Postgres reports no error when it does. Until now the pipeline counted every insert
and update as at least one row written, whatever Postgres reported. So a skipped row was reported
as delivered, and the pipeline moved on without it. The pipeline now stops on that batch. It says
how many rows Postgres wrote and how many it was sent, and tells you to look for such a trigger.
If you filter rows with a trigger on a destination table, your pipeline will now stop on the
first row the trigger discards, instead of carrying on without it.
When Postgres reports that it wrote nothing, the pipeline checks whether your table already
holds the row exactly as it was sent. If it does, the row counts as delivered. That happens on a
table with a trigger that skips updates that change nothing, such as Postgres’s own
suppress_redundant_updates_trigger, when a pipeline resumes and sends rows it had already
written, or when your source sends an update that changes nothing. If your table holds something
different, the pipeline stops. So a table with one trigger that rewrites rows and another that
skips unchanged updates stops on every such write, including any update from your source that
changes nothing, which many applications send routinely.
The check runs only when Postgres reports that it wrote nothing. A row that is written costs what it cost before.
Also changed:
- A first sync that copies your existing rows stops, and is not restarted, when a trigger discards a copied row. Until now it would have been restarted, copying the whole table again and stopping on the same row each time.
- Deleted rows are no longer counted in rows delivered for a Postgres destination, in
/v1/usageand the activity feed. Only inserted and updated rows count, as they already did for the Snowflake destination. This number has no price, so no charge changes.
A rule or a row-level security policy that refuses a row already stopped the pipeline with Postgres’s own error, and still does. A delete that a rule or policy discards still cannot be told apart from a delete of a row that was already gone, because Postgres reports 0 rows for both.
2026-09-27 (IST) — A pipeline resuming from a slot moved by something other than Reyansh is now refused
Section titled “2026-09-27 (IST) — A pipeline resuming from a slot moved by something other than Reyansh is now refused”Fixed: when a pipeline resumes from its last checkpoint, a replication slot moved by something
other than Reyansh is now refused with its positions named, instead of skipping the changes in
between. If a Postgres slot is advanced with pg_replication_slot_advance, read by a second
consumer, or recreated, the slot can be ahead of the last position the pipeline delivered.
Postgres then resumes from the slot’s position, not the pipeline’s, and the changes committed
between the two were skipped without an error.
The pipeline now stops before it streams anything. The activity feed says “replication gap” and
names both positions: the last one delivered, and the earliest position the slot will resume from
(its confirmed_flush_lsn). Nothing is skipped and nothing is re-copied without you choosing it.
Not covered yet: the first run. A first run has no checkpoint to compare, and replays from wherever the slot sits after the initial copy. So a slot moved while the initial copy is running still skips the changes in between without an error. Tracked in #967, which records the slot’s position before the copy and resumes from it.
2026-09-27 (IST) — A soft-deleted row keeps what the source last wrote to it, however the changes were batched
Section titled “2026-09-27 (IST) — A soft-deleted row keeps what the source last wrote to it, however the changes were batched”Changed: a destination that keeps deleted rows (soft delete) now holds each one with the values the source last gave it. Until now, some deleted rows came out differently depending on whether the changes arrived in one flush or two:
- A row changed and then deleted in one flush kept the values it had before the change.
- A row created and deleted in one flush left no deleted row at all.
The same changes spread across two flushes left what the source had. So which rows showed as deleted, and what they held, depended on the flush interval. Now they hold the source’s last values whatever the batching. Rows that are not deleted were never affected.
Where this applies. Soft delete is the default for the Snowflake destination, which is not available yet; the catalogue lists it as planned. This is in place before it ships.
Nothing changes for a destination that removes deleted rows, such as Postgres. It is given exactly the writes it was given before.
What it costs under soft delete. A row changed or created and then deleted in one flush is now two writes where it was one, the change and the delete. Those rows and bytes are recorded in your usage as data moved, as they already were whenever a flush fell between the two changes. Data moved is recorded but not priced: you are billed for compute.
2026-09-27 (IST) — A Postgres destination accepts a date or timestamp past the year 9999
Section titled “2026-09-27 (IST) — A Postgres destination accepts a date or timestamp past the year 9999”Fixed: a Postgres destination no longer stops on a date or timestamp whose year has more than
four digits. PostgreSQL stores dates up to the year 5874897 and timestamps up to the year 294276.
Until now the Postgres destination refused any such value, and the error said your source was
using a non-ISO DateStyle and told you to change it. That setting was already right. A date
primary key past the year 9999 was also refused, as if it carried a time of day.
These values are now written as the source sent them, as a value or as a key, and can be deleted
by key. A date in the source’s other DateStyle formats, such as 07/27/2026, is still refused
with the DateStyle message, because that is the case it is for.
2026-09-27 (IST) — A pipeline that stops on a key it cannot follow now says why, and is not restarted
Section titled “2026-09-27 (IST) — A pipeline that stops on a key it cannot follow now says why, and is not restarted”Changed: when a pipeline stops because it cannot tell which row a change belongs to, it stops once, says why in the activity feed, and is not restarted into the same stop. This covers a key column the source did not send, sent as NULL, or that a row does not have at all; and a primary-key change that leaves out a large column the pipeline cannot fill in. Each of these stops on a change that is already in the source’s log, so a restart reads the same change and stops again.
Until now the pipeline was restarted after each of these stops, several times, until the restarts ran out, and all you were told was that it had restarted too often. The feed entry for a large column left out of a key change appeared once per restart. Now the feed shows “Schema change needs attention” once, with the table, the column and what to change at the source. It never shows a value or a key. The pipeline shows “Needs attention” straight away rather than after the restarts. Its detail page still gives the general reason (“a human must change something”); the feed entry is where the specific one is.
A stop that a restart can get past, such as a lost connection, is restarted as before. So is one whose entry could not be written to the feed, so that the next start can write it.
2026-09-27 (IST) — A pipeline that stops on a key change it cannot complete now says which table and column, on the feed
Section titled “2026-09-27 (IST) — A pipeline that stops on a key change it cannot complete now says which table and column, on the feed”Changed: when a primary-key change leaves out a large column the pipeline cannot fill in, the
stop now appears in the pipeline’s activity feed, in its own words. A key change on a Postgres
table with the default REPLICA IDENTITY does not carry a large column it left unchanged, and
the pipeline stops rather than write the row at its new key with that column empty (see “A row
whose primary key changes no longer leaves its old row behind”, below). Until now that stop
reached you only as “restarted too often”. The feed now shows “Schema change needs attention”
with the table, the columns and what to set at the source. It never shows a value or a key.
Nothing else about the stop changes yet. The pipeline is still restarted and stops at the same change again, so the entry can appear once per restart until the restarts run out (#936). Reading the missing value from the source instead of stopping is being built; when it ships, each read will show in the feed as a separate entry, with the table, the columns and how many rows were read.
2026-09-27 (IST) — A pipeline whose worker keeps failing says so, backs off, and gives up after 14 days
Section titled “2026-09-27 (IST) — A pipeline whose worker keeps failing says so, backs off, and gives up after 14 days”Fixed: a pipeline whose worker failed a little while after every start was restarted for ever,
and read healthy. A worker that failed more than about 12 seconds after each start never
reached the limit that stops a crash loop (five restarts in a minute), so it was restarted every
few seconds, indefinitely. Each restart read your source again and was metered, and nothing
said anything was wrong: no alert, no email, and no end.
Now failures are counted between progress: a checkpoint saved, or a sync completed. A failure after progress starts the count again. So does a run that stayed up for an hour, so a quiet source whose connection drops once a day is not treated as failing. An initial copy of your existing rows is not progress until the pipeline has saved a checkpoint after it: a copy that stops starts again from the beginning, and so does one that finished but was lost before its first checkpoint. So a copy that keeps failing is a failure however long each attempt ran.
- From the second failure in a row with nothing delivered,
healthisretryingand theretryingalert is raised (the same word and alert a pipeline gets while it retries reading its credentials). They stay while the worker is restarted and runs again, and clear when it makes progress. While a restarted worker is copying your existing rows and writing them, the pipeline readsincomplete, as any copy in progress does; if that copy fails, it readsretryingagain. One gap, stated: a worker that recovers on a source with nothing new to deliver has nothing to show for it, so the pipeline keeps readingretryingfor up to an hour after it recovered, until it has stayed up that long. - A case this does not cover, stated: a worker that saves a checkpoint on every attempt and
then fails soon after has made progress each time, so each failure starts the count again. It is
restarted quickly, as before, and reads
healthy. Fivetran shows every failed sync; here such a pipeline is visible in its history (each exit and restart) but not in its status. This is being looked at separately. - Every restart from the second failure in a row is in the pipeline’s history as
launch_retrying, with areasonnaming how the worker stopped (its exit code, never its output), theattempt(which failure in a row, from 2),failed_atandnext_attempt_at. In the console this row now reads “Failed, retrying”. The first failure of a streak is restarted without a row. If our own database refuses the row for the whole wait, it is dropped rather than written after the next attempt has started (where it would be read as a new failure), and the next failure writes its own. - The first restarts are still quick, so a worker that fails as it starts is still given up on
within about a minute, as before. After five quick restarts with nothing delivered, restarts
follow Fivetran’s schedule: every 5 minutes to 1 hour (by the pipeline’s sync frequency) for a
day, at the sync frequency until 72 hours, then daily. After 14 days of failures in a row, the
pipeline gives up:
broken, with the reason in its history, and it is not restarted until you start it. A give-up counts toward the failure email as before. Restarts between two give-ups do not hide the first from it, however many there are; and, as before, a give-up that comes after the pipeline has been working for a while is not counted as the second in a row.
Not yet, and stated rather than implied (tracked in #961, as for retried credential reads):
- No email is sent for a restart. Fivetran emails from the second consecutive failure; here the
pipeline shows
retryingand raises its alert, and the failure email is sent only for the second give-up in a row. - The count starts again whenever our service restarts, which it does on every deploy. So the 14-day limit is reached only between deploys; until then a failing pipeline keeps being restarted on the schedule, visibly.
2026-09-27 (IST) — Turning email off and on again stops an email already waiting, as turning it off does
Section titled “2026-09-27 (IST) — Turning email off and on again stops an email already waiting, as turning it off does”Fixed: an error email already waiting to be sent still went out if, before it was sent, you turned error email off and back on, or cleared your notification address and entered it again. Turning error email off, or clearing the address, stops a waiting email (see “Turning email off also stops the email that was already on its way”, below). But the check before sending looked only at your settings as they then stood, so if you switched back before it ran (within about a minute), it saw email on, with an address, and sent it. Whether you were emailed depended on when we happened to check.
Now a waiting email is checked the same way as a pipeline that has just stopped: against the moment the pipeline stopped. If error email was turned on, or an address was entered, after that moment, the email is not sent, and it is recorded as not sent, with the reason. Changing from one address to another, or turning warnings on or off, does not stop an email that is due, and a pipeline that stops after you turn email back on is emailed about as usual. As before, the record is kept so support can tell you what happened; nothing in the console shows it yet.
2026-09-27 (IST) — A Postgres source now uses TLS, verified by default
Section titled “2026-09-27 (IST) — A Postgres source now uses TLS, verified by default”Fixed: a Postgres source’s connections were unencrypted, and a URL that asked for TLS
could not be used. With no sslmode in the URL, the change stream, the initial copy of your
existing rows and the catalogue reads all crossed the network in the clear, with nothing to say
so. A URL asking for sslmode=require stopped the pipeline with a TLS error that did not say why,
and verify-ca or verify-full were refused as an invalid URL.
- A Postgres source now uses TLS, and verifies the server by default. A URL with no
sslmodenow meansverify-full: the connection is encrypted, the server’s certificate must chain to a certificate authority in the operating system’s trust store, and it must name the host in your URL in its subjectAltName. - ⚠ Check your source before its next start.
verify-fullrefuses a certificate that does not chain to the operating system’s store, which includes a self-signed certificate and the certificates Amazon RDS and Google Cloud SQL issue from their own CAs. It also refuses a certificate that names its host only in the common name (CN), whichpsqlaccepts. For any of these, addsslmode=requireto the URL for now: the connection is encrypted, and the server’s certificate is not checked. Uploading your CA so the certificate can be verified is coming next. - A URL that asks for TLS is never silently downgraded. Under
require,verify-caorverify-full, a server that does not offer TLS is refused with a message naming the mode and saying the server does not offer TLS; a certificate that does not verify is refused naming why (an unknown CA, a name that does not match, an expired certificate). A reply that breaks the TLS handshake is refused too. The pipeline stops and says so on its feed rather than retrying. - Every
sslmodeworks, in libpq’s spelling:disable,allow,prefer,require,verify-ca,verify-full.sslmode=disablestill works, with a warning logged on every start that the source’s data travels unencrypted;allowandpreferwarn the same way whenever they end up without TLS. sslrootcertin the URL accepts onlysystem(the operating system’s store, withverify-full). A file path there is refused: the URL is yours, and the file it names would be on our machine.
If your source’s server does not offer TLS at all, a pipeline whose URL has no sslmode will
now stop at its next start with the message above. Either enable TLS on the server (ssl = on) or
add sslmode=disable to the URL deliberately.
2026-09-27 (IST) — A manual pipeline syncs once, and again only when you start it
Section titled “2026-09-27 (IST) — A manual pipeline syncs once, and again only when you start it”Fixed: a pipeline on a manual schedule whose source finishes its sync (Stripe) was synced again seconds after each one finished, for as long as it existed. Finishing was recorded as “stopped” while you still wanted the pipeline on, and the service starts any pipeline that is wanted on and stopped. Every one of those syncs read your source again and was metered like any other, and every one succeeded, so nothing looked wrong.
Now a finished sync with nothing due is reported as status: completed (the value added in
the entry below), and the pipeline stays at rest until you ask for the next sync:
POST /v1/pipelines/{id}/starton a completed pipeline is “sync now”:statusmoves tostopped, the pipeline starts within one reconciliation interval, runs one sync, and iscompletedagain. Thenoticeon a completed pipeline says so. Stopping a completed pipeline leaves itcompleted.- Moving a completed pipeline onto an interval or a cron schedule resumes it: the schedule
PUTmoves it tostopped, it syncs once and then on the new schedule. Saving a manual schedule leaves it at rest. A schedule change never moves a running or given-up pipeline. - Changing a manual pipeline while its sync is running (its schedule, or anything else) takes effect: when that sync finishes, the pipeline starts again on the new definition rather than resting on the old one.
- Switching an interval pipeline to manual runs one sync straight away, then rests. That sync is the restart every definition change already causes, and it is metered like any other; before this fix the manual pipeline then kept syncing for ever.
Pipelines on an interval or cron schedule are otherwise unchanged: between runs they stay
running.
2026-09-27 (IST) — A brief fault in our database no longer stops a pipeline starting
Section titled “2026-09-27 (IST) — A brief fault in our database no longer stops a pipeline starting”Fixed: if our own database failed for a moment while a pipeline was starting, the pipeline gave up, and you had to press start. Starting a pipeline begins by reading its saved credentials. A brief fault in that read (a dropped connection, a busy database, a read that took too long) was recorded as the pipeline giving up, although nothing was wrong with it. Now it is retried on its own, on the same schedule Fivetran uses: every 5 minutes to 1 hour (by the pipeline’s sync frequency) for a day, at the sync frequency until 72 hours, then daily. A credential that is missing or cannot be decrypted, or a connection our database refuses for a reason waiting does not change, still stops the pipeline at once.
Added: health can be retrying, and an alert of kind retrying is raised meanwhile.
While it retries, nothing is syncing, so the pipeline says so: retrying on every endpoint that
returns a pipeline, and a retrying alert in the Errors column (it blocks syncing). Both
describe the pipeline’s CURRENT start only: stopping it clears them, and a start after a stop
does not inherit them. They clear when a retry starts the pipeline. If your client lists the
values of health, or the alert kinds, add this one. One gap, stated: when a retried read
succeeds, the pipeline keeps reading retrying until its worker reports that it has started,
normally seconds later; a worker that fails before that point keeps the word, and the reason,
until it gives up.
Added: every retried attempt is in the pipeline’s history, as a new event kind,
launch_retrying, with reason, attempt, failed_at and next_attempt_at. If your client
lists observation kinds, add this one. A retried attempt is not a failed sync, so it does not
count toward the failure email, and it no longer hides an earlier failure from it.
Fixed: reading a pipeline’s credentials now has a time limit (10 seconds). A read that hung
used to leave the pipeline showing as running while nothing ran; now it is retried like any
other brief fault, and shows as retrying while it waits.
Corrected: GET /v1/alerts said a page may carry up to three more alerts than limit. One
pipeline raises at most three alerts at once, so a page carries at most two more; the summary
now says so.
Not yet, and stated rather than implied (tracked in #961):
- The schedule starts again whenever our service restarts, which it does on every deploy. So the 14-day limit, after which Fivetran pauses a connection, is not reached in practice: a pipeline keeps retrying, visibly, until it starts or you stop it.
- No email is sent for retried attempts. Fivetran emails from the second consecutive failed
sync; here a pipeline that is retrying shows
retryingand raises its alert, and the failure email is still sent only for the second give-up in a row.
2026-09-27 (IST) — A pipeline’s status can be completed
Section titled “2026-09-27 (IST) — A pipeline’s status can be completed”Added: status has a fourth documented value, completed, on every endpoint that returns a
pipeline. It will mean that the pipeline’s last sync finished, its schedule is manual, and nothing
more is due: it is at rest, and starting it runs the next sync. health reads healthy for it,
and the app shows it as “Synced — start it to sync again”, with Start available.
Nothing reports it yet. It is documented, and understood by the app, ahead of the change that
starts reporting it, so that change cannot reach a client that does not know the value. If your
client lists the values of status, add this one now.
2026-09-27 (IST) — Entering a notification address does not email you about a pipeline that stopped while you had none
Section titled “2026-09-27 (IST) — Entering a notification address does not email you about a pipeline that stopped while you had none”Fixed: entering a notification address could email you about a pipeline that had stopped while you had no address. The Settings page says that with no address, email is off and nothing will be sent. But if a pipeline stopped while you had no address, and you entered one within about a minute (before we next checked), we emailed you about that stop.
Now whether you are emailed is decided by whether you had an address at the moment the pipeline stopped, as it already was for turning error email on and off: a pipeline that stopped while you had no address is not emailed about when you enter one, and it is recorded as not emailed, with the reason. The same holds if you clear your address and enter it again while a pipeline is stopped. A pipeline that stops after you enter an address is emailed about as usual, and changing from one address to another does not stop an email that is due.
This closes the case that “Turning email back on does not email you about a pipeline that stopped while it was off”, below, describes as only narrowed. As before, the record is kept so support can tell you what happened; nothing in the console shows it yet.
2026-09-27 (IST) — A pipeline starting while we restart is no longer left as “gave up”
Section titled “2026-09-27 (IST) — A pipeline starting while we restart is no longer left as “gave up””Fixed: a pipeline that was being started while we restarted our service could be left as “gave up”, and waited for you to press start. Starting a pipeline begins by reading its saved credentials. If our restart came during that moment, the interruption was recorded as the pipeline giving up, although nothing was wrong with it. Now it is recorded as stopped, and the pipeline starts again on its own once the service is back.
2026-09-27 (IST) — A pipeline that could not be started now says so in its history
Section titled “2026-09-27 (IST) — A pipeline that could not be started now says so in its history”Fixed: a pipeline that could not even be started showed “gave up” with nothing in its history saying why. Starting a pipeline begins by reading its saved credentials. If that failed, we recorded that the pipeline had given up, but added no entry to its history. So its feed was silent, and the failure did not count toward the error email.
Now it gets the same history entry as any other give-up, and it counts toward the error email in the same way. The entry is one sentence of ours and never quotes the internal error. When a saved credential could not be found or decrypted, it says that a saved credential could not be read. For any other failure at that point, such as our own database not answering, it says the pipeline could not be started and that this is ours to fix. The status detail on the pipeline’s page shows the same sentence, where it used to show internal error text.
2026-09-27 (IST) — A Postgres publication that sends only part of a table stops the pipeline, and is refused at start
Section titled “2026-09-27 (IST) — A Postgres publication that sends only part of a table stops the pipeline, and is refused at start”Fixed: a Postgres pipeline kept running, and reported healthy, while its publication stopped sending some of the synced table’s changes. Since 2026-09-26 a running pipeline has stopped when its table leaves the publication. Three other changes to a publication leave the table in it and still lose changes, and none of them stopped anything:
ALTER PUBLICATION … SET (publish = 'insert'), or anypublishlist without all ofinsert, update, delete: the missing kinds of change are not sent;- a row filter (
SET TABLE orders WHERE (…)): changes to rows outside the filter are not sent; - a column list (
SET TABLE orders (id, a)): the columns it leaves out are not sent.
Now a running pipeline checks for all three on the same schedule as before (every retention interval, 60 seconds by default), stops, and says which one it found, the statement that fixes it, and that the changes made in between are not in the stream even after the publication is changed back: to include them, create a new pipeline and copy the table’s rows. The stop reaches the pipeline’s feed as “Schema change needs attention”.
A pipeline cannot be started on such a publication either. The start, and the deep check on the setup screen, refuse a publication that does not publish inserts, updates and deletes, that filters the table’s rows, or whose column list leaves out a column the destination table has, and name every one of those that applies in a single message, each with the statement that fixes it. A column list that leaves out only columns the destination does not have is allowed: that is how a column is left out on purpose, and the fix-it statements keep such a list rather than telling you to publish those columns.
With truncate published, a TRUNCATE stops the pipeline (neither destination applies one
yet). Without it, the TRUNCATE is not sent and the destination keeps its rows. So a
publication without truncate is neither refused nor a stop, and dropping truncate from a
running pipeline’s publication does not stop it.
What this cannot see:
- a change undone within one check interval, whose changes in between are lost without a stop; the check reads the catalogue on a schedule and is not in the stream;
- a column added to the table while its publication has a column list, even a list naming every column: the list does not include the new column, so it is never synced, and nothing says so. The destination keeps its columns and the rows arrive without the new one. Tracked in #948.
No API change. PostgreSQL 13 and 14 have no row filters or column lists; the check’s catalogue read was also run on PostgreSQL 14, 15 and 16, and the pipeline’s tests run on 18 and 17.
2026-09-27 (IST) — Starting a pipeline that gave up is no longer undone a moment later
Section titled “2026-09-27 (IST) — Starting a pipeline that gave up is no longer undone a moment later”Fixed: a pipeline you started again after it gave up could go straight back to “gave up”, and then nothing started it. When a pipeline gives up, we record that and retry the record if our own database does not confirm it. If the record was in fact saved but the confirmation was lost, the retry could land after you had seen “gave up” and pressed start, and it wrote “gave up” again over your start. The pipeline showed as given up, and would not run until you pressed start a second time.
Now a retried give-up is recorded only while the pipeline is still running. Once you have started it again, the retry records nothing, and the pipeline starts as you asked. You still get one feed entry and one email for the give-up, as before.
2026-09-27 (IST) — A failed pipeline create can be retried under the same name
Section titled “2026-09-27 (IST) — A failed pipeline create can be retried under the same name”Fixed: after creating a pipeline failed, trying again under the same name failed every time, with “Something went wrong at our end”. The New pipeline page stores your two connection strings first and then creates the pipeline. When the second step was refused (a field it did not accept, a slot and publication already in use, an outage), the connection strings stayed stored under names taken from the pipeline’s name, and the retry was refused because they already existed. The only way out was a different name.
Now a retry under the same name replaces the connection strings the failed attempt stored with the ones you enter this time, and goes on to create the pipeline. It does this only when no pipeline has that name and no source or destination in your account uses those connection strings; otherwise it tells you to pick a different name, and replaces nothing. The page still clears both connection strings once they are stored, so a retry means entering them again, and it now says so beside the error.
Also fixed: a name that an existing pipeline already has is now refused before anything is stored, with “You already have a pipeline with that name.” It used to fail the same way as above.
No API change. The page uses GET /v1/pipelines/{id}, POST /v1/credentials,
POST /v1/credentials/{ref}/rotate, GET /v1/sources and GET /v1/destinations, as they
already were. Connection strings from an attempt you abandon stay stored until credentials
can be deleted.
2026-09-27 (IST) — Two text keys that differ only in trailing spaces are never merged into one row
Section titled “2026-09-27 (IST) — Two text keys that differ only in trailing spaces are never merged into one row”Fixed: a varchar(n) or char(n) destination key column could merge two source keys into one
row. Postgres drops the trailing spaces of a value longer than a varchar(n) allows, without an
error, so a varchar(3) key stored abc as abc and the second row overwrote the first. A
char(n) column pads every value to its width and compares values ignoring trailing spaces, so a
char(3) key took ab and ab as one row.
- A text key the destination column would store with different trailing spaces now stops the pipeline before anything is written, naming the key column, its type and how many characters the value carries, and saying it is about trailing spaces. It never prints the key itself.
- What is refused: a
varchar(n)key longer thannwhose excess is spaces; achar(n)key shorter thann(the column pads it) or longer thannby spaces only (the column trims them); a key ending in a space in abpcharcolumn declared without a length. A key longer than its column by anything other than spaces was already refused, by Postgres itself (“value too long”). - What is not: a
textor length-lessvarcharkey column keeps trailing spaces, soabandabstay two rows, and so does avarchar(n)key they fit in (abcin avarchar(4)). Achar(n)source into achar(n)destination of the same width is unaffected: achar(n)source always sends its values padded to their full width, which is exactly what the column stores. Only a space counts: a tab or a no-break space is part of the key. - Some refusals are cautious, where no merge was possible. The value alone cannot say which
kind of column sent it, so a
char(n)source into a widercharkey column, or into abpcharwithout a length, is refused on every padded key, although the source had already madeabandabone key. So is atextorvarcharsource whose keys are shorter than achar(n)destination column. Each stops the pipeline with the message above. (MySQL sources do not readCHARcolumns yet; MySQL sendsCHARwithout its padding, so a MySQLCHARkey into achar(n)key column would be refused the same way once they do.) - The fix is on the destination: make the key column
text, or the source’s own type. - A known limit: under a non-deterministic collation (a case-insensitive ICU collation, for
example) a destination key column can still treat two different keys as one,
abcandABCin atextcolumn. That is older than this change and is tracked in #930. - Other columns are unchanged. A value column is still written as Postgres writes it.
2026-09-27 (IST) — Turning email back on does not email you about a pipeline that stopped while it was off
Section titled “2026-09-27 (IST) — Turning email back on does not email you about a pipeline that stopped while it was off”Fixed: turning error email back on, or entering a notification address, could email you about a pipeline that had stopped while email was off. If a pipeline stopped on an error twice in a row while error email was off, or while you had no address, and was still stopped when you turned email back on, you were emailed about it then: a problem you had chosen not to hear about, arriving the moment you switched email back on.
Now whether you are emailed is decided by your error email setting at the moment the pipeline stopped, not when we next checked it: a pipeline that stopped while error email was off is not emailed about, even if you turn error email back on straight away, and it is recorded as not emailed, with the reason. A pipeline that stops after you turn error email back on is emailed as before. As with emails stopped by turning email off, the record is kept so support can tell you what happened; nothing in the console shows it yet.
One case is only narrowed: with no address set, entering one within about a minute of a pipeline stopping can still send the email about it.
2026-09-27 (IST) — A connection string in a log line hides its user, host and database as well as its password
Section titled “2026-09-27 (IST) — A connection string in a log line hides its user, host and database as well as its password”2026-09-27 (IST) — A connection string that reaches a log line is hidden whole, not only its password
Section titled “2026-09-27 (IST) — A connection string that reaches a log line is hidden whole, not only its password”Fixed: the safety net that hides credentials in our logs could hide the password inside a
connection string and leave the rest of that string in place. The safety net exists for text
that quotes a connection string in full, from wherever it comes. When such a line quoted a
connection string that carried a password, the password was replaced by *** but the user
name, host and database around it were not, because the password was hidden first and the
whole string then no longer matched anything.
Now a line quoting a whole connection string has all of it replaced, including the user and the password as it is written in the string. What gets hidden no longer depends on the order in which the values to hide were registered, and where two of them overlap in one line, no part of either is left visible. A password quoted on its own is still hidden, as before.
2026-09-27 (IST) — Turning email off also stops the email that was already on its way
Section titled “2026-09-27 (IST) — Turning email off also stops the email that was already on its way”Fixed: an error email already waiting to be sent, or being retried, still went out after you turned error email off or cleared your notification address. The Settings page says that with error email off, or with no address, nothing will be sent. For an email queued a moment before you changed that, it was not true: it was sent anyway on its next attempt. With the address cleared, it waited instead and was sent whenever you next entered an address, possibly weeks later and about a pipeline that had long since recovered.
Now every waiting email is checked against your settings again shortly before it is sent: the address first, then error email for an error (turning warnings off does not stop an error). If either says no, the email is not sent, and it is not sent later either: turning error email back on, or entering an address again, does not send it, because it was about a problem you had chosen not to hear about. We keep a record that it was not sent and why, so support can tell you what happened; nothing in the console shows that record yet.
A change you save can still miss an email that was already being checked or sent at that moment. That window is short: at most one check of every account’s settings plus the time one send takes.
One case is different, and is tracked in #923: if a pipeline stops while email is off and is still stopped when you turn email back on, you are emailed about it then, because no email had been queued for it yet.
2026-09-27 (IST) — A Postgres table’s replica identity changed while its pipeline runs stops the pipeline
Section titled “2026-09-27 (IST) — A Postgres table’s replica identity changed while its pipeline runs stops the pipeline”Fixed: changing a synced table’s REPLICA IDENTITY while its pipeline was running could
leave two rows at the destination for one source row, and nothing reported it. A pipeline
is keyed by the table’s replica identity, read when it starts (2026-09-26). Changed to
another key while it ran, for example from USING INDEX on code to DEFAULT on the
primary key id, an UPDATE that changed code alone arrived with no previous row, so the
new code was written as a new row and the old one stayed.
Now the pipeline stops at the first change made after the replica identity changes, and the pipeline’s feed shows a schema stop naming the key the pipeline was built for and the key the source uses now. Transactions committed before that change are delivered; nothing after it is. While it is stopped, its replication slot holds the source’s WAL.
- What stops: a move between
DEFAULTandUSING INDEXwhose key differs,USING INDEXmoved to another index,USING INDEXchanged toFULL, which keys by the primary key, and a table left with no usable key (its identity index or primary key dropped). The last is said as such: the source then rejects everyUPDATEandDELETEon the table. - What does not:
DEFAULTchanged toFULLor back, which keeps the primary key, and re-issuing the identity the table already has. - When the changes still to be delivered were made under the OLD identity, which happens
when the
ALTERwas inside a transaction that had already changed the table, when the pipeline was stopped across theALTER, or when a stop’s own delivery failed, the pipeline stops at the first of them with its own message: those changes were made under one key and this run reads another. That stop happens again on every restart, until the pipeline gives up restarting, which is announced on the feed and by email. The way on is a new pipeline for the table, copying its rows; the changes made under the old key are not delivered to the old pipeline’s destination. A pipeline that waits for you without restarting is planned. - If it is restarted as it stands, it reads the key again and is refused at start,
before it touches the source’s slot, when the destination cannot match rows on the new key:
the refusal is on the feed and names the fix (
CREATE UNIQUE INDEX ON ... ("id");), and the pipeline is not restarted again. - To continue, either make the destination match rows on the new key as the refusal says
(a unique index on it, and the key columns
NOT NULL) and restart, which continues from the change keyed by the new key, or create a new pipeline for the table and copy its rows.
2026-09-27 (IST) — A Postgres pipeline remembers which table it was set up on
Section titled “2026-09-27 (IST) — A Postgres pipeline remembers which table it was set up on”Fixed: a pipeline whose source table was dropped and re-created, or swapped, between two runs
silently followed the new table. A pipeline syncs a table by its name, and a name can pass to
another table: DROP TABLE orders followed by a new CREATE TABLE orders, a rename followed by a
new table under the old name, or the swap online-schema-change tools make (orders renamed to
orders_old, orders_new renamed to orders). A running pipeline already stopped when it saw
this. But the stop restarts the pipeline, and the restarted pipeline looked the name up afresh, so
it adopted the new table: its rows were written into the same destination, beside the old table’s,
and after a rename the old table’s later changes were skipped. Under a publication that lists its
tables the restart was refused instead, with a message asking you to add the table to the
publication, which would have added the new one.
Now the pipeline stores its table’s identity the first time it runs, and every start checks it, before anything else. If the name belongs to a different table, the pipeline does not start. It is announced on its feed as a problem only you can fix, and it is not restarted. The message names both tables’ relation numbers and says what to do: to sync the new table, create a new pipeline for it, which copies its existing rows first. Adding the new table to the publication does not make this pipeline follow it. The stop a running pipeline gives for the same change now says the same thing.
- Existing pipelines store their table’s identity on their next run, from the table that has the name at that moment, and are checked from then on. A first run refused at start (a table with no primary key, say) stores nothing, so re-creating the table to fix it is not refused.
- A source database restored from a dump, or moved to another server, gives every table a new
identity, so it is refused the same way, and the message says so. Upgrading Postgres in place with
pg_upgrade, or failing over to a physical standby, keeps them. After a restore or a move the pipeline’s replication slot is gone too, so a new pipeline is the way on either way. - MySQL and Stripe pipelines are unchanged.
2026-09-26 (IST) — A pipeline that gives up during a database blip still tells you
Section titled “2026-09-26 (IST) — A pipeline that gives up during a database blip still tells you”Fixed: a pipeline could show as given up with nothing in its history saying why, and no email. When a pipeline’s worker kept failing and the control plane stopped restarting it, two things were saved: the pipeline’s state (given up) and an entry in its history, which is also what the “syncing is blocked” email is decided from. If the control plane’s own database was briefly unavailable at that moment, the state was saved once the database came back, but the history entry was lost. You saw a stopped pipeline with no entry explaining it, and the email that entry would have counted towards was never sent.
The two are now saved together, and the control plane keeps trying until both are, so the entry and the email arrive a little late rather than not at all. A give-up is recorded once however many tries it takes, and a pipeline that gives up again later gets a new entry of its own.
2026-09-26 (IST) — A Postgres pipeline whose table leaves its publication stops, instead of going quiet
Section titled “2026-09-26 (IST) — A Postgres pipeline whose table leaves its publication stops, instead of going quiet”Fixed: a pipeline whose source table was taken out of its publication, or swapped under it, kept reporting healthy while delivering nothing. Whether the publication covers the table was checked only when the pipeline started. Two ordinary operations change that under a running pipeline:
ALTER PUBLICATION … DROP TABLEon the synced table;- a table swap under a publication that lists its tables, as online-schema-change tools make
it (
ordersrenamed toorders_old,orders_newrenamed toorders). The publication follows the renamed table, so the newordersis not in it.
Either way the pipeline received nothing for the table, raised no error and no retention warning, and the next restart, possibly days later, was the first thing to notice.
Now the pipeline re-checks on its retention interval (REYANSH_RETENTION_INTERVAL_SECS,
60 seconds by default) and stops within one interval, announced on its feed as a stop that
needs attention:
- A table that left its publication gets the same message a start would give, with the
statement that adds it back (
ALTER PUBLICATION "…" ADD TABLE "public"."orders";), and one more sentence: changes made to the table while it was outside the publication are not sent, and adding it back does not send them. Measured on PostgreSQL 18.6: a row written in that window never reaches the pipeline, even after the table is added back. To include them, create a new pipeline and copy the table’s existing rows. - A table swapped under the name names both tables’ relation numbers and says the pipeline stopped rather than go on delivering nothing or mix the two tables’ rows. It also says not to add the new table to the publication: this pipeline was built for the table that was replaced, and following the new one is a new pipeline’s job.
Restarting a pipeline stopped because its table left the publication is refused at start, as
before, until the table is back. A restart does not hold the swap stop, and here is what it
does instead: under a publication that lists its tables, the restart is refused with the
“add the table to the publication” message, and running that statement would add the NEW table;
under FOR ALL TABLES, the restart follows the new table, keeping the replaced table’s rows in
the destination beside it. The message says so. A pipeline that remembers which table it was
built for across restarts is still to come.
What this does not catch, yet:
- A table dropped from its publication and added back within one retention interval is never seen, and rows written in that window are lost: a check on an interval cannot see what happened between two looks.
ALTER PUBLICATION … SET (publish = 'insert'), or a row filter added while the pipeline runs, leaves the table in the publication, so updates and deletes, or the filtered rows, stop arriving with nothing said (#920).- MySQL:
binlog_formatchanged toSTATEMENTwhile a pipeline runs is logged and the run goes on (#919). Nothing changes on the source: the check is a read of its catalogue on the connection the pipeline already holds. A catalogue read that fails is logged and retried at the next interval, and does not stop the pipeline.
2026-09-26 (IST) — A timestamp column stores what the source held, whatever the destination’s time zone
Section titled “2026-09-26 (IST) — A timestamp column stores what the source held, whatever the destination’s time zone”Fixed: on a Postgres destination whose time zone is not UTC, timestamps were converted
through that zone on their way in. Two things went wrong, with the zone set to
America/New_York:
- Where a column’s kind differed from the source’s, every row was shifted by the zone’s
offset. A
timestamptzsource value2026-07-27 12:00:00+00written into atimestampcolumn was stored as08:00:00; atimestampsource value2026-07-27 12:00:00written into atimestamptzcolumn was stored as16:00:00+00. - Around a daylight-saving change, two rows could become one or a value could move an
hour, whatever the kinds. The
timestampkeys2026-03-08 02:30:00and03:30:00became one row, because 02:30 does not exist in New York that night, and atimestampvalue of2026-03-08 02:30:00was stored as03:30:00. Thetimestamptzkeys2026-11-01 05:30:00+00and06:30:00+00, in atimestampcolumn, became one row: both are 01:30 in New York, in the hour that happens twice.
Each column is now written as its own kind, and the destination’s settings no longer decide
anything. A timestamp (without time zone) column stores the value exactly as the source held
it; a timestamptz column stores the same instant; a timestamptz value written into a
timestamp column is stored as its UTC time; and a timestamp value written into a
timestamptz column is read as UTC.
New refusal: a timestamp with a non-UTC offset is refused for a timestamp column, rather
than stored with its offset silently dropped, which could make 06:30+05:30 and 06:30+00 one
row. No source sends one today. The fix it names: make the column timestamptz, or send UTC.
The destination connection now runs in UTC, and that reaches columns the pipeline does not
write. A default or trigger on your table is evaluated in the connection’s zone, so on a New
York destination a timestamp DEFAULT now() column now stores UTC wall-clock time (15:52
where it stored 11:52), and current_date is the UTC date. A timestamptz DEFAULT now()
column is unaffected: it is the same instant either way.
Nothing changes for a destination whose time zone is UTC. To tell, connect as the
destination’s role and run SHOW TimeZone. UTC and Etc/UTC (the official Docker image’s
default) mean you are unaffected.
Before upgrading a destination whose time zone is not UTC, check its timestamp keys. Rows
already written keep the values they were written with. Where a table is keyed by a timestamp
column whose kind differs from the source’s, or holds a key that fell in a spring-forward gap,
the value this release computes for the same source row no longer matches the one stored:
after the upgrade that row’s next update inserts a second row beside the old one, and its
delete leaves the old one behind. Such a table needs re-syncing from the source under UTC
semantics: after upgrading, or before it with the destination’s time zone already set to UTC.
Setting the zone to UTC without re-syncing does not avoid this, because the old release then
computes the same values this one does. A shifted value in a column that is not a key is
corrected the next time its row changes. Each pipeline now logs the zone its destination
connection had before being set to UTC (destination session time zone was …), so an exposed
pipeline can be found from its log.
2026-09-26 (IST) — A destination table that cannot match rows on the pipeline’s key is refused at start
Section titled “2026-09-26 (IST) — A destination table that cannot match rows on the pipeline’s key is refused at start”Fixed: a pipeline whose destination table cannot match an arriving row to the one already
stored is refused when it starts, with the statement that fixes it. Reyansh writes with
INSERT ... ON CONFLICT, which needs a unique index on exactly the pipeline’s key columns.
Before, a destination without one (for example keyed on id while the source table is keyed
on order_id) was found at the first write: the pipeline failed with “there is no unique or
exclusion constraint matching the ON CONFLICT specification”, was restarted five times
against the same table, and gave up. Now it stops before it reads a single change, is not
restarted, and says what to run, such as CREATE UNIQUE INDEX ON "public"."orders" ("order_id");.
The same check refuses a unique index that cannot be used (partial, over an expression, or
DEFERRABLE), a key column the destination table does not have, and a key column that allows
NULL under an index that treats NULLs as distinct. That last one is new for an existing
destination: such a table used to accept writes, and would have inserted a second row for a
NULL key on every retry. ALTER TABLE ... ALTER COLUMN ... SET NOT NULL fixes it.
A connection test with a stream picked reports it too, against the destination
("subject": "destination", not retryable), so it can be fixed before the pipeline is saved.
PostgreSQL 13 and 14 destinations are checked too. They have no NULLS NOT DISTINCT, so
the check reads every unique index there as treating NULLs as distinct, which is what those
versions do. This was tested against PostgreSQL 18 only, not against a real 13 or 14 server.
2026-09-26 (IST) — Error messages no longer contain long runs of spaces
Section titled “2026-09-26 (IST) — Error messages no longer contain long runs of spaces”Fixed: some error messages contained a long run of spaces in the middle of a sentence, where a line break in the source had been lost. The words were always right; only the spacing was wrong. Among those affected: the advice shown when a pipeline stops on a source or destination fault, every message explaining why a value could not be converted to its destination column’s type, and the refusal shown when an initial copy could not be recorded. Nothing about when these messages appear, or what they ask you to do, has changed.
2026-09-26 (IST) — A connection test says which destinations it can test
Section titled “2026-09-26 (IST) — A connection test says which destinations it can test”Changed: a connection test whose destination is not a Postgres connection string is refused
with unsupported_destination_kind (422), naming what the test takes. Before, such a
destination was passed to the worker, which refused it inside the check as “not a postgres://
URI”, and the test came back as a 500 check_unreadable (“produced a result this server could
not read”). Nothing changes for a postgres:// or postgresql:// destination. A Snowflake
destination cannot be tested yet; its test arrives with its setup form.
Also: a scheme is read with its case, as the worker reads it. POSTGRES:// or
Postgresql:// is refused with unsupported_source_kind or unsupported_destination_kind
(422) rather than reaching the worker, which never accepted it, and coming back as the 500
above. Write the scheme in lower case.
2026-09-26 (IST) — A pipeline’s checkpoint has one writer at a time
Section titled “2026-09-26 (IST) — A pipeline’s checkpoint has one writer at a time”Fixed: two workers running one pipeline at once could make it skip rows for good. Where a pipeline resumes from was saved by whichever worker wrote last. If an older worker was still running when a newer one started, for example while a restart overlapped, the older one could move the resume point past rows the newer one had not delivered. Those rows were then never delivered, and nothing reported an error.
- A newer worker now takes the pipeline over when it starts, before it reads where to resume. From then on an older worker’s saves change nothing.
- The older worker stops and says a newer worker has claimed the pipeline. Its last batch is delivered again by the newer worker, which is harmless because rows are merged by key.
2026-09-26 (IST) — A pipeline’s hosts are checked before it starts, as a connection test’s are
Section titled “2026-09-26 (IST) — A pipeline’s hosts are checked before it starts, as a connection test’s are”Fixed: a stored credential could make a pipeline connect to an address a connection test
refuses. POST /v1/connections/test refused loopback, link-local, private and our own
addresses, but a pipeline created with the same connection string was started anyway. The
worker’s error then reached your pipeline’s page, which made a started pipeline a way to probe
those addresses.
- Every start of a pipeline’s worker now runs the same check, on the credential as it is stored at that moment: the first start, every restart and every scheduled run. Rotating a credential, or changing where its name points, cannot skip it.
- A refused pipeline is not started. It shows as given up with one sentence that names neither the host nor what it resolved to, and appears in the pipeline’s activity.
- A host written in the connection string’s parameters (
host=,hostaddr=,port=), or more than one host, is refused at launch, as the connection test already refuses it. - A host that cannot be looked up is not a refusal. Nothing starts, and it is tried again with the ordinary restart backoff, so a brief DNS failure does not stop a pipeline. A name that never resolves gives up as a pipeline that keeps failing does.
- Self-hosted operators: your own pipelines to your own databases are exempt by tenant, with
REYANSH_TRUSTED_TENANTS(see the deployment runbook).
2026-09-26 (IST) — The worker refuses a connection string with a host in its parameters
Section titled “2026-09-26 (IST) — The worker refuses a connection string with a host in its parameters”Changed: a Postgres connection string must name its one host and port in the URL itself. The
worker and the control plane now both refuse one with host=, hostaddr= or port= in its
parameters, with more than one host, or with an unencoded @ or # after its host. A pipeline
stops with a message naming the fix: postgres://user:password@host:5432/database. An @ in a
password or a parameter value still works when it is percent-encoded as %40.
- Fixed: a connection string could name one host to our check and another to the connection.
With an unencoded
@after the host, the check read the host before the@and the database driver the one after it, so a pipeline or connection test could reach an address it should have been refused.
2026-09-26 (IST) — Two different keys are never merged into one destination row
Section titled “2026-09-26 (IST) — Two different keys are never merged into one destination row”Fixed: a destination key column narrower than your source’s could merge two rows into one.
When the destination’s key column keeps fewer digits than the source’s, it rounds each key as
it is written. A numeric(12,2) key column stores 1.005 and 1.006 as the same 1.01, so the
second row overwrote the first. A timestamptz(0) key column stores 10:00:00.5 as 10:00:01,
so a later delete of that row matched nothing, and the row stayed.
- A key the destination would store differently now stops the pipeline, naming the column,
its type, and how many digits the value carries against how many the column keeps. It never
prints the key itself. This covers a
numerickey with more decimals than its scale, a timestamp key with more fractional seconds than its precision, adatekey holding a time of day, and arealordouble precisionkey with more precision than the column holds (adouble precisionstores9007199254740993as9007199254740992, so ids above 2^53 merge). - A
numerickey column with a negative scale (numeric(5,-2), which rounds to hundreds) is now refused by name at the first write, rather than taken as unconstrained. - The fix is on the destination: change its key column to the source’s type, or to one at least as precise.
- Other columns are unchanged. A value column is still rounded exactly as Postgres rounds it, because refusing those would stop pipelines over values your destination accepts.
2026-09-26 (IST) — Alerts page: what is wrong across your account, errors first
Section titled “2026-09-26 (IST) — Alerts page: what is wrong across your account, errors first”New: an Alerts page in the console, a count of errors beside it in the navigation, and a
banner on each pipeline’s page. They read GET /v1/alerts and
GET /v1/pipelines/{id}/alerts, which already existed. No API change.
- Errors come first. An error means syncing is blocked until someone acts; a warning means data is still flowing. Within each, an alert whose start we recorded comes before one whose start we did not, oldest first. (Starts are not recorded yet, so for now the order within each is the server’s.)
- Each alert says which pipeline, what is wrong in plain words, and whether syncing is blocked. “Since” appears only when we recorded when the problem began. When we did not, it shows nothing, not “just now”.
- The navigation count is errors only. It reads the feed until it finds a page with an error (up to five pages, about a thousand pipelines) and adds a “+” when more pages exist, because then it is a lower bound. It never shows “0”: no badge is not a promise that nothing is wrong. The Alerts page is.
- No alerts shows “No alerts”. A paused pipeline raises none, because you stopped it.
2026-09-26 (IST) — Settings: choose where notification email goes
Section titled “2026-09-26 (IST) — Settings: choose where notification email goes”New: a Settings page, linked from the header, over GET/PUT /v1/notification-settings. No
API change.
- One email address. Leave it empty and save to turn email off; the page says so.
- One toggle: “Email me about errors that stop syncing”. The page says what sends an email today: a pipeline stopping on an error twice in a row (after its automatic restarts run out), with no successful run between, one email per episode.
- No warnings toggle yet. No event sends a warning email, so a toggle would promise mail that never comes. A warnings subscription set through the API is kept when you save.
2026-09-26 (IST) — A pipeline no longer gets stuck when its state cannot be saved
Section titled “2026-09-26 (IST) — A pipeline no longer gets stuck when its state cannot be saved”Fixed: a pipeline could stop running for good, with nothing on screen to say so. If the worker for a pipeline exited at a moment when the control plane could not save that fact (a brief database blip), the pipeline stayed marked as running with nothing running, and was never started again. The control plane now keeps trying to save it and starts the pipeline again once it has.
- A worker that keeps stopping on its own now gives up, and tells you. A pipeline’s worker that exits cleanly without being asked to, over and over, used to be started again every few seconds for ever. It is now restarted the way a crashing worker is, and once it has stopped that way too often in a minute, the pipeline shows as given up, with the reason, and waits for you to start it.
2026-09-26 (IST) — A Postgres table syncs by its own key, whatever the key is called
Section titled “2026-09-26 (IST) — A Postgres table syncs by its own key, whatever the key is called”Fixed: a Postgres pipeline could only sync a table whose key was a column named id. The
worker keyed every table by id. A table keyed by anything else, such as order_id, a uuid
or a composite (order_no, line_no), could not sync: every change was refused as missing its
id. A table whose replica identity is a unique index other than its primary key was keyed by
the wrong columns.
- The key is now the table’s replica identity, read from your source when the pipeline
starts. Under the default identity (and
FULL) that is the primary key, every column of it, in the key’s declared order. UnderREPLICA IDENTITY USING INDEXit is that index. Only an index’s key columns count, never itsINCLUDEcolumns. It is the only key an update’s old row carries, so a change of the key moves the row at the destination rather than leaving the old one behind. - Test connection now refuses a table with no usable key, and says how to add one: a table
with no primary key, a table with
REPLICA IDENTITY NOTHING, aDEFERRABLEprimary key under the default identity, and aUSING INDEXidentity whose index was dropped or is not valid. Postgres rejects every update and delete on each of these. Each message names theALTER TABLEstatement that fixes it. A pipeline over such a table also stops at start with the same message, before anything is read from the table. - Your destination table must be keyed the same way. The pipeline upserts on those columns, so the destination needs a primary key or unique index on exactly them. A destination without one is not yet checked at start: the pipeline stops at its first write, with the database’s own error. Checking it at start is #899.
- Known limit: the key is read once, at start. If you change the table’s replica identity while the pipeline runs, restart the pipeline. Stopping it by itself when the identity changes is #896.
- MySQL and Stripe are unchanged: MySQL is withdrawn (#436) and still keys by
id, and each Stripe stream is keyed by the key its connector declares.
2026-09-26 (IST) — A Postgres pipeline writes only its own table’s changes
Section titled “2026-09-26 (IST) — A Postgres pipeline writes only its own table’s changes”Fixed: a pipeline whose publication covered other tables wrote their changes into its
destination table. A pipeline syncs one table, and a publication can cover several: one that
lists more than one table, one created FOR ALL TABLES, or one shared with another tool. The
source sends every covered table’s changes to the pipeline, and the pipeline applied all of them
to its one destination table. A row from another table was written there. Where it had the same
primary key as a row already there, it replaced that row, and a delete in the other table
deleted it. A TRUNCATE or a dropped column on another table stopped the pipeline.
- The pipeline now reads only the table it syncs. Changes to every other table in the
publication, including their
TRUNCATEs and schema changes, are skipped. - The other tables do not hold back your source’s WAL. While the synced table is quiet, the pipeline releases the WAL the other tables write, so a busy table beside a quiet one does not pin the replication slot.
- A pipeline whose publication does not cover its table no longer starts. It stops with a
message naming the publication and the
ALTER PUBLICATIONstatement that fixes it. Before, it would have run and delivered nothing. - Renaming the synced table stops the pipeline, naming the old and new names, rather than losing the changes made under the new name. Restarting it, or renaming the table back, does not deliver those changes, because they are recorded under the name they were made under: create a new pipeline for the table under its current name, copying its existing rows.
- A different table under the synced name stops the pipeline too: a table dropped and recreated, or another table renamed into its place (the swap online schema-change tools make). If the pipeline is restarted it follows whichever table has the name then, and the destination keeps the other table’s rows beside it, so start clean with a new pipeline instead.
- As a second guard, a pipeline that is ever handed another table’s change stops, naming both tables, and writes nothing from that batch.
- If your pipeline’s publication covers more than one table, check its destination table.
This fix does not repair what other tables’ changes did there before it: rows replaced or
deleted, and rows added. To see which tables a publication covers, run
SELECT * FROM pg_publication_tables WHERE pubname = '<your publication>';on your source. If the destination table differs from the source table, copy the table again into an empty destination table.
2026-09-26 (IST) — The control plane exits 78, not 2, when it is misconfigured
Section titled “2026-09-26 (IST) — The control plane exits 78, not 2, when it is misconfigured”For self-hosted operators. A control plane that cannot start because of its configuration (a
missing or invalid variable, a port already in use, a database role that can bypass row-level
security) now exits 78 (EX_CONFIG) instead of 2.
- Why: 2 is also what the Go runtime exits with after an unrecovered panic, and the shipped systemd unit told systemd never to restart on 2. So a control plane that crashed on a bug stayed down, and read in the journal exactly like a missing variable.
- What to change: if you run your own unit or supervisor, change
RestartPreventExitStatus=2toRestartPreventExitStatus=78, then runsystemctl daemon-reload. The unit indeploy/already says 78. A panic now exits 2 and is restarted like any other crash. - The worker is unchanged: it still exits 2 when misconfigured, which the control plane reads directly.
2026-09-26 (IST) — MySQL sources are withdrawn until known data-loss bugs are fixed
Section titled “2026-09-26 (IST) — MySQL sources are withdrawn until known data-loss bugs are fixed”MySQL is no longer offered as a source. Reading from MySQL has open defects that can lose or change data without any error: rows that existed before the pipeline was created are never copied, and some values (partial JSON updates, binary and non-UTF-8 text, columns left out of a minimal row image, tables of more than 250 columns) are decoded wrongly or dropped. It comes back once they are fixed together.
GET /v1/connectorslists themysqlsource card with the new statuswithdrawn. A withdrawn card is one we can run but do not offer for new work. It is neitherlivenorplanned.POST /v1/sourceswith"kind": "mysql"is refused with422 unsupported_kind, as a planned kind already was.POST /v1/pipelinesnaming asource_idordestination_idwhose kind is not live is refused with422 unsupported_kind, naming the object and its kind. Before this, a pipeline could be created from an existing object whatever its kind, so an existing MySQL source could still start new pipelines.POST /v1/pipelines/{id}/startrefuses a pipeline that has never run and reads a source kind that is not live, with422 unsupported_kind. Its first run would be new work on the withdrawn connector, and a MySQL first run is exactly what misses the existing rows.POST /v1/connections/testrefuses amysql://source with422 unsupported_kindbefore anything connects, rather than answering usable for a pipeline that cannot be created.- A MySQL pipeline that has already run keeps running, and can be stopped and started again. Nothing stops it or changes it.
2026-09-25 (IST) — A pipeline syncs one table, and now says so
Section titled “2026-09-25 (IST) — A pipeline syncs one table, and now says so”Fixed: picking several tables created a pipeline that synced only the first. A pipeline reads one table and writes one destination table, so every other table you picked was stored with the pipeline and never given a destination table of its own, with nothing on screen to say so.
POST /v1/pipelinesrefuses more than one stream with422 one_stream_per_pipeline, naming how many were sent. Create one pipeline for each table. A schema-qualified stream name is still refused first, by name (invalid_stream_name).- The New pipeline screen picks ONE table, with radio buttons. A table outside the
publicschema is listed and cannot be picked yet, with the reason below the list, because a pipeline reads and writespublic.<table>. Two tables of the same name in different schemas no longer send both. - Name only that table in your publication. The setup step now says so: the publication decides which tables’ changes are sent to the pipeline.
- A pipeline created earlier with several tables still shows them all and still syncs only the first. Create a pipeline for each of the others.
- Syncing several tables in one pipeline, and choosing the schema, are on the way; the refusal goes when they land.
2026-09-25 (IST) — The connector catalogue lists Snowflake as a planned destination
Section titled “2026-09-25 (IST) — The connector catalogue lists Snowflake as a planned destination”Added: GET /v1/connectors returns a snowflake destination card with status: "planned".
It records interest; it opens no setup form, and POST /v1/destinations refuses the kind with
422 unsupported_kind until the card goes live. The card goes live in the release that can
run a Snowflake pipeline end to end.
2026-09-25 (IST) — New pipeline screen: your Postgres source’s setup, shown before you create anything
Section titled “2026-09-25 (IST) — New pipeline screen: your Postgres source’s setup, shown before you create anything”Changed: testing a Postgres connection on the New pipeline screen now shows how to prepare your source.
- Name the pipeline first. The test needs the name, because it names the source objects after it.
- A first test shows “Prepare your source”, with the statement that creates your publication (run it now, listing the tables to sync) and the one that creates the replication slot (copy it now, and run it right before you start the pipeline, not earlier: a slot holds your database’s write-ahead log from the moment it exists). We never run these for you.
- Test again after creating the publication to pick the tables. The screen keeps the names from your first test, so every later test and the pipeline itself use exactly the objects you created.
- Renaming the pipeline starts over, because the names belong to the pipeline.
2026-09-25 (IST) — Connection test: it runs again, and shows the Postgres setup for your pipeline
Section titled “2026-09-25 (IST) — Connection test: it runs again, and shows the Postgres setup for your pipeline”Fixed: POST /v1/connections/test answered 500 check_unreadable for every request (#844).
It started a check that could not read its own configuration, so no test ever ran.
Changed: testing a Postgres source now needs the pipeline’s id, and returns its setup.
- The request gains
id(required for a Postgres source), an optionalsource_kind(which must agree with the URL’s scheme), andslot_nameandpublication_name, which you send back on a re-test so it reads the same publication. - The answer gains
setup: the replication slot and publication this pipeline will read, and the SQL to create them on your source, in two groups.statementscreates the publication, and you run it now.start_statementscreates the slot, and you run it right before starting the pipeline: a slot with nothing reading it holds your database’s write-ahead log from the moment it exists. We never run those statements ourselves. POST /v1/pipelinesaccepts the sameslot_nameandpublication_name, and stores them as given, so the pipeline reads exactly the objects you created. Without them, it draws names as before. Only a pair a connection test returned is accepted; names you choose yourself are refused with422 invalid_field. A pair already used by another pipeline is409 source_names_in_use: test again to draw new names.- A connection string that names its host or port in its parameters (
host,hostaddrorport), or more than one host, is refused with422 invalid_connection_string. Put exactly one host and port in the URL itself. - A MySQL source is tested as before and gets no
setup.
2026-09-25 (IST) — Postgres pipelines: each new pipeline gets a replication slot name no other pipeline can share
Section titled “2026-09-25 (IST) — Postgres pipelines: each new pipeline gets a replication slot name no other pipeline can share”Changed: a Postgres pipeline created from today uses a replication slot and publication named
after it AND unique to it, for example reyansh_orders_6e66ac13dbe916dc and
reyansh_pub_orders_6e66ac13dbe916dc. A pipeline deleted and created again under the same id gets
new names, so it never picks up the slot the deleted one left on your database. The names used to be reyansh_<pipeline id>, and three kinds
of pipeline could end up sharing one:
- pipelines with the same id in two accounts;
- ids differing only in case or punctuation (
Ordersandorders,eu-ordersandeu_orders); - two long ids that start the same way.
Two pipelines on one slot take turns failing, and one of them can skip changes the other already
acknowledged. You still create the slot and publication yourself. A pipeline that cannot find
its slot names it exactly, as before, and the publication’s name is the slot’s with reyansh_pub_ in
place of reyansh_. Showing both names, and the statements that create them, at setup is #844.
Existing pipelines are unaffected. They keep the names they already use, because you created their slots under those names.
2026-09-25 (IST) — MySQL sources: wide tables under a partial row image decode correctly
Section titled “2026-09-25 (IST) — MySQL sources: wide tables under a partial row image decode correctly”Fixed: on a MySQL table with more than eight columns, binlog_row_image=MINIMAL or NOBLOB
could decode an insert, an update or a delete wrongly. Each row in a binlog event carries a small bitmap of
which of its values are NULL, sized by the columns that row actually contains. The decoder sized it
by the table’s full column count, which agrees only for tables of eight columns or fewer. For a
wider table, a change under a partial row image (an update, a delete, or an insert naming only some
columns) usually stopped the pipeline with “row values ended while reading”, and in some cases
decoded the wrong values without any error. Tables of eight columns
or fewer, and every table under binlog_row_image=FULL (the default), were never affected.
2026-09-25 (IST) — Setup checks: the settings that stop a primary-key change are named up front
Section titled “2026-09-25 (IST) — Setup checks: the settings that stop a primary-key change are named up front”Changed: the setup check now says, before a pipeline starts, which source settings will make it stop on an UPDATE that changes a row’s primary key. Such an update is applied as a delete of the old row and an insert of the new one, and the insert needs every column. Some settings leave a column out of such an update, and then nothing else carries its value, so the pipeline stops at that change rather than write the row with it empty:
- a PostgreSQL table under its default replica identity leaves out a large value stored out of line;
- a MySQL server under
binlog_row_image = MINIMALleaves out every column the update did not touch; NOBLOBleaves out the BLOB and TEXT columns it did not touch.
The advisories name the fix: REPLICA IDENTITY FULL for the table, or binlog_row_image = FULL.
A PostgreSQL table under REPLICA IDENTITY USING INDEX has the same exposure, and the setup check
does not flag it yet (#838).
Corrected: the MySQL advisory no longer says every omitted column is safe. Under
binlog_row_image = MINIMAL, an INSERT that names only some columns logs only those, so a column the source filled from
its DEFAULT arrives empty at the destination. The advisory now says so.
2026-09-25 (IST) — Postgres destinations: a row can be deleted whatever the type of its key
Section titled “2026-09-25 (IST) — Postgres destinations: a row can be deleted whatever the type of its key”Fixed: a delete failed at a PostgreSQL destination whose table key was not text. A source
DELETE of a row keyed by an integer, numeric, uuid, date, timestamp, boolean, floating-point,
bytea or jsonb column stopped the pipeline with “error serializing parameter 0”. Rows were
inserted and updated correctly; only removing one failed. The key is now compared the way the
destination stored it: rounded to a numeric column’s precision and scale, and padded for a
char(n) column. Tables keyed by text, varchar or char(n) were never affected. One case
remains: a key in a timestamp column with fewer than six digits of fractional seconds, given a
more precise value, is rounded when stored and not when deleted, so the delete misses it (#833).
2026-09-25 (IST) — A row whose primary key changes no longer leaves its old row behind
Section titled “2026-09-25 (IST) — A row whose primary key changes no longer leaves its old row behind”Fixed: an UPDATE that changed a row’s primary key left the row under its old key in place
at the destination. The destination received the row at its new key and kept the old one
too, a stale duplicate, and every write reported success. A key change now arrives as a delete
of the old key and an insert of the complete row at the new key. A destination that keeps
deleted rows (soft delete) shows the old key as deleted, which is what happened to it at the
source. This holds when the pipeline’s key is the table’s replica identity. Pipelines are keyed
by a column named id today, so that is a table whose primary key is id under the default
identity; a table whose REPLICA IDENTITY USING INDEX names another column still cannot see a
change of the primary key alone (#838).
Also fixed: a table whose key is a long value no longer stops on an ordinary update. Postgres
sends a key stored out of line (a value over about 2 kB) as if the key had changed, even when it
did not. That used to stop the pipeline with “the source withheld key column”; it is now read as
the same row, updated. The same goes for MySQL with binlog_row_image=MINIMAL, whose updates
leave an unchanged key out of the new row: they flow now, where every one of them used to stop.
One caution comes with that for MySQL MINIMAL: an INSERT that names only some columns logs
only those, so a column the source filled from its DEFAULT arrives empty at the destination (#842,
open). A MINIMAL pipeline used to stop at its first update, which bounded how long that could go
on; it now keeps running. Until #842 is fixed, use binlog_row_image=FULL if your inserts leave
columns to their defaults.
One case now stops the pipeline instead of writing a NULL. A key change on a Postgres table
with the default REPLICA IDENTITY does not carry a large column that it left unchanged, and
nothing else in the change holds its value. Rather than write the row at its new key with that
column empty, the pipeline stops and names the table and the columns. REPLICA IDENTITY FULL on
the table makes later key changes carry the whole row, so they do not stop. MySQL with
binlog_row_image=MINIMAL (or NOBLOB, for a blob column) stops on a key change for the same
reason; binlog_row_image=FULL is the remedy there. The change that stopped the pipeline is
already in the source’s log, so resuming stops at it again: keep the pipeline stopped.
And an update whose old row does not hold the pipeline’s key now stops, where it used to be
applied. Such a change cannot say which row it came from. It happens when the pipeline’s key
is not the table’s replica identity. Pipelines are keyed by a column named id today (#838). So it
happens, for example, on a Postgres table whose REPLICA IDENTITY USING INDEX names another column,
or whose primary key is some column other than id (under the default identity; FULL sends the
whole old row): an update that changes the replica identity
arrives without id in its old row. Before this change it was applied to
whichever row its NEW values named, which left the old row live if the key had also changed. Such
a table already stopped at its first delete, for the same reason.
2026-09-23 (IST) — Postgres sources: floats arrive exact whatever the server is configured for
Section titled “2026-09-23 (IST) — Postgres sources: floats arrive exact whatever the server is configured for”Fixed: a double precision or real column could arrive rounded. Postgres renders every
value as text through the session’s settings. We pinned the date and time ones (DateStyle,
TimeZone) and inherited the rest from your server — so a server configured with
extra_float_digits = 0 sent 3.141592653589793 as 3.14159265358979, already rounded
before it left the source. Nothing downstream could tell, and nothing could recover the lost
digits. PostgreSQL 11 and earlier shipped with 0 as the default, so on those versions
this happened without anyone configuring anything.
Both the initial copy and the change stream now also pin extra_float_digits = 3,
bytea_output = hex and IntervalStyle = postgres. On PostgreSQL 12 and later each is
what a default server already renders with, so a 12+ server on its defaults sees no change
at all. A server configured otherwise, or an older one, now delivers the canonical form:
exact floats, \x hex for bytea, and 1 day 02:00:00 rather than 1 2:00:00 or P1DT2H
for an interval.
Rows already delivered from such a server keep what they were written with. A re-sync of the table rewrites them in the exact form.