Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

Two Months Late, PostgreSQL 19 Is Finally Here: Repack Tables While They Run, and Make Standbys Wait for Your Writes

On 19 November 2026, PostgreSQL 19 shipped — two months late, after a flood of AI-reported vulnerabilities rewrote the schedule. It brings REPACK (CONCURRENTLY), pg_plan_advice, and WAIT FOR LSN: tables can be reorganized while they run, query plans can be pinned, and standbys wait for your writes.

A modern data center corridor lined with black server racks, cable trays and ventilation ducts overhead, blue indicator lights blinking on the racks

In short: two months late, PostgreSQL 19 finally shipped on 19 November

On 19 November 2026, the PostgreSQL Global Development Group announced the release of PostgreSQL 19. In most years a new major version arrives in September; this year it was two months late. Simon Willison put it directly in his commentary the same day: the release came late mainly because the team had to work through a flood of issues reported as part of what he called the ongoing "AI-reported vulnerability apocalypse". That is not a joke: this site covered the other side of the story in October, when PostgreSQL 19's release had already been pushed back by AI review. That piece was about "why it was late"; this one is about "now that it is late, what actually shipped".

For readers who do not follow database release rhythms, some background: PostgreSQL is the most widely used open-source relational database in the world, and the database vibe coding projects reach for most often — Supabase and Neon run on it, and when you ask an agent to build you an app with logins and data, the data most likely lands in Postgres. So a major release is never just a database administrators' affair; it decides which new tools you will have in hand when you build apps next year.

This piece answers three questions: first, why it was two months late, and whether the delay was worth it; second, which new features are actually worth an ordinary developer remembering; and third, what to watch out for if you are running a Postgres project and thinking about upgrading.

First, the two-month delay: AI finds vulnerabilities faster than people can fix them

The chain of events goes like this. In 2026, AI security tools began scanning open-source projects at scale, and the number of vulnerability reports reaching PostgreSQL surged. Willison's account is that the reports piled up to the point where the team had to delay the release and work through them first. On 12 November, minor releases across the supported branches (18.7, 17.12, 16.16, 15.20) shipped, and PostgreSQL 19's second release candidate, RC2, came out the same day; the final release followed on 19 November. In other words, between September and November the team spent two months receiving AI reports, fixing them, and folding the fixes into the release.

The delay itself is more interesting than the feature list. It shows AI changing a basic rhythm of open-source work: the release schedule used to be set by how fast people found vulnerabilities; now it is set by how fast AI reports them. The ability to find bugs has, for the first time, outrun the ability to fix them — that sentence was the headline of this site's October piece on the delay, and it still holds today. And PostgreSQL is not alone in this: in his blog on 19 November, Willison also noted that Daniel Stenberg, the curl maintainer, is facing the same flood of AI-reported issues — reports running at four to five times the 2024 rate and double the 2025 rate, more than one a day on average.

But "late" does not mean "wasted". Two months bought a cleaner release: the final version folds in all the fixes from the 12 November minor releases, so what users get is a version polished for two extra months. For a database, shipping two months late is far better than shipping with known problems. The PostgreSQL team's choice fits its thirty-year style: better to slip the date than to ship sick.

Incidentally, this year is also the 30th anniversary of the PostgreSQL open-source project. EDB marked the day with an announcement celebrating it, and Michael Stonebraker, the creator of Postgres, recorded a podcast conversation for the occasion. For an open-source project to live 30 years and ship a major version every year without fail is itself worth respecting; this year's "two months late" becomes, in that 30-year history, a very of-its-time footnote: the first time the release calendar was rewritten by AI.

Headline feature one: REPACK — clean up a table without taking it offline

The number one feature of PostgreSQL 19 is the new REPACK command. Its purpose can be stated in one sentence: reclaim wasted disk space and reorganize a table's contents so queries run faster. Every database gets this problem over time: as rows are updated and deleted again and again, a table accumulates dead space that eats disk and slows queries. Until now, fixing it meant VACUUM FULL (which locks the table, so the business has to stop), or the third-party pg_repack extension (which you had to install separately), or CLUSTER (which also locks the table).

The new idea is in the word in parentheses: REPACK (CONCURRENTLY). With that option, reorganizing a table does not block reads and writes to it — the business carries on as normal. For a live system that means work that used to need a middle-of-the-night maintenance window can now be done in daylight. The release also adds a system view, pg_stat_progress_repack, that reports the progress of REPACK, CLUSTER, and VACUUM FULL in real time — jobs like these used to run as a black box, and now you can at least see how far they have got.

For vibe coding readers, the point is practical. The apps you build with agents usually start with "just get it running": schemas change back and forth, data gets deleted and refilled, and after a few months the tables are bloated. Until now you might not even have known the dead space was there, or known and not dared to touch it — touching it meant locking the table. REPACK (CONCURRENTLY) brings that job down to a single command, with no downtime. It is not magic: reorganizing a large table still takes time and disk space, and the documentation states its limits plainly; but "daring to reorganize a table in daylight" is itself a large change in how it feels.

It is worth adding that REPACK does not arrive alone — it comes with a matching set of cleanup improvements in version 19: parallel autovacuum can use several worker processes to clean up a table's indexes at once, and a new scoring system decides which tables to clean first; a new view, pg_stat_autovacuum_scores, shows the cleanup score for every table. Taken together, PostgreSQL 19 offers a complete toolkit for the problem that "tables get dirty as they are used": autovacuum handles the everyday case, REPACK does the thorough periodic clean, and progress is visible at every step. For anyone who manages their own database, that combination matters more than any single command.

The road to PostgreSQL 19: September release window, October delay reports, RC2 and minor releases on 12 November, general availability on 19 November

Headline feature two: pg_plan_advice — query plans you can finally pin down

The second feature worth remembering is the pg_plan_advice extension, with a companion called pg_stash_advice. They attack an old problem in databases: the query planner sometimes picks the wrong execution plan. For the same query, a change in data volume can make the planner suddenly switch to a much slower way of running it, and the system slows down for no obvious reason — hard to reproduce, hard to explain.

The idea of pg_plan_advice is to give you better control over the planner's decisions: you can give the planner "advice" so it runs a query the way you specify, while pg_stash_advice applies that advice automatically based on the query. In plain terms, it turns "the execution plan" from something entirely up to the planner into something where the planner leads but you can step in. That is useful for anyone running important workloads: you can finally tell a critical query "run it this way, and don't switch on your own".

There is another layer to this feature in the context of 2026: more and more code is written by AI, and so is more and more SQL. The queries agents write rarely consider execution plans, and they slow down once data volumes grow. Until now, when that happened you had to read the plan yourself and rewrite the SQL; now pg_plan_advice at least gives you a safety net. It is not an excuse to stop optimizing SQL — the right approach is still to write a sensible query first, and then use advice to lock down the critical paths.

Headline feature three: WAIT FOR LSN — standbys that wait until your write lands

The third feature is Simon Willison's favorite in his commentary, and also the easiest to explain: read-your-writes consistency. The scenario is common: your application writes to the primary and reads from standbys — standard read-write splitting. The problem is replication lag: you change a row on the primary, then immediately read from a standby and get the old data. A user edits their profile, refreshes, and sees nothing changed. That bug comes and goes, and it is one of the hardest to track down.

PostgreSQL 19 answers with a new WAIT command, written WAIT FOR LSN. An LSN is a log sequence number — effectively a timestamp for a write on the primary. The flow is: after writing, ask the primary for an LSN; before reading from a standby, make the standby wait until it has replayed the write-ahead log up to that LSN. Willison gave a complete example in his blog post:

UPDATE movie SET genre = 'Dramatic' WHERE genre = 'Drama';
SELECT pg_current_wal_insert_lsn();
-- returns a value like '0/0306EE20'; store it, then on the next request:
WAIT FOR LSN '0/0306EE20' WITH (TIMEOUT '0.1s');
SELECT * FROM movie WHERE genre = 'Drama';

The TIMEOUT in that example is optional: if the replica cannot catch up within 0.1 seconds, the command errors instead of waiting forever. Willison also noted that he first saw this pattern at Wikipedia: MediaWiki hand-built its own version against MySQL replication, saving the primary's binlog position in the session and waiting for the replica to catch up at the start of the next request. Wikipedia needed to solve the same problem you and I have: after a user does something, a refresh must show it. PostgreSQL 19 turns something every team used to hand-build into a built-in feature.

For people who build apps with agents, the value is that it kills a whole class of ghost bugs that are hardest to describe to an agent. "I just changed it, refreshed, and it changed back" — a problem that comes and goes, that an agent struggles to reproduce and struggles to fix, because it was never a code bug at all, but replication lag. Now you can add a WAIT FOR LSN after a critical write, and the problem is solved at the root. Not every query needs the wait; use it where "the user just wrote something and is about to read it", and the price is a little latency in exchange for certainty.

Other changes worth knowing: replication, performance, and a few tightenings

Beyond the three headline features, the release notes carry a list worth scanning. Logical replication can now be enabled without restarting the server when wal_level is set to replica; sequence values can be replicated logically too — sequences falling out of sync used to be a well-known gap in logical replication. Parallel autovacuum has arrived, with a new scoring system to prioritize which tables get cleaned; the number of I/O worker processes can scale automatically instead of being tuned by hand through io_workers (that parameter itself is gone in version 19, replaced by four new ones). Foreign-key checks are faster, COPY imports of text and CSV use SIMD instructions, the default TOAST compression method moves from pglz to the more efficient lz4, and sorting uses radix sort.

There are also several changes that tighten things rather than loosen them, and you should know them before upgrading. JIT is disabled by default: it used to be enabled by default and switched on based on cost estimates, but the team now considers that costing unreliable, so it is off unless you turn it on — sites running many large analytical queries will need to enable it manually. A warning now appears after a successful MD5 password authentication — MD5 was marked deprecated in version 18, and version 19 starts pushing you to move away. RADIUS support has been removed, because PostgreSQL only supported RADIUS over UDP, which is unfixably insecure. standard_conforming_strings is forced to on; dumps made with older pg_dump versions with that option off may not load cleanly into version 19. And the default for max_locks_per_transaction rises from 64 to 128, with lock memory allocation changed, so capacity needs to be re-estimated on the new basis.

Put together, the character of PostgreSQL 19 is clear: it is not a release chasing showpiece features, but one that pulls out the thorns of day-to-day operations one by one. Reorganizing tables without downtime, pinning execution plans, making standbys wait for your writes, enabling replication without restarts, letting the system prioritize cleanup — each item on its own is small, but each is a pain point that people who live with databases run into again and again.

Three concrete things it changes for people who build apps

If you do not normally manage databases yourself, you might ask: what does any of this have to do with me? The answer is three concrete things. The first is a new answer to "tables get slower the longer you use them". The apps you build with agents tend to run for months with schemas changing and data being deleted and refilled, and the tables bloat. Until now you either lived with it or found a late-night window to stop the service and clean up; now REPACK (CONCURRENTLY) makes it a one-line job you can run in daylight. For a personal project, that means your app does not slowly go stale, and you do not need to learn a database maintenance routine to keep it fresh.

The second is a standard fix for ghost bugs of the "I just changed it and it changed back" kind. Read-write splitting is the default architecture for many apps, and replication lag is the hardest class of problem to describe to an agent and the hardest to reproduce. WAIT FOR LSN turns it from a matter of luck into a matter of writing one clear statement. You do not need to understand all of replication; after a critical write, add one wait, and let the database handle the rest.

The third is about attitude, and the release process itself is the lesson. AI made finding vulnerabilities faster, but fixing them, making decisions, and taking responsibility are still human work. The PostgreSQL team spent two months working through the AI-reported issues one by one — verifying them, fixing them, folding them into the release — rather than shipping on the September schedule with known problems. That rhythm is worth learning: agents can help you write code fast, but the gate before release — check it, verify it, then ship it — cannot be skipped or rushed. The same applies to your app: however fast an agent builds it, run it in a test environment and walk the critical paths before it goes live. That habit matters more than any new feature.

One more detail is worth recording: the timeline of this release is itself a public lesson. A September target, delay reports in mid-October, RC2 and minor releases across the branches on 12 November, general availability on 19 November. Every step of it is public: release candidates, fix lists, release notes, all checkable on the official site. That transparency is one reason PostgreSQL has lived 30 years, and the biggest difference between it and much commercial software — you do not have to guess why it was late, because the timeline is right there.

Before you upgrade: a few things to think through

First, a PostgreSQL major upgrade is not a button press. The documentation states it plainly: moving to version 19 from any older version requires a dump and restore with pg_dumpall, or pg_upgrade, or logical replication. There is no in-place upgrade. The safest approach is to run the full upgrade in a test environment first, and confirm that your application, your extensions, and your backup process all still work before touching production.

Second, check your extensions and clients. JIT off by default, standard_conforming_strings forced on, the default index opclasses for inet and cidr changed, RADIUS removed, MD5 warnings — any of these can affect an existing deployment. In particular, if you still store passwords as MD5, or you have an old system using RADIUS authentication, deal with those two before upgrading. The release notes carry a whole section on compatibility changes, and it is worth reading through item by item before you upgrade.

Third, managed services will move before you do. Supabase, Neon, AWS RDS, Azure, and others typically offer a new major version over the months after release. Azure announced a day-one preview of version 19 with in-place major version upgrades; other platforms have their own timetables. If you use a managed service, upgrading is mostly a matter of waiting for the notice and clicking a button — but the behavior changes above (such as JIT being off by default) will affect you just the same, and knowing them in advance beats discovering them after launch.

How this relates to what this site has already covered

This piece is the release follow-up to this site's October story on the PostgreSQL 19 delay (slug: postgres-19-delayed-llm-code-review), not a repeat of it. That piece covered mid-October: AI review forcing a delay, based on The Register's 16 October report and Peter Eisentraut's official blog. This piece covers what happened after 19 November: REPACK, pg_plan_advice, and WAIT FOR LSN, none of which appeared in the delay story. The "why it was late" takes one section here, to give new readers the background, and is not the body of the piece. The two pieces agree on the facts: AI-reported vulnerabilities caused the delay, a conclusion that has not changed between the October and November sources.

It is also a different angle from this site's pgvector semantic-search guide and database-selection guide: those are about "how to do things with a database", while this one is about "the database itself has a new version". If you are building on Postgres, the advice is simple: new projects can start on 19 directly; older projects should run the upgrade in a test database first and follow once their managed provider offers 19. With a database, steady beats fast.

Views 0Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates