The 12-Factor App Manifesto, released by Heroku in 2011, gradually became a gold standard in modern software development. While there are debates in some quarters today (and justifiably so) whether this manifesto represents the needs of modern SaaS applications, the fundamental philosophy of this approach is not challenged. The focus is on building software applications with clean architecture (loose-coupling, cloud-deployable, portability, scalability, stateless services, etc.) and efficient processes (continuous deployment, setup automation, etc.)

The 12 Factors

Factor 1 – Codebase – One codebase tracked in revision control, many deploys.

Factor 2 – Dependencies – Explicitly declare & isolate dependencies.

Factor 3 – Config – Store config in the environment.

Factor 4 – Backing Services – Treat backing services as attached resources.

Factor 5 – Build, Release, Run – Strictly separate build and run stages.

Factor 6 – Processes – Execute the app as one or more stateless processes.

Factor 7 – Port Binding – Export services via port binding.

Factor 8 – Concurrency – Scale out via the process model.

Factor 9 – Disposability – Maximize robustness with fast startup & graceful shutdown.

Factor 10 – Dev/Prod Parity – Keep development, staging, and production as similar as possible.

Factor 11 – Logs – Treat logs as event streams.

Factor 12 – Admin Processes – Run admin/management tasks as one-off processes.

The Relevance of the Factors in 2021

In general, these twelve factors are still highly relevant today, particularly for building microservices-based and cloud-native applications. Modern programming languages, development environments and frameworks enable easy adoption of these factors. Having said that, there may also be certain applications where one or more of these factors may not be practically relevant. For example, treating logs as event streams may not be needed in all use cases. Furthermore, the twelve factors may not address all the needs of modern software applications. Other factors like API strategies, distributed development, evolving security challenges, observability & maintainability aspects, and model development & deployment strategies (in case of AI/ML applications) also need to be considered.

Broadly speaking, the 12-factor app contributes to four critical areas of modern software engineering:

• Continuous Integration/Deployment – automatically validate & deploy new code, build a single package for each path-to-production chain, etc.
• Monitoring/Observability – primarily through the focus on logs.
• Scalability – enable applications to support dynamic load increases through resource addition (and vice-versa), and by externalizing the system state & configuration.
• Technical Debt Management – through improved build/dependency debt management, and the emphasis on loosely-coupled architectures.

Finally, it is important for development teams to keep evaluating the extent to which their software applications are compliant to these twelve (and more) factors. Code analysis, DevSecOps process audits, and software composition analysis are useful tools in this regard.