Welcome to my blog!

Hello everyone! In this article, we will continue our series on the 12 factors for modern application development, inspired by the books of the legendary Martin Fowler. If you missed our previous articles, feel free to check out the other factors.

Today, we will cover the eighth factor:


The eighth factor states that an application should scale out through the process model, which means that the application should be designed to handle concurrency and be able to scale its capacity according to changes in demand.

The Process Model

The process model is a way of organizing an application into multiple concurrent processes, each handling a specific task or set of tasks. This allows the application to scale horizontally, by adding more processes as needed to handle increased load. The process model can also improve the application’s fault tolerance, as the failure of one process does not necessarily lead to the failure of the entire application.

Key Principles for Concurrency

  1. Design for concurrency: When designing your application, consider how it can be organized into concurrent processes to handle tasks efficiently and scale according to demand.

  2. Scale out, not up: Scaling out (adding more processes) is generally more efficient and cost-effective than scaling up (adding more resources to a single process). Design your application to scale horizontally through the process model.

  3. Ensure fault tolerance: By organizing your application into multiple concurrent processes, you can improve its fault tolerance, as the failure of one process does not necessarily lead to the failure of the entire application.

  4. Use appropriate tools and technologies: There are many tools and technologies available to help implement concurrency in your application. Choose the ones that best fit your needs and requirements.

Examples and Tools

Here are some examples of tools and technologies that can help implement concurrency in your application:

  1. Node.js: Node.js is a JavaScript runtime built on Chrome’s V8 JavaScript engine, designed for building scalable network applications. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient for handling concurrency.

  2. Erlang: Erlang is a programming language designed for building highly concurrent, fault-tolerant, distributed systems. It has built-in support for concurrency through lightweight processes and message-passing.

  3. Akka: Akka is a toolkit and runtime for building highly concurrent, distributed, and fault-tolerant systems on the JVM. It provides abstractions for concurrency, such as actors and futures, to simplify the development of concurrent applications.

  4. Celery: Celery is an asynchronous task queue/job queue based on distributed message passing. It is focused on real-time operation but also supports scheduling. Celery is often used with Django, Flask, or other Python web frameworks to handle background tasks and offload work from the main thread or web workers. It can be used to facilitate concurrency in Python applications.

  5. HAProxy: HAProxy is an open-source load balancer that can be used to distribute incoming requests among concurrent processes, ensuring efficient resource utilization.

In summary, the eighth factor of the 12 factors is “Concurrency.” It emphasizes the importance of designing applications to scale through concurrent processes, allowing the application’s capacity to be adjusted according to changes in demand. The tools and technologies mentioned above can help you achieve this goal.

In our next article, we will cover the ninth factor of the 12 factors. Stay tuned!

Stay Tuned

Thank you for following our series on the 12 factors. Don’t forget to subscribe to our newsletter to receive updates on new articles and other useful information directly in your inbox. Also, share this article with your colleagues and leave a comment below if you have any questions or suggestions. We’d love to hear your thoughts!

Until next time!