SQLite database development
SQLite is the most deployed database in the world and it runs inside the application rather than beside it. On mobile, on the edge and in tests, that is exactly the right shape.
Where we use SQLite
SQLite is part of the stack on these 2 services. Each page covers how we work, what you get and what it costs to start.
SQLite in practice
SQLite runs inside the application rather than beside it, so there is no server, no connection pool and no network hop. It is the most widely deployed database in the world — in every phone, browser and countless embedded devices — and its test suite is famously more thorough than most software’s.
On mobile it is how offline-first apps work. In test suites it turns a slow integration run into a fast one. And with WAL mode it is increasingly viable for small production web applications, though multi-writer concurrency remains the point where a client-server database takes over.
What we build with SQLite
Local persistence and offline-first behaviour on iOS and Android, where the data has to survive with no network.
On-device storage where running a database server is not an option.
Fast, disposable databases for test suites, so a full run takes seconds rather than minutes.
Is SQLite right for you?
Ask usA good fit when
- Local storage in mobile apps, including offline-first behaviour
- Embedded and IoT devices with no room for a server
- Test databases, where speed and disposability matter
- Small web applications with low write concurrency
Probably not when
- Multiple application servers needing shared writes
- High write concurrency from many clients
- Datasets requiring horizontal scaling
What we run alongside SQLite
The rest of the setup, and why each piece is there. We keep this list short on purpose — every dependency is something someone has to maintain.
- WAL mode
- Concurrent readers alongside a writer — the setting that makes production use plausible.
- Room or Core Data
- The platform-idiomatic layers over it on Android and iOS.
- Litestream
- Continuous replication to object storage, which gives durability without a server.
- A sync strategy
- The hard part of offline-first: agreed conflict resolution, decided before the first sync.
Why SQLite
Let’s talkZero operations
A file on disk — nothing to provision, secure, back up separately or keep patched.
Genuinely fast locally
No network hop and no connection pool, which makes local reads faster than any client-server database can be.
Extremely well tested
Its test suite is famously exhaustive, which is why it ships in phones, browsers and aircraft systems.
What we get called in to fix
Get a second opinionDatabase locked errors
Concurrent writes without WAL mode or a sane busy timeout.
No migration strategy on mobile
Schema changes that lose user data on upgrade, which is discovered in reviews.
Sync conflicts resolved by accident
Offline edits silently overwriting each other because no rule was ever agreed.
Unbounded local growth
Caches on device growing until the app is the largest thing on the phone.
SQLite or the alternative
The comparisons we are actually asked to make, answered the way we would answer them on a call.
SQLite when the database lives inside the application. Postgres the moment several processes or servers must write.
Realm is more object-oriented and pleasant on mobile. SQLite is portable, universal and has no vendor dependency.
For low write concurrency, yes, especially with Litestream. Not for a multi-instance application behind a load balancer.
SQLite works well with:
Angular
Django
JavaScript
Laravel
MongoDB
MySQL
Node.js
PHP
PostgreSQL
Python
ReactGot an idea? Let’s make it real.
Tell us the short version
This could be the first step towards a new and successful collaboration. A one-line idea and a finished spec are both fine — tell us the problem, the deadline you’re working to and what’s in your way.
Keep looking
Frequently asked questions
For low write concurrency, yes — increasingly so with WAL mode. For multi-writer workloads we use PostgreSQL.
Yes. Local-first storage with a sync layer is the standard pattern for apps that must work without a connection.
With an explicit strategy agreed up front — last-write-wins, server authority or per-field merge, depending on the data.
Yes — it is among the most rigorously tested software in existence. Data loss on mobile is nearly always a migration bug, not the engine.
With an explicit conflict strategy agreed up front — server authority, last-write-wins or per-field merge — depending on what the data can tolerate.