Last updated: November 18, 2026
By Jennifer Burdick, Recruiting Manager, KORE1
Elixir developer interview questions in 2026 should have the candidate read broken OTP code, explain what a supervisor does when a worker keeps crashing, and show how they would find a memory leak on a live node. Questions about immutability and pattern matching still belong in a phone screen. They do not show whether anyone has watched the BEAM fail under load.
Elixir searches reach my desk at KORE1 less often than Python or Java ones, and the ones that go wrong tend to go wrong in the same place. The resume says Elixir. The candidate talks well about pipes, pattern matching, and why immutable data is pleasant to work with. Everyone on the panel nods. Nobody asks. What happens when something breaks is the whole reason a company picks this runtime in the first place.
Picture a fleet-tracking company in Minneapolis, about forty engineers, moving its vehicle status service from Rails to Phoenix. This is a made-up case, though I have watched every piece of it happen somewhere. They hire a senior Elixir developer who is fluent at a whiteboard. One GenServer holds the current status of every truck, and in week six somebody adds a lookup against an outside geocoding service inside one of its callbacks. On a Tuesday afternoon that service gets slow. Requests stack up behind a single process, the five-second call timeouts start firing, request after request fails, and the dashboard that reads from that process goes dark. It stays dark. The syntax is fine. The code reads well. The fault is in the design, and one question in the interview loop would have found it. Just one.
Most published Elixir lists would not have asked it. They ask what a GenServer is, how an Agent differs from a Task, what the BEAM is, and what let it crash means. A candidate can answer all of that after one weekend with a book, and the answer sounds the same from a hobbyist as from someone who has carried a pager for five years. Identical, almost. You need questions that cannot be memorized. Break something instead.
My stake, stated before the questions start. KORE1 collects a fee once an Elixir engineer from our shortlist signs an offer and begins work, and an engineer who cannot keep a service up at three in the morning is a search we run twice. The screen our Elixir developer staffing desk uses is a design conversation, a live OTP bug, and a production war story. What follows is the client-panel version of it.

Decide Which Half of Elixir the Seat Needs
Elixir is one title over two jobs. Very different jobs. A Phoenix developer builds web features, APIs, and LiveView screens on top of Ecto. An OTP engineer designs the layer underneath, the processes, the supervision, the queues, and the way a cluster behaves when the network does not. Most of the candidate pool arrived from Rails and writes very good Phoenix. Far fewer have designed the layer below it. Our guide to hiring Elixir developers walks through the split and the pay on each side, and it describes a settlement-engine search where all fourteen applicants turned out to be Phoenix developers. Good ones. Wrong search.
The people you want are not hunting. The Stack Overflow 2025 Developer Survey ranks Elixir third among the most admired programming languages at 66 percent, behind Rust and Gleam, so engineers who write it tend to stay with it. A slow loop loses them to the other conversations they already have running. Speed matters. The tooling moves too. Elixir 1.20 shipped on June 3, 2026, requires Erlang/OTP 27 or later, and runs on OTP 29, which came out in May, so ask which versions a candidate has actually deployed.
Not every seat needs every question. Use the table below to decide where the hour goes. The headings further down match its wording. Choose two or three. Not all of them. The printed module goes in every loop.
| Seat you are filling | Spend the hour on | Keep short |
|---|---|---|
| Phoenix product team (forms, APIs, LiveView screens) | The database pool, LiveView memory | More than one node |
| Real-time layer (chat, presence, live dashboards) | The mailbox, LiveView memory, the node at three in the morning | The database pool |
| Job and event pipelines | The duplicate job, the database pool, supervision | LiveView memory |
| Payments, settlement, anything that moves money | Supervision, more than one node, the duplicate job | LiveView memory |
| Rails-to-Elixir migration team | The printed module, the database pool, judgment | More than one node |
A Cache Module With Six Things Wrong in It
Print this on paper. No screens. Nobody runs it. Hand it over, say it is up for review before it merges, and stay quiet for ten minutes.
Circle everything you would change before this merges.
defmodule Rates.Cache do
use GenServer
def start_link(_opts) do
GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
end
def get(code), do: GenServer.call(__MODULE__, {:get, code})
def init(state), do: {:ok, state}
def handle_call({:get, code}, _from, state) do
key = String.to_atom(code)
case Map.fetch(state, key) do
{:ok, rate} ->
{:reply, rate, state}
:error ->
rate = HTTPoison.get!("https://rates.example.com/" <> code).body
{:reply, rate, Map.put(state, key, rate)}
end
end
endThere are six. The HTTP request runs inside handle_call, and a GenServer handles one message at a time, so every caller waits behind the slowest fetch while the default five-second call timeout runs out on everyone queued behind it. String.to_atom turns caller-supplied text into atoms, which are never garbage collected, and the Erlang system limits cap the atom table at 1,048,576 by default. A loop of unique strings can bring the node down, and the Elixir docs for String.to_atom warn against exactly this. HTTPoison.get! raises on a transport error, the server crashes, and its whole map goes with it, so the supervisor brings it back empty and every caller refetches at once. Nothing expires. For exchange rates, that is a bug of its own. One process serializes every read, where an ETS table with read concurrency and a single writing process would not. And nothing checks the status code, so an error page returned on a bad day becomes the cached rate.
Strong candidates find the blocking call first. Most find the atoms too, because the warning is in the docs and a lot of people were burned by it once. Fewer find the status code. The finalist worth hiring asks a question before circling anything. What is the cache for, who reads it, and how stale can a rate be? Then they circle different things for different reasons.
Ask the follow-up. Rewrite the module so a slow fetch cannot block a read. Good answers move the fetch into a Task under a Task.Supervisor or into a separate refresher process, keep the rates in ETS, store an expiry beside each one, and decide what a caller gets when the rate is stale and the outside service is down. That last decision belongs to the business, and the candidate should say so out loud.

Questions About Supervision
Supervision is the reason anyone chooses this runtime, and it is where rehearsed answers run thinnest. Let it crash comes out of the Erlang tradition and is laid out in Joe Armstrong’s 2003 thesis, Making Reliable Distributed Systems in the Presence of Software Errors. A candidate who can only recite the phrase has not been paged for it. Ask for the incident.
One worker in this tree crashes four times in five seconds. Walk me through what happens next.
MyApp.Supervisor strategy: :one_for_one (no other options set) MyApp.Repo Phoenix.PubSub MyAppWeb.Endpoint MyApp.CardWorker calls an outside card processor
Start with the defaults. According to the Supervisor docs, a supervisor tolerates three restarts in five seconds unless told otherwise. The fourth crash inside that window makes it give up, stop every other child, and exit, and the failure climbs to whatever supervises it. In this tree that is the top. A mix release starts applications in permanent mode by default, and the release docs say the node shuts down if a permanent application terminates, regardless of reason. One flaky card processor has now taken the endpoint, the database pool, and the node. All from one worker.
Strong candidates reach for the same repairs, and the first is to put the risky worker in its own subtree so that giving up costs one branch and not the trunk, which is a design choice made before any crash and not a fix applied after one. Raise the intensity or add backoff when the failure is an outside service that will come back. Ask whether the worker needs a restart at all, or whether the caller should simply get an error and move on. The weakest answer is restart it, full stop.
The worker needs the database pool running before it starts. Which strategy do you pick?
Rest for one. The pool goes first in the list. Children start in list order, and that strategy restarts the crashed child plus everything started after it, so a pool restart takes the dependent workers with it and leaves everything before it alone. One for all fits children that share state and cannot survive without each other. One for one fits strangers. Ask why the order of the list matters. People who have only read about supervisors never saw the list as a dependency graph.

Questions About the Database Pool
Ecto talks to the database through a pool of connections, and the Ecto.Repo docs put the default size at ten. Small number. Candidates who have only worked on laptops never think about it.
A checkout handler inserts an order, calls the card processor, and updates the order, all inside one Repo.transaction. The processor starts taking eight seconds. What happens to the app?
Each in-flight checkout holds a connection for the full eight seconds, and ten connections divided by eight seconds is a ceiling of about 1.25 checkouts a second. Everything else waits in the pool queue, and when the wait runs out the request fails with a connection error. Pages that never touch checkout fail too, because they draw from the same ten. A strong candidate does that arithmetic out loud, then moves the outside call out of the transaction and says what it costs, since the order can now exist without a charge. The better answers continue. An idempotency key sent to the processor so a retry after a timeout cannot charge twice. An Oban job or an outbox table for the work that happens after commit.
Weak candidates raise the pool size to fifty. Easy. That moves the failure to the database, which now serves five times the connections and still waits on the same slow processor. Sometimes it is fine as first aid. It is never the answer.
Questions About LiveView and Memory
Four thousand users are connected, and each LiveView holds a list of 500 rows in its assigns. Memory climbs all afternoon. What do you change?
Every connected LiveView is its own process with its own copy of that state, so 500 rows across 4,000 users is 2,000,000 row copies. At roughly 2 KB a row as an Elixir map, that is about 4 GB spread over four thousand heaps. The usual fix is streams. The LiveView docs say stream items are freed from socket state right after the render, which is the whole point. Better candidates also paginate, keep ids in assigns and not whole structs, and ask which of the 500 rows each user ever scrolls to.
The weak answer is a bigger server. Not wrong for a week.
Questions About the Node at Three in the Morning
Memory on one node has grown for nine days. No single process is large. Where do you look?
With :erlang.memory(), to see which category is growing, because processes, binaries, ETS, and atoms each point somewhere different. If binaries are the climber, the next stop is reference-counted binaries. Anything over 64 bytes lives off the process heap and is counted by reference, and the Erlang binary handling guide describes how a small sub binary can hold a large binary alive long after anyone needed the rest of it. A process that keeps ten bytes of a ten-megabyte response keeps the response. The fixes are :binary.copy on the piece you keep, or hibernating processes that sit idle. Fred Hébert’s free book Erlang in Anger covers the tooling, and candidates who have been through one of these nights will name recon.
Then ask how they got into the production node, what they were careful not to run once they were there, and what they wrote down afterward so the next person on call would not have to rediscover any of it. People who say they would restart it have solved the night and kept the problem. Restarts are not a diagnosis.
Questions About More Than One Node
Two nodes lose contact for ninety seconds, and both kept accepting writes for customer 4417. What happens when they reconnect?
Erlang distribution connects nodes and passes messages between them. It does not decide who is right. A strong answer starts by asking which node was supposed to own the customer and what ownership meant, then moves to a single writer, the database as the arbiter, versioned writes, or merging when the data allows it. Some data cannot be merged. Somebody loses. The candidate should be willing to say which write. A library name is not an answer. Each registry or clustering tool has a failure mode during a split, and the candidate should know the one that belongs to whatever they name.
A nightly invoice job ran twice after a deploy. Why, and what do you change?
Job systems deliver at least once. Not exactly once. A worker killed mid-run gets retried, a deploy restarts nodes, and Oban retries failed jobs up to a configured maximum number of attempts. The change belongs in the work. Make it idempotent at the database, with a unique constraint on the invoice and the period, so a second run finds nothing to do. The Oban docs describe unique jobs, which cut duplicate inserts, but they sit in front of the problem and do not replace the constraint. Candidates who answer with the unique option alone have met the feature and not the failure.
Where Judgment Shows
Elixir 1.20 started type checking programs that carry no annotations. What did that change for your team?
The 1.20 release announcement describes type inference across every language construct, and the changelog says it can flag redundant clauses and dead code in existing projects. A candidate who upgraded can tell you what the new warnings found and whether they treated the output as findings or silenced it. A candidate whose team is on an older release is not a bad sign. Listen for curiosity about what the checker would say about their own code.
Name a service you would refuse to write in Elixir.
Good answers come fast. CPU-bound number crunching, a small command-line tool that ships as one binary, a team with nobody to review the code. Some name a service they would write in Go or Rust, and our Go developer interview questions and Rust developer interview questions cover the other side of that conversation. The red flag is nothing. A candidate who thinks the BEAM suits every problem has not run one long enough to learn its edges.
How the Same Question Sounds From Two Different Candidates
Some of the people on your panel have never operated an OTP system. Print the table below for them, and they will hear the difference.
| Question | Someone who has run it | Someone who has read about it |
|---|---|---|
| The printed cache module | Asks what the cache is for, then finds the blocking call, the atoms, and the status code | Fixes naming and formatting |
| Four crashes in five seconds | Restart intensity, escalation to the top, a separate subtree, backoff | It restarts |
| Choosing a strategy | Rest for one, child order as a dependency list | Recites all three strategies in the abstract |
| The eight-second checkout | Pool arithmetic, the call moved out of the transaction, an idempotency key | A bigger pool |
| LiveView memory | One copy per process, streams, ids instead of structs | A bigger server |
| Nine days of memory growth | Memory by category, reference-counted binaries, a remote shell, recon | Restart the node |
| Two nodes, one customer | Who owns the customer, a single writer, which write loses | Names a clustering library |
| The job that ran twice | At-least-once delivery, a unique constraint on the work itself | The unique option and nothing else |
| A service to keep out of Elixir | A specific workload and the reason | Nothing, it suits everything |
Fit the Hour to the Level
- Early career. Skip distribution entirely. Watch for pattern matching in function heads and pipes that read naturally, and expect two or three finds on the printed module. Three is a good sign.
- Mid-level Phoenix. The database pool and LiveView memory, plus the printed module. Four of the six faults is a solid result.
- Senior. Supervision and one of the last three groups, and all six faults, followed by the rewrite. Then ask what they would change about the tree they run today.
- OTP specialist. Skip nothing. Add the partition question and listen for what they have seen, not what they have read.
- Coming from Rails. Ask what surprised them about processes. Ruby habits show up as conditionals where a pattern-matched function head belongs, and the answer tells you how far the move has gone, and whether the candidate is describing the language they use now or the one they used to. Our Ruby on Rails developer staffing desk sees plenty of these moves.
Put somebody in the room who has run Elixir in production, since the follow-up questions are the interview and a rubric cannot ask them, which is why a panel of strong engineers who have never operated a BEAM system still produces a polite, confident, and badly informed yes. If nobody on your team has, that is a fair reason to borrow a screener. If the seat reaches past the BEAM into general services work, our backend engineer interview questions cover the rest of the loop. The posting those candidates answer matters too, and our job description for Elixir seats covers the lane and version lines a finalist checks first.
Things the Engineering Lead Wanted Settled Before the Panel Met
Do we really need a take-home for this?
Usually not, because the printed module and a conversation measure the same judgment in under an hour and ask nothing of the candidate’s evening. If you assign one anyway, cap it at two hours, compensate it if you can, and spend the interview asking why each choice was made.
A strong Rails developer is willing to learn Elixir. Do we still run this loop?
Run it, but weight it differently, since a Rails developer’s first year in Elixir is mostly Phoenix and Ecto, and the printed module and pool questions show how far past that they have moved. Hire for the trajectory and plan for the mentoring. Our hiring guide says three to six months to productive for web work, and longer for OTP.
Can a candidate use an AI assistant in the interview?
Not during the printed module, which needs no screen, and not on the judgment questions, but allow it in a separate shorter round if the candidate uses one at work. Then ask them to explain every line it produced. Explanation is where the gap shows. A candidate who cannot say why a supervisor was configured that way did not choose the configuration.
How many rounds does a loop like this need?
Three is plenty, and four is the ceiling. Start with a recruiter screen, then a sixty-minute technical round built on this page, a conversation with one engineer and one product owner, and a final with whoever owns the system. Aim for two weeks. First call to offer, no longer. Engineers who write Elixir well have other conversations running, and a fifth round adds little. It does change whether they still answer email.
What will the offer need to look like?
Our hiring guide puts senior Phoenix base pay at $140,000 to $185,000 and senior OTP systems roles at $170,000 to $250,000, so a loop this demanding should end in an offer inside the right band. The salary benchmark assistant will price your own city and level, and a band set below the median for the profile you need lengthens the search.
Is a contractor worth it while the permanent search runs?
Contract suits a bounded build, a Ruby-to-Elixir migration for example, or a pipeline rollout. Direct hire suits the seat that will still exist in two years. If you go the contract staffing route, aim the printed exercise at the real system the contractor would touch, and you see the first week of the job before it starts. Many teams do both, with a permanent direct hire search running alongside.
Hand Over a Module From Your Own Repo With the Safeties Removed
Pick the module in your codebase that everyone is slightly afraid of. Strip the timeouts, the supervision, and the comments, print it, and give it to the next finalist, then watch how long it takes them to ask what the module is supposed to do before they touch a single line. Then wait. What they miss tells you which hour to schedule next.
If you would rather not build the exercise alone, bring the module and the architecture diagram to our Elixir recruiters and we will turn them into the exercise and the shortlist. Two numbers from our own files, for comparing agencies. The average IT search takes 17 days from intake call to accepted offer, and 92 percent of placements are still with the client a year later. Elixir runs longer than the average, and the hiring guide has the honest range.

