As your business grows, it’s increasingly important to understand how to scale engineering processes and methodologies. The amount of time spent on setup, deployment and manually testing code is often ignored by technology teams and managers. Manual server configuration and code quality tests are not only error prone, but they ultimately result wasted time and money.
3 steps to automate software development
Introducing automation into your Software Development Lifecycle (SDLC) and infrastructure scaling projects is the most effective way to improve code quality and deployment velocity. These three steps will help you do that:
1. Implement a continuous integration strategy
Continuous integration (CI) is a development practice where code is checked into a code repository, tested and verified in an automated process. By regularly integrating changes into a centralized repository that is automatically tested for code quality, syntax errors and unit/integration test issues, errors can be detected and located more easily.
There are various continuous integration tools available—the most popular being Jenkins, Travis and TeamCity—and each offers benefits for different organizational use cases.
At Cloud9, we’ve adopted Jenkins as our continuous integration (CI) platform. All changes to shared code repositories are automatically picked up by Jenkins, which we’ve configured to run quality, syntax and unit tests on any new code that is committed. Builds that fail these tests will automatically notify the person who was responsible for the failed build and include the reason why it failed. This automated testing and deployment structure helps developers and engineers focus on creating exceptional code and sets the stage for smart technological growth.
2. Make code testing a shared responsibility
Developers and quality assurance (QA) share the same goal in the SDLC: delivering a quality product on time and on/under budget. To ensure cooperation and alignment towards this goal, developers should share the responsibility of quality testing.
Following the agile methodology, all members of my team (including development and QA) are responsible for testing code. Before a build even reaches the QA department for black-box testing, it has already been thoroughly tested, including unit and integration testing via a CI process. Load tests are performed to ensure race conditions are caught and mitigated, and smoke testing is performed automatically before the QA department is even involved.
From the moment a sprint is started to the time QA receives a qualified build, a constant stream of communication has already been established, ensuring QA knows exactly what to test, how to test it and what can go wrong.
Adopting a mentality of shared responsibility for testing reduces the number of obvious functional bugs that make it to QA, and it decreases the time to market for builds.
3. Implement the concept of infrastructure as code
Infrastructure as code (IAC) means writing code using a high-level language to manage the configuration and provisioning of infrastructure. This allows for quick and repeatable deployments of new application or web servers in your environment.
The concept of scripting infrastructure is not new, but IAC goes beyond basic scripting. By using a configuration management tool such as Puppet, Chef, Saltstack, or Ansible, changes in infrastructure can be written in a language that is consistent with the SDLC process at your company.
These tools enable teams to provision a server and spin up a new environment in minutes and also foster an environment of cooperation and innovation. Rather than leaving the process of server provisioning and configuration management to system administrators, any engineer can easily write infrastructure code and engage in the activities of the DevOps team
Implementing an IAC strategy eliminates infrastructure and configuration sprawl, decreases chances of outage-causing production changes, and ultimately saves your company time and money.
Going through these steps should make your company a lean, mean, rapidly scaling machine. But remember DevOps automation isn’t a one-shot effort—the whole process requires continuous monitoring and improvement. By continuously reevaluating your processes, you’ll be able to introduce additional automation over time.