Software deployment is a big deal; without it, you wouldn't be able to push any updates, fix any bugs or, hell, even push your product live in the first place! So, understandably, it can be pretty brutal when something along the line goes wrong.

Whether it falls down to a lack of proper testing or neglecting to run required DevOps scripts, deployment isn't something that you can just rely on your memory for and hope for the best. Potentially your entire project can be shut down with one wrong move, so you need a documented, fool-proof way to guarantee that won't happen.

Which is why you're here! By following this checklist for each stint of software deployment, you can ensure a consistently solid approach to updating and fixing the product you've worked so hard on.

After all, won't it be nice to deploy a bug fix and not worry about causing over a dozen more?

We thought so; let's get started!


Gather the code you're deploying

First things first, your software deployment needs to kick off with collecting the code that needs implementing. Although an obvious step, it is vital that you are certain that the update you later apply is the correct one.

This can be done by checking the completed user stories within your project management software or by checking the original message which prompted you to start off the deployment process. Either way, head to the correct fork in your code repository and get a hold of the update you need to implement.

Record a copy of the code using the form field below.

Enter version release notes

This is a nice and easy step to follow up with - you should now enter your code version's release notes in the form fields below.

Although mostly for documentation purposes, this can greatly help in the event that you need to roll back to a particular update, or wish to track down the moment when a bug first occurs.

Check that the required server is running smoothly

This will vary depending on your team's setup and the project you're working on, but in general, you must now check that the server you need to upload your code to is set up correctly and running smoothly.

If you only use one server, this should be easy. If, however, you need to organize a new server for your code, we have a handy little server setup process to help you on your way.

Configure your staging environment

In order for your pre-production tests to be accurate, you need to ensure that your staging environment is set up correctly. To this end (and only if required), you need to make any necessary configuration changes to the environment, ready for your update to be put through its paces.

The method for this will vary depending on the setup of your server and staging environment, along with the configs that are required. In general, though, you'll want to create a backup of your production server, copy that backup, make your alterations, then update your test server with the altered backup.

Don't forget to restart the server after any changes are made!


Deploy the update to your test environment

The time has come in your software deployment for you to test the updates in the staging environment. To start us off, upload your new code to the testing environment.

This can be done (if using open source development) by merging the appropriate repo branch with your test environment and selecting the upgrade to be "Immediately".

Test the code

Whether you're using automatic tests, manual tests or (better yet) a mixture of the two, now is the time to run them. Put the new update through its paces in the test environment and note your findings.

At the very least you'll want to be running several integration and unit tests, but a good practice is to also just go through the test environment and see if any new vulnerabilities have been exposed by the update through simulating a normal user.

For example, if the update is to your login page, make sure that no hidden fields or data is shown by entering an incorrect password, etc. Be as thorough as possible and note down your findings for review shortly.

If you haven't got set tests already set up, why not take a look at our software testing tutorial to get you off the ground?

Review the results

This stage in your software deployment is pretty self-explanatory. You must now go over the results of your tests and assess whether or not the code is fit to deploy. Record the status of the test results in the form field below (which can be edited if you desire).

Now, we do not mean that the slightest error or bug should cause the delay of a major update; there will always be small errors which are missed or caused by an unforeseen effect. However, any problems caused by the code should be weighed up against the benefit (and functionality) of the update.

For example, it does not make sense to delay an entire feature's release because of a relatively harmless bug, such as a user's date of birth no longer showing on their profile.

Assess the test results, notifying the developers and returning the code (with a copy of the test results) if it is not up to scratch. Otherwise, note any new minor problems as a new user stories in your project management software and carry on this checklist.


Copy your update to the production environment

Now that you're certain the update won't completely kill your site, it's time to merge it into the production environment. This is done in exactly the same manner as with your test environment, and so should pose little to no problems at this stage.

Run any necessary DevOps scripts

In the final step before you set the update to be live, you need to assess whether it is necessary to run any DevOps scripts in order to update your databases. If so, these scripts must be executed now in order to support the code.

Use the sub-checklist below to keep track of the areas you still need to run scripts in.

  • 1
    Front End
  • 2
    Back End
  • 3
  • 4

Usually, this will only be required when there is a significant updated being deployed, however, you must be incredibly thorough when running these. You need to ensure that every one of your databases is updated with the correct scripts.

Although the databases you need to update will vary, the sub-checklist can easily be edited to suit your needs.

In the next task, you'll get approval to deploy the software from your team lead.

Make sure to assign the lead to the approval task in the template editor, so they're always automatically assigned to the approval task whenever future instances of this checklist are launched.

Approval: Team lead

Will be submitted for approval:
  • Gather the code you're deploying
    Will be submitted
  • Enter version release notes
    Will be submitted
  • Review the results
    Will be submitted
  • Run any necessary DevOps scripts
    Will be submitted

Set your changes live

The big moment is here, and it's to set your changes to be live! Push your updates in the production environment onto the live version of the site and rejoice in the gloriously sparkly new updates. Record the date of the live deployment in the form field below.

Consider that, if this is a large update, you may want to schedule and announce some downtime whilst this occurs.

Test on the live server

The final step in the software deployment checklist is to check your live server for bugs once the changes have been applied. This should be as thorough as possible, as it is much better for your team to notice a bug and record it than leaving the job to your customers.

If you find a critical bug which cannot be ignored, it may even be worth considering a server roll-back, but (thanks to your previous checks) this should not occur. Instead, any minor bugs which are picked up should be reported as new user stories within your porject management software.

Congratulations on completing the software deployment checklist! Enjoy your new-and-improved product, and don't forget to keep an eye out for new bugs that are spotted down the line.


Relevant Checklists:

Sign up for a FREE account and
search thousands of checklists in our library.

Sign up for a FREE account and search thousands of checklists in our library.