Twelvefactor

Twelve-factor is a methodology for building software-as-a-service applications that emphasizes portability, scalability, and maintainability in modern cloud environments. It originated with developers at Heroku and was published in the early 2010s as a set of best practices for web applications designed to run on cloud platforms. The approach defines a set of twelve factors that guide architecture and deployment across a range of languages and frameworks.

The twelve factors cover: codebase (one codebase tracked in revision control, with many deploys); dependencies (explicitly declare and isolate dependencies); config (store config in the environment); backing services (treat attached services as attached resources); build, release, run (strict separation between build and run stages); processes (execute the app as one or more stateless processes); port binding (export services via port binding); concurrency (scale out via the process model); disposability (fast startup and graceful shutdown); dev/prod parity (keep development, staging, and production as similar as possible); logs (treat logs as event streams, aggregated by a tooling system); admin processes (run admin or maintenance tasks as one-off processes).

The methodology emphasizes stateless processes, externalized configuration, and declarative dependencies, with backing services accessed via URLs or credentials provided through the environment. It is language-agnostic and widely cited as guidance for building cloud-ready applications, particularly those deployed to platform-as-a-service or containerized environments. It is not a universal blueprint; some architectures, such as monoliths with substantial state or teams outside cloud contexts, may adapt or omit factors, and critics note that it does not replace security, testing, or organizational considerations.