Question 1

When would you choose handle_call over handle_cast in a GenServer, and what are the failure modes you need to think about for each?

Accepted Answer

handle_call is synchronous, gives a reply, and lets the caller know if the server crashed (it gets an error). handle_cast is fire-and-forget, faster, but the caller has no visibility into failure or ordering. A strong answer mentions that using cast for state mutation without knowing if it succeeded can cause subtle bugs, and that call adds back-pressure naturally while cast can overwhelm a slow server.

Question 2

Describe the difference between the :one_for_one, :one_for_all, and :rest_for_one supervisor strategies. Give me a concrete scenario where you would choose each one. How does DynamicSupervisor replace the old :simple_one_for_one strategy, and when would you reach for it?

Accepted Answer

A strong answer gives concrete examples: :one_for_one for independent workers like connection pool members, :one_for_all when child processes share state and a crash in one invalidates the others (e.g., a registry and its worker), :rest_for_one when children have a pipeline dependency where later children depend on earlier ones. For dynamically spawned homogeneous workers like per-user sessions, the answer should name DynamicSupervisor, which replaced :simple_one_for_one in Elixir 1.6 and OTP 20. DynamicSupervisor.start_child/2 is the idiomatic way to add children at runtime.

Question 3

Explain how Phoenix LiveView decides what HTML to send over the WebSocket on each update. What are assigns, what is the diff algorithm doing, and how can poorly structured templates hurt performance?

Accepted Answer

LiveView tracks assigns in the socket, renders templates through a compile-time analysis that separates static and dynamic parts, and on each change only sends the dynamic segments that changed. A strong answer mentions that deeply nested or computed values embedded directly in templates bypass this optimization, and that using components and passing assigns explicitly allows finer-grained diffing.

Question 4

You are reviewing a Phoenix endpoint that lists 100 blog posts and their authors. Someone wrote it with Repo.all(Post) followed by Repo.get(User, post.user_id) in a loop. How do you fix this, and what Ecto features make it idiomatic?

Accepted Answer

The fix is to use Ecto preloads: either preload in the original query with a join, or use Repo.preload/2 which batches the secondary query into a single IN clause. A strong answer distinguishes between query preloads (join-based, single query) and Repo.preload (separate query with IN), and knows when each is appropriate. Mentioning dataloader for GraphQL contexts is a bonus.

Question 5

How do you structure changeset pipelines in Ecto when you have different validation rules for create versus update, and how do you handle embedded schemas with their own changesets?

Accepted Answer

A strong answer shows using separate named functions (e.g., create_changeset/2 and update_changeset/2) that call a shared base changeset, using cast_embed/3 or cast_assoc/3 for nested schemas, and using with_action/2 to distinguish insert from update constraints. Knowing the difference between validate_ functions (pure) and constraint/3 functions (database-backed) is essential.

Question 6

Describe how Phoenix's request pipeline is built on Plug. What is a Plug, how does conn flow through a pipeline, and how would you write a custom authentication Plug that halts the connection?

Accepted Answer

A Plug is any module implementing init/1 and call/2, or a function taking conn and opts. Phoenix router, pipelines, and controllers are all Plug stacks. Calling Plug.Conn.halt/1 sets conn.halted to true, which stops further plugs from executing. A strong answer shows writing a module Plug that checks for a token in the Authorization header, assigns the current user, and halts with send_resp(conn, 401, ...) if not authenticated.

Question 7

Walk me through how the BEAM VM schedules Elixir processes. What is a reduction, how does preemption work, and what happens when a process exceeds its reduction budget?

Accepted Answer

A strong answer covers reductions as a unit of work (roughly one function call or built-in operation), the per-scheduler run queues, preemptive scheduling at reduction limits (default 4000), and how the process is suspended and re-queued without blocking the scheduler thread. Bonus points for mentioning dirty schedulers for NIF-heavy work and the impact of long-running NIFs on latency.

Question 8

You need to store and look up a large, frequently-read, rarely-written in-memory table of data. Why might you choose ETS over a GenServer holding a map, and what tradeoffs does that choice carry?

Accepted Answer

ETS tables allow concurrent reads without going through a single process, eliminating the bottleneck of a GenServer serializing all reads. A strong answer covers table types (set, ordered_set, bag), concurrency modes (:public, :protected, :private), the lack of transactions across multiple keys, and the fact that ETS is not persistent across node restarts. Persistent term (:persistent_term) is worth mentioning for global read-mostly config.

Question 9

You need to create a user, send a welcome email via a third-party API, and record an audit log entry, all atomically. How would you structure this with Ecto.Multi, and how do you handle the case where the email API call fails?

Accepted Answer

Ecto.Multi lets you build a pipeline of named operations that run inside a single database transaction. A strong answer acknowledges that external API calls inside a database transaction are an anti-pattern because holding a DB connection while waiting on an HTTP call risks connection exhaustion and the transaction cannot roll back a sent email. The idiomatic fix is to use an outbox pattern or enqueue a background job (Oban) after the transaction commits.

Question 10

A GenServer in production is getting slower and slower. You suspect its mailbox is growing. How would you diagnose this, and what are the common architectural causes and fixes?

Accepted Answer

Diagnosis: Process.info(pid, :message_queue_len) or :sys.get_status/1 for a running server, or observing via :observer or Telemetry. Common causes: too many callers sending casts to a slow consumer, blocking work inside callbacks. Fixes: add back-pressure by using call instead of cast, move slow work to Task processes spawned from handle_info, shard state across multiple GenServers, or use a poolboy/Poolex pool.

Question 11

Describe how two Elixir nodes communicate in a distributed cluster. What is the Erlang distribution protocol, how do nodes discover each other, and what are the security implications of the default setup?

Accepted Answer

Nodes connect over TCP using the Erlang Port Mapper Daemon (EPMD) for discovery by default. All communication uses a shared cookie as authentication. A strong answer calls out that the default cookie-based auth is weak (shared secret, no encryption without TLS distribution), that you can enable TLS distribution for security, and that in Kubernetes environments EPMD-free clustering via libcluster with DNS or Kubernetes API strategies is preferred.

Question 12

You are building a real-time multiplayer game. When would you use Phoenix Channels over LiveView, and are there scenarios where both belong in the same feature?

Accepted Answer

Channels are a lower-level primitive suited for bidirectional messaging patterns like multiplayer games where the client drives events frequently and the server does not own the UI. LiveView makes sense when the server owns the view and you want to avoid writing a separate client-side app. A strong answer notes that you can use both: LiveView for lobby/matchmaking UI and a Channel for the in-game low-latency event loop.

Question 13

How does the :telemetry library work, and how would you instrument a custom business operation in a Phoenix app to emit metrics that Prometheus can scrape?

Accepted Answer

telemetry:execute/3 emits an event with measurements and metadata to any attached handlers. A strong answer mentions :telemetry.attach or :telemetry.attach_many to wire handlers, using PromEx or TelemetryMetricsPrometheus to aggregate counters/summaries/histograms, and Phoenix's built-in telemetry events (phoenix.router.dispatch.start/stop). Also covers span patterns using telemetry span helpers.

Question 14

You use Oban for background jobs backed by PostgreSQL. Walk me through how Oban prevents duplicate jobs, handles job failures, and ensures at-least-once delivery even if the BEAM node crashes mid-job.

Accepted Answer

Oban persists jobs to a Postgres table before returning success to the caller. It uses advisory locks on job IDs to prevent concurrent execution of the same job. On node crash, jobs remain in the table with state 'executing' and a rescue mechanism re-queues them after a timeout. A strong answer also covers the unique/4 option for deduplication, the max_attempts and backoff settings, and how to design idempotent workers.

Question 15

A LiveView page needs to initialize a third-party chart library on mount and update it when server-side data changes, without losing chart state on each re-render. How do you implement this with LiveView JS hooks?

Accepted Answer

LiveView hooks allow attaching JavaScript lifecycle callbacks (mounted, updated, destroyed, etc.) to DOM elements via phx-hook. A strong answer covers defining the hook in app.js, using this.el to access the DOM node, using pushEvent to send events from JS to the server, and receiving updates via handleEvent. The phx-update='ignore' attribute on the chart container prevents LiveView from patching the DOM that the chart library manages.

Question 16

You need to show all users currently viewing a shared document, across multiple nodes in your cluster. How does Phoenix.Presence work under the hood, and what consistency model does it use?

Accepted Answer

Phoenix.Presence uses a CRDT (conflict-free replicated data type) called a state-based CRDT under the hood, synced via PubSub across nodes. Each node owns the presence entries for connections on that node and gossips state. On merge, conflicts resolve by taking the union, so it is eventually consistent. A strong answer covers the Presence.track/3, Presence.list/2, and handle_diff callback, and notes that presence data should be treated as eventually consistent, not strongly consistent.

Question 17

A search endpoint accepts optional filter parameters: name, status, inserted_after, and sort_by. How do you build the Ecto query incrementally without adding if-nil branches everywhere, and what is the idiomatic pattern for this in Elixir?

Accepted Answer

The idiomatic pattern is to build a base query and pipe it through filter functions that pattern-match on nil vs value, adding clauses only when the parameter is present. Using Enum.reduce over the params map with a function dispatch table is an alternative. A strong answer also mentions scoping query composition into a dedicated Filters module for testability and reuse.

Question 18

A user clicks a 'like' button in LiveView. The server roundtrip takes 150ms and the UI feels sluggish. How do you implement an optimistic update in LiveView so the button responds immediately, and how do you reconcile if the server call fails?

Accepted Answer

LiveView's JS module allows client-side attribute toggling (push with optimistic DOM mutation) before the server responds. A strong answer covers using JS.toggle or JS.set_attribute to flip the liked state immediately on click, then letting the server's push_event or assign update reconcile on completion. On failure, a push_event can signal the client hook or a LiveView event can reset the assign.

Question 19

A process on a production node is behaving unexpectedly but you cannot redeploy. What tools do you reach for to inspect its state, trace its messages, and profile its reductions without taking the node down?

Accepted Answer

:sys.get_state/1 retrieves a GenServer's current state non-intrusively. :sys.trace/2 turns on tracing for a specific process. recon_trace (from the recon library) does safe rate-limited message tracing in production without flooding the scheduler. :erlang.process_info/2 gives mailbox length, heap size, and reductions. A strong answer mentions the risk of :dbg and :sys.trace on high-throughput processes and prefers recon_trace for production.

Question 20

What delivery guarantee does Phoenix.PubSub provide? If a subscriber is slow or temporarily offline, does it receive messages it missed, and how would you design around that limitation?

Accepted Answer

PubSub is fire-and-forget: it delivers to currently subscribed processes only, with no buffering or persistence. A slow subscriber does not get replayed messages after reconnect. A strong answer covers designing around this with a combination of PubSub for live updates and a database or event store for authoritative state that clients fetch on reconnect, or using a persistent queue like Oban or Kafka for events that must not be lost.

Question 21

How does Dialyzer work in the context of an Elixir project, what is PLT, and what kinds of bugs does Dialyzer catch that ExUnit tests typically miss?

Accepted Answer

Dialyzer performs success typing analysis: rather than proving code correct, it proves code wrong when it can find a contradiction. The PLT (persistent lookup table) caches analyzed beam files. It catches type inconsistencies, dead code branches, calls to non-existent functions, and pattern matches that can never succeed. A strong answer mentions dialyxir as the Mix integration, the high initial PLT build cost, and that Dialyzer is sound but not complete (will not catch all bugs).

Question 22

You notice that LiveView processes on your server are growing in memory over time and never shrinking. Users have not noticed yet but memory is climbing. What steps do you take to diagnose and fix this before it becomes an incident?

Accepted Answer

Use :erlang.process_info(pid, :memory) and :sys.get_state/1 to inspect a live LiveView process. Check assigns for unbounded growth (lists, maps accumulating). Look for handle_info clauses that accumulate data without pruning, or subscriptions that deliver messages with no handle_info match (filling the mailbox). Fix by adding explicit cleanup in handle_info, resetting assigns, or pruning accumulating state. Set up a Telemetry metric on process memory for ongoing monitoring.

Question 23

You check your Oban dashboard and one queue has 200,000 pending jobs and is falling further behind. The queue normally processes in near real time. What do you do?

Accepted Answer

Diagnose first: is the backlog from a sudden spike or a slowdown in workers? Check worker error rate (are jobs failing and retrying?), check database connection pool utilization, check for a long-running job holding resources. Mitigation: temporarily increase concurrency for that queue, check for a poison pill job blocking others, pause non-critical queues to free resources. Long-term: add worker-level Telemetry, set up alerts on queue depth.

Question 24

You need to add an index to a PostgreSQL table with 500 million rows in a running production system. How do you do this without locking the table and causing downtime, and how does this interact with your Ecto migration strategy?

Accepted Answer

Use CREATE INDEX CONCURRENTLY in the Ecto migration via execute/1. This avoids a full table lock but takes longer and can fail without cleanup, leaving an invalid index. Ecto migrations wrap in a transaction by default; disable that with @disable_ddl_transaction true and use concurrent: true on the index. A strong answer also covers the risk of a concurrent index failing (leaving an INVALID index that needs REINDEX), monitoring index build progress via pg_stat_progress_create_index, and blue-green deploy implications.

Question 25

Walk me through how hot code upgrades work in an OTP release. What files are involved, what constraints exist on process state, and when would you avoid hot upgrades in production?

Accepted Answer

A strong answer covers appup and relup files, the code_change/3 callback on GenServer for migrating state, the two-version code loading mechanism in the BEAM, and the constraint that you cannot change the module interface in incompatible ways during a hot upgrade. Most production teams avoid hot upgrades due to complexity, preferring blue-green deploys or rolling restarts, which is a valid and honest answer.

Question 26

You need to broadcast a message to all processes handling a particular tenant's connections. What are your options among Registry, :pg, and Phoenix.PubSub, and how do they differ in a multi-node cluster?

Accepted Answer

Registry is local to a single node. :pg (process groups, added in OTP 23 as a replacement for the removed PG2 module) is distributed across the cluster and part of OTP itself. Phoenix.PubSub abstracts over either a local backend (the default :pg adapter since Phoenix.PubSub 2.0) or a Redis adapter for cross-cluster scenarios. A strong answer knows that for multi-node broadcast, PubSub with the :pg adapter is the idiomatic choice in a BEAM cluster, and that Registry with :duplicate keys is useful for local fan-out patterns. Mentioning that PG2 is gone as of OTP 24 and should not be referenced in new code is a bonus.

Question 27

When would you use Mnesia for persistence in an Elixir cluster instead of PostgreSQL, and what operational hazards does Mnesia carry that PostgreSQL does not?

Accepted Answer

Mnesia is co-located with the BEAM, supports transactions, and can replicate data across nodes without an external service, making it good for low-latency distributed coordination like RabbitMQ's metadata storage. Hazards include split-brain without automatic resolution, schema migration being manual and painful, limited query capability, and the complexity of managing disc_copies vs ram_copies. Most production Elixir teams prefer external Postgres and keep Mnesia for specialized use cases.

Question 28

Explain how macros work in Elixir: what is the AST, what does quote/unquote do, and what distinguishes a macro from a function? Give me a case where a macro is the right tool and one where it is not.

Accepted Answer

Macros receive code as quoted AST at compile time and return AST to be injected at the call site. quote captures code as data; unquote injects values into a quoted expression. Good use: defining DSLs (Ecto schemas, Phoenix Router), compile-time validation, eliminating boilerplate that cannot be expressed with HOFs. Bad use: anything a function can do, because macros are harder to debug, cannot be passed as values, and increase compile time.

Question 29

You are building a data pipeline that processes incoming events faster than your downstream sink can handle them. How do GenStage and Flow address this, and what configuration knobs control the back-pressure?

Accepted Answer

GenStage implements a demand-driven protocol: consumers request N items from producers, and producers only emit when demand exists. Flow wraps this into a higher-level API with partition, map, filter, and reduce operations. The min_demand and max_demand options on subscribe/2 control the buffer window. A strong answer also covers windowing (time-based or count-based) for stateful aggregations and the difference between parallel and sequential stages.

Question 30

Walk me through setting up Broadway to consume messages from a Kafka topic. What are batchers, what is the difference between a batcher and a processor, and how does Broadway handle acknowledgements?

Accepted Answer

Broadway uses producers (Kafka via brod or kafka_ex), processors (concurrent per-message handlers), and optional batchers (group messages by batch key before a batch handler). Acknowledgements are sent back to the Kafka producer only after all processors confirm success, enabling at-least-once delivery. A strong answer also mentions that Broadway handles concurrency, back-pressure, and partial batch failure by marking failed messages as failed while acking successful ones.

Questions

GenServer handle_call vs handle_cast tradeoffsRole-specificeasyVery common

As asked

Sample answer outline

Expect these follow-ups

OTP supervisor restart strategies explainedRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

How LiveView sends minimal diffs to the clientRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

Diagnosing and fixing N+1 queries in EctoRole-specificeasyVery common

As asked

Sample answer outline

Expect these follow-ups

Designing layered Ecto changeset pipelinesRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

How the Plug pipeline works in PhoenixRole-specificmediumVery common

As asked

Sample answer outline

Expect these follow-ups

How does the BEAM scheduler manage processes?Role-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

When to use ETS instead of GenServer for stateRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Using Ecto.Multi for atomic multi-step operationsRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Diagnosing a backed-up GenServer message queueRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

How Elixir nodes communicate in a clusterRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

Choosing between Phoenix Channels and LiveViewRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Instrumenting a Phoenix app with TelemetryRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Ensuring reliable background job processing with ObanRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

LiveView JavaScript hooks for custom client behaviorRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Phoenix.Presence for distributed presence trackingRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

Composing Ecto queries dynamicallyRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Implementing optimistic UI updates in LiveViewRole-specificmediumCommon

As asked

Sample answer outline

Expect these follow-ups

Using :sys, :observer, and recon for live debuggingRole-specifichardCommon

As asked

Sample answer outline

Expect these follow-ups

Delivery guarantees of Phoenix.PubSub broadcastsRole-specificmediumCommon

As asked

Sample answer outline