Quickstarters
How to Develop a CRUD Application with Flask?

32min
Overview
This tutorial will guide you through building a CRUD (create, read, update, delete) application using Flask. 
We'll integrate Back4app as our backend service to simplify data management. You will learn to set up a Back4app project, design a flexible data structure, and implement CRUD functionalities using Flask.
In this walkthrough, you'll first create a Back4app project named Basic-CRUD-App-Flask that offers a robust, non-relational data storage solution. 
You'll define your data schema with classes and fields either manually or using Back4app’s AI Agent.
After configuring your backend with Back4app’s Admin interface, you will connect your Flask application to the service via REST API calls. This tutorial also covers secure access management for your data.
By the end, you will have a production-ready Flask application capable of performing CRUD operations along with secure user authentication and data handling.
What You Will Learn
How to create a Flask-based CRUD app with a non-relational backend.
How to structure your backend on Back4app and integrate it with a Flask project.
How to utilize the Back4app Admin interface to manage CRUD operations effortlessly.
How to deploy your Flask application, including using Docker for containerization.
﻿
Prerequisites
Before you begin, ensure you have:
A Back4app account with a configured project.
Need help? Refer to Getting Started with Back4app.
A Python development environment set up.
Use an editor like VSCode or PyCharm and install Python 3.8 (or later).
Basic knowledge of Python, Flask, and REST APIs.
Consult the Python documentation if necessary.
﻿
Step 1 – Initial Project Setup
Creating Your Back4app Project
Log in to your Back4app account.
Click on “New App” from your dashboard.
Enter the project name: Basic-CRUD-App-Flask and complete the setup process.
Create New Project
﻿
After creation, your project appears on the dashboard, serving as the base for your backend configuration.
﻿
Step 2 – Building the Data Schema
Defining Your Data Structures
For this application, you'll establish several classes in your Back4app project. Below are examples of the core classes and their fields essential for CRUD operations.
1. Items Class
Field
Type
Description
_id
ObjectId
Auto-generated unique identifier.
title
String
The name or title of the item.
description
String
A brief overview of the item.
createdAt
Date
Timestamp when the item was created.
updatedAt
Date
Timestamp for the latest update.
2. Users Class
Field
Type
Description
_id
ObjectId
Auto-generated unique identifier.
username
String
Unique username for the user.
email
String
Unique email address.
passwordHash
String
Securely hashed password for authentication.
createdAt
Date
Timestamp when the user account was created.
updatedAt
Date
Timestamp for the last account update.
You can create these classes and add fields directly in your Back4app dashboard.
Create New Class
﻿
You can add columns by choosing a data type, naming the field, setting default values, and marking it as required.
Create Column
﻿
Utilizing Back4app’s AI Agent for Schema Creation
The AI Agent in your dashboard can automatically establish the schema based on your instructions. This tool simplifies the process and ensures your data model is optimal for CRUD tasks.
How to Use the AI Agent:
Open the AI Agent:
Sign in to your Back4app dashboard and locate the AI Agent under project settings.
Describe Your Schema:
Provide a detailed prompt listing the classes and fields.
Confirm the Setup:
Review the proposed schema and approve the changes.
Example Prompt
Text
Create the following classes in my Back4app project:

1) Class: Items
- Fields:
  - _id: ObjectId (auto-generated)
  - title: String
  - description: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)

2) Class: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
Create the following classes in my Back4app project:

1) Class: Items
- Fields:
  - _id: ObjectId (auto-generated)
  - title: String
  - description: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)

2) Class: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
﻿
This AI-driven process saves time and guarantees a consistent, effective data model.
﻿
Step 3 – Enabling the Admin Interface & Handling CRUD Operations
Overview of the Admin Interface
Back4app’s Admin interface provides a no-code solution to manage your backend data. With its drag and drop features, you can easily perform CRUD operations—such as adding, editing, or deleting records.
Enabling the Admin Interface
Go to the “More” menu on your Back4app dashboard.
Select “Admin App” and click “Enable Admin App.”
Create your admin account, which also sets up initial roles like B4aAdminUser.
Enable Admin App
﻿
After activation, sign in to the Admin interface to manage your project data.
Admin App Dashboard
﻿
Using the Admin Interface for CRUD
Within the Admin interface, you can:
Insert New Entries: Click “Add Record” within a class (e.g., Items) to create new data.
View and Modify Entries: Select any record to see details or update fields.
Delete Records: Remove entries that are no longer required.
This easy-to-use interface improves productivity by streamlining backend management.
﻿
Step 4 – Connecting Your Flask Application to Back4app
With your backend set up, the next step is to link your Flask application to Back4app.
Making API Calls from Flask
Since there isn’t a dedicated Parse SDK for Flask, you will use REST API calls. In your Flask app, you can utilize the requests library to perform CRUD operations.
Example: Setting Up API Communication
Install the Requests Library:
Run the following command in your terminal:
Bash
pip install requests
pip install requests
﻿
Configure a Python Module for API Calls:
Create a file called back4app_api.py:
Python
# back4app_api.py
import requests

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
BASE_URL = "https://parseapi.back4app.com/classes"

HEADERS = {
    "X-Parse-Application-Id": APPLICATION_ID,
    "X-Parse-REST-API-Key": REST_API_KEY,
    "Content-Type": "application/json"
}

def get_items():
    response = requests.get(f"{BASE_URL}/Items", headers=HEADERS)
    return response.json()

def create_item(title, description):
    data = {"title": title, "description": description}
    response = requests.post(f"{BASE_URL}/Items", headers=HEADERS, json=data)
    return response.json()

def update_item(object_id, title, description):
    data = {"title": title, "description": description}
    response = requests.put(f"{BASE_URL}/Items/{object_id}", headers=HEADERS, json=data)
    return response.json()

def delete_item(object_id):
    response = requests.delete(f"{BASE_URL}/Items/{object_id}", headers=HEADERS)
    return response.json()
# back4app_api.py
import requests

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
BASE_URL = "https://parseapi.back4app.com/classes"

HEADERS = {
    "X-Parse-Application-Id": APPLICATION_ID,
    "X-Parse-REST-API-Key": REST_API_KEY,
    "Content-Type": "application/json"
}

def get_items():
    response = requests.get(f"{BASE_URL}/Items", headers=HEADERS)
    return response.json()

def create_item(title, description):
    data = {"title": title, "description": description}
    response = requests.post(f"{BASE_URL}/Items", headers=HEADERS, json=data)
    return response.json()

def update_item(object_id, title, description):
    data = {"title": title, "description": description}
    response = requests.put(f"{BASE_URL}/Items/{object_id}", headers=HEADERS, json=data)
    return response.json()

def delete_item(object_id):
    response = requests.delete(f"{BASE_URL}/Items/{object_id}", headers=HEADERS)
    return response.json()
﻿
Integrate API Functions in Your Flask Routes:
For example, in app.py:
Python
# app.py
from flask import Flask, request, jsonify, render_template
from back4app_api import get_items, create_item, update_item, delete_item

app = Flask(__name__)

@app.route("/")
def index():
    items = get_items()
    return render_template("index.html", items=items.get("results", []))

@app.route("/add", methods=["POST"])
def add_item():
    title = request.form.get("title")
    description = request.form.get("description")
    result = create_item(title, description)
    return jsonify(result)

@app.route("/update/<item_id>", methods=["PUT"])
def modify_item(item_id):
    data = request.get_json()
    result = update_item(item_id, data.get("title"), data.get("description"))
    return jsonify(result)

@app.route("/delete/<item_id>", methods=["DELETE"])
def remove_item(item_id):
    result = delete_item(item_id)
    return jsonify(result)

if __name__ == "__main__":
    app.run(debug=True)
# app.py
from flask import Flask, request, jsonify, render_template
from back4app_api import get_items, create_item, update_item, delete_item

app = Flask(__name__)

@app.route("/")
def index():
    items = get_items()
    return render_template("index.html", items=items.get("results", []))

@app.route("/add", methods=["POST"])
def add_item():
    title = request.form.get("title")
    description = request.form.get("description")
    result = create_item(title, description)
    return jsonify(result)

@app.route("/update/<item_id>", methods=["PUT"])
def modify_item(item_id):
    data = request.get_json()
    result = update_item(item_id, data.get("title"), data.get("description"))
    return jsonify(result)

@app.route("/delete/<item_id>", methods=["DELETE"])
def remove_item(item_id):
    result = delete_item(item_id)
    return jsonify(result)

if __name__ == "__main__":
    app.run(debug=True)
﻿
This example illustrates how to use REST calls within Flask to interact with your Back4app backend.
﻿
Step 5 – Protecting Your Backend
Implementing Access Controls
Safeguard your data by configuring access controls. For instance, when creating a new item, you might restrict access to its creator.
Below is an example using API calls with controlled access:
Python
import requests

def create_private_item(title, description, user_token):
    data = {"title": title, "description": description}
    headers = {
        "X-Parse-Application-Id": "YOUR_APPLICATION_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "X-Parse-Session-Token": user_token,
        "Content-Type": "application/json"
    }
    response = requests.post("https://parseapi.back4app.com/classes/Items", headers=headers, json=data)
    return response.json()
import requests

def create_private_item(title, description, user_token):
    data = {"title": title, "description": description}
    headers = {
        "X-Parse-Application-Id": "YOUR_APPLICATION_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "X-Parse-Session-Token": user_token,
        "Content-Type": "application/json"
    }
    response = requests.post("https://parseapi.back4app.com/classes/Items", headers=headers, json=data)
    return response.json()
﻿
Configuring Class-Level Permissions
Adjust the Class-Level Permissions (CLPs) directly in the Back4app dashboard to ensure only authenticated users can access specific classes.
﻿
Step 6 – Implementing User Authentication
Setting Up User Management
Back4app offers built-in user management via its Users class. In your Flask app, you can create endpoints for registration and login.
Example: User Registration and Login
Python
# auth.py
import requests

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
HEADERS = {
    "X-Parse-Application-Id": APPLICATION_ID,
    "X-Parse-REST-API-Key": REST_API_KEY,
    "Content-Type": "application/json"
}

def register_user(username, password, email):
    data = {"username": username, "password": password, "email": email}
    response = requests.post("https://parseapi.back4app.com/users", headers=HEADERS, json=data)
    return response.json()

def login_user(username, password):
    params = {"username": username, "password": password}
    response = requests.get("https://parseapi.back4app.com/login", headers=HEADERS, params=params)
    return response.json()
# auth.py
import requests

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
HEADERS = {
    "X-Parse-Application-Id": APPLICATION_ID,
    "X-Parse-REST-API-Key": REST_API_KEY,
    "Content-Type": "application/json"
}

def register_user(username, password, email):
    data = {"username": username, "password": password, "email": email}
    response = requests.post("https://parseapi.back4app.com/users", headers=HEADERS, json=data)
    return response.json()

def login_user(username, password):
    params = {"username": username, "password": password}
    response = requests.get("https://parseapi.back4app.com/login", headers=HEADERS, params=params)
    return response.json()
﻿
You can create corresponding Flask routes to handle user registration and login using these functions.
﻿
Step 7 – Deploying Your Flask Application
Back4app simplifies deployment. You can deploy your Flask app via several methods, including Docker.
7.1 Packaging Your Flask Application
Prepare Your Application:
Ensure all required files and dependencies are included.
Test Locally:
Run your app locally with:
Bash
flask run
flask run
﻿
7.2 Organizing Your Project Structure
A typical structure might be:
Text
Basic-CRUD-App-Flask/
|-- app.py
|-- back4app_api.py
|-- auth.py
|-- templates/
|     |-- index.html
|-- static/
|-- requirements.txt
|-- Dockerfile
Basic-CRUD-App-Flask/
|-- app.py
|-- back4app_api.py
|-- auth.py
|-- templates/
|     |-- index.html
|-- static/
|-- requirements.txt
|-- Dockerfile
﻿
7.3 Containerizing with Docker
Include a Dockerfile at the project root:
Dockerfile
# Use a lightweight Python image
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code
COPY . .

# Expose the port Flask runs on
EXPOSE 5000

# Start the Flask app
CMD ["python", "app.py"]
# Use a lightweight Python image
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code
COPY . .

# Expose the port Flask runs on
EXPOSE 5000

# Start the Flask app
CMD ["python", "app.py"]
﻿
7.4 Deploying via Back4app Web Deployment
Connect Your GitHub Repository:
Ensure your code is pushed to GitHub.
Configure Deployment Settings:
In the Back4app dashboard, use the Web Deployment feature to link your repository (e.g., Basic-CRUD-App-Flask) and select your branch.
Define Build Commands:
Specify the build command (e.g., pip install -r requirements.txt) and the location of your application.
Deploy:
Click Deploy and monitor the logs until your application is live.
﻿
Step 8 – Wrapping Up and Future Directions
Great job! You have successfully created a Flask-based CRUD application integrated with Back4app. 
You established a project named Basic-CRUD-App-Flask, defined data models for Items and Users, and managed your backend via the Back4app Admin interface. 
Additionally, you connected your Flask application using REST API calls and implemented security measures.
What’s Next?
Expand Functionality:
Consider adding features like advanced search, detailed item views, or real-time updates.
Enhance Backend Services:
Explore cloud functions, integrate third-party APIs, or implement role-based access control.
Deepen Your Skills:
Visit the Back4app documentation and other resources to further refine your application.
Happy coding and best of luck with your Flask CRUD application!
Field	Type	Description
_id	ObjectId	Auto-generated unique identifier.
title	String	The name or title of the item.
description	String	A brief overview of the item.
createdAt	Date	Timestamp when the item was created.
updatedAt	Date	Timestamp for the latest update.
Field	Type	Description
_id	ObjectId	Auto-generated unique identifier.
username	String	Unique username for the user.
email	String	Unique email address.
passwordHash	String	Securely hashed password for authentication.
createdAt	Date	Timestamp when the user account was created.
updatedAt	Date	Timestamp for the last account update.
Updated 17 Feb 2025
Did this page help you?
How to Build a CRUD App with Python?
How to Build a Basic CRUD App with Java?