SQLite or Postgres: when the file is the database
SQLite is a library that keeps a whole database in one file inside your application; Postgres is a server that owns the data and answers many clients at once. They solve different problems, so the choice turns on workload and deployment: where the data sits relative to the code, how many writers act at once, and how big the data grows. From sqlite.org's own appropriateness checklist and PostgreSQL's architecture documentation, read 21 November 2026.
Few technical arguments run as long as "just use Postgres" versus "SQLite is enough". The most useful contribution to that argument comes from the SQLite project itself, whose appropriateness guide opens with a concession most advocates skip: SQLite is not directly comparable to client/server databases like PostgreSQL, because it is trying to solve a different problem. "SQLite does not compete with client/server databases. SQLite competes with fopen()." Everything below comes from that guide (last updated 31 May 2025) and PostgreSQL's own architecture documentation, both read 21 November 2026.
Two different jobs
PostgreSQL's documentation describes a client/server model: a server process manages the database files and accepts connections from client applications, forking a new process for each connection so it can handle many concurrent clients, potentially over a TCP/IP network from other machines. It is built as a shared repository of enterprise data, emphasizing scalability, concurrency, centralization and control. SQLite is a library built into your application, providing local data storage for individual applications and devices, emphasizing economy, efficiency, reliability, independence and simplicity. There is no server process, no connection protocol, and the entire database is one ordinary file your code reads and writes directly.
Where SQLite fits, per its own project
The sqlite.org guide lists the workloads where SQLite works well: embedded devices and the internet of things, where no administrator exists; the application file format for desktop programs (File/Open attaches the database, and File/Save becomes unnecessary); low-to-medium traffic websites; data analysis, where results live in a single file you can email; a local cache in front of an enterprise database; and, notably, server-side storage behind an application server, where requests arrive application-specific rather than as raw SQL - developers report success sharding by user, one SQLite file per user, so thousands of connections each touch a private database. It also serves as a data transfer format between systems, a container slightly richer than a ZIP archive, a replacement for ad-hoc home-grown file formats, an internal scratch database, and a stand-in during demos, testing and teaching.
Where a client/server database like Postgres fits
The same guide lists the cases that argue for client/server. If many client programs send SQL to the same database directly over a network, choose client/server: SQLite over a network filesystem suffers latency and, worse, buggy file-locking implementations on both Unix and Windows network filesystems, which can let two clients modify the same part of the file simultaneously and corrupt it - a filesystem bug SQLite cannot prevent. If a website is write-intensive or busy enough to need multiple servers, the guide points to an enterprise client/server engine. For very large datasets, SQLite's own limit is 281 terabytes (2^48 bytes), but the whole database lives in one file and many filesystems cap file sizes below that, so the guide advises considering client/server as content creeps into the terabyte range. And for high write concurrency: SQLite allows unlimited simultaneous readers but only one writer at any instant, so applications whose writers cannot queue and take turns need a database with a coordinating server process - which is exactly the Postgres model.
The three questions that settle most cases
SQLite's guide ends with a checklist, and it is deliberately about deployment and workload, not benchmark numbers. One: is the data separated from the application by a network? Choose client/server - the engine-to-disk link should not cross the network. The guide adds a note that changes everything for web apps: "application" means the code issuing SQL, so if your app server and its data file sit on the same machine, SQLite can still be right even with users on the far side of the internet. Two: will many threads or processes write at the same instant, unable to take turns? Choose client/server - SQLite writes are usually milliseconds, so writers often can simply queue, but genuine write concurrency belongs to server databases. Three: will the data outgrow a single disk file you are comfortable with? Choose client/server. Otherwise, the guide's answer is SQLite: fast, reliable, zero configuration.
About the 100,000-hits figure
The most-quoted number in this debate comes from the same page: generally speaking, any website getting fewer than 100K hits per day should work fine with SQLite, with the explicit caveat that this is a conservative estimate, not a hard upper bound, and that the real limit depends on how heavily the site uses its database. The page's own evidence is dated: as of 2015, sqlite.org itself handled about 400K to 500K HTTP requests per day, 15-20% of them dynamic pages touching the database, on a single virtual machine sharing a physical server with 23 others. Treat both figures as historical context from the project's own page (updated 31 May 2025), not as a capacity promise for your workload - a write-heavy forum and a read-mostly documentation site with identical hit counts are different cases.
Sources, both read 21 November 2026: sqlite.org, Appropriate Uses For SQLite (the different-problems framing and fopen() line; the workload lists for both engines; the network-filesystem locking warning; one-writer-at-a-time; 281-terabyte limit; the three-question checklist and its application-server note; the 100K-hits-per-day conservative figure and the 2015 site-traffic example; page last updated 31 May 2025); PostgreSQL Documentation, Architectural Fundamentals (client/server model: server process manages database files, accepts connections, forks a process per client connection, clients may connect over TCP/IP from other hosts).
Frequently asked questions
Can SQLite run a real production website?
Yes, within the workload shape its own project describes: sqlite.org says most low-to-medium traffic websites work fine on SQLite, citing under 100K hits per day as a conservative estimate - not a hard limit - and reporting that sqlite.org itself served about 400K to 500K requests per day as of 2015. The same page redirects write-intensive sites, and sites busy enough to need multiple servers, to a client/server engine.
Can many users write to an SQLite database at once?
One writer at a time per database file, with unlimited simultaneous readers. sqlite.org's guide says writers usually just queue - each write takes milliseconds - and that SQLite handles more write concurrency than many people suspect. If your application's writers genuinely cannot take turns, that is the case the guide sends to a client/server database such as PostgreSQL, whose server process exists to coordinate exactly that.
Is SQLite a toy database?
No - it is a different tool. In sqlite.org's framing, client/server databases strive to be a shared repository of enterprise data, while SQLite provides local storage for individual applications and devices: "SQLite does not compete with client/server databases. SQLite competes with fopen()." Its listed production uses include embedded devices, application file formats, enterprise caches and server-side storage sharded per user.
Why is SQLite over a network share risky?
sqlite.org's guide warns that file-locking logic is buggy in many network filesystem implementations, on both Unix and Windows. If locking fails, two clients can modify the same part of the database file simultaneously and corrupt it - and because the bug is in the filesystem, SQLite cannot prevent it. Its rule of thumb: avoid SQLite when the same database will be accessed directly, simultaneously, from many computers over a network.
How big can an SQLite database get?
The format limit is 281 terabytes (2^48 bytes), per sqlite.org. The practical limit is lower: the entire database is one file, and many filesystems cap file sizes below that. The guide suggests considering a client/server database - which can spread content across multiple files and volumes - once content creeps into the terabyte range.
Does choosing SQLite lock me out of Postgres later?
The checked sources do not address migration, so this article makes no claim about it. The decision the sources do support is about fit: sqlite.org's checklist turns on where the data sits relative to the application, how many writers act at once, and whether the data outgrows one file.