Elixir OTP FAQs: GenServers, Supervisors, and Application Lifecycles

In Elixir OTP, a GenServer provides a standard way to implement a process that handles requests and can own state; a supervisor starts and monitors child processes and applies restart rules; and an OTP application packages functionality with configuration and a start/stop lifecycle, commonly launching a top-level supervision tree. These pieces work together, but they solve different problems.

What is a GenServer in Elixir?

GenServer is a behavior for implementing the server side of a client-server relationship. It is not itself a process: using it defines callbacks for a process that handles messages, while the behavior supplies the process loop and standard interaction machinery. It also supports tracing and error reporting and fits into OTP supervision trees. The GenServer v1.20.4 documentation describes it as “A behaviour module for implementing the server of a client-server relation.”

#	Preview	Product	Price
1		Elixir in Action, Third Edition	$52.46	Buy on Amazon
2		Programming Elixir ≥ 1.6: Functional |> Concurrent |> Pragmatic |> Fun	$37.72	Buy on Amazon
3		Advanced Functional Programming with Elixir: Model Behavior, Manage Complexity, and Maximize...	$49.12	Buy on Amazon
4		The Art of Elixir: elegant, functional programming	$39.70	Buy on Amazon
5		Introducing Elixir: Getting Started in Functional Programming	$23.61	Buy on Amazon

As an Amazon Associate I earn from qualifying purchases.

A GenServer can own state and serialize access to it through messages. For example, a stack server might initialize a list in init/1, remove and return its head in handle_call/3, and add an item in handle_cast/2. Of the GenServer callbacks, only init/1 is required. Using use GenServer also defines child_spec/1 so the module can be started as a supervisor child.

Keep callers insulated from callback details with a small client API:

#1 Best Overall

Sale

Elixir in Action, Third Edition

$52.46

Buy on Amazon

defmodule Stack do
  use GenServer

  def start_link(initial  []) do
    GenServer.start_link(__MODULE__, initial)
  end

  def pop(server), do: GenServer.call(server, :pop)
  def push(server, item), do: GenServer.cast(server, {:push, item})

  @impl true
  def init(items), do: {:ok, items}

  @impl true
  def handle_call(:pop, _from, [item | rest]), do: {:reply, item, rest}
  def handle_call(:pop, _from, []), do: {:reply, nil, []}

  @impl true
  def handle_cast({:push, item}, items), do: {:noreply, [item | items]}
end

This example shows the callback shape, not a complete production stack API. In a real application, decide explicitly how an empty pop should be represented and whether a push needs confirmation.

When is a GenServer appropriate?

Use one when the work benefits from a long-lived process identity, message handling, serialized ownership of mutable state, or supervision as part of an application. A process is not automatically the right home for every value that changes. If a counter can be updated by passing an integer into a function and returning the next integer, ordinary functions and values are simpler.

What is the difference between GenServer.call and GenServer.cast?

GenServer.call/2 is synchronous from the caller’s perspective: it sends a request, waits for a reply, and dispatches to handle_call/3. GenServer.cast/2 sends an asynchronous message and dispatches to handle_cast/2; it does not return an application-level reply confirming that the requested work finished.

Use the interaction that matches the contract callers need. A cast is not a guarantee that application work succeeded, and neither choice should be treated as a universal performance ranking. Messages sent directly to the process rather than through these APIs can be handled with handle_info/2.

What does a supervisor do in Elixir?

A supervisor is a process that starts and monitors child processes according to child specifications. When a child terminates, the supervisor uses the child’s restart setting and its own strategy to decide what happens next. Supervisors provide structure for application startup, shutdown, and fault recovery. The Supervisor v1.20.4 documentation says, “Supervision trees provide fault-tolerance and encapsulate how our applications start and shutdown.”

Rank #2

Sale

Programming Elixir ≥ 1.6: Functional |> Concurrent |> Pragmatic |> Fun

$37.72

Buy on Amazon

Restarting a process does not magically recover its in-memory state. If a GenServer crashes and is started again, its init/1 runs again. A counter initialized to zero, for example, returns to zero unless its state is restored from another source.

What is a child specification?

A child specification tells a supervisor how to start and manage a child. It includes an identifier and start instructions, along with restart and shutdown configuration. A child may be specified as a map, or as a module or {module, argument} when that module provides child_spec/1. A module using GenServer gets a default child specification, which can be customized if the application needs different options.

What is the difference between one_for_one and one_for_all?

A supervisor strategy describes how a child’s termination affects its siblings. Choose it to reflect real lifecycle dependencies, not as a default unrelated to how the processes work.

These strategies govern the affected children; the child restart setting separately determines whether a particular termination triggers a restart.

What do the restart values mean?

A long-running service is commonly permanent, while a finite task may need different semantics. Treat the restart value and supervisor strategy as separate choices: one says whether a child should restart; the other says which related children are affected.

Rank #3

Sale

Advanced Functional Programming with Elixir: Model Behavior, Manage Complexity, and Maximize Maintainability

$49.12

Buy on Amazon

How do I start a GenServer under a supervisor?

Define a child with start_link/1 and a child specification, then include it in the supervisor’s children list. The usual pattern is for the supervisor to start the server, rather than starting it separately and leaving it outside the tree.

1. Define the server module and its initialization callback:

   defmodule Counter do
     use GenServer
   
     def start_link(initial  0) do
       GenServer.start_link(__MODULE__, initial, name: __MODULE__)
     end
   
     def value, do: GenServer.call(__MODULE__, :value)
     def increment, do: GenServer.cast(__MODULE__, :increment)
   
     @impl true
     def init(initial), do: {:ok, initial}
   
     @impl true
     def handle_call(:value, _from, count), do: {:reply, count, count}
   
     @impl true
     def handle_cast(:increment, count), do: {:noreply, count + 1}
   end

2. Place the child in a supervisor’s child list and start the supervisor:

   children = [Counter]
   
   Supervisor.start_link(children, strategy: :one_for_one)

   The module form works because use GenServer defines child_spec/1. The supervisor starts the child via its start function and monitors it. In an application, this supervisor is usually returned by the application callback rather than started independently.

For a named server, the name must be unique among running processes. If the supervisor restarts the server, callers using that registered name can address the new process; callers holding an old process identifier cannot use it as though it were the replacement.

Rank #4

The Art of Elixir: elegant, functional programming

$39.70

Buy on Amazon

What is an OTP application?

An OTP application is a standardized package of functionality with configuration and a lifecycle. It is not the same thing as an operating-system process. Applications can be loaded, started, and stopped; the Application v1.20.4 documentation states, “Applications are loaded, started, and stopped.” A Mix project declares application information and can define an application callback module. Its start/2 callback commonly starts and returns the top-level supervisor.

What is a supervision tree?

A supervision tree is a hierarchy of supervisors and child processes. A top-level supervisor can supervise other supervisors as well as workers, giving the application a structured way to start components, stop them, and respond to failures. The tree is the process-management structure; the application lifecycle is the package-level mechanism that starts and stops that structure.

How does an Elixir application start and stop?

1. The application is loaded, making its code and application information available.

2. When started, its callback module’s start/2 is invoked if one is configured. That callback typically starts a top-level supervisor and returns it as the application’s supervision root.

   ×Recommended: Fix Windows Errors and Clear Junk Files in Minutes - Free Scan →Free scan · no reinstallRecommended: Crashes or Glitches? A Free Driver Scan Usually Finds the Culprit →Free scan · under a minuteRecommended: PC Feels Slow? A Free Scan Shows What's Dragging Windows Down →Free scan · Windows 10 & 11
   Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

3. When the application is stopped, OTP shuts down its process tree according to the children’s shutdown configuration.

   Best Value

   Sale

   

   Introducing Elixir: Getting Started in Functional Programming

   $23.61

   Buy on Amazon

The application controller manages application lifecycle operations; an application does not imply one operating-system process. Processes in the supervision tree run on the Erlang VM.

How does application configuration work?

Each application has an application environment: a keyword list mapping atoms to terms. This is distinct from the operating-system environment, and the Application API cautions libraries against using application environment as general-purpose global storage.

In a Mix project, config/config.exs is loaded at build time, while config/runtime.exs is loaded at runtime just before the application starts. Put values that need to be supplied or resolved at deployment/runtime in the runtime configuration rather than assuming build-time configuration will be recalculated on the target system.

Which Elixir version do these examples target?

The official documentation index identified Elixir v1.20.4 as stable when checked on 2026-10-04, and listed support for Erlang/OTP 27, 28, and 29. The installation documentation says Elixir v1.20.4 requires Erlang/OTP 27.0 or later. These requirements can change; check the official supported-version documentation and the installation guide against the Elixir and OTP versions installed on your system.

Quick Recap

SaleBestseller No. 1

Elixir in Action, Third Edition

$52.46

SaleBestseller No. 2

Programming Elixir ≥ 1.6: Functional |> Concurrent |> Pragmatic |> Fun

$37.72

SaleBestseller No. 3

Advanced Functional Programming with Elixir: Model Behavior, Manage Complexity, and Maximize Maintainability

$49.12

Bestseller No. 4

The Art of Elixir: elegant, functional programming

$39.70

SaleBestseller No. 5

Introducing Elixir: Getting Started in Functional Programming

$23.61

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.