For about a decade, the standard narrative about databases has been fragmentation. The relational monolith cracked. NoSQL shattered the consensus. Now there are hundreds of specialised engines, each optimised for one shape of data, and the era of one database to rule them all is over. This narrative felt true because it was true, roughly from 2010 to 2018. But the real story of the past five years is the opposite: databases are converging, and the convergence is happening so fast that the question of which engine to use is becoming less interesting than the question of who is going to run it.

Understanding why requires looking at what the NoSQL movement actually rejected. It was not a single idea but a bundle: schemas, joins, SQL as a query language, and ACID transactions. The movement treated these as a package — if you rejected the relational model, you rejected everything associated with it. Documents instead of tables. Key-value lookups instead of joins. Procedural aggregation pipelines instead of SQL. Eventual consistency instead of transactions. Each rejection addressed a genuine pain point. Schemas required upfront design that clashed with agile development. Joins did not scale horizontally. SQL was verbose for simple operations. Transactions forced a coordination overhead that limited throughput. But the NoSQL movement made a category error that took a decade to unwind: it assumed that rejecting the relational model required rejecting the entire bundle as a package.

What followed was a slow, expensive process of putting each piece back, one by one, in every database that threw them away. MongoDB was the most visible example. Its entire pitch was that schemas are oppressive and joins are slow. Then its users started building real applications, and they discovered that schemas are how you know what shape your data actually has, joins are how you ask questions across collections without writing application code to stitch answers together, and consistency is the difference between a payment that processes once and a payment that processes twice. MongoDB added multi-document ACID transactions in 2018, added a query planner that increasingly resembles PostgreSQL’s, and added SQL-style window functions. Cassandra told the same story from a different starting point. Built for horizontal write scaling and eventual consistency, it added lightweight transactions through Paxos consensus, then materialized views, then secondary indexes, and Apache Cassandra 5.0 is adding ACID transactions. Redis, which was never supposed to be a database — it was a cache — grew RedisJSON, RediSearch, RedisGraph and RedisTimeSeries, becoming a multi-model database without anyone quite noticing. DynamoDB, the database born to prove SQL was unnecessary, added ACID transactions in 2018, global tables for multi-region replication, and PartiQL — a SQL-compatible query language — in 2019. Every NoSQL database that survived is spending its engineering budget on putting back the features it originally rejected.

The convergence has been happening from the other direction too. PostgreSQL has been moving just as fast in the opposite direction. JSONB arrived in 9.4 and provided document storage with indexing competitive with MongoDB. PostGIS turned it into the spatial database powering OpenStreetMap. pgvector implemented approximate nearest neighbour search, making PostgreSQL a vector database without anyone building a new company. Foreign Data Wrappers let it query Parquet files in S3, MySQL tables on another server, and Redis caches, all in a single SQL statement. Extensions like Citus turn it into a distributed database sharded across multiple nodes. TimescaleDB adds time-series compression and continuous aggregates. A single PostgreSQL instance today can store documents in JSONB, execute spatial queries, run vector similarity search, compress time-series data, federate queries to external sources, and serve as a message queue — all in one process, speaking one query language, with one set of authentication rules and one backup pipeline. It is not a relational database anymore. It is a database that has absorbed every data model it was supposed to compete with.

The most important convergence, however, is the query language. SQL won. Not because it is perfect — it has accumulated fifty years of warts. SQL won because it is the only language for querying structured data that has ever achieved universal adoption, and universal adoption matters more than technical elegance. MongoDB has its aggregation pipeline, which is SQL expressed as JSON. Cassandra has CQL. Redis has RediSearch queries that increasingly look like SQL. DynamoDB has PartiQL. ClickHouse and DuckDB speak PostgreSQL-compatible SQL. Even Kafka, which is not a database, has ksqlDB for stream processing. The NoSQL movement was right that the relational model is not optimal for every problem — documents, graphs, time-series and vectors are genuinely different shapes of data. But the movement was wrong that rejecting the relational model required rejecting SQL and transactions. SQL is not the relational model. It is a query language, and describing what data you want in a declarative way is a universal need.

If every database speaks SQL, and every database has transactions, and every database supports multiple data models, then what is left to differentiate them? The answer is operations — who runs it and how. PlanetScale gives you serverless MySQL with branching for schema changes. Turso gives you SQLite with read replicas deployed across hundreds of edge locations. Cloudflare D1 gives you SQLite at the edge with zero configuration. Neon gives you serverless PostgreSQL with branching and instant provisioning. Supabase gives you PostgreSQL wrapped in a Firebase-like experience with authentication and real-time subscriptions. These are not new databases. They are new operational models for existing databases, and they are succeeding because developers have made it clear that they do not want to operate databases.

The convergence on SQL and transactions is the database industry learning the same lesson the programming language industry learned decades ago: ecosystems win. PostgreSQL has the ecosystem — the extensions, the tooling, the documentation, the hiring pool. The NoSQL databases that survived are the ones that adopted SQL and joined the existing ecosystem. The ones that refused have either disappeared or retreated to niches invisible to the mainstream. Fragmentation was the adolescent phase of the database industry — every new idea spawned a new project. Convergence is the adult phase — the ideas that work are absorbed into the mainstream and the ideas that do not are quietly abandoned. We are in the convergence phase now. SQL is the standard. Transactions are the default. The databases are becoming the same database. The only question left is who you trust to keep it running.