Quickstarters
How to Create a CRUD Application with Kotlin?

27min
Overview
In this walkthrough, you'll discover how to develop a simple CRUD (create, read, update, delete) application using Kotlin. 
We will utilize Back4app as our backend service, which simplifies data management. This guide illustrates the essential components of a CRUD system, including setting up a Back4app project, designing a flexible data schema, and executing CRUD operations with a Kotlin application.
We begin by configuring a Back4app project named Basic-CRUD-App-Kotlin that offers a scalable  environment. You will create data models either manually or with the assistance of Back4app's AI Agent.
Next, you will leverage the Back4app Admin interface—a user-friendly drag-and-drop tool—to manage your data effortlessly. 
Finally, you'll integrate your Kotlin application with Back4app using the Parse Java SDK (or API calls when required) while ensuring secure access management. 
By the conclusion of this guide, you'll have built a production-ready Kotlin application capable of performing standard CRUD operations, complete with secure user authentication and efficient data handling.
Major Insights
Learn to construct a Kotlin-based CRUD application with a robust  backend.
Understand how to architect a scalable backend and connect it with a Kotlin app.
Master using Back4app’s intuitive Admin interface for streamlined CRUD tasks.
Get acquainted with containerizing your Kotlin app with Docker for a smooth deployment process.
﻿
Prerequisites
Before you begin, ensure that you have:
An active Back4app account with a new project set up.
Need guidance? See Getting Started with Back4app.
A Kotlin development environment.
Utilize an IDE such as IntelliJ IDEA, and ensure you have Kotlin and JDK 11 (or later) installed.
Basic knowledge of Kotlin, object-oriented programming, and REST APIs.
Consult the Kotlin documentation if required.
﻿
Step 1 – Setting Up the Project
Creating a New Back4app Project
Log in to your Back4app account.
Click on the “New App” button from your dashboard.
Input the project name: Basic-CRUD-App-Kotlin and complete the setup steps.
Create New Project
﻿
After the project is created, it will appear on your dashboard, establishing the foundation for your backend configuration.
﻿
Step 2 – Crafting the Data Schema
Defining Your Data Structures
For this CRUD application, you'll define several collections within your Back4app project. Below are sample classes and fields needed for standard CRUD operations.
1. Items Collection
Field
Data Type
Purpose
_id
ObjectId
System-generated unique identifier.
title
String
Name of the item.
description
String
Brief summary describing the item.
createdAt
Date
Record creation timestamp.
updatedAt
Date
Timestamp for the latest modification.
2. Users Collection
Field
Data Type
Purpose
_id
ObjectId
Automatically generated unique identifier.
username
String
Unique username for each user.
email
String
Distinct email address.
passwordHash
String
Securely encrypted user password.
createdAt
Date
Account creation timestamp.
updatedAt
Date
Timestamp for account modifications.
You can manually add these collections and fields directly through the Back4app dashboard.
Create New Class
﻿
You can define fields by choosing the data type, naming the field, assigning default values, and marking required fields.
Create Column
﻿
Utilizing the Back4app AI Agent for Schema Generation
The Back4app AI Agent simplifies schema setup by automatically generating the data model based on your description. This efficient tool speeds up project initialization and ensures your schema supports all CRUD functionalities.
How to Use the AI Agent:
Locate the AI Agent:
Log into your Back4app dashboard and find the AI Agent within the project settings.
Detail Your Data Schema:
Provide a prompt outlining the required collections and their respective fields.
Review and Confirm:
Inspect the proposed schema and approve it to implement the changes.
Sample Prompt
Text
Create the following collections in my Back4app project:

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

2) Collection: 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 collections in my Back4app project:

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

2) Collection: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
﻿
This AI-powered feature minimizes manual configuration and optimizes your data model for CRUD operations.
﻿
Step 3 – Enabling the Admin Interface & Managing CRUD Operations
Overview of the Admin Interface
The Back4app Admin interface is a no-code solution that simplifies backend data management. Its intuitive design allows you to easily create, view, modify, and delete records.
Activating the Admin Interface
Go to the “More” menu on your Back4app dashboard.
Select “Admin Interface” and then click on “Enable Admin Interface.”
Configure your admin credentials by setting up an initial administrator account. This also establishes roles (e.g., B4aAdminUser) and system collections.
Enable Admin App
﻿
Once activated, sign in to the Admin Interface to manage your application data.
Admin App Dashboard
﻿
Using the Admin Interface for CRUD Actions
Within this interface, you can:
Insert Records: Utilize the “Add Record” option in a collection (like Items) to input new data.
Inspect and Modify Records: Click on a record to review or update its fields.
Remove Records: Delete records that are no longer needed.
This user-friendly interface streamlines data management significantly.
﻿
Step 4 – Connecting Your Kotlin Application with Back4app
After configuring your backend, the next phase is to link your Kotlin application with Back4app. It’s important to note that although we are using the Parse Java SDK, Kotlin’s seamless interoperability with Java allows you to integrate it without any issues.
Option A: Utilizing the Parse SDK for Kotlin (via Java)
Include the Parse SDK Dependency:
If you are using Gradle, add the following to your build.gradle.kts:
Kotlin
dependencies {
    implementation("com.parse:parse-sdk:1.18.0")
}
dependencies {
    implementation("com.parse:parse-sdk:1.18.0")
}
﻿
Initialize Parse in Your Kotlin Application:
Create a configuration file (e.g., ParseConfig.kt):
Kotlin
// ParseConfig.kt
import com.parse.Parse

object ParseConfig {
    fun initialize() {
        Parse.initialize(
            Parse.Configuration.Builder("YOUR_APPLICATION_ID")
                .clientKey("YOUR_KOTLIN_KEY")
                .server("https://parseapi.back4app.com")
                .build()
        )
    }
}
// ParseConfig.kt
import com.parse.Parse

object ParseConfig {
    fun initialize() {
        Parse.initialize(
            Parse.Configuration.Builder("YOUR_APPLICATION_ID")
                .clientKey("YOUR_KOTLIN_KEY")
                .server("https://parseapi.back4app.com")
                .build()
        )
    }
}
﻿
Implement CRUD Methods in Kotlin:
For example, create a service to manage items:
Kotlin
// ItemsService.kt
import com.parse.ParseException
import com.parse.ParseObject
import com.parse.ParseQuery

object ItemsService {
    fun getItems(): List<ParseObject>? {
        return try {
            ParseQuery.getQuery<ParseObject>("Items").find()
        } catch (e: ParseException) {
            println("Error retrieving items: ${'$'}{e.message}")
            null
        }
    }

    fun createItem(title: String, description: String) {
        val item = ParseObject("Items")
        item.put("title", title)
        item.put("description", description)
        try {
            item.save()
            println("Item successfully created.")
        } catch (e: ParseException) {
            println("Failed to create item: ${'$'}{e.message}")
        }
    }

    fun updateItem(objectId: String, newTitle: String, newDescription: String) {
        val query = ParseQuery.getQuery<ParseObject>("Items")
        try {
            val item = query.get(objectId)
            item.put("title", newTitle)
            item.put("description", newDescription)
            item.save()
            println("Item updated successfully.")
        } catch (e: ParseException) {
            println("Update failed: ${'$'}{e.message}")
        }
    }

    fun deleteItem(objectId: String) {
        val query = ParseQuery.getQuery<ParseObject>("Items")
        try {
            val item = query.get(objectId)
            item.delete()
            println("Item deleted successfully.")
        } catch (e: ParseException) {
            println("Deletion error: ${'$'}{e.message}")
        }
    }
}
// ItemsService.kt
import com.parse.ParseException
import com.parse.ParseObject
import com.parse.ParseQuery

object ItemsService {
    fun getItems(): List<ParseObject>? {
        return try {
            ParseQuery.getQuery<ParseObject>("Items").find()
        } catch (e: ParseException) {
            println("Error retrieving items: ${'$'}{e.message}")
            null
        }
    }

    fun createItem(title: String, description: String) {
        val item = ParseObject("Items")
        item.put("title", title)
        item.put("description", description)
        try {
            item.save()
            println("Item successfully created.")
        } catch (e: ParseException) {
            println("Failed to create item: ${'$'}{e.message}")
        }
    }

    fun updateItem(objectId: String, newTitle: String, newDescription: String) {
        val query = ParseQuery.getQuery<ParseObject>("Items")
        try {
            val item = query.get(objectId)
            item.put("title", newTitle)
            item.put("description", newDescription)
            item.save()
            println("Item updated successfully.")
        } catch (e: ParseException) {
            println("Update failed: ${'$'}{e.message}")
        }
    }

    fun deleteItem(objectId: String) {
        val query = ParseQuery.getQuery<ParseObject>("Items")
        try {
            val item = query.get(objectId)
            item.delete()
            println("Item deleted successfully.")
        } catch (e: ParseException) {
            println("Deletion error: ${'$'}{e.message}")
        }
    }
}
﻿
Option B: Using REST or GraphQL APIs
If you prefer not to use the Parse SDK, you can execute CRUD operations via REST calls. For example, to retrieve items using REST:
Kotlin
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL

object RestClient {
    fun fetchItems() {
        try {
            val url = URL("https://parseapi.back4app.com/classes/Items")
            val connection = url.openConnection() as HttpURLConnection
            connection.requestMethod = "GET"
            connection.setRequestProperty("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
            connection.setRequestProperty("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

            BufferedReader(InputStreamReader(connection.inputStream)).use { reader ->
                val response = reader.readText()
                println("Response: $response")
            }
        } catch (e: Exception) {
            println("Error fetching items: ${'$'}{e.message}")
        }
    }
}
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL

object RestClient {
    fun fetchItems() {
        try {
            val url = URL("https://parseapi.back4app.com/classes/Items")
            val connection = url.openConnection() as HttpURLConnection
            connection.requestMethod = "GET"
            connection.setRequestProperty("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
            connection.setRequestProperty("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

            BufferedReader(InputStreamReader(connection.inputStream)).use { reader ->
                val response = reader.readText()
                println("Response: $response")
            }
        } catch (e: Exception) {
            println("Error fetching items: ${'$'}{e.message}")
        }
    }
}
﻿
Integrate these API calls within your Kotlin classes as needed.
﻿
Step 5 – Enhancing Security for Your Backend
Access Control Lists (ACLs)
Ensure your data remains secure by setting up ACLs on your objects. For instance, to create an item that is accessible only by its owner:
Kotlin
import com.parse.ParseACL
import com.parse.ParseException
import com.parse.ParseObject
import com.parse.ParseUser

fun createPrivateItem(title: String, description: String, owner: ParseUser) {
    val item = ParseObject("Items")
    item.put("title", title)
    item.put("description", description)

    val acl = ParseACL()
    acl.setReadAccess(owner, true)
    acl.setWriteAccess(owner, true)
    acl.setPublicReadAccess(false)
    acl.setPublicWriteAccess(false)
    item.acl = acl

    try {
        item.save()
        println("Private item created successfully.")
    } catch (e: ParseException) {
        println("Error saving private item: ${'$'}{e.message}")
    }
}
import com.parse.ParseACL
import com.parse.ParseException
import com.parse.ParseObject
import com.parse.ParseUser

fun createPrivateItem(title: String, description: String, owner: ParseUser) {
    val item = ParseObject("Items")
    item.put("title", title)
    item.put("description", description)

    val acl = ParseACL()
    acl.setReadAccess(owner, true)
    acl.setWriteAccess(owner, true)
    acl.setPublicReadAccess(false)
    acl.setPublicWriteAccess(false)
    item.acl = acl

    try {
        item.save()
        println("Private item created successfully.")
    } catch (e: ParseException) {
        println("Error saving private item: ${'$'}{e.message}")
    }
}
﻿
Class-Level Permissions (CLPs)
Set up CLPs via the Back4app dashboard to enforce default access policies, ensuring only authenticated users interact with sensitive collections.
﻿
Step 6 – Implementing User Authentication
Configuring User Management
Back4app leverages Parse’s built-in User collection for authentication. In your Kotlin app, you can handle user registration and login as follows:
Kotlin
import com.parse.ParseException
import com.parse.ParseUser

object AuthService {
    fun signUp(username: String, password: String, email: String) {
        val user = ParseUser()
        user.username = username
        user.setPassword(password)
        user.email = email

        try {
            user.signUp()
            println("Registration successful!")
        } catch (e: ParseException) {
            println("Sign up error: ${'$'}{e.message}")
        }
    }

    fun logIn(username: String, password: String) {
        try {
            val user = ParseUser.logIn(username, password)
            println("Logged in as: ${'$'}{user.username}")
        } catch (e: ParseException) {
            println("Login failed: ${'$'}{e.message}")
        }
    }
}
import com.parse.ParseException
import com.parse.ParseUser

object AuthService {
    fun signUp(username: String, password: String, email: String) {
        val user = ParseUser()
        user.username = username
        user.setPassword(password)
        user.email = email

        try {
            user.signUp()
            println("Registration successful!")
        } catch (e: ParseException) {
            println("Sign up error: ${'$'}{e.message}")
        }
    }

    fun logIn(username: String, password: String) {
        try {
            val user = ParseUser.logIn(username, password)
            println("Logged in as: ${'$'}{user.username}")
        } catch (e: ParseException) {
            println("Login failed: ${'$'}{e.message}")
        }
    }
}
﻿
This structure can be extended for session management, password resets, and additional authentication mechanisms.
﻿
Step 7 – Conclusion and Future Enhancements
Congratulations! You have successfully built a Kotlin-based CRUD application integrated with Back4app. 
In this guide, you set up a project named Basic-CRUD-App-Kotlin, defined data collections for Items and Users, and managed your data through the Back4app Admin interface. 
Furthermore, you connected your Kotlin app via the Parse SDK (or API calls) and implemented robust security practices.
Next Steps:
Expand the Application:
Integrate additional features such as advanced search capabilities, detailed item views, or real-time updates.
Enhance Backend Functionality:
Consider exploring cloud functions, third-party API integrations, or advanced role-based access controls.
Deepen Your Expertise:
Visit the Back4app documentation for further guidance and advanced tutorials.
Happy coding and best of luck with your Kotlin CRUD application!
Field	Data Type	Purpose
_id	ObjectId	System-generated unique identifier.
title	String	Name of the item.
description	String	Brief summary describing the item.
createdAt	Date	Record creation timestamp.
updatedAt	Date	Timestamp for the latest modification.
Field	Data Type	Purpose
_id	ObjectId	Automatically generated unique identifier.
username	String	Unique username for each user.
email	String	Distinct email address.
passwordHash	String	Securely encrypted user password.
createdAt	Date	Account creation timestamp.
updatedAt	Date	Timestamp for account modifications.
Updated 20 Feb 2025
Did this page help you?
How to Build a CRUD App with Astro?
How to Build a CRUD App with Xamarin?