Quickstarters
How to Build a Backend for Elixir?

39min
Introduction
In this tutorial, you’ll learn how to build a backend for Elixir using Back4App. 
We’ll walk through integrating essential Back4App features—such as database management, Cloud Code Functions, REST and GraphQL APIs, user authentication, and real-time queries (Live Queries)—to create a secure, scalable, and robust backend. 
Elixir, running on the Erlang VM (BEAM) and leveraging OTP (Erlang OTP), is known for its fault-tolerant, concurrent environment, which pairs well with Back4App to form a modern, high-performance infrastructure.
You’ll see how Back4App’s quick setup and intuitive environment can drastically reduce your time and effort compared to manually configuring servers and databases. 
This includes leveraging pattern matching, plus hooking into Elixir’s web framework of choice. 
By the end of this tutorial, you’ll have a solid foundation you can extend into a production-ready application or enhance with custom logic and third-party APIs.
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.
Basic Elixir development environment
 Ensure you have Elixir installed on your machine. If you plan to use a web framework such as Phoenix, see the Phoenix installation guide for reference.
Familiarity with Elixir concepts
 Elixir Official Documentation.
If you’re new to Elixir, review these resources or a beginner’s tutorial before starting.
Make sure you have all these prerequisites in place before you begin. Having your Back4App project set up and your local Elixir environment ready will help you follow along more smoothly.
Step 1 – Creating a New Project on Back4App and connecting
Create a New Project
The first step in how to build a backend for Elixir on Back4App is creating a new project. If you have not already created one, follow these steps:
Log in to your Back4app account.
Click the “New App” button in your Back4App dashboard.
Give your app a name (e.g., “Elixir-Backend-Tutorial”).
﻿
Once the project is created, you will see it listed in your Back4App dashboard. This project will be the foundation for all backend configurations discussed in this tutorial.
Connecting via REST or GraphQL
Back4App uses the Parse platform as a foundation. For Elixir, there is no official Parse SDK at the moment. Instead, you can easily connect to Back4App using the REST or GraphQL APIs. In your Elixir project, you’ll:
Retrieve your Application ID and REST or GraphQL Keys from your app’s “App Settings” or “Security & Keys” section in the Back4App dashboard.
Configure HTTP requests using an Elixir library such as HTTPoison or Tesla.
For example, to store credentials in a config file (config/dev.exs or similar):
Text
config :my_app, :b4a,
  app_id: "YOUR_APPLICATION_ID",
  rest_key: "YOUR_REST_API_KEY",
  server_url: "https://parseapi.back4app.com"
config :my_app, :b4a,
  app_id: "YOUR_APPLICATION_ID",
  rest_key: "YOUR_REST_API_KEY",
  server_url: "https://parseapi.back4app.com"
﻿
You can then reference these credentials in your code to make REST calls. Throughout this guide, we’ll showcase how to interact with the Back4App database, user system, and other features using standard HTTP or GraphQL requests.
Step 2 – Setting Up the Database
Creating a Data model
In Back4App, data is stored in classes. You can create a new class in the Back4App dashboard:
Navigate to the “Database” section in your Back4App dashboard.
Create a new class (e.g., “Todo”) and add relevant columns, such as title (String) and isCompleted (Boolean).
Create New Class
﻿
Creating a Data model using the AI Agent
Back4App also provides an AI Agent to help you describe and create your data model:
Open the AI Agent from your App Dashboard or the menu.
Describe your data model in plain language (e.g., “Please, create a new Todo App with a complete class schema.”).
Let the AI Agent create the schema automatically.
﻿
Reading and Writing Data using SDK (If Applicable)
Since Elixir does not have an official Parse SDK, we’ll skip direct SDK usage. Instead, we’ll showcase REST, GraphQL, and Live Queries approaches below.
Reading and Writing Data using REST API
Install an HTTP client like HTTPoison in your mix.exs:
Text
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
defp deps do
  [
    {:httpoison, "~> 1.8"}
  ]
end
﻿
Then, run mix deps.get.
To create (save) a Todo object from your Elixir application:
Text
defmodule MyApp.Todo do
  @moduledoc false
  require Logger
  alias MyApp.Config

  def create_todo(title, is_completed) do
    url      = Config.server_url() <> "/classes/Todo"
    headers  = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body     = Jason.encode!(%{"title" => title, "isCompleted" => is_completed})

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("Todo created: #{resp_body}")
        {:ok, resp_body}

      {:ok, %HTTPoison.Response{status_code: status, body: error_body}} ->
        Logger.error("Error creating todo (#{status}): #{error_body}")
        {:error, error_body}

      {:error, error} ->
        Logger.error("HTTP error: #{inspect(error)}")
        {:error, error}
    end
  end
end
defmodule MyApp.Todo do
  @moduledoc false
  require Logger
  alias MyApp.Config

  def create_todo(title, is_completed) do
    url      = Config.server_url() <> "/classes/Todo"
    headers  = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body     = Jason.encode!(%{"title" => title, "isCompleted" => is_completed})

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("Todo created: #{resp_body}")
        {:ok, resp_body}

      {:ok, %HTTPoison.Response{status_code: status, body: error_body}} ->
        Logger.error("Error creating todo (#{status}): #{error_body}")
        {:error, error_body}

      {:error, error} ->
        Logger.error("HTTP error: #{inspect(error)}")
        {:error, error}
    end
  end
end
﻿
And to query your Todo objects:
Text
def fetch_todos() do
  url     = Config.server_url() <> "/classes/Todo"
  headers = [
    {"X-Parse-Application-Id", Config.app_id()},
    {"X-Parse-REST-API-Key", Config.rest_key()}
  ]

  HTTPoison.get(url, headers)
end
def fetch_todos() do
  url     = Config.server_url() <> "/classes/Todo"
  headers = [
    {"X-Parse-Application-Id", Config.app_id()},
    {"X-Parse-REST-API-Key", Config.rest_key()}
  ]

  HTTPoison.get(url, headers)
end
﻿
Reading and Writing Data using GraphQL API
You can also interact via GraphQL. For example, creating a Todo:
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
    }
  }
}
﻿
In Elixir, you might send this with an HTTP client as well:
Text
graph_query = """
mutation {
  createTodo(input: {
    fields: {
      title: "New from GraphQL",
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
    }
  }
}
"""

url = Config.server_url() <> "/graphql"
headers = [
  {"X-Parse-Application-Id", Config.app_id()},
  {"X-Parse-REST-API-Key", Config.rest_key()},
  {"Content-Type", "application/json"}
]

HTTPoison.post(url, Jason.encode!(%{"query" => graph_query}), headers)
graph_query = """
mutation {
  createTodo(input: {
    fields: {
      title: "New from GraphQL",
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
    }
  }
}
"""

url = Config.server_url() <> "/graphql"
headers = [
  {"X-Parse-Application-Id", Config.app_id()},
  {"X-Parse-REST-API-Key", Config.rest_key()},
  {"Content-Type", "application/json"}
]

HTTPoison.post(url, Jason.encode!(%{"query" => graph_query}), headers)
﻿
Working with Live Queries (Optional)
For real-time updates, Back4App offers Live Queries. You can enable Live Queries in your app’s Server Settings. Since there’s no native Elixir Parse client library at the moment, you’d typically connect through a Phoenix channel or any custom WebSocket client to the provided wss://YOUR_SUBDOMAIN_HERE.b4a.io endpoint. This can be more advanced, requiring custom coding to handle subscriptions, messages, etc.
Step 3 – Applying Security with ACLs and CLPs
Brief Overview
Back4App offers Access Control Lists (ACLs) and Class-Level Permissions (CLPs) to protect and manage data access. ACLs apply to individual objects, while CLPs apply to the entire class.
﻿
Step-by-step
Class-Level Permissions (CLPs): In your Back4App Dashboard, under Database, select a class (e.g., “Todo”) and open the Class-Level Permissions tab. Adjust settings (e.g., “Requires Authentication” or “No Access” for the public).
Configure ACLs: When creating or updating an object, you can send ACL data in your REST or GraphQL request. For instance, specify the _ACL field in JSON if you need fine-grained per-object control.
Edit ACL
﻿
For more information, visit the App Security Guidelines.
Step 4 – Writing Cloud Code Functions
Why Cloud Code
Cloud Code lets you run server-side logic without managing your own servers. With Elixir, you usually rely on OTP for concurrency, but here you can simply create JavaScript Cloud Code in Back4App to handle validation, triggers, or custom business logic. This code runs on Parse Server, so you can keep your Elixir code focused on client or microservice tasks while the heavy lifting happens in Cloud Code.
Example Function
In your main.js on the Back4App Dashboard or using the CLI:
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 };
});
﻿
Deployment
Deploy via the Back4app CLI or by pasting into the dashboard under Cloud Code > Functions and clicking Deploy.
﻿
Calling Cloud Code
From Elixir, you might use:
Text
defmodule MyApp.CloudFunctions do
  alias MyApp.Config

  def calculate_text_length(text) do
    url = Config.server_url() <> "/functions/calculateTextLength"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{text: text})

    HTTPoison.post(url, body, headers)
  end
end
defmodule MyApp.CloudFunctions do
  alias MyApp.Config

  def calculate_text_length(text) do
    url = Config.server_url() <> "/functions/calculateTextLength"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{text: text})

    HTTPoison.post(url, body, headers)
  end
end
﻿
Step 5 – Configuring Authentication
Enable or Set Up Authentication
Back4App uses the Parse User class for authentication. You can manage sign-up, login, and password resets easily. From Elixir, you’ll typically use REST calls:
Text
defmodule MyApp.Auth do
  alias MyApp.Config

  def sign_up_user(username, password, email) do
    url = Config.server_url() <> "/users"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{
      username: username,
      password: password,
      email: email
    })

    HTTPoison.post(url, body, headers)
  end

  def log_in_user(username, password) do
    url = Config.server_url() <> "/login?username=#{username}&password=#{password}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()}
    ]

    HTTPoison.get(url, headers)
  end
end
defmodule MyApp.Auth do
  alias MyApp.Config

  def sign_up_user(username, password, email) do
    url = Config.server_url() <> "/users"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{
      username: username,
      password: password,
      email: email
    })

    HTTPoison.post(url, body, headers)
  end

  def log_in_user(username, password) do
    url = Config.server_url() <> "/login?username=#{username}&password=#{password}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()}
    ]

    HTTPoison.get(url, headers)
  end
end
﻿
Social Login
Back4App supports integration with Google, Apple, Facebook, and more. In most cases, you’ll direct users to the OAuth flow, then use tokens returned by these providers to complete the Parse login. See Social Login Docs for details.
Step 6 – Handling File Storage
Setting up File Storage
Back4App stores files securely. From Elixir, you’d upload files via REST:
Text
defmodule MyApp.FileStorage do
  alias MyApp.Config
  require Logger

  def upload_file(file_path) do
    file_name = Path.basename(file_path)
    url = Config.server_url() <> "/files/#{file_name}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/octet-stream"}
    ]
    body = File.read!(file_path)

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("File uploaded: #{resp_body}")
        {:ok, resp_body}
      error ->
        Logger.error("Error uploading file: #{inspect(error)}")
        error
    end
  end
end
defmodule MyApp.FileStorage do
  alias MyApp.Config
  require Logger

  def upload_file(file_path) do
    file_name = Path.basename(file_path)
    url = Config.server_url() <> "/files/#{file_name}"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/octet-stream"}
    ]
    body = File.read!(file_path)

    case HTTPoison.post(url, body, headers) do
      {:ok, %HTTPoison.Response{status_code: 201, body: resp_body}} ->
        Logger.info("File uploaded: #{resp_body}")
        {:ok, resp_body}
      error ->
        Logger.error("Error uploading file: #{inspect(error)}")
        error
    end
  end
end
﻿
You’ll receive a JSON response with the file URL, which you can store in a class (e.g., Photo) for reference.
Security Considerations
You can configure who can upload files in fileUpload settings on your Back4App project, restricting uploads to authenticated users if desired.
Step 7 – Email Verification and Password Reset
Overview
Email verification ensures that users own the email address used during sign-up. Password reset lets them recover accounts securely. Both features are built in on Back4App.
Back4App Dashboard Configuration
Enable email verification under your app’s “App Settings” or “Authentication.”
Configure the From address and email templates.
Enable password reset to let users reset via a link emailed to them.
Code/Implementation
Once enabled in the dashboard, you can trigger password resets:
Text
defmodule MyApp.Auth do
  def request_password_reset(email) do
    url = Config.server_url() <> "/requestPasswordReset"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{email: email})

    HTTPoison.post(url, body, headers)
  end
end
defmodule MyApp.Auth do
  def request_password_reset(email) do
    url = Config.server_url() <> "/requestPasswordReset"
    headers = [
      {"X-Parse-Application-Id", Config.app_id()},
      {"X-Parse-REST-API-Key", Config.rest_key()},
      {"Content-Type", "application/json"}
    ]
    body = Jason.encode!(%{email: email})

    HTTPoison.post(url, body, headers)
  end
end
﻿
Step 8 – Scheduling Tasks with Cloud Jobs
What Cloud Jobs Do
Cloud Jobs let you automate routine tasks like cleaning old data or sending periodic emails. You write them in Cloud Code.
Example
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);
  }
});
﻿
Deploy the code.
Go to the Back4app Dashboard > App Settings > Server Settings > Background Jobs.
Schedule the job to run daily or at a frequency you choose.
Scheduling a Cloud Job
﻿
Step 9 – Integrating Webhooks
Definition
Webhooks allow your Back4App application to send HTTP requests to an external service (e.g., a Slack channel or Stripe) when certain events occur.
Configuration
Navigate to the Webhooks configuration in your Back4App dashboard > More > Webhooks.
Set the endpoint (for example, https://your-service.com/webhook-endpoint).
Configure triggers such as “New record in the Todo class.”
Adding a Webhook
﻿
Example
If you want to send data to Slack whenever a Todo is created, you can add a new webhook pointing to your Slack incoming webhook URL. You might also define Webhooks in Cloud Code by sending custom HTTP requests in triggers like afterSave.
BeforeSave WebHook
﻿
Step 10 – Exploring the Back4App Admin Panel
Where to Find It
The Back4app Admin App is a user-friendly interface for managing your data. You can enable it from App Dashboard > More > Admin App.
Enable Admin App
﻿
Features
Create a First Admin User, which sets up the B4aAdminUser role and additional classes.
Assign a Subdomain to access the admin interface.
Log in to view and manage data in a simple interface.
﻿
Conclusion
By following this tutorial on how to build a backend for Elixir with Back4App, you have:
Created a secure backend structure on Back4App’s platform using Elixir for integration.
Set up a database with classes, data types, and relationships.
Used REST/GraphQL to interact with your data from Elixir.
Applied security using ACLs and CLPs.
Added custom logic with Cloud Code functions.
Configured user authentication with email verification and password resets.
Handled file storage and retrieval.
Scheduled background jobs for automation.
Integrated external services with webhooks.
Explored the Back4App Admin Panel for easy data management.
With Elixir’s concurrency model (powered by the Erlang VM) and OTP, combined with Back4App’s scalable and flexible services, you can build highly robust backends. 
Continue exploring more advanced features, integrate your business logic, and let Back4App help you handle the heavy lifting.
Next Steps
Build a production-ready Elixir app by layering this backend with your preferred Elixir/Phoenix web framework.
Integrate advanced features like role-based access control or third-party APIs (payment gateways, messaging services).
Explore Back4app’s official documentation for advanced security, logs, performance tuning, and more.
Check out other tutorials for real-time apps, IoT dashboards, or location-based services. With pattern matching and OTP concurrency at your disposal, you’re equipped to tackle a wide range of applications!
﻿
Updated 16 Jan 2025
Did this page help you?
How to Build a Backend for Ruby?
How to Build a Backend for Play Framework?