Elixir has a strange reputation. People either describe it as the language that will replace everything, or as a niche tool with no jobs.

Neither is true. Elixir is a small language with a very specific shape. It is excellent at keeping many things running at once, isolating failures, and handling real-time traffic. It is a poor choice for raw number crunching, heavy machine learning training, and simple CRUD apps where the team already has a stack it knows well.

That shape explains both its successes and its limits. Once you see it, the question stops being “should I use Elixir?” and becomes “does my problem look like the problems Elixir was built for?”

This post answers that with current production examples, the reasons companies choose it, and the cases where I would reach for something else.

1. What the BEAM Actually Gives You

Elixir runs on the BEAM, the virtual machine built for Erlang at Ericsson. The BEAM was designed for telephone switches, which had to handle huge numbers of concurrent calls and keep working when parts failed.

Four properties come from that history.

Processes are cheap and isolated. A BEAM process is not an OS process and not a thread. It starts at a couple of kilobytes, has its own heap, and communicates only by message passing. A single node can run millions of them. Because there is no shared memory, one process cannot corrupt another.

Failures are contained. A crashing process dies alone. A supervisor watches it and restarts it with a known-good state. This is the “let it crash” philosophy, and it only works because processes share nothing. In a language with shared memory, a crash can leave the whole program in a bad state. On the BEAM, the blast radius is one process.

A supervisor restarting one crashed worker while the other processes keep running

Scheduling is preemptive. The VM counts reductions and pauses a process when its budget runs out. One busy process cannot freeze the rest of the system. That makes tail latency more predictable under load.

Distribution is built in. Nodes can connect into a cluster and send messages across machines with the same primitives used locally. You still have to design for partitions and consistency, but you do not start by inventing a transport.

Where the BEAM fits: real-time messaging, web and LiveView, distributed systems, streaming, IoT and data pipelines

That combination is rare. Most languages give you concurrency as a library. The BEAM gives you concurrency, isolation, and supervision as the default execution model.

2. Where Elixir Is Used in Production Today

The official Elixir case studies read like a map of the workloads where the BEAM’s shape matters. Here are the main clusters.

Real-time communication. Discord is the most cited example. By the time of its 2020 case study, Discord was running more than 12 million concurrent users, pushing more than 26 million WebSocket events per second through 20 or so Elixir services on 400 to 500 machines, with a chat infrastructure team of five engineers. That ratio is the point. The BEAM let a small team own a very large number of long-lived connections.

Other examples in this category include Supabase Realtime, which uses Elixir for clustering, messaging, and process registration; Slab, a real-time collaborative wiki; and Community, a messaging platform used by large public figures. These systems all have the same shape: many connections, small messages, and a need to fan out updates quickly.

Streaming and media. Veeps, a live music streaming service owned by Live Nation, published a case study about scaling to hundreds of thousands of concurrent viewers. Mux uses Elixir and Phoenix for an API that serves billions of video views. The BBC’s 2025 ElixirConf EU talk described Elixir serving almost all of its web and app traffic. Frame.io, part of Adobe, talked in 2026 about AI-powered search at scale built on Elixir. Spotify has also used Elixir for concurrency-heavy services.

The common thread is not video itself. It is many concurrent consumers, backpressure, and pipelines that cannot drop data when load spikes.

Fintech and enterprise software. Remote, the employment platform, started on Elixir and grew to unicorn status. Its 2025 case study describes nearly 300 engineers working in one Elixir monolith, running on five Kubernetes pods with 10 GB of memory each, with Oban for background jobs and PostgreSQL behind it. The infrastructure is deliberately simple.

The Royal Bank of Canada’s capital markets group uses Elixir and LiveView for live-updating financial tools. PepsiCo has used Elixir across multiple internal teams. Change.org migrated a messaging system for a platform with hundreds of millions of users. These are not toy systems, and they are not all real-time chat.

IoT and embedded systems. SparkMeter uses Elixir and Nerves for grid-management hardware in emerging markets. FarmBot uses Nerves for open-source farming robots. X-Plane built its multiplayer server on Elixir and UDP. Cyanview used Elixir and MQTT to coordinate camera shading at the Super Bowl. This is one of the least discussed strengths of the ecosystem: you can run the same language from a small device to the cloud.

Data pipelines and background jobs. Broadway handles queue processing with backpressure. Oban handles durable background jobs inside the same application. Membrane builds audio and video pipelines. These libraries exist because the BEAM is good at supervised, concurrent streams of work with bounded memory.

Machine learning and notebooks. Nx, Bumblebee, Axon, and Livebook make Elixir useful for numerical work and interactive notebooks. Nx can compile to GPUs through EXLA. This is a real ecosystem, but it is not PyTorch. Elixir is a good place to run and serve some models, not the default place to train frontier ones.

Government and open data. The French Ministry of Ecological Transition used Elixir and Phoenix to explore, validate, and visualize transportation data across the country. Open data work often means many imports, transformations, and dashboards, which fits the stack well.

One clarification that comes up often: WhatsApp is the famous Erlang success story, not an Elixir one. It runs on the same VM. Elixir inherits that runtime, which is why the comparison keeps appearing.

3. Why Companies Choose It

The production examples are not random. They share a few pressures.

They need failure isolation more than raw speed. In a chat system, a video platform, or a payment dashboard, one bad request should not take down the whole node. BEAM processes and supervisors make that isolation the default rather than something you bolt on.

They have many long-lived connections. A CRUD API handles a request and forgets it. A chat gateway, a live dashboard, or a streaming service holds connections open for minutes or hours. One process per connection is a natural model, and the BEAM makes it affordable.

They care about tail latency. Average latency is easy to optimize. The p99 is what users feel. Preemptive scheduling and per-process isolation reduce the chance that one slow job stalls everyone else.

They want one language for the whole product. Phoenix handles the web layer, LiveView handles real-time UI without a separate frontend build, Ecto handles the database, Oban handles jobs, and Broadway handles queues. That reduces the number of services and the number of teams needed to ship a feature.

They value operational simplicity. Remote’s five-pod monolith is a good example. A small team can run a large system when the runtime handles supervision and distribution. That is not a guarantee, but it is a real advantage over a pile of services that each need their own deploy, metrics, and on-call rotation.

They want to hire for potential. Remote’s case study notes that the pool of Elixir developers is smaller, but the signal-to-noise ratio in candidates was higher. The company built an internal training camp for engineers without Elixir experience. That trade is common in Elixir shops: fewer candidates, but often very strong ones.

There is also a language-level change worth knowing in 2026. Elixir 1.20 became a gradually typed language. It infers types across the whole program and reports verified bugs without requiring type annotations. That does not turn Elixir into a statically typed language, but it does catch real errors in existing code with very few false positives. For teams worried about maintainability in a large monolith, that matters.

4. Where Elixir Is the Wrong Tool

The same properties that make Elixir good at concurrency make it a poor fit for some workloads.

CPU-bound number crunching. Image encoding, video transcoding, compression, cryptography, and simulation belong in C, C++, Rust, or Go, or in a NIF or port called from Elixir. The BEAM is optimized for many cheap processes, not for saturating every core with one tight numeric loop. Nx and EXLA help for tensor work, but they do not change the general rule.

Heavy machine learning training. The Python ecosystem has the libraries, the hardware support, and the talent. Elixir can serve models and run notebooks, but training large models there is swimming against the current.

Hard real-time systems. The BEAM is soft real-time. It is excellent at predictable latency under load, but it does not provide the deterministic guarantees of an RTOS. If a missed deadline can hurt someone, use an RTOS and C or Rust. Nerves and AtomVM are impressive, but they are not a hard real-time platform.

Tiny memory budgets. A BEAM node has a runtime, a scheduler, and per-process overhead. On a microcontroller with kilobytes of RAM, AtomVM can work, but the constraints are real. Measure before committing.

Simple CRUD applications. Phoenix is a pleasure for CRUD. But if your app is forms, tables, and a database, and your team already knows Django, Rails, or Node, Elixir’s advantages may not pay for the learning curve. Choose the stack that lets the team ship and maintain the product.

Ecosystem gaps. If your product depends on a niche library that only exists in Python, JavaScript, or the JVM, you will spend your time writing bindings instead of features. Check the ecosystem before you fall in love with the runtime.

Teams that will not learn OTP. “Let it crash” is not an excuse to skip error handling. Supervisors, process ownership, message timeouts, and backpressure are design skills. A team that treats Elixir like Ruby with different syntax will build a system that is harder to debug than the one it replaced.

5. A Simple Decision Guide

Flowchart for deciding between Elixir, Rust or Go, and the team’s existing stack

Ask these questions in order.

  1. Does the system hold many long-lived connections or fan out real-time updates? If yes, Elixir is a strong candidate. Chat, presence, live dashboards, multiplayer state, IoT fleets, and streaming control planes all fit.
  2. Does it need failure isolation and supervision? If one bad job must not take down the node, the BEAM model is a real advantage.
  3. Is the work CPU-bound? If yes, use Rust, Go, or C++ for that part, and call it from Elixir through a NIF or port if the rest of the system is Elixir.
  4. Is it simple CRUD with no real-time needs? Use the stack your team already knows. Elixir will work, but it will not be the reason the product succeeds.
  5. Does the ecosystem have the libraries you need? If not, estimate the cost of writing bindings before you commit.

The pattern is clear. Elixir wins at coordination, concurrency, and failure. It loses at raw compute and at ecosystems it does not have.

6. What Building Exstore Taught Me

My own Elixir project is exstore, an in-memory key-value store inspired by Redis. It is a learning project, not a production database, but it made the BEAM model concrete in a way that reading about it did not.

In a Redis-style store, shared state is the whole problem. In Elixir, each piece of state lives in a process with its own heap. Reads and writes are messages. If a process crashes, a supervisor restarts it. There are no locks to forget, because there is no shared memory to lock.

That design also shows the cost. Messages are copied between processes. A single process holding a large map becomes a bottleneck. You end up thinking about partitioning, process ownership, and mailbox growth, which are different problems from the ones you think about in Go or C.

That is the honest trade. Elixir gives you isolation and supervision, and asks you to design around message passing and process boundaries. For the right system, that is a great deal. For the wrong one, it is overhead.

7. The Short Answer

Elixir is used today in real-time messaging, streaming and media, fintech dashboards, IoT fleets, data pipelines, and open-data platforms. Companies like Discord, Remote, the BBC, Veeps, Supabase, Adobe’s Frame.io, RBC, PepsiCo, and Change.org have shipped it at real scale.

They choose it because the BEAM makes many concurrent, failure-prone, long-lived things manageable. They do not choose it because it is fast at everything.

Where should you use Elixir? Where the problem is concurrency, real-time behavior, fault tolerance, and distributed coordination. Where should you not? Where the problem is raw computation, heavy ML training, hard real-time constraints, or a simple CRUD app that your current team can already maintain.

That is a narrower answer than the hype, and a more useful one.