Small example of scaling up processes to handle an increased workload

scaling.erl

-module(scaling).

-export([start_router/0, init_router/0, process_message/1]).

-define(MESSAGE_LIMIT, 3).

start_router() ->
  register(scaling, spawn(scaling, init_router, [])).

init_router() ->
    process_flag(trap_exit, true),
    loop().

loop() ->
  receive
    {messages, Messages} ->
      io:format("Generating ~p processes to handle ~p incoming messages.~n",
                [(length(Messages) + ?MESSAGE_LIMIT - 1) div ?MESSAGE_LIMIT, length(Messages)]),
      spawn_message_handlers(Messages),
      loop();
    {quit, Reason} ->
      io:format("The server and linked processes will now quit. Reason: ~p~n", [Reason]);
    {'EXIT', Pid, Reason} ->
      io:format("Received EXIT signal from ~p: ~p~n", [Pid, Reason]),
      loop()
  end.

spawn_message_handlers([]) ->
  ok;
spawn_message_handlers(AllMessages) when length(AllMessages) =< ?MESSAGE_LIMIT ->
  spawn_link(scaling, process_message, [AllMessages]);
spawn_message_handlers(AllMessages) ->
  {Messages, RestOfMessages} = lists:split(?MESSAGE_LIMIT, AllMessages),
  spawn_link(scaling, process_message, [Messages]),
  spawn_message_handlers(RestOfMessages).

process_message(Messages) ->
  lists:foreach(fun(Message) ->
                  io:format("Process ~p handling message: ~p~n", [self(), Message])
                end, Messages).