No backend by design: how generated apps keep data on the device

Leanfinit apps store user data on the device, with no backend by default. Tomas explains the architecture and the trade-offs: sync, backups and sharing.

Tomas·5 min read

Apps generated by Leanfinit have no backend by default: every entry a user makes is stored on their own device, not on a server we run. We chose this because most personal and small-business tools don't need a server, and a server they don't need is a cost, a privacy risk and one more thing that can break. The trade-offs are real, and I'll go through each of them.

What "no backend" means here

A typical web or mobile app built by an AI tool today has two halves: the interface you see, and a hosted database plus API that stores everything. Sign-up, data, sync and permissions all live in that second half.

A Leanfinit app has only the first half by default. The generated Flutter app includes its own data layer, which reads and writes to storage on the device. When a user adds a workout, a bill or a note, nothing leaves the phone or the browser.

No backend also means there is nothing on our side for the app's users to sign up to, so by default the app doesn't need an account.

Why we made it the default

Most small apps don't need shared data. A training log, a medication schedule, a savings tracker, a stock list for one shop counter: one person enters the data and one person reads it. A server adds nothing to that loop.

Privacy you don't have to promise. If user data never reaches us, we cannot leak it, analyze it or be asked to hand it over. I trust architecture more than policy. Barbara writes about this in Private by architecture, not by policy.

It works without a signal. Local data means the app opens and saves on a train, in a basement gym or on a flight. More on that in Offline-first in practice.

Nothing to keep paying for. A backend has to be hosted, patched and monitored for as long as the app exists. A personal tool someone uses every day for five years shouldn't stop working because a database plan lapsed.

Fewer moving parts for the generator. Every API and schema an AI model writes is a place for subtle bugs. Keeping the data layer local and predictable makes generated apps more reliable.

The trade-offs

No architecture is free. These are the costs of this one, stated plainly.

No sync across devices by default

Data on a phone stays on that phone. If you use the same app on your phone and laptop, each has its own data. For most single-person tools this is acceptable; for some it isn't, and you should know before you build.

Backups are the user's job

If data lives only on the device, losing the device or clearing browser storage can lose the data. The fix is to make export a feature of the app itself: ask for "an export to CSV button" or "a backup file I can save" in your prompt. You then decide where the backup goes.

Sharing needs a decision

Two people can't edit the same list in real time without something in between. A household chore rota or a team stock list may need shared data. That is the case where a backend earns its place, and it should be a deliberate choice rather than an invisible default.

No central view for you as the builder

If you build an app for others, you won't see their data in a dashboard. For a client project that is often a benefit. For a product where you need usage analytics or a shared admin view, plan for it.

When to add a backend

Use this as a rough test before you build:

QuestionLocal onlyNeeds a backend
Who enters the data?One personSeveral people
Who reads it?The same personOthers, or you as the owner
Must it appear on several devices at once?NoYes
Does it involve payments or accounts?NoYes

If every answer sits in the first column, the default architecture fits. If one lands in the second, the app needs a server component, and it is better to design it in than to bolt it on.

Because code export is available, a team that later needs a backend can take the Flutter project and connect the service it prefers. The local data layer is a starting point, not a dead end.

What the app's data layer looks like

Without going into every detail, a generated app is organized like this:

1Models describe each kind of record: a workout, a bill, a plant.
2A repository reads and writes those records to device storage.
3Screens use the repository and never talk to a network for their data.

This separation is what makes a later change possible. To add a server, you replace or extend the repository; the screens don't need to change. If you work in Flutter yourself, the exported project will look familiar.

Why this matters beyond us

The question "where does my data go?" now comes up before people build anything. The insights section on private and offline apps collects the most common versions of it, and the guide to an offline tracking app with no account shows what this looks like for a typical tracker.

Our answer is to make the private, local version the default and the networked version a choice. Many personal apps never need the second.

Describe the app you need and see how it's built: studio.leanfinit.com.