When you set out to develop an app, time is of the essence. Your app will not exist in a vacuum. There are likely dozens or hundreds of applications under development or already live that do nearly the same thing as your new app does. Ergo, it’s vital that you minimize the time it takes to develop and roll out the application to users but without compromising on quality and functionality.
Traditionally, much of the effort toward accelerating the software development lifecycle has been concentrated in the main programming and testing phases. Yet, plenty of time is lost during deployment. Deployment issues can ruin what is otherwise an excellent application.
Accidental deletion of folders, wrong configuration parameters, conflicts with host environments and glaring security gaps are some of the key challenges you can expect to run into during deployment. Fortunately, you can make deployment a quick, routine and uneventful phase of the development workflow. Here are some tips to help you do that.
1. Automation
Why should you be bogged down with manually performing repeatable processes when you can task machines to do the work for you far more efficiently? By investing some time and resources in creating scripts, you won’t have to worry about forgetting a step during deployment.
Test the scripts for accuracy in both development and test environments. Note that scripting in this sense doesn’t refer to just a basic bash script that’s hard to understand. You can make the most of disposal tools such as Jenkins, Ansible and Terraform that allow you to leverage code principles and improve infrastructure health metrics.
You can place all the scripts in version control so that all project team members can know in real time the what, when and why of any changes. Automation makes the deployment process simple by ensuring the process is reliable, repeatable and reversible. You won’t event need technical persons to do deployments. Non-tech staff can run with the process unassisted.
2. Build and Pack Just Once
The build often takes a considerable amount of time so it makes sense for you to minimize the number of times you do it at deployment. The idea is to build just once. You can continue coding and applying changes without needlessly worrying about code that isn’t ready. Once you are done with building the app, pack it and ensure the package is untouchable. With that, you’ll be regularly taking snapshots of the app.
There will be instances when the app has incomplete code or is full of errors but that won’t be an impediment since you get to pick which particular package will get deployed. The same package moves across all environments so when you eventually generate the package for development, it’ll be the same version you’ll use to update the live environment.
All this may sound a little complicated but is actually fairly easy to do if you have good configuration management. Simply replace placeholders with the appropriate environmental values such as database endpoints. To make packing seamless, you must develop a habit of continuous integration. Such habits allow for constant integration in a shared repository, automated tests for process verification and quick repairs whenever needed.
3. Stick to the Same Deployment Method
There’s no benefit in perfecting the deployment process if you won’t deploy the app, in the same way, all the time. The reason you packed once was to make sure you deploy identical code everywhere. That way, you keep unpleasant surprises in the production environment at a minimum.
To achieve this consistency, all environments must be production-like. You don’t necessarily have to have identical data in each environment since that is not only costly but can be a security risk if all environments don’t enjoy equal levels of protection.
Rather, production-like implies if there’s a load balance in the production environment, you must have one in the development ecosystem. If the production environment is hosted in the cloud, so should development. Identical environments give you the confidence to move the app from testing to production.
Bonus Tip: Deploy Often and in Small Batches
If you apply the tips we’ve discussed so far, it’s almost natural that you’ll start deploying the app frequently and in bite-size batches. It takes some practice to make this process something you don’t even consciously think about but it will be more than worth it in terms of the reliability and predictability it delivers.
For this to work, automating testing is an absolute necessity. If you have to spend plenty of time testing the application, there’ll be a little material benefit in automating the rest of the deployment process.
How small should the batches be and what’s the ideal frequency of deployment? There’s no perfect answer to this but the general principle is to deploy the app whenever it achieves a state that can be deployed. It doesn’t even have to be complete.
You have to view deployment in the same way as coding. It would be strange for a programmer to spend days coding with no testing. The longer you wait to deploy, the harder it becomes to track down and resolve the things that go wrong. The fewer the changes you have to review, the easier the task of troubleshooting.
App deployment doesn’t have to be a slow, nerve-wracking and complex process that fills you with dread whenever you have to do it. By following the above tips, you can make deployment fast, easy and predictable.