Category Application Development
12-Factor App Methodology Use 12-factor app model to plan and execute your app development efficiently.

In today’s world, most of the SAAS services are being deployed as the web applications. This action requires the development team to deal with many processes to successfully deploy the app. If you are a member of such team then you must know that the process isn't easy, the team encounters with many complicated steps and tasks. However, the new generation developers are shifting to the new approach for a development named 12 Factors App Methodology. This approach helps the developers in avoiding the situations where they found everything messed up due to the complex task like virtualization and setting up the runtime environment. However, 12 Factor app idea doesn't eliminate the complexity of the work instead it creates a structure for the entire process to carry out a healthy app at the end of the process. 

The 12 Factor App Methodology can be used for the apps 

  • That uses the declarative formats for setting up the automation
  • Compatible with modern cloud-based platforms and works with a clean contract with the operating system.
  • Reduces the gap between development and production for on-time deployment. 
  • Allows the scaling up and down without the need for significant changes

With the help of 12-factor approach, some of the common challenges can be overcome. The new methodology will help you in finding the answer for below questions.

  • How to get all the things ready from the beginning, so the team need to start the work with clear vision?
  • How can you take the code and make it available faster for the production?
  • How can you make sure to continue the process of development, production, and delivery aligned together without stretching the assigned time?
  • How to manage the framework of the entire process for increased productivity without hindering the quality?

The 12 Pillars Of The Methodology

As per the name goes, the methodology is based on 12 principles that make you understand how to handle the various subset of your application. Go through all the 12 Factors below-

Codebase- You should build one code base that is fully tracked with the revised controls and can be used for multiple deployments. This means you should have only one code base at the top instead of having various. There could be branches but not multiple codes as the branches may be needed for the further process. The deployment will be automatic, and that will assure that everything will be running in a different environment without any extra effort. 


Dependencies-  You must put the maximum dependencies and declared them initially instead of relying on the pre-installed software. In case the deployment is automated, and the presence of the tool is guaranteed you shouldn’t waste your time in searching for the library for wrapping it. If the task requires you to put the executable script into a jar file and then extract it using the tool, then it is a good thing. On the other hand, if it ask you to install, you should try it and check if it starts and fail fast. This factor is important as it requires you to declare the isolated dependencies for the standalone app to install the dependencies conveniently. So you should know first, what you need in the code under this factor of 12 Factor App Methodology.

Config-This factors assure the proper storage of your configuration files during all the process. Sometimes most of the app stores config as a constant in the code which is opposed to what 12 app factor asks to do. As the config file varies depending upon the different deployment, but the code remains the same. The process shows that the database Uniform Resources Identifier will be different in each of the processes including development, QA, and production. This factor also includes handling the resources and other backend services while giving credentials to the external services like Amazon S3 and Twitter per deploy values name including canonical hostname

Backing Services- This factor of the methodology tells you to treat the backing services as attached resources because every team requires a different database. By addressing the external services equally regardless of where you manage them eliminates many complications during the process. This factor is important as developers need more log comparing to the QA team as every team has different requirements. With the help of backing services, every developer has its own config file. In the 12 app factor, the code sees no difference between the local and external services. For the code, both the services are attached resources that can be accessed via a URL or a stored locator in the config file. 

Backing Services

Build, Release, Run- This factor advises to separately manage the build and Run stages as all the processes get the desired library they want. Afterwards combined all the things in a single shell that can be run in the compatible environment. The codebase goes through three different stages for the deployment. 

  1. Build- This stage takes the codes repo and converts them into a single bundle of the actionable process that can fetch the data to perform actions. The build stage fetches the dependencies and compiles the assets. 
  2. Release stage- This stage takes the build from the build stage and combines it with config files. The outcome of the release stage has the build ready with the config files that can execute immediate in the compatible environment. 
  3. Run stage- With the help of the some set form the app release this stage help the app to execute. 

Build Release

Processes- With this the approach you are required to execute the app as one or more stainless processes for making sure that your data is stored at the backing store. This is important because during the development and testing a code is just a script that runs in a single environment by the developer. On the other hand, the fully developed app deployed for the users have to run multiple processes from zero to more running processes. 

Port Binding- During the development process, sometimes the web apps get executed inside a web server containers. This makes the port binding an essential step for the entire process that allows the app to become a backing service for another app. However, some of the people didn't agree with the factor and said, exporting services using the port binding gives the external users authority to access the app without facing the security. The 12 app factor creates a web-facing service as it is entirely self-contained and does not depend upon the runtime injection. With the port binding, you will be able to access your app directly, or you can know its just another point in the stack that isn't working well. 

Concurrency- Every computer program while running depends upon one or more processes for the execution. The web apps use different execution program to carry out the entire process successfully. The 12-factor app treats the app like the first-class citizen, and all the processes take a cue in order to execute from an Unix model. So, you need to divide the app into smaller processes that will allow the app for calling out, and it will be able to manage varying loads. 


Disposability- This factor of the approach makes the process much faster and flexible to come up with the maximum productivity. The 12 app’s processes are quick they can start and stopped at any moment instantly. Besides, these are flexible enough to facilitate the changes quickly that result in the rapid deployment of the app. This factor ensures that you can start and shut down the process fasters and as well as handle a crash. 

Dev/Op Parity- Ever since the computer program creation takes place, there is one thing that keeps hindering the process. The gap between the developer stage and the production leads to delay and further problems in the app development process. There are several numbers of reasons responsible for this gap, here some of the common causes-

  • The time gap- The developers require to write the code that may take months or weeks and then will be sent to the operation team for deployment.
  • The gap between the team, developers, need to write the code then it will be pushed by the operating engineers
  • There's a gap between the tools used by developers and the operation team for the same code.

With the help of the 12-factor app development approach, you can keep the gap between development and production as small as possible. 

Logs- The app that you are working on is only able to create a sort of event stream. So, this approach requires you to write all your logging information to the system out. Afterward, with the help of the configuration, you can decide where you want to place the logs. 

Admin Process- The app is composed of an array of processes that it needs to carry out in order to perform the requested task from the user. The developers sometimes want to execute a one-off administrative or maintenance task that includes running a database migration or running a console to inspect the model against the live database. However, this action may hurt the system or the database and result in unpleasing actions. The 12 app factor approach advice to use a REPL shell that will make it easy to run the one-off administrative script in the app. 

The 12 app factor methodology is the modern approach for the developers to make sure that the development process goes smooth. However some of the factors mentioned above are still a part of the debate in the developer community, but this approach helps you to tackle all your problems. The process is flexible enough to figure out the solution for almost every development-related question. 

Sakshi Kaushik

By Sakshi Kaushik LinkedIn Icon

A passionate writer and tech lover, she strives to share her expertise with mobile app developers and fellow tech enthusiasts. During her moments away from the keyboard, she relishes delving into thriller narratives, immersing herself in diverse realms.

Uncover executable insights, extensive research, and expert opinions in one place.