Database Overview Video

​
Overview

Every Anything project includes a free database. As you chat with Anything, it handles all database details - from designing the structure to writing the code that enables your application to save and retrieve data. Use databases to:
  • Store user submissions (forms, feedback, uploads)
  • Save content (blog posts, products, galleries)
  • Persist data between application sessions
  • Build dynamic data-driven features

​
Chat-based database management

Anything automatically updates your database structure and how your application retrieves and stores data as you chat. When a feature requires storing data, it:
  1. Designs the database structure based on your description
  2. Creates Functions to save and retrieve data from the database
  3. Designs Pages and Components to display and interact with the data
  4. Connects everything to ensure your Pages use the Functions that retrieve/store data

​
Example: Task management application

If you say “Make me a tasks app”, Anything:
1

Creates a tasks table with title, due date, and other fields

2

Creates Functions to save and fetch tasks

3

Builds a Page with a task list and add form

4

Makes your Page use your Functions to save and grab tasks from the database

As you continue describing your application, Anything updates your database structure, Functions, and Pages to match your requirements.

​
Common database modifications

Here are common ways to modify your database through chat:

​
Set the scene

Start with a specific description of what you want your application to do. Prompt: 
Make a tasks app. Users should be able to add, view, and delete tasks. 

Each task has title, description and comments

Comments should show up under the task and show who wrote them.
Anything will:
  • Create the necessary tables
    • Make a Tasks table with title, description, and comments fields
    • Make a Users table with name and avatar fields
    • Make a Comments table with text and author fields
  • Create Functions to save and fetch tasks, users, and comments
  • Build a Page with a task list, add form, and comment list
  • Make the Page use your Functions to save tasks when submitted and grab tasks to display

​
Add fields

Add a description to todos. Show it below the title in italics.
Create will:
  • Add the description column to the Todos table
  • Update Functions to handle the new field
  • Modify the UI to display descriptions

​
Remove fields

Remove the priority from todos, we won't use it anymore
Create will:
  • Remove the priority column
  • Update queries to exclude the field
  • Clean up any UI elements showing priority

​
Add tables

Let users add comments on todos. Each comment should have the text and who wrote it
Create will:
  • Make a new Comments table
  • Link it to the Todos table
  • Add UI for viewing/adding comments
  • Handle saving comments to the database

​
Change structure

Instead of due dates, let's use status (Todo, In Progress, Done) to track progress
Create will:
  • Convert the due_date field to a status field
  • Update existing data
  • Modify the UI to show status options

​
Manage relationships

Let users assign todos to team members. Show their avatar next to each todo
Create will:
  • Add user relationships to todos
  • Update queries to fetch user data
  • Show assignee info in the UI

​
Generate sample data

Generate 10 sample todos with different statuses and assignees
Create will:
  • Generate 10 sample todos with different statuses and assignees based on your structure
  • Insert the data into your database
  • Preserve relationships between tables

​
Add validation

Make sure every todo has a title
Create will:
  • Add validation rules to the database
  • Update Functions to check data
  • Show validation errors in the UI
Always describe both what data you want to store AND how you want to use it. This helps Create build the right database structure, Functions, and UI.
The more specific you are in your prompt, the better Create can help.If you describe something at a high level, “make a todo app”, Create will guess what fields each todo should have.If you describe what you want in detail, “make a todo app with a title, due date, and priority field”, Create will ensure each todo has those fields.

​
View and edit data

Create includes a built-in database viewer for manual edits to your data. You can quickly verify that data is being stored correctly when you use your application.

​
Access the database viewer

​
Database viewer features

  • See all tables
  • Edit individual rows
  • Sort and filter data
  • Download data in bulk
  • Run custom SQL queries to fetch data
You can also create your own internal tools to update multiple tables at once:
  • Make a new Page
  • Describe your tool and how it should update the database
  • Test your UI
Changes in Demo mode in the Builder use a test database. This lets you experiment safely without affecting your live data.

​
Test vs. live databases

Create maintains separate test and live databases for each project:

​
Test database

  • Used in Demo mode from the builder
  • Allows you to verify your application is saving data correctly before publishing

​
Live database

  • Used in your published application
  • Access your live database from the builder

​
Publishing

When you publish your application, Create automatically:
  • Creates your live database
  • Applies the latest structure from the Test database to your Live database so that it has the same tables and fields
  • Runs your application with that structure

​
Troubleshooting

Here are effective ways to troubleshoot common errors:

​
Data isn’t saving or retrieving

If data isn’t saving when you use your application, there are 3 common failure points to check. Go in this order to test each in isolation:

​
1. Database structure

How to check:
  • Open the database viewer
  • Verify tables and fields match what you expect
If there’s an issue:
  • Describe the correct structure you want in chat
  • Example: “Update the Tasks table to have title, description, and dueDate fields”
  • Create will modify the database to match

​
2. Function -> Database

How to check:
  • Identify the specific part of your application that is not saving data
  • Ask the builder to test this for you and describe your current behavior
  • The builder will construct a test parameter and run it
  • Check database viewer to verify data was saved
  • Delete test records if needed
If there’s an issue:
  • Copy any error messages
  • Paste them into the function chat
  • Ask Create to fix the specific error
  • Example: “I see this error when I run saveTask and test it with this data: [error] [example data]“

​
3. UI -> Function

How to check:
  • Try the application in Demo mode from the UI
  • Check that data is being saved when you use the application in the database viewer
  • Watch database viewer to see if records appear
If there’s an issue:
  • Verify with the builder your flow and expectations of input to output (doing x should create y in z)
  • Example: “Connect the tasks form to the saveTask function when I submit a task”
  • Create will update the code to properly wire everything together
For any errors you encounter, you can paste them directly into Create’s chat. It often recognizes specific error patterns and knows how to fix them.

​
Reset database structure

When you publish your application, Create pushes your test database structure to your live database. If you continue making changes to your test database structure in the builder and don’t like the changes, you can reset to the structure of your last published version.

Reset button located in the top right corner of the database viewer

Reset your database structure to match your published app

This is helpful when:
  • You’ve made experimental changes you don’t want to keep
  • Your database structure has become complex or incorrect
  • You want to start fresh from your last stable version

​
Reset process

To reset your database structure:
  1. Open your database in the builder
  2. Look for the “Reset” button in the top right corner
  3. Confirm that you want to reset to the published version

​
Remove multiple databases

In 99.99% of cases, you don’t need multiple databases per project. A single database can have an arbitrary number of tables. It’s easy to add more tables (just describe what you want to store, and Create adds a table for it). It’s better to have multiple tables in the same database than multiple databases as it makes joins easier. If you have multiple databases in a single project, you can remove ones you don’t need:
1

Tap on the database you want to remove in the builder

Select the database from the project selector
2

Look for the 'Remove from Project' button

Top right corner next to Reset and View Live
3

Confirm removal

Verify you want to remove this database from your project
If you had data in the database you removed, you can ask Create to update your single database with tables that support all of your use cases. It will update the remaining database to have multiple tables instead of having multiple databases.
Before removing a database, make sure you understand which application features are using it. Create will attempt to warn you if removing a database would break functionality.

​
Use existing databases

Create will automatically create a new database for your project. However, there are some scenarios where you might want to use an existing database for a new project:
  • You already have data in one database that you want to reuse for a new application
  • You’re making a new application or frontend for the same data (e.g., an internal tool or another application)

​
Add an existing database

To add an existing database to your project:
  1. Go to the new project
  2. Press / > Databases > select the database you want to use
  3. Prompt Create on what you want to build with the database chip in the chat
When you add an existing database to a project, both projects will share the same data. Changes made in one project will be visible in the other.
This approach is excellent for creating multiple views of the same data, such as customer-facing applications alongside internal admin tools.
If you no longer want to use this database in your project, you can remove it from the project.

​
FAQ

​
Database terminology

Create handles the technical details of your database, but understanding some key concepts can help you work more effectively. Think of a database as a collection of connected spreadsheets:
  • A table is like a spreadsheet (e.g., “Users”, “Products”)
  • Fields (or columns) are the types of information stored (e.g., “name”, “email”)
  • Rows are individual entries
  • Relationships connect data between tables using foreign keys

​
Key terms

TermDefinitionExample
SchemaThe structure of your database (tables and fields)Your application’s blueprint showing Users table with name, email fields
QueryInstructions to get or save data”Get all products where price < $100”
JoinCombining data from different tablesShowing posts with their authors’ names from the Users table
Foreign KeyA field that references another tablePost’s authorId connects to User’s id
SQLThe language databases understandCreate writes this for you!
MigrationChanges to your database structureAdding a “phone” field to Users table
Don’t worry about memorizing these! Just describe what data you want to store and how you want to use it - Create handles the technical implementation.