A buzz word at the beginning, cloud-native applications have emerged and developed to turn into every business' reality nowadays. Understanding cloud-native, however, brings with itself other concepts, such as continuous delivery provision, containers' efficiency and speed implementation, microservices-oriented development and last but not least - the imposing need of collaboration between software Developers and IT Operations, or the so called DevOps.

But apart from those concepts, there is an additional characteristic required that glues all building stones together. This is the mindset of the developer or the DevOps specialist who is going to turn those separate pieces into a scalable and ready for the cloud?s paradigm application.

Here comes the 12-factor app methodology - a set of guidelines that should be considered within the software product?s development. Each of the factors, analyzed in the methodological framework, contributes to the developer?s problem-solving mindset. The idea of the team behind the project, as they define it, is to create a ?methodology that can be applied to apps written in any programming language, and which use any combination of backing services (database, queue, memory cache, etc).?

The Nemesis Platform architecture is built on top of all these methodological guidelines, which gives benefits like: deployable on each and every cloud, automatic scalability, easy integration to any software stack, consistent omnichannel experience for the customer.

So let?s go in details and explore all 12 fundamental requirements for scalable apps development process:


An app?s versioning mishandling, multiple databases, local changes without pre-streamed way of merging - all these may lead to development problems and, respectfully, to loss of teams? time. To comply with the principle, a single project?s database is to reside in a shared code repository, such as Github. This comes as an easy solution for versions? and local changes? management.

2. Dependencies

The implicit existence of system-wide packages is strongly against the principles a cloud-native app is built on. Throughout the development process, the amount of dependencies either towards external libraries, or on the project's package level, is steadily growing. In order better code-management to be achieved and not-versioned dependencies to be avoided, a dependency declaration manifest comes in handy. A dedicated file, such as a pom.xml in a Java application, aims at handling all dependencies, as well as their versioning, throughout the whole application?s lifecycle.

3. Config

In a scalable app, configs are stored in environment variables. Your app?s configuration details is what gets easily altered based on the environment it is run in. Sample configuration attributes may include: database-oriented resource handling, your credentials to external services, implemented within the application (such as Amazon S3, for instance), other development-specific pre-deployed values.

None of these or any other configuration-specific details are to be hard coded in your application, as, otherwise, it turns not to be built with the environment's change in mind. Just imagine how much time such values? alteration would cost to the team that works in different environment.

4. Backing services

Your cloud-native application?s code should make no distinction between local and third party services. Regardless of the service called - being a local or a remote - it should not lead to any code changes. Keep in mind your app is to reflect each and every customer?s need as fast as possible. A swap of service-providers cannot require more than the reasonable (if any) development time. The right way this requirement to be implemented is to call a backing service via an API. Otherwise you risk the migration from your local to the production?s Database.

5. Build, release, run

The lifecycle of your application is characterized by entering different stages. Within the context of the scalable app methodology, each of these stages - the building, the release and the running itself - need to be clearly separated. It is here that the team?s management comes at first place. The right choice of frameworks and tools, as well as the implementation of automation processes, are what your team?s mindset is to be oriented towards. Each step taken at a time leads to the main goal - the next-generation application to be built. One that is ready for the cloud.

6. Processes

A cloud-native app is to be built with failure in mind. In other words - how your application behaves in the case of an underlying hardware component. The right approach - it should be developed in a way to act independently, to withstand the failure. As the terminology runs - your app should be stateless. In the long run, a stateless app is more failure-resistant, more easily manageable and more easily scalable.

7. Port binding

In the context of the already discussed backing services comes the principle of port-binding. Your scalable app is completely self-contained, it is not coupled to any particular web server. In other words, following the pattern you consume backing services, the application must interface to the world on the same way - via a simple URL. This may have already been implemented in your web app, as most of the developer tools used support it natively.

8. Concurrency

Or, in other words, how to make your application scale better. It is all to processes, to separation of concerns. As your app, by design, handles different tasks to meet the client?s needs (by web requests, API calls, emails management and so on), it is of great importance all these to be separated in processes that run independently. This implemented, you can end up with different things, don concurrently. As a result comes you app that scales better and faster.

9. Disposability

Your scalable app handles processes that are disposable. They are developed and implemented in such a way, that can be easily started and stopped. Such a feature contributes to the effectiveness of the product and the customer?s satisfaction. Such a disposability does inevitably lead to elastic scaling, to faster implementation of the config changes. Your app is more easily prepared for deploy in different environments, in the cloud as well.

10. Dev/prod parity

Code consistency is a key when a scalable app comes to implementation. The more consistent your app is among all environments, the better the whole process is to run. Continuous deployment is a basic characteristic of each and every cloud-native app - regardless of the development, production and staging environments. Time gaps, personal gaps and tool gaps are what should be minimized. A successful team starts with the mindset of little time required between the deploys, of working on different tasks and being in different roles simultaneously, of using as similar environments as possible.

11. Logs

Your cloud-native app heads for consolidating and taking advantage of the logs. Whatever the information provided - from a successful start to a critical error - logs are treated as event streams. Again - this leads to better production, to building a team?s mindset, to better results.

12. Admin processes

On an app?s version entering production, comes more work for the team. It is the time when your application?s state needs to be carefully controlled when not running by design. All these ?admin processes? get analyzed based on the latest deployed version of the code - on the way they run on a user?s machine. In other words - the admin tasks need to be run one-off an identical to the production environment.

These guidelines help your team build a mindset of development in fast production mode, where all environments are kept as similarly as possible, where scalability matters, where an app is built with the cloud in mind. Not long time considered as a distant-option, cloud-native apps are the present already. Before starting your next project, you?d better consider if the platforms you are opting for have been built with the cloud in mind. If your app will be scalable. If it may be deployed on any cloud. In other words - is your app to be one that is ready for the future.

Have you already applied any of these methodological guidelines in your development process? Do you see any significant improvements when they are followed? Leave a comment to share your thoughts on the topic.

If you want to learn how we implemented the 12-factor methodology, request a demo of the Nemesis platform.

Admin user