Quickstarters
How to Build a Backend for Play Framework?

36min
Introduction
In this tutorial, you’ll learn how to build a complete backend for the Play Framework using Back4App. 
We’ll walk through essential features for server backends, including configuration setting, database management, Cloud Code Functions, REST and GraphQL APIs, user authentication, file storage, and real-time queries. 
You’ll see how Back4App simplifies the process of setting up, scaling, and maintaining a web application backend while allowing you to focus on your Play Framework code.
By learning how to build a backend for Play Framework with Back4App, you’ll cut down on development time and minimize dev ops headaches. 
You’ll also add robust features like social login, scheduling tasks (Cloud Jobs), and webhooks. Once you complete this, you can extend the system into a production-grade solution, integrating more advanced features as needed.
When you’re finished, you’ll have a solid blueprint to create your next scalable and secure Play Framework web application. 
You’ll be ready to dive deeper into performance enhancements, integrations, or dev mode optimizations to handle real-world demands.
Prerequisites
To complete this tutorial, you will need:
A Back4App account and a new Back4App project
Getting Started with Back4App.
If you do not have an account, you can create one for free. Follow the guide above to get your project ready.
A working Play Framework environment
Ensure you have Java 8+ installed.
Install sbt or use sbt through your IDE.
Basic knowledge of Play Framework
Refer to the Play Documentation if you need to brush up on fundamentals.
Familiarity with REST or GraphQL
This will help you interact with Back4App, especially if you decide not to use or if you can’t use the Parse SDK directly.
Make sure you have these prerequisites in place before you begin. Having your Back4App project set up and your Play Framework environment ready will help you follow along smoothly.
Step 1 – Creating a New Project on Back4App and Connecting
Why You Need a New Back4App Project
A fresh Back4App project is the backbone for your backend because it manages your application’s data, authentication, and cloud logic. Whether you’re building a small prototype or a large-scale web application, it’s easy to connect your Play Framework app to a new Back4App project.
Creating a Back4App Project
Log in to your Back4App account.
Click “New App” in your Back4App dashboard.
Name your app, for example, “Play-Framework-Backend”.
﻿
Once created, your new project will appear in the dashboard.
Connecting with Back4App
Back4App leverages Parse Server. If your Play Framework app plans to interact with Back4App via the Parse Java SDK, you can add it to your build.sbt if needed. Otherwise, you can use REST or GraphQL endpoints.
Retrieve Your Parse Keys:
In your Back4App dashboard, open App Settings or Security & Keys to find your Application ID, REST API Key, JavaScript Key (if using front-end calls), or Client Key, plus the Server URL (usually https://parseapi.back4app.com).
﻿
Using the Java/Parse SDK (Optional):
If you want direct server-side integration using Parse SDK, add a dependency in your build.sbt:
Text
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
libraryDependencies += "com.parse" % "parse" % "1.0.40" // Example version
﻿
Then, in your Play Framework code, you can initialize Parse:
Text
object ParseConfig {
  def init(): Unit = {
    Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
      .server("https://parseapi.back4app.com")
      .clientKey("YOUR_CLIENT_KEY")
      .build()
    )
  }
}
object ParseConfig {
  def init(): Unit = {
    Parse.initialize(new Parse.Configuration.Builder("YOUR_APP_ID")
      .server("https://parseapi.back4app.com")
      .clientKey("YOUR_CLIENT_KEY")
      .build()
    )
  }
}
﻿
You might place this in your Global.scala or call it from a suitable initialization point. This sets you up for direct interaction with your Back4App project.
If you prefer, use the REST or GraphQL endpoints for data operations, especially if you want more control over your HTTP requests or if you’re building microservices.
Step 2 – Setting Up the Database
Back4App’s data storage service supports a broad range of data types and dynamic schema creation. This lets you store your Play app’s data with minimal hassle.
Creating a Data Model
Open the “Database” section in your Back4App dashboard.
Create a new class (e.g., “Todo”) and add columns (e.g., title as String, isCompleted as Boolean).
Save to finalize your database schema.
Create New Class
﻿
Creating a Data Model with the AI Agent
If you want to quickly define your data structure:
Open the AI Agent in your App Dashboard.
Describe your desired data model in plain language (e.g., “Create a simple ToDo model.”).
The agent generates the schema for you automatically.
﻿
Reading and Writing Data Using the Parse SDK (Optional)
If you’ve chosen to include the Parse Java SDK in your Play Framework app, you can save and query data:
Text
import com.parse.{ParseObject, ParseQuery}

object TodoService {
  def createTodo(title: String, isCompleted: Boolean): Either[Throwable, ParseObject] = {
    try {
      val todo = new ParseObject("Todo")
      todo.put("title", title)
      todo.put("isCompleted", isCompleted)
      Right(todo.save())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def fetchTodos(): Either[Throwable, java.util.List[ParseObject]] = {
    try {
      val query = ParseQuery.getQuery("Todo")
      val results = query.find()
      Right(results)
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
import com.parse.{ParseObject, ParseQuery}

object TodoService {
  def createTodo(title: String, isCompleted: Boolean): Either[Throwable, ParseObject] = {
    try {
      val todo = new ParseObject("Todo")
      todo.put("title", title)
      todo.put("isCompleted", isCompleted)
      Right(todo.save())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def fetchTodos(): Either[Throwable, java.util.List[ParseObject]] = {
    try {
      val query = ParseQuery.getQuery("Todo")
      val results = query.find()
      Right(results)
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
﻿
Reading and Writing Data Using REST
You can send HTTP requests from your Play Framework controllers or services:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Reading and Writing Data Using GraphQL
Back4App also provides a GraphQL API:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
This is handy if you’re building microservices or want a flexible API for your front-end clients.
Working With Live Queries
If your web application needs real-time data, enable Live Queries:
Enable Live Queries in the Back4App dashboard under Server Settings.
Set up your subscription in code. If using the Parse SDK or custom code, ensure you configure the liveQueryServerURL.
Subscribe to changes for classes like “Todo.”
Step 3 – Applying Security with ACLs and CLPs
ACLs and CLPs Overview
Back4App provides Access Control Lists (ACLs) for object-level security and Class-Level Permissions (CLPs) for broad restrictions. This helps keep your server backends safe and ensures only authorized operations occur.
﻿
Class-Level Permissions
In the Database section of your Back4App dashboard:
Select a class (e.g., “Todo”).
Open CLPs to limit read/write to authenticated users, roles, or the public.
Configure as needed (e.g., “Requires Authentication” for any writes).
ACLs
ACLs protect individual objects. For instance, you can ensure only a particular user can read or write a specific record. If you’re using the Parse SDK from Scala code:
Text
import com.parse.{ParseACL, ParseUser, ParseObject}

def createPrivateTodo(title: String, owner: ParseUser): ParseObject = {
  val todo = new ParseObject("Todo")
  todo.put("title", title)

  val acl = new ParseACL(owner)
  acl.setPublicReadAccess(false)
  acl.setPublicWriteAccess(false)

  todo.setACL(acl)
  todo.save()
  todo
}
import com.parse.{ParseACL, ParseUser, ParseObject}

def createPrivateTodo(title: String, owner: ParseUser): ParseObject = {
  val todo = new ParseObject("Todo")
  todo.put("title", title)

  val acl = new ParseACL(owner)
  acl.setPublicReadAccess(false)
  acl.setPublicWriteAccess(false)

  todo.setACL(acl)
  todo.save()
  todo
}
﻿
Step 4 – Writing Cloud Code Functions
Why Cloud Code
Cloud Code lets you run custom logic on Back4App’s servers, adding business rules or validations before or after data transactions. You won’t need to handle your own server provisioning or dev mode restarts to implement such functions.
Example Function
JS
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
You can call this from your Play app via REST, GraphQL, or if using Parse SDK, directly.
Deployment
Use the Back4App CLI or dashboard:
Install the CLI (Linux/MacOS example):
Configure account key:
Deploy:
Or deploy via the Dashboard by pasting your function in Cloud Code > Functions and hitting “Deploy”.
Using NPM Modules
Cloud Code supports NPM modules. For instance, if you need an HTTP client like axios:
JS
const axios = require('axios');
Parse.Cloud.define('fetchData', async (req) => {
  const response = await axios.get(req.params.url);
  return response.data;
});
const axios = require('axios');
Parse.Cloud.define('fetchData', async (req) => {
  const response = await axios.get(req.params.url);
  return response.data;
});
﻿
Step 5 – Configuring Authentication
Enabling User Authentication
Back4App uses the Parse.User class for sign-up, login, and session management. In your configuration setting, ensure “Enable Email Verification” and “Enable Password Reset” if desired.
Sample Code (Parse SDK)
Text
import com.parse.{ParseUser}

object AuthService {
  def signUpUser(username: String, password: String, email: String): Either[Throwable, ParseUser] = {
    try {
      val user = new ParseUser()
      user.setUsername(username)
      user.setPassword(password)
      user.setEmail(email)

      Right(user.signUp())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def logInUser(username: String, password: String): Either[Throwable, ParseUser] = {
    try {
      Right(ParseUser.logIn(username, password))
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
import com.parse.{ParseUser}

object AuthService {
  def signUpUser(username: String, password: String, email: String): Either[Throwable, ParseUser] = {
    try {
      val user = new ParseUser()
      user.setUsername(username)
      user.setPassword(password)
      user.setEmail(email)

      Right(user.signUp())
    } catch {
      case e: Throwable => Left(e)
    }
  }

  def logInUser(username: String, password: String): Either[Throwable, ParseUser] = {
    try {
      Right(ParseUser.logIn(username, password))
    } catch {
      case e: Throwable => Left(e)
    }
  }
}
﻿
Social Login
If you need social logins (Google, Apple, or Facebook), configure them in your Back4App dashboard. Parse provides utility methods or you can rely on standard OAuth flows, depending on your needs and approach.
Step 6 – Handling File Storage
Back4App stores files via Parse.File. From Play Framework, you can upload with REST or Parse SDK.
Text
// Example with Parse SDK
import com.parse.{ParseFile, ParseObject}
import java.nio.file.{Files, Paths}

def uploadImage(filePath: String): Either[Throwable, String] = {
  try {
    val data = Files.readAllBytes(Paths.get(filePath))
    val parseFile = new ParseFile("myImage.jpg", data)
    parseFile.save()
    Right(parseFile.getUrl)
  } catch {
    case e: Throwable => Left(e)
  }
}
// Example with Parse SDK
import com.parse.{ParseFile, ParseObject}
import java.nio.file.{Files, Paths}

def uploadImage(filePath: String): Either[Throwable, String] = {
  try {
    val data = Files.readAllBytes(Paths.get(filePath))
    val parseFile = new ParseFile("myImage.jpg", data)
    parseFile.save()
    Right(parseFile.getUrl)
  } catch {
    case e: Throwable => Left(e)
  }
}
﻿
Security Considerations: You can configure file upload permissions (enable for public, anonymous, or authenticated) in the Back4App server settings.
Step 7 – Email Verification and Password Reset
Navigate to Email Settings in the Back4App dashboard.
Enable email verification and set up the email templates for password resets.
In your Play app, you can call:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
This will trigger Back4App to send password-reset instructions to the user’s email.
Step 8 – Scheduling Tasks with Cloud Jobs
Cloud Jobs
If you need a start task for background work (e.g., cleaning up data or generating reports), you can schedule Cloud Jobs on Back4App.
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Scheduling:
Deploy your Cloud Code.
In App Settings > Server Settings > Background Jobs, schedule the job to run daily, weekly, or as required.
Scheduling a Cloud Job
﻿
Step 9 – Integrating Webhooks
If you want to notify external services whenever data changes, set up Webhooks in Back4App.
Go to More > WebHooks in your Back4App dashboard.
Add Webhook with an endpoint (e.g., Slack or Stripe).
Choose triggers, such as “New record in the Todo class.”
Adding a Webhook
﻿
You can also create Webhooks in Cloud Code triggers, making direct HTTP requests to third-party services.
BeforeSave WebHook
﻿
Step 10 – Exploring the Back4App Admin Panel
The Back4App Admin App is a user-friendly interface for data and record management. Non-technical users can handle CRUD operations without diving into the code.
Enabling the Admin App
Go to App Dashboard > More > Admin App.
Enable it and create an admin user.
Choose a subdomain for convenient access.
Enable Admin App
﻿
Once logged in, you can manage data entries without messing with the lower-level dashboards or CLI tools.
﻿
Conclusion
Congratulations! You’ve learned how to build a backend for Play Framework using Back4App’s services. Throughout this tutorial, you have:
Created a secure backend for a Play Framework app on Back4App.
Set up a database, including schema design, relationships, and real-time queries.
Applied ACLs and CLPs for secure data access.
Wrote Cloud Code for custom logic, triggers, and external integrations.
Configured user authentication, social login, and password resets.
Handled file uploads and added optional file security.
Scheduled background tasks with Cloud Jobs.
Integrated with third-party services through Webhooks.
Explored the Back4App Admin Panel for streamlined data management.
With these tools in place, you can optimize dev mode, scale as needed, and build robust web applications on the Play Framework. 
Embrace further integrations, performance tuning, and advanced security measures to take your server backends to the next level.
Next Steps
Enhance your production setup with caching, logging, or monitoring tools.
Explore advanced security with role-based access controls or zero-trust setups.
Integrate payment gateways or other third-party APIs for commerce or analytics.
Check out Back4App’s official documentation for deeper insights into performance and troubleshooting.
Review more tutorials on real-time chat apps, IoT solutions, or location-based services — many of which build upon the techniques in this guide.
﻿
Updated 16 Jan 2025
Did this page help you?
How to Build a Backend for Elixir?
How to Build a Backend for Spring Boot?