The 12 Factors App



As the software development landscape has evolved with the rise of cloud computing and microservices architecture, ensuring the robustness, scalability, and maintainability of applications has become paramount. Enter the “12 Factors”, a methodology conceived by Adam Wiggins in 2011. These twelve guiding principles offer a roadmap for creating modern, cloud-native applications that are agile and easily deployable. Let’s embark on a comprehensive exploration of each factor, understanding its nuances, and uncovering best practices.

The 12 Factors

1. Codebase

Description: Maintain a single codebase tracked in revision control, one codebase for one application. The codebase should be tracked in a version control, such as Git.
Example: A repository for a microservices-based e-commerce platform, with each service (like product, cart, payment) residing in its sub-directory.
Best Practice: Adopt a versioning strategy to track changes, ensuring that each release is traceable and reproducible.


2. Dependencies

Description: Declare dependencies explicitly and isolate them from the application.

  • Dependency declaration
    • Dependencies should be declared explicitly and stored in version control.
    • Dependency tracking is performed by language-specific tools such as Maven for Java and Pip for Python.
  • Dependency isolation
    • An app and it’s dependencies can be isolated by packing them into a container.
    • Container Registry can be used to store the images and provide fine-grained access control.

Example: Using a `Pipfile` in Python or `package.json` in Node.js to list project dependencies.
Best Practice: Utilize dependency management tools to lock versions, preventing unexpected changes during deployments.

3. Config

Description: Store configuration in the environment to ensure portability and separation of configuration from code. Every application has a configuration for different environments, like test, production, and development. This configuration should be kept external to the code and is usually kept in environment variables for deployment flexibility.
Example: Storing database connection strings, API keys, or feature toggles as environment variables.
Best Practice: Implement a configuration management system to centralize and secure sensitive configuration data.

4. Backing Services

Description: Treat backing services (databases, caches, messaging systems) as attached resources.
Example: Utilizing managed database services like AWS RDS or Azure SQL Database.
Best Practice: Implement circuit breakers and retries to handle transient failures and ensure application resilience.

5. Build, Release, Run

Description: Separate build, release, and run stages to streamline deployment processes. Each stage should result in an artifact that is uniquely identifiable.

  • Build will create a deployment package from the source code.
  • Every deployment package should be linked to a specific release that’s the result of combining a runtime environment configuration with a build. This allows for easy rollbacks and a visible audit trail of the history of every production deployment.
  • The run stage then simply executes the application.

Example: Implementing CI/CD pipelines using tools like Jenkins, GitLab CI/CD, or GitHub Actions.
Best Practice: Adopt infrastructure as code (IaC) practices to automate provisioning and configuration management.


6. Processes

Description: Run the application as stateless processes, facilitating horizontal scaling and resilience.

  • If state is required:
    • Avoid in-memory session storage, and store state data in decoupled storage
    • Cache state data for faster access

Example: Stateless RESTful APIs that do not store client state between requests.
Best Practice: Implement session affinity or utilize stateless authentication mechanisms like JWT to maintain scalability.

7. Port Binding

Description: Export services via port binding to facilitate communication between services. The applications bundle the web server as part of the application and do not require a separate server like Apache.
Example: Exposing RESTful APIs on specific ports using frameworks like Express.js or Spring Boot.
Best Practice: Use service discovery mechanisms or API gateways to manage and route traffic effectively.

8. Concurrency

Description: Design applications to handle concurrency, optimizing resource utilization and responsiveness. The application should be able to scale out by starting new processes and scale back in as needed to meet demand and load.
Example: Implementing thread pools or asynchronous processing in backend services.
Best Practice: Monitor system resources and implement throttling or rate limiting to prevent resource exhaustion.

9. Disposability

Description: Design applications for quick startup and graceful shutdown to ensure robustness and resilience. This means they should be able to handle temporary failures in the underlying infrastructure and gracefully shut down and restart quickly. Applications should also be able to scale up and down quickly, acquiring and releasing resources as needed.
Example: Using container orchestration platforms like Kubernetes to manage application lifecycle.
Best Practice: Implement health checks, liveness probes, and readiness probes to facilitate seamless scaling and rolling updates.


10. Dev/Prod Parity

Description: Maintain consistency across development, staging, and production environments to minimize discrepancies and ensure reliability. Infrastructure as code and Docker containers make this easier. Environments can be rapidly and consistently provisioned and configured via environment variables.
Example: Using containerization technologies like Docker to encapsulate application dependencies and configurations.
Best Practice: Adopt a GitOps approach to manage infrastructure and application configurations declaratively.

11. Logs

Description: Treat logs as event streams, enabling real-time analysis, monitoring, and troubleshooting. Logs provide an awareness of the health of your apps. It’s important to decouple the collection, processing, and analysis of logs from the core logic of your apps. Logging should be to the standard output and aggregating into a single source. This is particularly useful when your apps require dynamic scaling and are running on public clouds, because it eliminates the overhead of managing the storage location of the logs and the aggregation from distributed (and often ephemeral) VMs or containers.
Example: Implementing centralized logging solutions like the ELK stack or Splunk.
Best Practice: Implement log aggregation, indexing, and retention policies to facilitate efficient log analysis and storage management.

12. Admin Processes

Description: Run admin/management tasks as one-off processes, ensuring idempotency and minimizing operational overhead.
Example: Automating database migrations using tools like Flyway or Liquibase.
Best Practice: Implement versioning and rollback mechanisms to facilitate safe and efficient management of administrative tasks.


The “12 Factors” serve as a timeless framework for building cloud-native applications, emphasizing principles that promote agility, scalability, and maintainability. By embracing these factors and adhering to best practices, organizations can navigate the complexities of modern software development, ensuring the delivery of robust, resilient, and efficient applications that leverage the full potential of cloud computing. As the technological landscape continues to evolve, the principles encapsulated by the “12 Factors” remain invaluable, guiding developers and organizations towards success in an ever-changing environment.