Establishing A Professional Website Deployment Process For Growing Businesses

Scale can change a lot of things, the same way you wouldn’t build a skyscraper like you would build a dog house, the lack of a formal deployment process that your team could get away with on a small website is not appropriate for a business that has gained some scale and credibility.

Unfortunately a lot of developers don’t have the knowledge of how to fit together all the pieces of the puzzle. A robust deployment process however is only made up of a few sequential steps or changes to your process.

• Migrate to a hosting provider with SSH support
• Ensure your team are using Version Control
• Adopt a terminal-based approach for building websites
• Utilise a Continuous Deployment system

Those 4 steps alone will be enough to transform your development process.

Is A Formal Deployment Process Required?

Yes absolutely, if any of the following issues are familiar to you and your team then it’s long overdue:

• Developers are afraid to make changes to the live sites
• Changes are deployed by manually updating files on the live site
• You don’t have a development and staging version before going live
• New deployments often break your live site
• Multiple developers struggle to collaborate on the same task
• New developers don’t want to join your company

These are the most prevalent side-effects caused by a lack of process but certainly not the only ones, you may have even more subtle issues such as a general tension between your development staff. 

Should Developers Have Taken Care Of This?

Not necessarily, developers generally have a single narrow skill set within IT which is programming, whereas IT itself is a very wide field. The job of establishing the development stack that your websites sit on is generally taken care of by a DevOps engineer.

Generally we tend to think of IT professionals as knowing everything about IT, which honestly for some developers is absolutely on the mark because they love to know the whole process but we generally consider these unicorns in the industry and don’t come along too often.

If you hire a senior developer you would expect them to have enough of an awareness to either be able to piece together the deployment process or at least know that they need to flag a requirement for a DevOps engineer in the team.

Although it is very rare that a small or new business will hire a senior developer in the beginning, often cost is such a major factor that an affordable developer is far more useful to a small business, then as the business grows the pressure and expectation on the developer can disproportionately grow.

Finding Suitable Hosting

There is an abundance of high performance hosting from extremely reputable hosting companies at incredibly low prices. This will oftentimes significantly outperform shared hosting with a fairly low entry price.

Generally from as little as $5 (or £3.50) you can pick up a server that is likely to outperform your shared hosting. The reason for this incredibly cheap price is that nothing comes installed on the server, you are expected to set it up yourself, whereas with shared hosting this is already done for you. This is why the price is relatively similar, you are either paying for the benefit of a pre-set up host or for the performance.

Setting up your own server is actually a lot easier than it would first appear and gives the ability to install so many more tools that developers will love.

Adopt Version Control

Version control is the single most important factor when it comes to having a deployable and easily accountable development process. If there is nothing else you implement from this article make sure you implement version control using Git.

Version control will ensure that every single change of code is logged, accounted for and stored in a central repository. This is the greatest safety feature for your entire process because it allows:

• Code to be backed up in multiple places
• Code changes to be rolled back and forward to any date
• List of file changes to be accounted for
• Co-operative development to happen with no overwriting issues
• Stimulates a culture of small but frequent and incremental changes

You cannot be managing software in the modern development environment without version control. It is dangerous and irresponsible to do so.

Adopt a terminal-based approach for building websites

One of the hardest steps that developers find is moving from a process of manually uploading files via FTP and manual downloading libraries to a terminal based approach with packages.

This is especially true for Windows-based developers where the concept of a terminal is not common. Mac OS and Linux users are generally quite familiar with the terminal and are likely to have experience with the likes of: Homebrew and Yum or APT whereas the equivalent on Windows is far less known and far less utilised: Chocolatey.

Being able to use the terminal is very important because it’s how your developers will:

• Interact with the servers
• Save and deploy code changes
• Install libraries
• Build their assets

So pretty much everything they do going forward is dependent on their ability to use the terminal. 

This was actually a problem for Windows users for a long time because the modern development environment favoured terminal usage so heavily and this is where Windows was lacking. For developers who felt they needed to make the jump they often just ended up buying a MacBook Pro. 

Utilising a Continuous Deployment (CD) System

It’s rather a complex sounding name for a pretty simple process. A CD system is the final piece of the puzzle that pulls together all of your other development processes to automate the deployment of changes to your website.

Your CD system will continuously watch the Version Control repository for any changes, when it sees one it will automatically deploy it, hence ‘Continuous Deployment’, The following steps are considered a suitable deployment:

• Connect to the server where the website is hosted
• Pull down the latest changes from the repository
• Download any new packages that have been introduced
• Compile all of the fresh assets that the website will use

The whole process is very safe, all of the negatives from the start of this article have been completely taken care of by the automation.

Omitted Techniques & Limitations

For the sake of simplicity and mapping the whole process we have omitted certain techniques that you would likely need to implement on a real system listed below:

• Git branching should be used to manage individual features & environments
• Unit testing should be implemented a step before deployments to ensure stability
• A backup strategy should be implemented for the server image and Database
• Multiple environments should be utilised: Local, development, staging and production
• Local servers should be utilised on developer machines: Vagrant or Docker etc.

Additionally you may notice this guide doesn’t have much in the way of technical step-by-step guidance, that is because this guide is aimed at business owners and management rather than developers. So the plain English top-level concepts are what we have covered, from the steps presented in this article your development team should be able to come up with a plan or seek consulting to help nurture the process change to customise the solution to fit your specific needs.