Why SQL Is Making a Comeback: From Browsers to Backend

SQL, a language with a long history and clear standards, is undergoing a renaissance driven by three converging trends that bring it back to the center of data processing.

SQL's Revival Path

Lightweight relational databases such as SQLite have enabled SQL to run directly in browsers, creating a new client‑backend sync architecture where SQL, not JSON, is the core data format. PostgreSQL’s introduction of the jsonb type further strengthens this advantage by allowing schema‑less documents alongside traditional tables.

What seemed like the end of SQL’s relevance is actually a resurgence: developers now see SQL as both a classic choice and a cutting‑edge technology.

Frontend SQL

Running databases in the browser is now possible thanks to WebAssembly (WASM). Projects like PGlite (PostgreSQL compiled to WASM) and browser‑native SQLite turn the client into a full‑featured SQL engine. This shift enables serverless analytics with tools like DuckDB , allowing millions of rows to be processed on the user’s device without a massive cloud warehouse.

Synchronization technologies such as ElectricSQL and Replicache let the same data store be used both locally and on the server, automatically handling conflict resolution and data exchange. Developers can therefore insert records locally with a simple INSERT and let the sync engine push changes to the backend, eliminating the need for custom API endpoints.

Better SQL Clients

Modern lightweight ORM and query‑builder tools are closing the gap between SQL and programming languages. Libraries like Drizzle (TypeScript), Exposed (Kotlin), and jOOQ (Java) map SQL concepts to idiomatic code, offering type‑safe, fluent APIs that feel as natural as working with JSON collections.

const grumpyCats = await db.select().from(cats).where(eq(cats.mood, 'Judgmental'));

These tools let developers write code that mirrors the data model without sacrificing the rigor of relational schemas.

SQL with Schema‑less Types

PostgreSQL’s jsonb demonstrates that a relational database can store flexible, schema‑less documents while still providing ACID guarantees and index support. This hybrid approach reduces the need for separate persistence stacks (e.g., PostgreSQL for transactions and MongoDB for logs) and allows mixed queries that combine traditional columns with JSON fields without performance loss.

SQL and the Lindy Effect

The Lindy effect—"the longer a technology exists, the longer it will continue to exist"—explains SQL’s durability across mainframes, PCs, the internet, mobile, and now AI. Its ability to absorb JSON, run in browsers, and integrate with modern languages shows that SQL’s perceived friction is actually a feature that enforces thoughtful system design.

While SQL still requires connection‑pool management, migration scripts, and careful scaling, its evolving ecosystem offers a compelling blend of reliability and flexibility that many newer data stores cannot match.