Hopscotch like service and workflows in elixir.

service.award_acorns.ex

defmodule Service.AwardAcorns do
  alias ExSeeds.{Repo, Student}

  def call(student, amount \\ 3) do
    student
    |> ExSeeds.Student.changeset(%{acorns: student.acorns + amount})
    |> Repo.update
  end
end

service.ensure_enough_acorns.ex

defmodule Service.EnsureEnoughAcorns do
  def call(acorns, cost) when acorns >= cost do
    {:ok, ""}
  end

  def call(_acorns, _cost) do
    {:error, "not enough acorns"}
  end
end

servie.create_student_event.ex

defmodule Service.CreateStudentEvent do
  def call(map) do
    case create_student_event(map) do
      _event ->
        {:ok, "event created."}
      _ ->
        {:error, "event could not be created."}
    end
  end

  defp create_student_event(map) do
    # ie.
    # %{
    #   student_id: student.id,
    #   precinct: 'arcade',
    #   event_type: 'ArcadeGame'
    # }
    # BlakeProgress.Service.create_student_event(map)
    %{id: 1}
  end
end

workflow.arcade.playgame.ex

defmodule Workflow.Arcade.PlayGame do
  alias ExSeeds.{Repo, Student}

  def call(student, game) do
    steps(student, game)
    |> Workflow.Transaction.call
  end

  defp steps(student, game) do
    fn ->
      with {:ok, _} <- Service.EnsureEnoughAcorns.call(student.acorns, game.cost),
           {:ok, _} <- deduct_acorns(student, game.cost),
           {:ok, _} <- Service.CreateStudentEvent.call(%{id: 1}),
      do: {:ok, "workflow successful"}
    end
  end

  defp deduct_acorns(student, cost) do
    Service.AwardAcorns.call(student, -cost)
  end
end

workflow.transaction.ex

defmodule Workflow.Transaction do
  def call(function) do
    ExSeeds.Repo.transaction(fn() ->
      case function.() do
        {:ok, result} -> result
        {:error, error} -> ExSeeds.Repo.rollback(error)
      end
    end)
  end
end

This approach highlights how this could possibly be done with an OTP application that could be included into a phoenix application.