My first job out of college was in December of 1999. It was a small IT firm offering dial-up internet and web pages to small companies and individuals. At that time, websites were little more than the equivalent of marketing tri-fold brochures. Design, development, and modifications happened on the server, in production. It was a simpler time.
Further into my career, I was working for small-to-medium sized companies and agencies. Our development practices had evolved. We no longer made changes in production. Instead, we had a variety of lower environments, ex: Dev, QA, etc. However, deployments were manual, tedious affairs. It would often take weeks or even months to see the simplest changes make it into a production environment.
The last few years have really been exciting in the world of software development. It seems the pains we felt in the past were enough to ensure that better ways were adopted. It no longer takes a team of people and weeks or months of work for changes to be pushed through. That is, if the work is put in upfront.
Work smarter, not harder
In order to set yourself up for success, putting in a little work upfront can ensure that code developed today can be deployed tomorrow or even sooner. How, you might ask? Write clean, well-tested code, and automate away the mundane tasks.
Free yourself from the tedious task of verifying functionality manually and from having to regression test previous features. Write code that is testable and write the tests to cover business rules. Learn what Test-Driven Development (TDD) is and how it might benefit your application. TDD can lead to better software design and has the added benefit of documenting your application functionality. With the tests written, ensure that they are run regularly and added to if when bugs are discovered or when new functionality is added.
As code is written and features are completed, make sure that those features are integrated into the shared code base regularly. Utilize the myriad of tools available for source control and build automation. We at New Signature love Azure Repos using git and build pipelines using Azure Pipelines, just a few of the offerings from the Azure DevOps line of tools.
When code is checked in, be sure to utilize a pull request. Have someone on your team review the code. After all, a second set of eyes would never hurt.
Ensure that your team is using branch policies to require approvers, code-quality gates, automatically running your unit test suite, and any number of other quality checks that are available today.
Once the pull request has been approved, the code should be ready to deploy. Use tools such as Release Pipelines from Azure Pipelines to automatically deploy the newly updated code to lower environments. Make sure as much of the deployment steps and verification is as automated as possible. This will allow members of your team to be free to tackle more exciting and valuable tasks where their expertise is needed.
Once the newly updated code has been deployed, make sure you have some way of determining a features success and usage. Use something like Application Insights to catch, capture, and evaluate failures and trends. Be proactive. Use these metrics to focus your team’s efforts where they would be most impactful.
Put in some extra effort on the front end of a project to automate as much of the mundane tasks as early as possible. If you find yourself working on a project that does not have as much automated as you would like, spend some time now to remedy the situation. It is always cheaper to spend effort early and reap the rewards later.