Skip to main content
BumbleTap
Add to ChromeInstall

PostgreSQL 19 End of Life (EOL): November 2031, Release Date and What's New

PostgreSQL 19 came out on 19 November 2026 and is supported until November 2031. What it adds, what breaks when you upgrade, which early features were cut, and when RDS, Aurora, Cloud SQL, Azure and Heroku are due to offer it.

Written Shahzeb Umer

Subscribe

Status

Supported

Support ends .

Time left
1826 days
Latest release
19.0
Support type
Standard

5 years of support

  • Supported19 Nov 2026 – 19 Nov 2031

Supported for 5 years, from 19 Nov 2026 to 19 Nov 2031.

Who still patches it

Four places PostgreSQL 19 runs, three deadlines.

  • PostgreSQL (community): Final release 19 Nov 2031
  • apt.postgresql.org (Debian 12, 13; Ubuntu 22.04 to 26.10): Follows the community, 19 Nov 2031
  • yum.postgresql.org (RHEL 9, 10 and rebuilds; Fedora; Amazon Linux 2023): Follows the community, 19 Nov 2031
  • Docker image (postgres:19rc2 so far; latest is still 18): Rebuilt, no end announced
Sources: postgresql.org versioning policy and release announcements, apt.postgresql.org, yum.postgresql.org, docker-library official images. Checked 19 Nov 2026.

Where to move

Be on PostgreSQL 19.

The short version

  • PostgreSQL 19 was released on 19 November 2026 and is supported until November 2031, five years under the project's versioning policy. The only release so far is 19.0, and the first fix release, 19.1, is due with the next scheduled minor releases on 11 February 2027. General availability was expected in October and moved so that 19.0 would carry the fixes from the 12 November update release.
  • On release day it is in the PostgreSQL project's own apt and yum repositories, while the official Docker image has only the second release candidate and its latest still means 18. Amazon RDS has offered only release candidates, in a preview environment, and Aurora, Cloud SQL, Azure and Heroku have announced no date. Their published policies put Cloud SQL by 17 February 2027, RDS within 30 days of 19.1 and Aurora within eight months of it.
  • Take 19 where you run PostgreSQL yourself and your extensions are ready; on a managed service, stay on 18 until 19 arrives there. Before upgrading, check what changed: JIT is now off by default, max_locks_per_transaction is counted differently, io_workers and RADIUS authentication are gone, and pg_upgrade refuses a few things 18 allowed.
On this page
  1. How long PostgreSQL 19 is supported
  2. Should you upgrade to PostgreSQL 19?
  3. Where PostgreSQL 19 runs, as of 19 November 2026
  4. What's new in PostgreSQL 19
  5. What was cut from PostgreSQL 19
  6. What breaks when you upgrade to 19
  7. How to upgrade to 19
  8. How to check what you run
  9. What comes next
  10. Sources

PostgreSQL 19 was released on 19 November 2026 and is supported until November 2031. The PostgreSQL project supports each major version for five years after its first release, then publishes a final minor release and stops. Until then 19 gets bug, security and data corruption fixes in the quarterly minor releases.

On release day 19 is the newest major version, but not yet the one most platforms run: PostgreSQL 18 is still the default on Cloud SQL, Heroku and Ubuntu 26.04. This page covers when 19 reaches the managed services, what it adds, what changes when you upgrade, and which features from the early betas didn't ship, as of 19 November 2026.

How long PostgreSQL 19 is supported

Five years from 19.0. Minor releases come at least once every three months, normally on the second Thursday of February, May, August and November, and each one installs over the last without a dump and restore. The next scheduled date is 11 February 2027, when 19.1 is due unless an urgent fix brings a release sooner. That leaves about twenty 19.x releases, the last in November 2031.

The road to 19.0:

Milestone Date
Feature freeze 8 April 2026
Beta 1 4 June 2026
Beta 2 16 July 2026
Beta 3, with the August update release 13 August 2026
Beta 4, which reverted five features 24 September 2026
Release candidate 1 15 October 2026
Release candidate 2, with the November update release 12 November 2026
19.0, general availability 19 November 2026

It came about eight weeks later than usual. 18.0 shipped on 25 September 2025 and 17.0 on 26 September 2024. Beta 1's announcement expected 19 "around September/October 2026", and Beta 4's still said October. When RC 1 came out on 15 October, the release team chose to wait for the 12 November update release, which fixed 52 security vulnerabilities and over 140 bugs across the supported versions, so that 19.0 would include those fixes. That added a second release candidate and moved general availability to 19 November.

Should you upgrade to PostgreSQL 19?

You run Supported until What to do now
14 or older Ended; 14's final release was 12 Nov 2026 Upgrade now: to 18 on a managed service, to 18 or 19 where you run PostgreSQL yourself
15 11 Nov 2027; Heroku ends it 28 Feb 2027 18 now on a managed service; 19 if you self-host and your extensions support it
16 9 Nov 2028; Heroku ends it in Q3 2027 The same as 15
17 8 Nov 2029 19 once your platform offers it, skipping 18
18 14 Nov 2030 No rush; 19 when your platform and extensions are ready

Take 19 now if you run PostgreSQL yourself, from apt.postgresql.org or yum.postgresql.org, or from the Docker image once it publishes 19.0, your extensions have 19 builds, and you want REPACK CONCURRENTLY, parallel autovacuum or the new upsert form. It buys a year of support over 18, and the upgrade costs the same either way.

Stay on 18 for now if you are on a managed service, since none offers 19 for production yet; if you depend on TimescaleDB, which has no release for 19; or if you run large analytical queries that rely on JIT and haven't tested them with JIT off.

On 14, 15 or 16, don't wait for 19 to reach your platform. 14 is already out of community support, Heroku ends 15 on 28 February 2027, and 18 runs everywhere today. Move to 18 now; it is supported until 14 November 2030, so the next upgrade can wait for years.

Where PostgreSQL 19 runs, as of 19 November 2026

Where Status When to expect it Source
PostgreSQL community 19.0 since 19 November 2026 Supported until November 2031 Versioning policy
apt.postgresql.org, Debian and Ubuntu postgresql-19 for Debian 12, 13, testing and unstable, and Ubuntu 22.04, 24.04, 26.04 and 26.10; the release candidates were in a separate 19 component Available now; builds follow the community's support apt.postgresql.org, Apt wiki
yum.postgresql.org, RHEL and Fedora postgresql19 for RHEL, Rocky Linux and AlmaLinux 9 and 10, Amazon Linux 2023 and Fedora 43 to 45, but not RHEL 8; the release candidates were in a testing repository Available now; builds follow the community's support yum.postgresql.org
Docker official image Only postgres:19rc2 so far; latest still points to 18.7, and a pull request to publish 19.0 is open Once published, rebuilt with each minor release; no end announced official-images
Amazon RDS for PostgreSQL Not generally available. The Database Preview Environment has had 19 since Beta 1 (8 June 2026); its last announced build was RC 1, on 15 October 2026 Within 30 days of 19.1: by 13 March 2027 if 19.1 ships on 11 February RDS calendar, RC 1 preview
Aurora PostgreSQL Not available Within 8 months of 19.1: by October 2027 if 19.1 ships in February Aurora calendar
Google Cloud SQL for PostgreSQL Not available; no preview announced Within 90 days of general availability: by 17 February 2027 Versions, release notes
Azure Database for PostgreSQL flexible server Not in Azure's version policy; no preview announced No published timeline Version policy, release notes
Heroku Postgres Not available; 18 is the default No date; 18 took ten months Version support, 18 beta, 18 GA

latest is about to mean 19. For 18, the official Docker image moved its latest tag on release day, 25 September 2025. On 19 November it still pointed to 18.7, with a pull request open to publish 19.0 and move latest to it. Once that lands, anything that pulls postgres or postgres:latest gets 19 on its next pull, and the 19 image, like 18's, exits with an error when it finds data from another major version under /var/lib/postgresql. It keeps its own data in /var/lib/postgresql/19/docker, so an 18 and a 19 data directory can sit in one volume for pg_upgrade --link, but the image doesn't run pg_upgrade for you. Pin postgres:18 until you upgrade on purpose.

The project's repositories had 19 first. apt.postgresql.org built the betas and release candidates, in a 19 component you had to add next to main, for the same Debian and Ubuntu releases it supports for 18. yum.postgresql.org kept them in a testing repository for RHEL 9 and 10 and Fedora; that repository had no 19 builds for RHEL 8, and 19.0 has none either. With 19.0 both moved it into their regular repositories, and yum.postgresql.org added Amazon Linux 2023 builds.

AWS counts from 19.1, not 19.0. RDS commits to a new major version "within 30 days of the community release for first minor of the new major version", and Aurora within 8 months of it. Cloud SQL counts 90 days from the community's general availability instead. For 18 that meant RDS on 14 November 2025, the day after 18.1, Cloud SQL on 20 November 2025, after a preview that opened eight days after 18.0, Aurora on 11 June 2026 and Heroku on 4 August 2026. Azure's policy table lists 18 from 25 September 2025 but promises nothing for new versions.

Heroku's arrival starts a clock for 16. Heroku's rule is that "Heroku Postgres 16 deprecates when Heroku Postgres 19 releases", and it lists 16's end of life as Q3 2027, six months after that deprecation, which suggests Heroku expects to offer 19 in early 2027. Three months after the deprecation it stops new 16 databases, after five it schedules forced upgrades, and after six it starts deleting databases still on 16. Note that pg:upgrade without --version goes to the newest version Heroku offers.

Extensions decide many upgrades. Three of the most used ones, as their maintainers have published it:

  • PostGIS 3.7.0, released on 30 October 2026, requires PostgreSQL 14 to 19, and apt.postgresql.org already builds it for 19.
  • pgvector has said nothing about 19 specifically. Its newest release, 0.8.7 from 1 October 2026, describes itself as supporting "Postgres 13+", and apt.postgresql.org already builds it for 19.
  • TimescaleDB has no release for 19. Its newest, 2.32.0 from 12 November 2026, is "compatible only with PostgreSQL versions up to 18.6, 17.11, and 16.15". A bug filed by a TimescaleDB developer on 13 November, in which continuous aggregates created on 18 could fail pg_upgrade's checks for 19, was fixed in its development branch on 19 November but is in no release yet.

What's new in PostgreSQL 19

From the PostgreSQL 19 release notes and the beta and release candidate announcements.

REPACK replaces VACUUM FULL and CLUSTER. REPACK rewrites a table to hand dead space back to the operating system, and REPACK ... USING INDEX also reorders it, which is what CLUSTER did. Both old commands still work. The real change is REPACK (CONCURRENTLY): it holds only a SHARE UPDATE EXCLUSIVE lock while it copies, catches up on concurrent changes through logical decoding, and takes the ACCESS EXCLUSIVE lock only to swap the files at the end.

REPACK (CONCURRENTLY, VERBOSE) orders;
REPACK orders USING INDEX orders_created_at_idx;  -- what CLUSTER did

It has limits. The concurrent form needs a primary key or a replica identity index, doesn't work on partitioned or unlogged tables or materialized views, uses a replication slot counted against max_repack_replication_slots, and fails if more than about 104 million rows are updated or deleted while it runs. It is also not MVCC-safe: a transaction whose snapshot predates the repack sees the table as empty afterwards. pg_stat_progress_repack shows how far it has got.

Planner advice. The new pg_plan_advice module lets you stabilize and steer the planner's choices for a query, and the pg_stash_advice extension applies stored advice automatically by query ID.

Faster in many places.

  • I/O workers scale themselves. With io_method = worker, 18's default, 19 runs between io_min_workers (2) and io_max_workers (8) processes as load requires, replacing the fixed io_workers.
  • Foreign key checks are quicker; the Beta 1 announcement measured up to twice the insert speed with foreign keys present.
  • The planner turns more NOT IN and LEFT JOIN queries into anti-joins, can aggregate before a join (eager aggregation), and simplifies IS DISTINCT FROM when inputs can't be null. Sorts use radix sort, COPY FROM parses text and CSV with SIMD instructions, and NOTIFY wakes only the sessions listening on that channel.
  • Ordinary table scans can mark pages all-visible, which used to be left to VACUUM, so later vacuums have less to do.
  • New values are TOAST-compressed with lz4 instead of pglz by default, where the server was built with lz4.

Autovacuum. Autovacuum can process a table's indexes with parallel workers, capped by autovacuum_max_parallel_workers and set per table with autovacuum_parallel_workers. A scoring system decides which tables go first, with five weight settings and a pg_stat_autovacuum_scores view.

Replication.

  • With wal_level = replica, logical replication is now enabled automatically when it is needed, without a restart. effective_wal_level shows the level in force.
  • Sequences can be replicated: publish them with CREATE PUBLICATION ... FOR ALL SEQUENCES, and the subscriber copies their values when it subscribes and whenever you run ALTER SUBSCRIPTION ... REFRESH SEQUENCES. It is on demand, not continuous, and the publisher must run 19 or later, so it helps the move from 19 to 20 rather than from 18 to 19.
  • CREATE PUBLICATION ... FOR ALL TABLES EXCEPT (TABLE ...) publishes everything but a list, and CREATE SUBSCRIPTION ... SERVER takes its connection from a foreign server.
  • WAIT FOR LSN makes a session on a standby wait until a given WAL position has been replayed, written or flushed, for read-your-writes after a write on the primary.

SQL.

  • INSERT ... ON CONFLICT DO SELECT ... RETURNING returns the row that blocked the insert, optionally locking it with FOR UPDATE or FOR SHARE.
  • lead(), lag(), first_value(), last_value() and nth_value() accept IGNORE NULLS.
  • COPY ... TO writes JSON with FORMAT json (one array with FORCE_ARRAY) and copies partitioned tables directly. COPY FROM can turn bad values into NULL with ON_ERROR SET_NULL and skip several header lines.
  • jsonpath gains string methods such as lower(), replace() and split_part(); random() takes dates and timestamps; encode() and decode() handle base64url; uuid casts to and from bytea; and GRANT ... GRANTED BY names the role a grant is made as.

Security. The server can present different TLS certificates per host name (SNI), configured in a new pg_hosts.conf. password_expiration_warning_threshold warns users seven days before their password expires, and a successful MD5 login now draws a warning, which md5_password_warnings turns off. RADIUS support is gone.

Monitoring. New views pg_stat_lock and pg_stat_recovery; stats_reset columns on the table, index and function statistics views; started_by in the vacuum and analyze progress views; log_min_messages levels per process type; an IO option for EXPLAIN ANALYZE that reports asynchronous I/O; and wraparound warnings from 100 million transactions away instead of 40 million.

What was cut from PostgreSQL 19

Many articles written after Beta 1, AWS's own preview announcement among them, describe features that 19.0 doesn't have. The project reverted them during the beta "so they can be potentially be included in a later major release":

  • SQL/PGQ property graph queries (Beta 4)
  • enabling and disabling data checksums on a running cluster (Beta 4)
  • temporal UPDATE and DELETE with FOR PORTION OF (Beta 4)
  • ALTER TABLE ... MERGE PARTITIONS and SPLIT PARTITIONS (Beta 4)
  • pg_get_role_ddl(), pg_get_tablespace_ddl() and pg_get_database_ddl() (Beta 4)
  • GROUP BY ALL (Beta 3)
  • non-text output formats for pg_dumpall (Beta 2)

RC 2 also stopped JSON_ARRAY() and JSON_OBJECT() over arrays, composite and range types from being used in expression indexes, generated columns and partition keys. If you created such objects while testing a beta, drop or redefine them before upgrading, because pg_dump and pg_upgrade can't recreate them.

What breaks when you upgrade to 19

From the "Migration to Version 19" section of the release notes, roughly in order of how often it will matter.

1. JIT is off by default. Medium for analytics. 18 enabled JIT and used it when a query's estimated cost was high enough; the release notes say that costing "has been determined to be unreliable", so 19 ships with jit = off. Large analytical queries that gained from JIT can slow down, and the notes say sites running many of them need to turn it back on, which you can do globally or per role or database.

2. Lock table sizing changed. Medium if you set it. The default max_locks_per_transaction went from 64 to 128, but lock allocation changed with it, so 128 holds about what 64 used to. If your configuration sets the value, double it, as the notes advise; otherwise the lock table holds about half as much as before.

3. Settings that stop the server from starting. High if you set them. io_workers was removed in favour of io_min_workers, io_max_workers, io_worker_idle_timeout and io_worker_launch_interval, and escape_string_warning was removed. standard_conforming_strings still exists but can no longer be off. Remove them from postgresql.conf and any ALTER SYSTEM settings before you start 19.

4. RADIUS authentication is removed. High if you use it. PostgreSQL only spoke RADIUS over UDP, which the notes call "unfixably insecure". Move radius lines in pg_hba.conf to LDAP, certificates, OAuth or SCRAM before upgrading.

5. Old dumps made with standard_conforming_strings = off. Medium for dump and restore. A dump taken with a pre-19 pg_dump from a server running with that setting off won't load properly into 19. Dump with 19's pg_dump, or turn the setting on before dumping.

6. pg_upgrade refuses three things. Blocks the upgrade.

  • GiST indexes using btree_gist's inet or cidr operator classes, which "can exclude rows that should be returned". Rebuild them with the core GiST inet_ops, now the default for those types.
  • Database, role or tablespace names containing a carriage return or line feed, which 19 no longer allows at all.
  • Databases in the MULE_INTERNAL encoding, which was removed. Dump and restore them into another encoding.

7. Text search, pg_trgm and fuzzystrmatch. Reindex after pg_upgrade. Full text search and pg_trgm now classify characters with the database's locale provider instead of always with libc. In a database using ICU or the builtin provider whose behaviour differs from its LC_CTYPE, particularly an LC_CTYPE of C, results can change, and the notes recommend reindexing every full text search and pg_trgm index after pg_upgrade and recomputing stored tsvector values. Indexes using fuzzystrmatch's soundex(), metaphone(), difference() or dmetaphone() need a reindex too. Separately, the Dutch stemmer now uses a different algorithm (the old one is dutch_porter), and the English, French, German, Lithuanian, Norwegian, Spanish, Swedish and Turkish stemmers produce different stems for some words, so search results in those languages can shift.

8. Maintenance runs differently. Low. Parallel VACUUM workers now share one cost limit, so a parallel vacuum with cost-based delay can run slower than before. vacuumdb --analyze-only and --analyze-in-stages now include partitioned tables, which lengthens the post-upgrade analyze. log_lock_waits is on by default, and autovacuum's analyze runs are logged by the new log_autoanalyze_min_duration instead of log_autovacuum_min_duration.

9. Monitoring names changed. Low. pg_stat_subscription_stats.sync_error_count is now sync_table_error_count. The wait event type BUFFERPIN is now BUFFER, BufferPin is BufferCleanup, and BufferContent is replaced by BufferShared, BufferShareExclusive and BufferExclusive. Dashboards and alerts that match on them need updating.

10. Smaller ones. JSON_ARRAY() over a query that returns no rows gives an empty array instead of NULL. READ ONLY transactions stay read-only on postgres_fdw remote servers. COPY FROM ... WHERE can't use system columns. psql's \crosstabview honours \pset null. C extensions need 19 builds, as with every major version, and index access method handlers and some planner hooks changed in ways their authors have to adapt to.

How to upgrade to 19

pg_upgrade 19 accepts clusters from 9.2 on, and postgresql.org says you can skip major versions as long as you read the release notes of the ones you skip. Coming from 16 or older, 18's changes apply too: PostgreSQL 18 covers data checksums, asynchronous I/O and MD5, and PostgreSQL 16 the changes from 17.

Check the old cluster first. As a superuser, these find most of what blocks or changes the upgrade; run the index query in each database.

-- Settings 19 removed or changed (empty result: nothing to edit)
SELECT name, setting, source FROM pg_settings
WHERE name IN ('jit', 'max_locks_per_transaction', 'io_workers',
               'standard_conforming_strings', 'escape_string_warning')
  AND source <> 'default';

-- RADIUS lines in pg_hba.conf
SELECT line_number, auth_method FROM pg_hba_file_rules WHERE auth_method = 'radius';

-- Names with line breaks, which pg_upgrade refuses
SELECT 'database' AS kind, datname AS name FROM pg_database WHERE datname ~ '[\r\n]'
UNION ALL SELECT 'role', rolname FROM pg_roles WHERE rolname ~ '[\r\n]'
UNION ALL SELECT 'tablespace', spcname FROM pg_tablespace WHERE spcname ~ '[\r\n]';

-- btree_gist inet and cidr indexes, which pg_upgrade refuses (per database)
SELECT i.indexrelid::regclass AS index, opc.opcname
FROM pg_index i JOIN pg_opclass opc ON opc.oid = ANY (i.indclass)
WHERE opc.opcname IN ('gist_inet_ops', 'gist_cidr_ops');

-- Databases whose text search and pg_trgm indexes may need a reindex (15 and later)
SELECT datname, datlocprovider, datctype FROM pg_database WHERE datlocprovider <> 'c';

Then install 19 and your extensions' 19 builds, and run pg_upgrade --check with the mode you plan to use. It repeats the blocking checks and more.

After the upgrade, pg_upgrade carries most optimizer statistics across, and 19's documentation no longer lists those created with CREATE STATISTICS among the ones it leaves behind. Finish with vacuumdb --all --analyze-in-stages --missing-stats-only, then vacuumdb --all --analyze-only, and reindex the text search, pg_trgm and fuzzystrmatch indexes item 7 describes.

Replication slots and checksums. pg_upgrade keeps logical replication slots and subscriptions only when the old cluster is 17 or later; from 15 or 16, subscribers and change-data-capture slots have to be set up again. 19's initdb, like 18's, enables data checksums, and pg_upgrade needs both sides to match: if SHOW data_checksums says off on the old cluster, create the new one with initdb --no-data-checksums. The online switch that Beta 1 previewed was reverted, so pg_checksums --enable on a cleanly stopped cluster is still the only way to add them later.

On Debian and Ubuntu with apt.postgresql.org, pg_upgradecluster -v 19 -m upgrade 18 main wraps pg_upgrade; its default method is a dump and restore, so pass -m upgrade or -m link. In Docker, each image holds one major version, so pg_upgrade needs a setup with both versions' binaries, or a dump from the 18 container restored into a fresh 19 one. On a managed service, wait for the provider's own upgrade path; PostgreSQL 17 and 16 describe how RDS, Cloud SQL, Azure and Heroku run major upgrades today.

How to check what you run

Ask the server:

SELECT version();
SHOW server_version_num;  -- 190000 means 19.0
SHOW jit;                 -- off on 19 unless someone turned it on

For containers, find out what latest means today and which files rely on it:

docker run --rm postgres:latest postgres --version
grep -rnE 'image: *postgres(:latest)? *$' --include='*.yml' --include='*.yaml' .
grep -rnE '^FROM +postgres(:latest)?( |$)' --include='Dockerfile*' .

On Debian and Ubuntu, see whether apt.postgresql.org offers 19 and which clusters you run:

apt-cache policy postgresql-19
pg_lsclusters

On AWS, these return nothing until RDS and Aurora add 19:

aws rds describe-db-engine-versions --engine postgres \
  --query 'DBEngineVersions[?starts_with(EngineVersion, `19`)].EngineVersion' --output text

aws rds describe-db-engine-versions --engine aurora-postgresql \
  --query 'DBEngineVersions[?starts_with(EngineVersion, `19`)].EngineVersion' --output text

What comes next

19.1 on 11 February 2027, with the other supported versions' February releases, then quarterly through November 2031. RDS's 30 days and Aurora's 8 months both count from it. Cloud SQL's 90 days run out on 17 February 2027.

PostgreSQL 20 is in development, and apt.postgresql.org already builds snapshots of it. The project's roadmap plans it for September 2027. Every PostgreSQL version and its dates are on the PostgreSQL hub, and PostgreSQL 14 shows what the platforms do once a version's final release is out.

Sources

Common questions

When was PostgreSQL 19 released?
On 19 November 2026, as 19.0. Its first beta came out on 4 June 2026, followed by three more betas and two release candidates, the second on 12 November. Beta 4's announcement still expected general availability in October; with the first release candidate, the release team moved it to 19 November so that 19.0 would include the fixes in the 12 November update release.
When is PostgreSQL 19 end of life?
In November 2031. The PostgreSQL project supports each major version for five years after its first release, then publishes a final minor release and stops. Until then 19 gets bug, security and data corruption fixes in quarterly minor releases, starting with 19.1, due on 11 February 2027.
What's new in PostgreSQL 19?
The headline features are the REPACK command, which can rebuild a bloated table without blocking reads and writes, planner advice through the new pg_plan_advice module, parallel autovacuum, logical replication of sequences, logical replication without a restart when wal_level is replica, WAIT FOR LSN for read-your-writes on standbys, INSERT ... ON CONFLICT DO SELECT, JSON output from COPY and faster foreign key checks.
Does PostgreSQL 19 have SQL/PGQ graph queries?
No. SQL/PGQ property graph queries were in the first three betas and in many early write-ups, but the project reverted them in Beta 4 on 24 September 2026, along with online enabling and disabling of data checksums, temporal UPDATE and DELETE with FOR PORTION OF, ALTER TABLE ... MERGE PARTITIONS and SPLIT PARTITIONS, and three pg_get_*_ddl() functions. GROUP BY ALL went in Beta 3. The project says they may return in a later major release.
Is PostgreSQL 19 available on Amazon RDS?
Not for production as of 19 November 2026. The Amazon RDS Database Preview Environment has carried 19 builds since Beta 1, but it deletes instances after 60 days and its snapshots can't leave it. RDS commits to a new major version within 30 days of the community's first minor release, 19.1, due on 11 February 2027. Aurora allows itself 8 months from 19.1.
When will Cloud SQL, Azure and Heroku support PostgreSQL 19?
None has announced a date. Google Cloud SQL supports new major versions within 90 days of general availability, which means by 17 February 2027; for 18 it opened a preview eight days after release and reached general availability on 20 November 2025. Azure publishes no timeline for new major versions. Heroku added 18 as a beta on 14 July 2026 and made it generally available on 4 August 2026, ten months after 18.0.
Should I upgrade from PostgreSQL 18 to 19?
Not urgently. 18 is supported until 14 November 2030, so 19 adds one year of support. Move when your platform offers 19, your extensions have 19 builds, and you have tested the changed defaults, above all JIT, which 19 turns off. If you run PostgreSQL yourself and want REPACK CONCURRENTLY or parallel autovacuum, there is no reason to wait past your own testing.
Can I upgrade straight to PostgreSQL 19 from 15, 16 or 17?
Yes. pg_upgrade 19 accepts clusters from 9.2 on, and postgresql.org says you can skip major versions if you read the release notes of the ones you skip. From 17 or 18, logical replication slots and subscriptions survive pg_upgrade; from 15 or 16 they have to be set up again. On 15 or 16 and a managed service, move to 18 now rather than wait for 19.

Also on the calendar

End-of-life dates for the rest of your stack.

Dates checked against postgresql.org’s own data, because endoflife.date doesn’t list this version yet. How we check datesReport a wrong dateEvery PostgreSQL version