Couldn’t you create a new application (that all of the other applications depend on), whose supervision tree contains a GenServer that inserts the rows in :persistent_term?

If you’re using an umbrella I found it useful to create an application that is responsible for bootstrapping the actual app. This allows you to setup things before starting your actual “core”.
As an example, on the umbrella mix.exs I have the following release:

defmodule YourApp.MixProject do
  use Mix.Project

  def project do
    [
      apps_path: "apps",
      version: "1.0.0",
      start_permanent: Mix.env() == :prod,
      deps: deps(),
      releases: [
        your_release_name: [
          applications: [
            bootstrap: :permanent, #this is so that when releasing it starts this app which in turn will run its logic
            server: :load #this is the actual core application, we set it to only load its modules but not start the supervision tree
          ],
          include_executables_for: [:unix]
        ]
      ]
    ]
  end
  #other things.... like deps etc
end

Then the bootstrap app is a simple app with a supervision tree, it has a bootstrap.ex which is a gen_server to be started from the supervision tree, eg:

defmodule Bootstrap do
  
  @moduledoc """
  This starts mnesia and etc and once ok starts the web interface
  """

  use GenServer, shutdown: 50_000
  require Logger
  
  @mnesia_tables_attrs %{
    categories: [:slug, :title, :description, :image, :id, :struct]
  }

  @mnesia_tables Enum.reduce(@mnesia_tables_attrs, [], fn({table, _}, acc) ->
    [table | acc]
  end) |> :lists.reverse

  def start_link(_) do
    GenServer.start_link(__MODULE__, nil, name: __MODULE__)
  end

  def init(_) do
    System.cmd("epmd", ["-daemon"])

    #random_uuid = (:crypto.strong_rand_bytes(4) |> Base.encode16())
    #name = :"#{random_uuid}@#{:net_adm.localhost()}"

    #:net_kernel.start([name])
    
    case :mnesia.start() do
      :ok ->
        
        Enum.each(@mnesia_tables_attrs, fn({table, attributes}) ->
          :mnesia.create_table(table, [attributes: attributes])
        end)
        
        case :mnesia.wait_for_tables(@mnesia_tables, 5_000) do
          :ok ->
            Logger.warn("Mnesia tables loaded")
            {:ok, :started, {:continue, :ensure_all_started}}
          {:timeout, tables} ->
            Logger.error("Mnesia Unable to load tables: #{inspect tables} - shutting down...")
            :init.stop()
        end

      error -> :init.stop()
    end
  end

  def handle_continue(:ensure_all_started, state) do
    Logger.info("Starting server")
    {:ok, _started_apps} = :application.ensure_all_started(:server, :permanent)
    {:noreply, :started}
  end

  def copy_hex_cache(_, _, _) do
    File.cp_r!(Path.expand("~/.hex"), File.cwd!() <> "/hex")
    :ok
  end

  def delete_hex_cache(_, _, _) do
    File.rm_rf!(File.cwd!() <> "/hex")
    :ok
  end

end

Then it’s application file includes:

defmodule Bootstrap.Application do
  @moduledoc false

  use Application

  def start(_type, _args) do
    children = [
      {Bootstrap, []}
    ]

    opts = [strategy: :one_for_one, name: Bootstrap.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

And it has a task in all similar to the phx.server task:

defmodule Mix.Tasks.Bootstrap do
  use Mix.Task

  def run(_) do
    Application.put_env(:phoenix, :serve_endpoints, true, persistent: true)
    {:ok, _} = Application.ensure_all_started(:bootstrap)
    Mix.Tasks.Run.run run_args() ++ ["--no-start"]
  end

  defp run_args do
    if iex_running?(), do: [], else: ["--no-halt"]
  end

  defp iex_running? do
    Code.ensure_loaded?(IEx) and IEx.started?
  end

end

This task is to be run when in dev, so that you can do iex -S mix bootstrap
In my case I do Ecto migrations when I need manually, but there’s nothing preventing you from adding a step to run migrations as well as part of the bootstrap gen_server. Any other things you need to do before starting your actual core, can be done here too if needed. When running the release it will start the bootstrap app (you don’t run the task) and that start your actual app.

I have found this a good way of structuring the startup of an application.

I have used the Module @on_load callback to ensure persistent terms are set up the first time the wrapper module is used. That allowed me to avoid any concerns about app startup processes.