Using SQLite in FlutterFlow

Enabling SQLite

To enable SQLite, navigate to FlutterFlow > Settings and Integrations > App Settings > Integrations > SQLite and toggle it on.

The implementation is intentionally scoped rather than exhaustive, but what it does provide is solid and production-quality. You will need to upload a SQLite database file to your project as a starting point. Because this is local storage, a practical use case is reference data that ships with your app and is updated only when the app itself is updated. Think product catalogues, configuration tables, lookup data, or offline content libraries.

Plan carefully for the app update scenario. Your users will have a local database that may contain data they have created or modified inside the app. There is no automatic migration tooling in FlutterFlow, so you need to design your schema and update strategy with that in mind from the start. There is no sync, and there is no web support — test on real iOS and Android devices throughout development.

Designing and editing SQLite databases

You will see that the Database Configuration is already populated in the cloned example project.

For your own projects, you will need a tool to create and inspect SQLite database files. DB Browser for SQLite (DB4S) remains the go-to option in 2026 — it is open source, actively maintained, cross-platform, and uses a familiar spreadsheet-like interface that does not require you to write raw SQL to get started. On macOS with Homebrew, installation is a single command:

% brew install --cask db-browser-for-sqlite

Launch it and creating a database is straightforward:

• Click New Database, give it a meaningful name such as NoteTakingAppDB, and click Save.
• Enter a table name — Notes — and click Add to add each field.
• Add ID as an Integer, set it as not null, primary key, and auto increment using the checkboxes.
• Add Title and Details as Text fields, then DueDate and IsCompleted as Integers.
• Switch to the Browse Data tab, click Insert Row, populate the row with sample data, click Apply, then Save.
• Upload the resulting .db file to your Database Configuration in FlutterFlow.

If you prefer a more modern alternative, TablePlus is a polished commercial option with a generous free tier that supports SQLite alongside many other database engines and is worth considering if you work across multiple database types.

Create, Read, Update, Delete (CRUD) via FlutterFlow

FlutterFlow organises SQLite operations into two categories: Read queries (SQL SELECT statements) and Update queries (INSERT, UPDATE, and DELETE). Variables are passed from your app into queries using the ${variableName} syntax. For Read queries you also define the output columns so FlutterFlow knows what data to surface to your widgets.

For example: SELECT * FROM Notes WHERE IsCompleted = ${filterValue}

The example note-taking app defines four queries that cover the full CRUD surface.

GetAllNotes

Retrieves every note from the database for display in the UI.

SELECT * FROM Notes;

AddNote

Inserts a new note using the variables title, details, and dueDate:

INSERT INTO Notes (Title, Details, DueDate, IsCompleted) VALUES ('${title}', '${details}', ${dueDate}, 0);

UpdateNote

Updates an existing note using title, details, dueDate, isCompleted, and id:

UPDATE Notes
SET 
    Title = '${title}',
    Details = '${details}',
    DueDate = ${dueDate},
    IsCompleted = ${isCompleted}
WHERE ID = ${id};

DeleteNote

Deletes a note by its id:

DELETE FROM Notes WHERE ID = ${id};

Building your user interface

Show all notes

Build a FlutterFlow page using a ListView with containers, or simply examine the layout in the cloned example project.

• Add a SQLite backend query to the page — only Read queries will appear here — and click Confirm.
• For each widget in your ListView, open Set from Variable, select your query row, and choose the column you want displayed. Repeat for each field you want to show from the database record.

UNIX epoch timestamps in SQLite

Add a note

Wire up an Add action using the FlutterFlow Action Flow Editor:

• Select the widget that should trigger the action (typically a button).
• Open the Action Flow Editor and click + Add Action.
• Choose SQLite Query under Backend/Database.
• Select Update Query and choose AddNote.
• Map your form field variables to the query parameters.

Update a note

• Select the widget that triggers the update.
• Open the Action Flow Editor and click + Add Action.
• Choose SQLite Query under Backend/Database.
• Select Update Query and choose UpdateNote.
• Map all required variables, including the record id.

Delete a note

• Select the widget that triggers the deletion.
• Open the Action Flow Editor and click + Add Action.
• Choose SQLite Query under Backend/Database.
• Select Update Query and choose DeleteNote.
• Map the id variable to identify the record to remove.

Practical patterns and tips for 2026

Having used SQLite in FlutterFlow across a range of production projects, a few patterns are worth highlighting that go beyond what the basic example demonstrates.

• Pre-populate with reference data. SQLite shines when you ship the app with a pre-populated database — product catalogues, offline maps metadata, configuration tables, or localised content. The database file is bundled with the app and immediately available without any network call.
• Version your schema. Add a schema_version table with a single row from day one. When you release an app update with schema changes, your initialisation logic can read this value and apply the appropriate migration steps using custom Dart actions.
• Combine with App State for performance. Read your SQLite data into App State on app launch or page load, then bind your UI to App State variables. This avoids repeated database reads on every widget rebuild and keeps the UI responsive.
• Test on physical devices early. The FlutterFlow preview and web runner do not support SQLite. Build to a real iOS or Android device from the start of development — it will save you time and prevent surprises late in the project.
• Custom Dart actions for complex queries. FlutterFlow's built-in query editor handles straightforward SQL well. For joins across multiple tables, aggregations, or conditional logic, write a custom Dart action using the sqflite package that FlutterFlow uses under the hood. This gives you full SQL expressiveness without leaving the FlutterFlow ecosystem.

Pros and cons of SQLite in FlutterFlow

SQLite is an excellent choice for mobile apps with modest, self-contained database requirements. Here is an honest assessment as it stands in 2026.

When to choose SQLite — and when not to

SQLite in FlutterFlow is the right choice when your app needs to function fully offline, when you are shipping reference data with the app, or when you want a fast local cache that persists across sessions without depending on network availability. It is particularly well-suited to field service apps, inspection tools, catalogues, and any scenario where connectivity cannot be assumed.

It is not the right choice if you need real-time data shared across multiple users, if your app has a significant web presence, or if you need cloud sync without building it yourself. In those cases, Supabase or Firebase with appropriate offline persistence settings will serve you better. The two approaches are not mutually exclusive — some production FlutterFlow apps use SQLite for local reference data and Supabase for user-generated content that needs to sync.