I had the same concern, but it is difficult to avoid circular dependencies if You want to communicate between.

web → sales
sales → web

In order for sales to communicate with web with the least inference, You could configure a notifier in sales.

# game engine config
config :game_engine, notify: GameWeb.Notifier

# game_engine module
def notify(message) do
  module = Application.get_env(:game_engine, :notify)
  module.notify(message)
end

# game_web notifier
defmodule GameWeb.Notifier do
  @moduledoc false
  require Logger

  # Notification Hub for application
  # Used by GameEngine to notify worker's exit

  def notify(%{payload: payload, type: :game_created}) do
    GameWeb.Endpoint.broadcast!("lobby", "game_added", %{game: payload})
  end

  def notify(%{payload: payload, type: :game_stopped}) do
    GameWeb.Endpoint.broadcast!("lobby", "game_removed", %{uuid: payload})
    
    # Notify remaining guest the game has ended!
    GameWeb.Endpoint.broadcast!("game:#{payload}", "game_force_quit", %{uuid: payload})
  end

  def notify(%{type: :request_created} = message) do
    # Do nothing, notification is done in lobby channel
    Logger.debug(fn -> "No op #{inspect(message)}" end)
  end

  def notify(%{payload: payload, type: :request_stopped}) do
    GameWeb.Endpoint.broadcast!("lobby", "request_cancelled", %{uuid: payload})
  end

  def notify(message) do
    Logger.debug(fn -> "Unknown notification #{inspect(message)}" end)
  end
end

So I am just passing an atom in the engine, that points back to web.

Although ultra simplistic, it works well. But for more complex solution, I would have used GenEvent if it was not deprecated.

I have been thinking it would be possible to have a common dependency for all, eg LocalBusSystem, where engines would produces events, and web would consume those.

I am also curious of other people solution, as it seems to be a concern when using umbrellas.