EST5EDT vs America/New_York in PostgreSQL
Chat2DB TeamEST5EDT, CST6CDT, MST7MDT and PST8PDT look like convenient names for the four main US time zones, and plenty of old configuration files, Java properties and database settings still use them. For years they were simply aliases: in the time zone database (tzdata) they pointed to America/New_York, America/Chicago, America/Denver and America/Los_Angeles, so it did not matter which name you used.
That stopped being true with tzdata 2026f. According to the PostgreSQL 18.7 release notes, these four zones "now use their indicated fixed UTC offsets and abbreviations for all historical timestamps" instead of inheriting the history of the city-named zones. PostgreSQL 18.7, 17.12, 16.16, 15.20 and 14.25 (released November 12, 2026) bundle tzdata 2026f, so after a minor update, PostgreSQL can return a different local time for the same old timestamp depending on which of the two names you use. The same tzdata release also moved Manitoba and the Northwest Territories to year-round time. This article measures the difference, explains who is affected, and shows how to move settings and data to the city-named zones.
What These Names Mean
A name like EST5EDT is shaped like a POSIX TZ string: a standard-time abbreviation (EST), the offset in hours west of UTC (5), and a daylight-time abbreviation (EDT). Unlike a full POSIX string, it does not say when daylight time starts and ends. tzdata defines these four names as zones of their own, and since 2026f they follow US federal daylight saving rules throughout history, with no local exceptions.
City-named zones such as America/New_York follow what clocks in that city actually did. That includes local mean time before standard time zones were adopted in 1883, and the decades between the World Wars when New York observed daylight time under local law while there was no national rule.
There are also fixed-offset names, such as EST (always UTC-5, no daylight time), and full POSIX specifications such as EST5EDT,M3.2.0,M11.1.0 that spell out the transition rules. Those behave differently again, as shown below.
Measuring the Difference
We compared both names for every hour from 1900 to 2030, on PostgreSQL 18.6 (which bundles tzdata 2026c) and on 18.7 (2026f):
SET timezone = 'UTC';
SELECT count(*) FILTER (WHERE (g AT TIME ZONE 'EST5EDT') <> (g AT TIME ZONE 'America/New_York')) AS est_vs_ny,
count(*) FILTER (WHERE (g AT TIME ZONE 'PST8PDT') <> (g AT TIME ZONE 'America/Los_Angeles')) AS pst_vs_la,
count(*) FILTER (WHERE (g AT TIME ZONE 'CST6CDT') <> (g AT TIME ZONE 'America/Chicago')) AS cst_vs_chi,
count(*) FILTER (WHERE (g AT TIME ZONE 'MST7MDT') <> (g AT TIME ZONE 'America/Denver')) AS mst_vs_den,
min(g) FILTER (WHERE (g AT TIME ZONE 'EST5EDT') <> (g AT TIME ZONE 'America/New_York')) AS first_diff,
max(g) FILTER (WHERE (g AT TIME ZONE 'EST5EDT') <> (g AT TIME ZONE 'America/New_York')) AS last_diff
FROM generate_series(timestamptz '1900-01-01', timestamptz '2030-12-31', interval '1 hour') g;PostgreSQL 18.6:
est_vs_ny | pst_vs_la | cst_vs_chi | mst_vs_den | first_diff | last_diff
-----------+-----------+------------+------------+------------+-----------
0 | 0 | 0 | 0 | |PostgreSQL 18.7:
est_vs_ny | pst_vs_la | cst_vs_chi | mst_vs_den | first_diff | last_diff
-----------+-----------+------------+------------+------------------------+------------------------
168461 | 73222 | 170645 | 15620 | 1920-03-28 07:00:00+00 | 1966-10-30 05:00:00+00On 18.6 the names were identical over 131 years. On 18.7, EST5EDT and America/New_York disagree on 168,461 hours, all between 1920 and 1966. Chicago shows a similar count, Los Angeles fewer, and Denver the fewest, which matches how much local daylight saving each city observed in that period.
Sample Timestamps
Converting a handful of instants into both names on 18.7 shows the pattern:
SET timezone = 'UTC';
SELECT ts, ts AT TIME ZONE 'EST5EDT' AS est5edt, ts AT TIME ZONE 'America/New_York' AS new_york
FROM (VALUES (timestamptz '1883-11-18 12:00+00'), (timestamptz '1943-01-15 12:00+00'),
(timestamptz '1950-07-01 12:00+00'), (timestamptz '1974-01-15 12:00+00'),
(timestamptz '2027-01-15 12:00+00')) v(ts); ts | est5edt | new_york
------------------------+---------------------+---------------------
1883-11-18 12:00:00+00 | 1883-11-18 07:00:00 | 1883-11-18 07:03:58
1943-01-15 12:00:00+00 | 1943-01-15 08:00:00 | 1943-01-15 08:00:00
1950-07-01 12:00:00+00 | 1950-07-01 07:00:00 | 1950-07-01 08:00:00
1974-01-15 12:00:00+00 | 1974-01-15 08:00:00 | 1974-01-15 08:00:00
2027-01-15 12:00:00+00 | 2027-01-15 07:00:00 | 2027-01-15 07:00:00- 1883: New York still used local mean time, 4 hours 56 minutes 2 seconds behind UTC.
EST5EDTnow shows a clean UTC-5. - 1943: both show 08:00. That was nationwide "War Time", a federal rule, so the federal-rules zone has it too.
- 1950: New York observed summer daylight time under state and local law; there was no federal rule.
EST5EDTnow says standard time. - 1974: both show daylight time in January. That was the federal emergency daylight time of the energy crisis.
- 2027: identical. Current and future rules match.
On 18.6, every row showed the same value in both columns, including 07:03:58 for 1883 and 08:00:00 for 1950.
The difference goes in both directions. Converting the wall-clock time 1950-07-01 08:00 to an instant gives 12:00 UTC with America/New_York but 13:00 UTC with EST5EDT on 18.7. And with SET timezone = 'EST5EDT', timestamptz '1950-07-01 12:00+00' now displays as 1950-07-01 07:00:00-05 instead of 08:00:00-04.
Who Is Affected
Present-day and future timestamps are not affected; the US rules since 1967 are federal, so both names agree. You are affected if all of these are true:
- A session, role, database or server uses
EST5EDT,CST6CDT,MST7MDTorPST8PDTas itsTimeZone, or an application passes one of them toAT TIME ZONEor a driver. - You store or display timestamps from before 1967 (roughly; the exact range depends on the city): historical archives, genealogy data, birth dates stored as
timestamptz, insurance or pension records, scientific observations, or backfilled time series. - Something converts between local time and UTC using that name: rendering, parsing input,
date_truncby local day, grouping by local hour.
A birth date stored as timestamptz '1950-07-01 00:00' while the session zone was EST5EDT (and the rules were still the old ones) was saved as 04:00 UTC. On 18.7 the same session renders it as 1950-06-30 23:00:00-05, a different calendar day. This is the classic reason not to store dates as timestamps: a date column is immune to any time zone rule change.
Finding Where the Names Are Used
Start with the settings. Check the current value and where it came from:
SELECT name, setting, source, sourcefile
FROM pg_settings
WHERE name IN ('TimeZone', 'log_timezone');Per-database and per-role settings live in pg_db_role_setting:
SELECT coalesce(d.datname, '(all databases)') AS database,
coalesce(r.rolname, '(all roles)') AS role,
s.setconfig
FROM pg_db_role_setting s
LEFT JOIN pg_database d ON d.oid = s.setdatabase
LEFT JOIN pg_roles r ON r.oid = s.setrole
WHERE array_to_string(s.setconfig, ',') ~* 'timezone=(EST5EDT|CST6CDT|MST7MDT|PST8PDT)';Then look for stored zone names. If your schema has columns such as user_timezone or tz, count the legacy values:
SELECT tz, count(*)
FROM appointments
WHERE tz IN ('EST5EDT', 'CST6CDT', 'MST7MDT', 'PST8PDT')
GROUP BY tz;Outside the database, search application configuration for the same names: JDBC URLs and -Duser.timezone, TZ environment variables in containers and systemd units, ORM settings, and cron or scheduler definitions.
Moving to City-Named Zones
For settings, switch to the city zone that matches what you meant:
ALTER DATABASE app SET timezone = 'America/New_York';
ALTER ROLE reporting SET timezone = 'America/Chicago';
-- postgresql.conf: timezone = 'America/Los_Angeles', then reloadNew sessions pick up database and role settings at connect time; existing connections keep their value until they reconnect, so restart connection pools after the change.
For stored zone names, a direct mapping is safe for the US mainland zones:
UPDATE appointments
SET tz = CASE tz
WHEN 'EST5EDT' THEN 'America/New_York'
WHEN 'CST6CDT' THEN 'America/Chicago'
WHEN 'MST7MDT' THEN 'America/Denver'
WHEN 'PST8PDT' THEN 'America/Los_Angeles'
END
WHERE tz IN ('EST5EDT', 'CST6CDT', 'MST7MDT', 'PST8PDT');If you need a user's real location, the city zone may not be the right one either: someone in Indiana or Arizona has their own zone (America/Indiana/Indianapolis, America/Phoenix). The legacy names never captured that.
For stored instants (timestamptz) the question is which rules were used when they were written. Rows inserted with the old tzdata, where EST5EDT meant New York, are correct instants for New York local time; display them with America/New_York and they show what the user entered. Rows written by a session on the new tzdata with EST5EDT and a pre-1967 local time are one hour off compared with New York's actual clocks, if New York is what was meant. For those, reinterpret the instant:
-- instant written under new EST5EDT rules, meant as New York local time
SET timezone = 'UTC';
SELECT (ts AT TIME ZONE 'EST5EDT') AT TIME ZONE 'America/New_York' AS corrected
FROM (VALUES (timestamptz '1950-07-01 13:00+00')) v(ts);
-- 1950-07-01 12:00:00+00POSIX Strings and the Sign Trap
PostgreSQL also accepts full POSIX time zone specifications, and these are easy to confuse with the legacy names. On 18.7:
SET timezone = 'UTC';
SELECT ts AT TIME ZONE 'EST5EDT' AS est5edt,
ts AT TIME ZONE 'EST' AS est_fixed,
ts AT TIME ZONE 'EST5EDT,M3.2.0,M11.1.0' AS posix_full,
ts AT TIME ZONE 'XYZ5ABC' AS posix_no_rules
FROM (VALUES (timestamptz '1950-07-01 12:00+00'), (timestamptz '2027-07-15 12:00+00')) v(ts); est5edt | est_fixed | posix_full | posix_no_rules
---------------------+---------------------+---------------------+---------------------
1950-07-01 07:00:00 | 1950-07-01 07:00:00 | 1950-07-01 08:00:00 | 1950-07-01 08:00:00
2027-07-15 08:00:00 | 2027-07-15 07:00:00 | 2027-07-15 08:00:00 | 2027-07-15 08:00:00ESTis a fixed UTC-5 with no daylight time, ever.EST5EDT,M3.2.0,M11.1.0applies today's rule (second Sunday of March to first Sunday of November) to every year, including 1950.- A POSIX string without rules, such as
XYZ5ABC, gets PostgreSQL's default US rules, again applied to every year.
None of them reproduce the history of America/New_York. And note the sign convention: POSIX offsets count hours west of UTC, so SET timezone = 'UTC+5' produces -05, the same as Etc/GMT+5:
posix_sign_trap
------------------------
2027-01-15 07:00:00-05If you need a fixed offset, an ISO-style offset in the value ('2027-01-15 12:00+05') or interval arithmetic is clearer than a POSIX zone name.
Checking Other Systems
The same tzdata change reaches other software through its own update channel. Operating systems update /usr/share/zoneinfo through their tzdata package; Java has its own tzdata in the JDK (updated by JDK releases or the TZUpdater tool); Node.js and browsers use ICU's copy; Python's zoneinfo uses system files or the tzdata package. During the transition, two systems can disagree about 1950 in EST5EDT even when both are "correct" for their tzdata version. Moving to city-named zones everywhere removes that whole class of disagreement.
When comparing results from an updated and a not-yet-updated server, it helps to run the same query against both and look at the output side by side; Chat2DB (opens in a new tab) lets you open both connections in one workspace and diff the result grids.
Summary
Until tzdata 2026f, EST5EDT, CST6CDT, MST7MDT and PST8PDT behaved exactly like America/New_York, America/Chicago, America/Denver and America/Los_Angeles. Since PostgreSQL 18.7, 17.12, 16.16, 15.20 and 14.25, they follow US federal rules for all of history: no local mean time, and no local daylight time between 1920 and 1966. Current and future timestamps are unchanged, but historical timestamps can shift by an hour (or by a few minutes before 1883). Find the names in pg_settings, pg_db_role_setting, stored zone columns and application configuration, replace them with city-named zones, and store pure dates as date so that no time zone rule can move them.
