Revisiting the Twelve-Factor App: Core Principles for Building Robust and Scalable Services

Building a robust and easily extensible application service has always been a continuous pursuit. Nine years ago, the seminal article "The Twelve-Factor App" summarized software development best practices across twelve dimensions; despite rapid changes in the field, its guidance remains highly relevant, and this piece offers a concise refresher.

1. Codebase

The codebase should have a one‑to‑one relationship with the application. Even when deploying the same app to different environments, all deployments must originate from the same baseline code. Shared code among multiple apps should be extracted into independent libraries and managed via dependency mechanisms.

2. Dependencies

Declare all dependencies explicitly. An application must maintain a dependency manifest that precisely lists every required component, avoiding implicit reliance on system tools such as curl.

3. Config

Separate code from configuration. Different environments (development, staging, production) typically require distinct settings for databases, caches, third‑party services, etc. Hard‑coding these values in source code is explicitly discouraged by the Twelve‑Factor methodology.

A simple way to verify proper separation is to ensure the baseline code can be open‑sourced without exposing any sensitive information.

The recommended approach is to store configuration in environment variables rather than version‑controlled files.

4. Backing services

Treat backing services (databases, message queues, caches, etc.) as attached resources, whether they are locally hosted or provided by third‑party cloud platforms. These resources remain loosely coupled to the application, allowing them to be added or removed without code changes.

5. Build, release, run

Strictly separate the build, release, and run stages; modifying code while the application is running is strongly discouraged.

6. Processes

Run the application as one or more stateless processes; any persistent data must be stored in external services such as databases. Sticky sessions stored in process memory are opposed; instead, use external caches like Memcached or Redis with expiration.

7. Port binding

Export services via port binding.

8. Concurrency

Scale out by running multiple processes of different types (e.g., web processes for HTTP requests, worker processes for background jobs). The application should be horizontally scalable across many machines.

9. Disposability

Enable fast startup and graceful shutdown.

10. Dev/prod parity

Keep development, staging, and production environments as similar as possible.

11. Logs

The application should not manage its own log storage; instead, write logs to standard output and let the execution environment aggregate them.

12. Admin processes

Run administrative or maintenance tasks as one‑off processes that are tracked and reproducible.

Ultimately, reference the original material for full details and apply the principles flexibly to suit your specific context.