Elixir engineer interview questions

As asked

Design the OTP supervision tree for a Phoenix service that handles chat rooms, user presence, and outbound webhooks. What processes exist and what restarts when something fails?

Sample answer outline

A strong answer starts with process boundaries, not modules. Put room processes under a DynamicSupervisor so rooms can start and stop independently, and isolate webhook delivery workers so a bad third-party endpoint cannot take down chat state. Choose restart strategies deliberately: one_for_one for independent room workers, rest_for_one only where later children depend on earlier ones. Presence should be treated as derived state that can be rebuilt, while durable chat messages belong in the database. Candidates often trip up by making one GenServer own too much state or by restarting a whole subtree for a local failure.

Expect these follow-ups

• When would you use Registry versus pg for finding room processes?
• How do you avoid a thundering restart loop after a deploy?
• What state is safe to keep only in a process?

As asked

A GenServer that batches analytics events starts building a mailbox with millions of messages during a traffic spike. How do you debug it and redesign it?

Sample answer outline

The diagnosis should inspect process info, message queue length, reductions, memory, and the shape of incoming messages before guessing. The redesign should avoid treating a GenServer as an unbounded queue: use bounded demand, partition work across multiple processes, and push durable backlog into Broadway, Oban, RabbitMQ, or Kafka depending on delivery requirements. Batching should be time and size bounded, with explicit shedding or backpressure when downstream is slow. A senior answer distinguishes CPU saturation from downstream latency and from a single hot key. The common mistake is adding more callers while leaving one serial bottleneck in place.

Expect these follow-ups

• How would you expose mailbox length as an operational metric?
• When is dropping events acceptable?
• How would Broadway change the design?

As asked

You are building a LiveView dashboard with filters, charts, and realtime updates. What state belongs in the socket assigns, what belongs in the URL, and what belongs in the database?

Sample answer outline

Durable business state belongs in the database, shareable navigation state such as filters belongs in URL params, and ephemeral view state belongs in assigns. The answer should cover mount versus handle_params, reconnect behaviour, and how PubSub updates are merged without overwriting a user's current filters. Expensive chart data should be paged or summarised rather than stored wholesale in the socket. The interviewer wants to hear that LiveView is server stateful and therefore memory per connection matters. Weak answers treat LiveView like React with a socket bolted on and forget reconnects, browser history, and process memory.

Expect these follow-ups

• How do you make the dashboard deep-linkable?
• What happens to assigns during a reconnect?
• How do you prevent one user connection from consuming too much memory?

As asked

Write an Elixir function that handles chat commands represented as tuples, validates their shape, and returns tagged results without raising for normal bad input.

Sample answer outline

The answer should use multiple function heads and guards rather than a large nested case. Return tagged tuples such as {:ok, value} and {:error, reason} so callers can compose the parser without exceptions. Pattern matching should make the supported command shapes obvious and should reject malformed input at the boundary. Guards are useful for simple checks such as non-empty binary room names or positive integer limits. Candidates often overuse atom conversion on untrusted strings, which can exhaust the atom table.

Reference implementation (elixir)

defmodule Chat.CommandParser do
  def parse({:join, room}) when is_binary(room) and byte_size(room) > 0 do
    {:ok, {:join, room}}
  end

  def parse({:history, room, limit})
      when is_binary(room) and is_integer(limit) and limit in 1..100 do
    {:ok, {:history, room, limit}}
  end

  def parse({:send, room, body})
      when is_binary(room) and is_binary(body) and byte_size(body) > 0 do
    {:ok, {:send, room, String.trim(body)}}
  end

  def parse(_), do: {:error, :invalid_command}
end

Expect these follow-ups

• Why avoid String.to_atom on user input?
• How would you add a default limit while keeping the function heads readable?
• Where would you put validation that requires a database lookup?