The benefits of using the cloud for application development and deployment (whether public, private or hybrid solutions) are now well established- the cloud offers enterprises agility, efficiency and scalability that simply would not be possible with more traditional development environments. However, to maximise the benefits of the cloud, enterprises must consider cloud-native architecture, and in turn, cloud native principles when it comes to application development.
When a development team goes ‘cloud-native’, what they are essentially doing is taking a modular approach to development, i.e. abstracting away many ‘in-between’ layers of infrastructure, such as servers, operating systems, and networks. Instead, this infrastructure can be called upon by the application as and when required by simply running a script. This allows the developers to focus on the code of the application itself rather than the code of the infrastructure, which can be orchestrated via a program dedicated to such orchestration.
Cloud-native development is all about removing the constraints of traditional developmental models. Ultimately, in an enterprise environment, the goal is of course to deliver business value- this is where cloud-native applications are a great efficiency driver for businesses looking to innovate and respond quickly to changing customer demands.
With that in mind, let us look at some development principles that developers should follow to extract the maximum benefit from going, cloud-native. Digital transformation consultancy Contino has pulled together an extensive list here which is well worth a read, however, we have pulled together a list of our favourite cloud-native development principles below.
Remember that the software you are creating is a service to the customer, and not just a product
Development teams find it hard to shed the old school mentality from long developmental cycles, where the feedback process from customers and the time in between iterations were so long that it was easy to consider software as a product rather than a service being provided to live customers. Cloud-native development on the other hand is all about rapid iteration and improvement based on customer feedback. Therefore it should be considered more as a service rather than a product that you ship and forget.
Use ‘canary releases’ to minimise risk when you release new features
Cloud-native development offers developers the ability to use feature toggles to perform what is known as ‘canary releases’, i.e. releases that are only served to a relatively small percentage of users initially. The rationale behind this approach is to minimise the possible exposure of the full user base to bad code or faulty releases- it’s almost as if there are some ‘test subjects’ from the user base selected to experience new releases. Once data is collected from how these new releases are performing, decisions can be made algorithmically to introduce more and more users to the change until the change is rolled out to the entire user base.
Use small, rapid ‘commits’ to keep development moving forward and help pinpoint issues
This principle has two benefits: firstly, using frequent commits helps create a culture of ‘shipping’, where code is constantly being moved through the pipeline and tested out in the real world, and soliciting feedback directly or indirectly from the users. Secondly, it allows dev teams to pinpoint errors much more easily and efficiently. When you release a large batch of code and it throws an error, it can take a lot of time to debug. However, when each commit is fairly small and often dealing with a very specific issue or objective, it can make the debugging process much easier.
Utilise continuous / synthetic testing when you release new features
Continuous testing (also known as ‘synthetic testing’) is a way of testing the real-world impact of releasing new features by sending artificial traffic to a system. Cloud-native development programs allow for developers to see how their changes affect the overall system once exposed to traffic and usage load. This process can often uncover hidden issues and become part of a rapid QA process in an enterprise’s dev workflow, to give the dev and compliance teams confidence and peace of mind that upcoming feature releases are not going to break the whole system down.
Ensure end to end accountability by deploying cross-functional teams
One of the greatest benefits of using the cloud for development is that it makes the impact of the dev team’s work much more measurable, helping to get buy-in from management and other key stakeholders within the organisation. However, in large enterprises, it is still very normal for the IT, management, marketing, and compliance teams to operate in relative silos. One good way to get past this issue is to develop cross-functional project teams that include representatives of the key stakeholders in the business. This helps with internal communication, accountability, and can often help remove roadblocks to project sign-offs.
Cloud-native platforms provide several benefits to enterprises such as agility, efficiency, and scalability. However, to maximise these benefits, enterprise dev teams must follow cloud-native development principles.