PostgreSQL, MySQL, and SQLite have each been around for decades, but their positions in the developer ecosystem have shifted significantly. PostgreSQL has become the default recommendation for new projects. SQLite has undergone a renaissance driven by edge computing, embedded applications, and tools like Litestream and Turso. MySQL remains the most deployed database in the world but has lost mindshare among new projects.
This comparison examines each database through the lens of a developer choosing a database for a new web application. We are not comparing them as enterprise data warehouses or embedded IoT stores — we are evaluating them as the primary datastore for a typical SaaS application.
Architecture Fundamentals
Aspect
PostgreSQL
MySQL
SQLite
Model
Client-server
Client-server
Embedded (in-process)
Concurrency
MVCC
MVCC (InnoDB)
WAL mode (readers + 1 writer)
Storage
Heap-based
Clustered index (InnoDB)
B-tree file
Max DB size
Unlimited (practical)
Unlimited (practical)
281 TB (theoretical)
Replication
Streaming, logical
Binary log, group replication
Litestream, LiteFS
The fundamental architectural difference is that SQLite runs inside your application process. There is no separate database server, no TCP connections, no authentication. You open a file and query it. PostgreSQL and MySQL are traditional client-server databases that run as separate processes.
SQL Feature Depth
PostgreSQL implements the SQL standard more completely than any other open-source database. Features that PostgreSQL has had for years are still missing or limited in MySQL:
Feature
PostgreSQL
MySQL
SQLite
Window functions
Full support
Full support (since 8.0)
Full support
CTEs (WITH)
Full support, recursive
Full support (since 8.0)
Full support
JSON/JSONB
Native JSONB with indexing
JSON type, limited indexing
JSON functions
Full-text search
Built-in, configurable
Built-in (InnoDB)
FTS5 extension
Generated columns
Stored and virtual
Stored and virtual
Stored and virtual
Partial indexes
Yes
No
Yes
Array types
Yes
No
No
Custom types
Yes (enums, composites, domains)
Enums only
No (type affinity)
UPSERT
ON CONFLICT
ON DUPLICATE KEY
ON CONFLICT
PostgreSQL's JSONB support deserves special mention. You can store JSON documents, index specific paths within them using GIN indexes, and query them with dedicated operators. This makes PostgreSQL viable as a hybrid relational/document database:
-- Store and query JSON in PostgreSQL
CREATE TABLE events (
id serial PRIMARY KEY,
data jsonb NOT NULL,
created_at timestamptz DEFAULT now()
);
CREATE INDEX idx_events_type ON events USING GIN ((data -> 'type'));
SELECT data->>'user_id' as user_id, count(*)
FROM events
WHERE data @> '{"type": "page_view"}'
AND created_at > now() - interval '7 days'
GROUP BY data->>'user_id'
ORDER BY count(*) DESC
LIMIT 10;
MySQL's JSON support exists but lacks the indexing depth and operator richness of PostgreSQL's JSONB.
Performance
Performance comparisons between databases are notoriously context-dependent. A query that is fast on PostgreSQL might be faster on MySQL, and vice versa. That said, some general patterns emerge.
Read-heavy workloads: MySQL's InnoDB engine uses clustered indexes (data stored in primary key order), which gives it an edge for primary key lookups and range scans on the primary key. PostgreSQL's heap-based storage requires a separate index lookup, adding one extra I/O operation.
Write-heavy workloads: PostgreSQL's MVCC implementation handles concurrent writes more gracefully. MySQL's gap locking can cause unexpected lock contention under high write concurrency.
SQLite performance is surprising. For read workloads on a single server, SQLite often outperforms PostgreSQL and MySQL because it eliminates network overhead and connection management. A query that takes 2ms on PostgreSQL (including 0.5ms network round-trip) might take 0.1ms on SQLite.
The caveat is that SQLite's write performance degrades under concurrency. WAL mode allows concurrent reads with a single writer, but multiple processes attempting concurrent writes will contend on the write lock.
Hosting and Operations
PostgreSQL has the richest managed hosting landscape in 2026. Neon, Supabase, AWS RDS, Google Cloud SQL, Railway, Render, and dozens of other platforms offer managed PostgreSQL. Neon's serverless PostgreSQL with branching and scale-to-zero has made PostgreSQL particularly attractive for development and staging environments.
MySQL is available on all major cloud platforms (RDS, Cloud SQL, Azure Database) and through PlanetScale (which uses Vitess for horizontal scaling). PlanetScale's branching workflow is excellent for teams that want database schema changes reviewed like code.
SQLite traditionally required no hosting — it is a file on disk. But the rise of Turso (libSQL), LiteFS, and Litestream has changed this. Turso provides a distributed SQLite service with edge replicas, making SQLite viable for multi-region applications. Litestream continuously replicates SQLite databases to S3-compatible storage for durability.
# Litestream: continuous SQLite replication to S3
litestream replicate /data/app.db s3://my-bucket/app.db
# Restore from backup
litestream restore -o /data/app.db s3://my-bucket/app.db
When SQLite is Enough
The SQLite renaissance deserves attention. For many applications, SQLite is not just adequate — it is optimal. Consider using SQLite when:
Your application runs on a single server (no horizontal scaling needed)
You want zero operational overhead (no database server to manage)
Latency matters (no network round-trip to a database server)
You are building a CLI tool, desktop app, or mobile app
The 37signals team (creators of Ruby on Rails) migrated several applications to SQLite in production, demonstrating that it is a viable choice for real-world web applications at moderate scale.
Extensions and Ecosystem
PostgreSQL's extension system is a major differentiator. PostGIS for geospatial data, pg_vector for vector similarity search (AI/ML applications), TimescaleDB for time-series data, and Citus for horizontal sharding all run as PostgreSQL extensions. This means one database engine can serve multiple specialized use cases:
-- Vector similarity search with pgvector
CREATE EXTENSION vector;
CREATE TABLE documents (
id serial PRIMARY KEY,
content text,
embedding vector(1536)
);
CREATE INDEX ON documents USING ivfflat (embedding vector_cosine_ops);
-- Find similar documents
SELECT content, 1 - (embedding <=> '[0.1, 0.2, ...]') as similarity
FROM documents
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 5;
MySQL's extension ecosystem is more limited. ProxySQL and Vitess provide scaling solutions, but MySQL lacks the breadth of PostgreSQL's extension catalog.
SQLite supports loadable extensions and has a growing ecosystem of community extensions for JSON, full-text search, and vector operations.
Data Integrity
PostgreSQL is the strictest of the three regarding data integrity by default. It enforces type checking, rejects invalid dates, and raises errors for constraint violations. MySQL has historically been more permissive — silently truncating strings, accepting invalid dates like 0000-00-00, and converting types implicitly. MySQL's strict mode (enabled by default since 5.7) addresses many of these issues, but legacy behavior persists in older configurations.
SQLite uses dynamic typing (type affinity), which means you can store a string in an integer column without error. This flexibility is intentional but can cause subtle bugs if you rely on the database for type enforcement.
Replication and Scaling
Scaling Strategy
PostgreSQL
MySQL
SQLite
Read replicas
Streaming replication
Binary log replication
Litestream / LiteFS
Horizontal sharding
Citus extension
Vitess / ProxySQL
Turso (libSQL)
Connection pooling
PgBouncer
ProxySQL
N/A (in-process)
Multi-region
Logical replication
Group replication
Turso edge replicas
Who Should Use What
Choose PostgreSQL if:
You want the most capable SQL database available
You need advanced features (JSONB, full-text search, vector search, geospatial)
Data integrity and standards compliance matter
You want a rich managed hosting ecosystem
Choose MySQL if:
You have existing MySQL expertise and infrastructure
You need horizontal scaling via Vitess or PlanetScale
Your workload is read-heavy with simple queries
WordPress or other MySQL-dependent software is involved
Choose SQLite if:
Your application runs on a single server
You want zero operational overhead
You are building embedded, mobile, or desktop applications
Read performance and simplicity are priorities
The Verdict
PostgreSQL is the best general-purpose database for new web applications in 2026. Its feature depth, extension ecosystem, and managed hosting options make it the default choice. SQLite is the most underrated option — for applications that do not require horizontal scaling, it offers superior read performance with zero operational complexity. MySQL remains a solid, reliable database, but it is harder to justify over PostgreSQL for new projects unless you have specific MySQL-dependent requirements.
PostgreSQL (for features and correctness) / SQLite (for simplicity and embedded use)
Independent testing. No affiliate bias.
Frequently asked questions
?Which tool wins in Postgres vs MySQL vs SQLite: Database Comparison for 2026?
PostgreSQL (for features and correctness) / SQLite (for simplicity and embedded use). The full review above explains the scoring behind that verdict.
?How is Postgres vs MySQL vs SQLite: Database Comparison for 2026 scored?
This review scores 3 dimensions: PostgreSQL 9.2/10, MySQL 7.8/10, SQLite 8.5/10. PostgreSQL scores highest at 9.2/10.
?When was Postgres vs MySQL vs SQLite: Database Comparison for 2026 last updated?
This review was published on February 1, 2026 and last updated on October 21, 2026. Reviews are re-checked when a material change occurs — a pricing revision, a significant feature change, or a new competitor entering the space.
?What does Postgres vs MySQL vs SQLite: Database Comparison for 2026 cover?
Three databases, three different design philosophies. We tested PostgreSQL, MySQL, and SQLite on feature depth, performance, and operational complexity. Filed under Database on Dev Tool Reviews — see the reviews index for more Database coverage.
⚡ Proven System Architecture
Scale 1,000+ Developer Benchmark Pages on Autopilot
We run devtoolreviews.com using the SEO Content OS—the battle-tested Python automation engine that turns technical keywords into structured benchmark tables, FAQ schemas, and de-slopped engineering guides.