PostgreSQL

PostgreSQL — often shortened to Postgres — is a free, open-source object-relational database management system known for standards compliance, reliability, and an unusually deep capacity for extension. Data lives in tables defined by a schema and is queried with SQL, the declarative language in which you describe what data you want (SELECT name FROM users WHERE active = true) rather than how the engine should fetch it. What distinguishes PostgreSQL is how far it pushes beyond the classic relational model: custom data types, user-defined functions in many languages, table inheritance, a powerful rule and trigger system, and a long list of extensions that bolt new capabilities directly onto the engine.

The language developers write against PostgreSQL is SQL — a broad, highly standards-conformant dialect — layered with a procedural sub-language for server-side logic (PL/pgSQL) and pluggable procedural languages such as PL/Python, PL/Perl, and PL/Tcl. But PostgreSQL’s identity has always been as much about its engine and its philosophy as its syntax: correctness over shortcuts, extensibility over a fixed feature set, and a community-governed development model with no single corporate owner.

History and Origins

PostgreSQL’s roots reach back to one of the most influential figures in database history, Michael Stonebraker. In the 1970s at UC Berkeley, Stonebraker had led Ingres, an early relational database that helped prove Edgar Codd’s relational theory could be made practical. In 1986 he launched a successor project, POSTGRES (literally “post-Ingres”), to explore ideas that the strict relational model handled poorly: complex objects, user-defined types and operators, and an active rule system for enforcing business logic inside the database.

POSTGRES used its own query language, POSTQUEL, and circulated as a research system through the late 1980s and early 1990s. Version 1 reached outside users in 1989, with versions 2 and 3 following, before the Berkeley project formally ended at version 4.2 in 1994.

The pivotal turn came that same year. Two Berkeley graduate students, Andrew Yu and Jolly Chen, replaced POSTQUEL with an interpreter for the industry-standard SQL language, releasing the result the following year as Postgres95 on the open web in 1995. In 1996, recognizing both the SQL support and the system’s heritage, the project was renamed PostgreSQL. Stewardship passed to a distributed, all-volunteer group of contributors — the PostgreSQL Global Development Group — and version numbering resumed at 6.0 to continue from the original POSTGRES lineage. PostgreSQL 6.0 shipped in early 1997, beginning the project’s steady cadence of roughly annual major releases that continues today.

Design Philosophy

PostgreSQL’s culture prizes correctness and standards compliance above almost everything else. Where some databases historically took liberties with the SQL standard for speed or convenience, PostgreSQL’s community has tended to implement features carefully and conservatively, favoring data integrity and predictable behavior. This reputation for being “the database that does the right thing” is a large part of why it is trusted for systems of record.

The second pillar is extensibility, inherited directly from the POSTGRES research agenda. PostgreSQL was designed so that types, functions, operators, index methods, and even procedural languages can be added without modifying the core. This is why an extension like PostGIS can transform PostgreSQL into a world-class spatial database, or why TimescaleDB can adapt it for time-series data — the engine was built to be grown.

A third defining trait is its governance. PostgreSQL is not owned by any single company; it is developed by a global community under the permissive PostgreSQL License (a liberal, BSD/MIT-style license). That independence has insulated it from the acquisition dramas that buffeted other open-source databases and has encouraged a broad ecosystem of vendors building products on top of the same shared core.

Key Features

• Object-relational model — user-defined types, table inheritance, arrays, composite types, and ranges alongside ordinary relational tables.
• Standards-compliant SQL — one of the most complete and conformant SQL implementations among open-source databases, including window functions, common table expressions (including recursive CTEs), and rich JOIN support.
• MVCC concurrency — multi-version concurrency control lets readers and writers proceed without blocking each other, providing strong transactional isolation.
• JSON and JSONB — first-class document storage, with the binary, indexable JSONB type enabling document-style workloads inside a relational engine.
• Extensible indexing — multiple index types (B-tree, hash, GiST, SP-GiST, GIN, BRIN) and the ability to define new ones, supporting everything from full-text search to geospatial queries.
• Procedural languages — server-side logic in PL/pgSQL plus optional PL/Python, PL/Perl, PL/Tcl, and community languages.
• Replication and high availability — built-in streaming replication, hot standby, and logical replication for scaling reads and building resilient systems.
• Extensions — a packaging mechanism (CREATE EXTENSION) that powers a vast ecosystem: PostGIS, TimescaleDB, Citus, pgvector, and many more.

A short session shows the declarative core, with a PostgreSQL touch in the JSONB column:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

CREATE TABLE users (
  id       SERIAL PRIMARY KEY,
  name     TEXT NOT NULL,
  active   BOOLEAN DEFAULT TRUE,
  profile  JSONB
);

INSERT INTO users (name, profile)
VALUES ('Ada', '{"role": "engineer"}'),
       ('Linus', '{"role": "maintainer"}');

SELECT name, profile->>'role' AS role
FROM users
WHERE active = TRUE
ORDER BY name;

Evolution

PostgreSQL’s feature set has compounded steadily across decades of releases. 7.0 (2000) brought foreign keys and a much-improved optimizer. 8.0 (2005) added native Windows support, savepoints, point-in-time recovery, and tablespaces, opening the door to mainstream enterprise adoption. The 9.x series was transformative: 9.0 (2010) introduced built-in streaming replication and hot standby, and 9.4 (2014) delivered the indexable JSONB type that reframed PostgreSQL as a hybrid relational/document store.

PostgreSQL 10 (2017) modernized the version-numbering scheme — the leading number is now the major version — and shipped declarative partitioning and logical replication, both essential for large deployments. Subsequent releases refined performance, parallelism, and SQL/JSON standard support, through PostgreSQL 17 (September 2024) with incremental backups and improved vacuuming. PostgreSQL 18, released on 25 September 2025, introduced a new asynchronous I/O subsystem (selectable via the io_method setting, including Linux’s io_uring); the project reported that this AIO work delivered up to roughly 3× faster reads from storage in specific I/O-bound scenarios such as sequential scans and vacuum, relative to the previous synchronous I/O path — a figure that varies widely with hardware, storage, and workload. The 18 release also added virtual generated columns, native uuidv7() generation, OAuth 2.0 authentication, and page checksums on by default.

Current Relevance

PostgreSQL is, by many measures, the open-source database of the moment. It consistently ranks at or near the top of developer surveys for “most admired” and “most wanted” database, and it has steadily gained ground as a default choice for new applications — a position once held more firmly by MySQL. Its appeal spans startups and large enterprises alike: a single engine that handles transactional workloads, JSON documents, full-text search, geospatial data (via PostGIS), time-series (via TimescaleDB), and increasingly vector similarity search for AI applications (via pgvector).

Every major cloud offers managed PostgreSQL — Amazon RDS and Aurora, Google Cloud SQL and AlloyDB, Azure Database for PostgreSQL, and many specialized providers — and an entire industry of PostgreSQL-derived and PostgreSQL-compatible products has grown up around it, from analytics engines like Greenplum and Amazon Redshift to distributed SQL systems such as CockroachDB and YugabyteDB that speak the PostgreSQL wire protocol.

Why It Matters

PostgreSQL is a rare success story of academic research becoming durable infrastructure. The object-relational ideas Michael Stonebraker pursued at Berkeley — extensible types, user-defined functions, an engine you can grow rather than merely configure — turned out to be exactly what a world of varied, evolving data needed, and they live on in production systems handling some of the planet’s largest workloads.

It is also a landmark of community-governed open source. With no single corporate owner, a permissive license, and a development process run by a global volunteer group, PostgreSQL has remained free and independent for three decades while sustaining a thriving commercial ecosystem on top of its shared core. For a great many engineers, “just use Postgres” has become a kind of professional wisdom: a reliable, standards-respecting, endlessly extensible foundation that rewards trust — and for an ever-growing share of the software industry, it is the database of record.