Roberto Aloi and Michał Muskała discuss the realities of scaling WhatsApp with Erlang, OTP, and the BEAM virtual machine.
Everyone quotes WhatsApp when the topic of Erlang and scale comes up. Fewer people know what it actually looks like from the inside - what was hard, what was never hard, and what the team spent their time on once the concurrency stopped being the problem.
Roberto Aloi and Michał Muskała work on the team keeping it running. This is the first of two episodes with them.
Topics include:
what Roberto's first Erlang moment was - implementing a GenServer for a robot at university and learning binary pattern matching felt like cheating
why Michał came to Erlang backwards, from Elixir, and what the tooling gap actually felt like
the column numbers OTP bug that caused cascading failures and taught Roberto what no documentation could
the optimization that made the JSON Unicode parser slower - binary pattern matching was the wrong tool, and a custom state machine was faster
what "let it crash" actually means at WhatsApp scale: letting it crash is the easy part, recovery is where the engineering lives
why the 30th employee was the first person at WhatsApp with Erlang experience - and what that means for hiring
the most misunderstood thing about Erlang at WhatsApp: scaling isn't the exotic part, keeping the codebase healthy is
how WhatsApp does deployments: 1% of servers first, one region next, monitoring throughout, ready to roll back
what types of failures become normal at this scale - and why disaster recovery drills are a regular practice
overly dynamic code as the anti-pattern that creates the most sustained pain
Part two covers ELP, Equalizer, and the tooling that keeps a codebase this large navigable. You want both.
Recorded June 25, 2026.
Why it's here
1 person recommends this
What people say. Recommended for its insights into how WhatsApp scales with Erlang and why codebase scale, not concurrency, is the real challenge.
a
u/ancatrusca0in r/elixir • Recommends
The 30th employee at WhatsApp was the first person hired with Erlang experience. By that point the system was already serving a meaningful fraction of the planet.
New BEAM There, Done That with Roberto Aloi and Michał Muskała - the people on the team keeping it running. The main takeaway worth discussing: scaling is not the hard part. OTP handles concurrency well out of the box. The hard part is codebase scale - keeping millions of lines of Erlang navigable, maintainable, and safe to change when most engineers arrive never having written it before. That's what they spend their time on, and that's what part two is about.
[video
