RDS PostgreSQL 14 End of Standard Support: How to Upgrade Before February 28, 2027

MicroPyramid 15 min read
RDS PostgreSQL 14 End of Standard Support: How to Upgrade Before February 28, 2027

Short answer: RDS PostgreSQL 14 end of standard support is February 28, 2027. After that, depending on each database's Extended Support setting, AWS either keeps it running and charges for RDS Extended Support per vCPU-hour from March 1, 2027, or upgrades it to a newer major version itself, on or shortly after the deadline. One is a growing bill, the other an upgrade nobody rehearsed. Upgrade to PostgreSQL 17 or 18 before then, after a rehearsal on a copy restored from a snapshot.

The PostgreSQL project stopped supporting version 14 on November 12, 2026, so the AWS date is the last stop. Every date and behaviour below comes from AWS's documentation and postgresql.org, checked in November 2026. For the other 2026 and 2027 deadlines, see our end-of-life guide.

When does standard support end for each RDS for PostgreSQL version?

PostgreSQL on RDS Standard support ends Extended Support charges start Higher year 3 pricing from Extended Support ends
18 February 28, 2031 March 1, 2031 March 1, 2033 February 28, 2034
17 February 28, 2030 March 1, 2030 March 1, 2032 February 28, 2033
16 February 28, 2029 March 1, 2029 March 1, 2031 February 29, 2032
15 February 29, 2028 March 1, 2028 March 1, 2030 February 28, 2031
14 February 28, 2027 March 1, 2027 March 1, 2029 February 28, 2030
13 February 28, 2026 (ended) March 1, 2026 March 1, 2028 February 28, 2029
12 February 28, 2025 (ended) March 1, 2025 March 1, 2027 February 29, 2028
11 February 29, 2024 (ended) April 1, 2024 April 1, 2026 March 31, 2027

Source: AWS's release calendar for RDS for PostgreSQL. AWS lists 10 and 9.6 as deprecated, with no Extended Support.

  • Check the minor version too. 14.18 and 14.19 already left standard support on October 31, 2026; 14.20 to 14.24 run to February 2027.
  • PostgreSQL 15 buys one year (to February 29, 2028), so it is a poor target.
  • Extended Support for 14 ends on February 28, 2030. AWS then upgrades whatever is still on 14.

The AWS CLI shows the same dates:

# Standard and Extended Support dates for a major version
aws rds describe-db-major-engine-versions \
  --engine postgres \
  --major-engine-version 14

What does RDS Extended Support mean for PostgreSQL 14?

Extended Support lets a database stay on a major version after standard support ends, for an extra charge. From AWS's documentation:

  • Enrollment decides what happens on March 1. An enrolled database keeps running on 14, and AWS says enrollment changes neither the engine nor uptime or performance. A database with enrollment off is upgraded by AWS on or shortly after the deadline. Enrollment is on by default when you create or restore through the CLI, the API or CloudFormation, and off by default on the console's create screen, so check each database.
  • What you get: fixes for critical and high severity security issues and critical bugs, and support cases.
  • How it is charged: per vCPU per hour, at a rate that depends on the Region and the date, higher from the third year (March 1, 2029 for 14). Multi-AZ standbys and read replicas count, and Reserved Instance discounts do not apply. Stored snapshots are not charged, but an instance restored from a 14 snapshot after the deadline is. The rates are on AWS's RDS for PostgreSQL pricing page.
  • How it stops: upgrade to a version under standard support, or delete the database. Turning enrollment off after the deadline triggers the automatic upgrade instead.

How do we find every PostgreSQL 14 database we run?

RDS is regional, so check every Region enabled for the account. The loop below lists each PostgreSQL instance, read replicas included, with its version, class, Multi-AZ flag and Extended Support enrollment (open-source-rds-extended-support means enrolled). Multi-AZ DB clusters appear under aws rds describe-db-clusters, and Aurora PostgreSQL is a separate engine with its own calendar.

# Every RDS for PostgreSQL instance, in every Region enabled for the account
for region in $(aws ec2 describe-regions --query "Regions[].RegionName" --output text); do
  echo "== $region"
  aws rds describe-db-instances \
    --region "$region" \
    --filters Name=engine,Values=postgres \
    --query "DBInstances[].[DBInstanceIdentifier,EngineVersion,DBInstanceClass,MultiAZ,EngineLifecycleSupport]" \
    --output table
done

Every row whose EngineVersion starts with 14 needs a plan. Next, ask RDS which major versions your exact minor version can move to, in the Region where it runs. From 14.24, for example, AWS lists 15.19, 16.15, 17.11 and 18.6.

# Major version upgrade targets for one source version
aws rds describe-db-engine-versions \
  --region us-east-1 \
  --engine postgres \
  --engine-version 14.24 \
  --query 'DBEngineVersions[].ValidUpgradeTarget[?IsMajorVersionUpgrade==`true`].EngineVersion' \
  --output text

Should we upgrade to PostgreSQL 16, 17 or 18?

For most teams, 17 or 18. RDS upgrades directly from 14 to either, with no stop at 15 or 16.

  • PostgreSQL 18 has the longest runway, with RDS standard support until February 28, 2031, and has been on RDS since November 14, 2025. Check your extensions first: RDS PostgreSQL 18 drops plrust, and postgis_topology is unavailable on 18.1 and 18.2.
  • PostgreSQL 17 runs to February 28, 2030 and has been on RDS since November 14, 2024, so it has two years of minor releases behind it.
  • PostgreSQL 16 ends on February 28, 2029. Choose it only if a dependency rules out 17.

Skipping versions does not skip their changes: the PostgreSQL docs say to read the release notes of every version in between, especially the "Migration" sections. Three that reach applications:

  • 15 stops letting every user create objects in the public schema of new databases. Upgraded databases keep their permissions; new ones behave differently.
  • 16 changed the aclitem format, so AWS asks you to remove aclitem columns from user tables first.
  • 18 deprecates MD5 passwords, makes VACUUM and ANALYZE include inheritance children, and stops COPY FROM treating \. as end of file in CSV data.

Which upgrade method fits: in place, blue/green or logical replication?

Method Downtime Way back Fits when
In-place upgrade An outage until the upgrade finishes, read replicas included No downgrade: restore the pre-upgrade snapshot to a new instance, losing later writes The database can take a maintenance window
Blue/green deployment The switchover, typically under a minute (AWS) The old instance is kept, read-only, without writes made after the switch Every table has a primary key and schema changes can pause
Logical replication you run Several seconds at the switch (PostgreSQL docs) The old instance stays as it was at the switch Blue/green does not support your setup, or you want control of every step

In-place major version upgrade

RDS runs pg_upgrade on the instance. Per AWS's documentation:

  • A precheck runs first and logs problems to pg_upgrade_precheck.log. Clear these beforehand: open prepared transactions, reg* types in user tables (except regclass and regtype), aclitem columns, invalid databases, and logical replication slots (only from version 17 can slots survive an upgrade).
  • Everything goes down together. The Multi-AZ primary and standby upgrade at the same time, and in-Region read replicas upgrade with the primary. AWS says the database might be unavailable for several minutes; the rehearsal gives you your own number.
  • Snapshots: with backup retention above 0, RDS takes one before and one after. Point-in-time restore is unavailable while the upgrade runs.
  • Parameter groups: a custom group must be replaced by one from the new version's family. New groups start with default values, so copy your changes across.
# The parameter group family of the target version
aws rds describe-db-engine-versions \
  --engine postgres \
  --engine-version 17.11 \
  --query "DBEngineVersions[].DBParameterGroupFamily" \
  --output text

# The settings you changed in the current group, to copy across
aws rds describe-db-parameters \
  --db-parameter-group-name app-pg14 \
  --source user \
  --query "Parameters[].[ParameterName,ParameterValue]" \
  --output table

# A new group in the target family (use the family printed above)
aws rds create-db-parameter-group \
  --db-parameter-group-name app-pg17 \
  --db-parameter-group-family postgres17 \
  --description "App settings for PostgreSQL 17"
# The upgrade itself: on the rehearsal copy first, production later
aws rds modify-db-instance \
  --db-instance-identifier app-pg-rehearsal \
  --engine-version 17.11 \
  --allow-major-version-upgrade \
  --db-parameter-group-name app-pg17 \
  --apply-immediately

Blue/green deployment

RDS builds a green copy of production, upgrades it and keeps it in sync until you switch. For a major upgrade from 14.9 or later, the sync uses logical replication, and its limits become yours:

  • Logical replication must be on in production: rds.logical_replication set to 1 in a custom parameter group. It is a static parameter, so production needs a reboot; schedule it well ahead. Tune max_replication_slots, max_wal_senders, max_logical_replication_workers and max_worker_processes too: each database needs a worker.
  • Every table needs a primary key, because logical replication does not allow UPDATE or DELETE on tables without one. REPLICA IDENTITY FULL is the slower fallback.
  • No schema changes meanwhile. DDL (new partitions included) and GRANT or REVOKE on production put the deployment into "Replication degraded", and you delete it and start again. pg_partman must be disabled.
  • Some data does not travel: large objects (changing one also degrades replication) and unlogged tables. Materialized views need a refresh after switchover; RDS syncs sequences during it.
  • Heavy writes can outrun it. Green applies changes on a single thread while WAL piles up on production, so check free storage. For very high write volume, AWS points to AWS DMS.
  • Not supported: Multi-AZ DB clusters, cascading or cross-Region read replicas, CloudFormation, and master passwords managed in Secrets Manager.

At switchover the endpoints move to green, and the old instance is renamed with an -old1 suffix, read-only and no longer receiving changes. Point-in-time recovery on the new production instance only reaches back to when green was created.

# 1. Logical replication on, in production's custom parameter group.
#    The parameter is static, so it takes effect after a reboot.
aws rds modify-db-parameter-group \
  --db-parameter-group-name app-pg14 \
  --parameters "ParameterName=rds.logical_replication,ParameterValue=1,ApplyMethod=pending-reboot"
aws rds reboot-db-instance --db-instance-identifier app-prod

# 2. A green copy on the new version
aws rds create-blue-green-deployment \
  --blue-green-deployment-name app-pg14-to-pg17 \
  --source arn:aws:rds:us-east-1:123456789012:db:app-prod \
  --target-engine-version 17.11 \
  --target-db-parameter-group-name app-pg17

# 3. After testing green, with replication lag close to zero
aws rds switchover-blue-green-deployment \
  --blue-green-deployment-identifier bgd-1234567890abcdef \
  --switchover-timeout 600

Logical replication you run yourself

Create a new RDS instance on 17 or 18, copy the schema, and let a publication and subscription stream the data. Once it has caught up, stop writes, update the sequences and repoint the application. The PostgreSQL docs put that switch at several seconds of downtime.

The limits are PostgreSQL's own: only tables are replicated, not schema changes, sequence values or large objects. Production still needs rds.logical_replication and its reboot, and the replication user needs the rds_replication role. pg_dump copies no roles, so create them first. Afterwards, drop the subscription and check that no slot is left: AWS warns that an unread slot can quickly fill storage.

# Copy the schema (not the data) to the new instance; create roles there first
pg_dump --host=<old-endpoint> --username=<user> --dbname=<db> --schema-only --file=schema.sql
psql --host=<new-endpoint> --username=<user> --dbname=<db> --file=schema.sql
-- On the PostgreSQL 14 instance (publisher)
CREATE PUBLICATION upgrade_pub FOR ALL TABLES;

-- On the new instance (subscriber)
CREATE SUBSCRIPTION upgrade_sub
  CONNECTION 'host=<old-endpoint> port=5432 dbname=<db> user=<replication-user> password=<password>'
  PUBLICATION upgrade_pub;

-- At cutover, once writes have stopped. Sequences are not replicated:
-- run this on the old instance, then run its output on the new one.
SELECT format('SELECT setval(%L, %s, true);',
              quote_ident(schemaname) || '.' || quote_ident(sequencename),
              last_value)
FROM pg_sequences
WHERE last_value IS NOT NULL;

How do we rehearse the upgrade on a restored snapshot?

AWS recommends a dry run on a copy of production. It tells you how long the upgrade takes, what the precheck rejects and which queries slow down, while production carries on.

  1. Restore a snapshot of production as a new, private instance. Name the subnet group, security group and parameter group; otherwise the restore uses defaults.
  2. Warm it up before timing anything. A restored instance loads its data from S3 in the background, and AWS suggests full table scans on the tables you need.
  3. Run the prechecks below and fix what they find, in production too. AWS's upgrade page has the longer reg* and aclitem queries.
  4. Update extensions on 14 first. AWS's advice for PostGIS is to upgrade it before the engine upgrade and again after.
  5. Run the upgrade with your chosen method and time it end to end.
  6. Finish it: ANALYZE everywhere, extension updates, and a drop and recreate for pg_repack.
  7. Point a staging copy of the application at it. Run the tests, background jobs and slowest queries, and watch for query plan regressions, as AWS suggests.
  8. Write the runbook with timings, then delete the copy. With the CLI defaults, a copy restored from a 14 snapshot after February 28, 2027 is billed for Extended Support.
# 1. A manual snapshot of production
aws rds create-db-snapshot \
  --db-instance-identifier app-prod \
  --db-snapshot-identifier app-prod-pg14-rehearsal
aws rds wait db-snapshot-available --db-snapshot-identifier app-prod-pg14-rehearsal

# 2. A private copy in production's network, with production's settings
aws rds restore-db-instance-from-db-snapshot \
  --db-instance-identifier app-pg-rehearsal \
  --db-snapshot-identifier app-prod-pg14-rehearsal \
  --db-subnet-group-name app-db-subnets \
  --vpc-security-group-ids sg-0123456789abcdef0 \
  --db-parameter-group-name app-pg14 \
  --no-multi-az \
  --no-publicly-accessible
aws rds wait db-instance-available --db-instance-identifier app-pg-rehearsal
-- Instance-wide prechecks (run once)
SELECT count(*) FROM pg_catalog.pg_prepared_xacts;          -- must be 0
SELECT slot_name, database FROM pg_replication_slots
  WHERE slot_type = 'logical';                              -- drop or plan around
SELECT datname FROM pg_database WHERE datconnlimit = -2;    -- invalid databases

-- Per-database prechecks (run in each database)
SELECT count(*) FROM pg_largeobject_metadata;               -- large objects
SELECT extname, extversion FROM pg_extension ORDER BY extname;

-- Tables without a primary key (blue/green and logical replication need one)
SELECT c.oid::regclass AS table_name
FROM pg_class c
JOIN pg_namespace n ON n.oid = c.relnamespace
WHERE c.relkind = 'r'
  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
  AND NOT EXISTS (
    SELECT 1 FROM pg_constraint p
    WHERE p.conrelid = c.oid AND p.contype = 'p'
  );
-- After the upgrade, in every database
-- Optimizer statistics are not carried over by a major version upgrade
ANALYZE VERBOSE;

-- Extensions are not upgraded with the engine: list the ones behind
SELECT name, installed_version, default_version
FROM pg_available_extensions
WHERE installed_version IS NOT NULL
  AND installed_version <> default_version;

-- Then update each one, and PostGIS with its own function
ALTER EXTENSION <extension_name> UPDATE;
SELECT postgis_extensions_upgrade();

How do we cut over with a way back?

  1. Set the window from the rehearsal timings, and agree in advance which failures send you back and who decides.
  2. Freeze schema changes while a blue/green deployment or replication is running.
  3. Take a manual snapshot just before, with backup retention above 0 so RDS adds its own.
  4. Keep DNS caching short. For blue/green, AWS asks that clients cache the record for five seconds at most, or they keep writing to the old instance.
  5. Switch, then finish: ANALYZE, extension updates, and smoke tests on sign-in, payments, anything that writes data and the background jobs. Watch errors and slow queries for the first days.
  6. Know your way back. In place, there is no downgrade: rename the upgraded instance and restore the pre-upgrade snapshot under the original name (AWS's documented way to replace an instance), losing later writes. After blue/green, the -old1 instance is read-only until you change default_transaction_read_only, and lacks writes made since the switch. With your own replication, the old instance is untouched.
  7. Clean up. Keep the old instance for your recovery window, then delete it: a 14 instance kept past February 28, 2027 is billed for Extended Support (or upgraded by AWS). Update your infrastructure code, so the next deploy does not undo the change.

What drives the effort of an RDS PostgreSQL upgrade?

These decide the work more than the size of the database does:

  • How many databases, Regions and replicas, each with its own window or deployment.
  • Extensions: PostGIS before and after the engine, pg_repack recreated, plrust gone on 18, and pg_partman, pg_cron and pglogical handled specially for blue/green.
  • Schema traits: tables without primary keys, large objects, unlogged tables, and reg* or aclitem columns.
  • Downtime tolerance and write volume, which decide between in place, blue/green and replication.
  • How often migrations ship, which sets the cost of a schema freeze.
  • The application on top. If it is a Django app on an old release, our guide to upgrading Django 4.2 to 5.2 covers that side, including the database versions each release supports.

How we approach it at MicroPyramid

We start with an Upgrade Assessment, then run the upgrade as a fixed project that we finish and hand back to your team.

The Upgrade Assessment gives you a version, dependency and end-of-life audit of everything you run; an upgrade path with the test gaps and risks called out; and a cost and speed review of your cloud bill and slowest pages, which is where an Extended Support charge would show up. The scope is agreed before any upgrade work starts.

The upgrade is then a fixed project: prechecks cleared, a rehearsal on a restored snapshot with timings, the method that fits your downtime tolerance, and a cutover with a written way back. We hand it back with the runbook and notes on what changed. To keep the database and the application on supported versions afterwards, our software maintenance runs month to month with 30 days' notice.

Still running PostgreSQL 14 on RDS? Tell us what you run and we will show you what the path to 17 or 18 looks like for your databases.

Frequently Asked Questions

When does RDS for PostgreSQL 14 reach end of standard support?

On February 28, 2027. Extended Support charges start on March 1, 2027, move to year 3 pricing on March 1, 2029, and Extended Support ends on February 28, 2030. The PostgreSQL community stopped supporting version 14 on November 12, 2026.

What happens to an RDS PostgreSQL 14 database after February 28, 2027?

If it is enrolled in RDS Extended Support, it keeps running and AWS charges for Extended Support. If not, AWS upgrades it to a supported major version on or shortly after that date. aws rds describe-db-instances shows each database's EngineLifecycleSupport value.

How is RDS Extended Support for PostgreSQL charged?

Per vCPU per hour, at a rate that depends on the Region and the date and rises from the third year. Multi-AZ standbys and read replicas are charged too, and Reserved Instance discounts do not apply. AWS lists the rates on its RDS for PostgreSQL pricing page.

Which version should I upgrade to from PostgreSQL 14?

PostgreSQL 17 or 18. RDS supports 17 until February 28, 2030 and 18 until February 28, 2031. Choosing 15 or 16 means the next upgrade is due by February 2028 or February 2029.

Can I upgrade directly from PostgreSQL 14 to 18 on RDS?

Yes. RDS lists 18.x as an upgrade target for current 14.x minor versions. Check the targets for your exact version with aws rds describe-db-engine-versions, and read the release notes of every version in between.

Can I roll back an RDS PostgreSQL major version upgrade?

Not in place. The way back is to restore the snapshot RDS took before the upgrade to a new instance, losing later writes. A blue/green deployment keeps the old instance after switchover, read-only and without the writes made since.

How much downtime does the upgrade need?

In place, the database is down until the upgrade finishes, read replicas included; AWS says a Multi-AZ instance might be unavailable for several minutes. A blue/green switchover typically takes under a minute. Measure your own number on a restored copy before you book the window.

Share this article
Related service AWS Consulting Services

Start with a discovery call.

  1. 01 · TODAY Book a free 30-minute call Tell us what you run and where it hurts.
  2. 02 · WITHIN 24 HOURS We reply From the engineers you would work with.
  3. 03 · ON THE CALL Your first step A fixed-scope sprint or audit, not an open-ended retainer.
Book a Free Discovery Call
Email
hello@micropyramid.com
Phone
+91 99591 66266
Offices
Plano --:--Hyderabad --:--Sharjah --:--
You own
All code & IP, from day one

We reply within 24 hours