When the concept of lean principles of manufacturing is discussed, one cannot avoid mentioning about the 7 wastes (“Muda”), which need to be eliminated to enhance overall customer value at a lower cost and over a shorter lead time. While we at Evoke Technologies have been innovating with DevOps software development, testing, and releasing software for our existing clients and prospects, we discovered that software development using DevOps principles does help deliver software based on lean manufacturing principles such as following:

Value

Identifying value, primarily defined by the customer. With DevOps enabling continuous delivery, any feedback given by the customer can be incorporated in an easy manner, which improves the speed of product delivery. Hence, the software product starts assimilating features solely driven by customers’ continuous feedback rather than other traditional factors, leading to the delivery of innovative products, solutions and services.

Value stream

Identifying steps or sets of actions, which will lead to the creation of value. The focus here remains on adding value to customers.

Flow

Make the value flow through the value stream and remove wastes wherever required. Software development based on automation aids in removing several wastes, which are discussed later in this post, and, thus helps in adding value to the customer at a lower cost and in a shorter lead-time.

Pull

Release the product and its features, as required by the customers. As described in the ‘value’ section, DevOps, by enabling continuous delivery, makes it possible to amalgamate customers’ continuous feedback and release products uninterruptedly matching the value defined and required by the customer.

Perfection

Align and improve processes continuously in pursuit of perfection with software development from DevOps.

Let’s look at some of the wastes, 7 in total, in software development processes which you may seek to be addressed when one starts developing, testing, and releasing software based on the DevOps practice.

Talent Utilization

In an ideal scenario, developers should be writing code or performing debugging operations and, similarly, test engineers should focus on testing activities such as creating test cases, writing test scripts, etc. However, in the current IT environment and among existing methodologies, developers and testers are often found to be working on areas such as setting up environments, fixing configuration management issues of Dev or QA environments, etc.

In ideal scenarios for customers, these activities are part of waste and they wouldn’t be too keen to shell out money on these activities. Come to the world of software development with DevOps, and these activities could be completely eliminated.

With technologies such as containers (Dockers, CoreOS) and configuration management tools such as Chef, Puppet, Ansible, etc., one could automate creation of self-service environments and deployments, thereby removing the need for software developers and testers to spend time on activities for which customers hesitate to compensate.

Environments

One of the most common wastes of the current software development methodology, including Agile, is setting up development and test environments. Each time a new software developer joins the team, IT staff is found to be spending a considerable amount of time setting up and configuring Dev/QA environments. Additionally, if there is any change in the configuration of existing applications, developers/IT staff gets involved in reconfiguring the environments.

When talking about test environments, these are dedicated test servers and any changes to application configuration requires the dedicated test server’s configurations to be changed relatively. A self-service test environment is a luxury process. However, with software development from DevOps, creating self-service Dev and test environments is completely automated using containers such as Dockers, CoreOS and configuration management technologies such as Ansible, Chef, Puppet, etc. The waste related to time and human involvement (and, thus cost) in setting up of environments is completely eliminated.

Deployments

As the application moves ahead in the value stream via testing, staging, and pre-production phases, performing deployments in these phases with relevant artifacts, scripts, and configurations requires a lot of collaboration and communication between dev, testing, and operations staff. If only the deployments through these phases are automated, it would minimize the redundant collaboration/communication between different stakeholders and help them focus on the tasks at hand to enhance the end product/solution.

Waiting

One of the common wastes in a software development life-cycle (SDLC) is the waiting time in relation with following:

• Test engineers wait for the development process to be completed, after which they commence testing. This waiting time adds up to the overall cost, which can be reduced.
• Due to fixed release schedules vis-a-vis the available operations team release slots, the releases often tend to get delayed even after the Dev and testing phase is completed.

With DevOps, the waiting time can be reduced in following manners:

1. Testing team adopts the continuous testing approach (Shift-Left) where they automate following and reduce waiting time:

• Test environment creation
• Dynamic provisioning
• Service virtualization
• Test database automation

2. With the operations team working as part of a Scrum Dev team (and, thus, DevOps team), waiting time is reduced to a bare minimum.

Over collaboration

In existing scenarios, even in scrum teams, it has been seen that Dev, Testing and Ops team communicate and collaborate to a great extent when the deployments move across different stages of testing, staging and production. There are several meetings, including change control meets between different stakeholders, before going live. These could be seen as waste which adds no value to the end product.

Could this be solved by software development? Yes, for sure. Because the environment setup and deployments are automated, the need for communication and collaboration between Dev and testing team is almost nullified. Also, the communication between operations and Dev/QA team is reduced to a bare minimum as the configuration management and deployments are automated. Thus, the cost associated with communication and collaboration is minimized to a great extent.

Resource utilization

One of the common observations during the software development life cycle in general is related to provisioning of Dev and Test environments and the required hardware/server infrastructure. Both time and money are invested into provisioning of environments for development and testing stages. This is a waste that adds no direct value to the end product, except additional costs. With DevOps, IT enterprises can use container technologies such as Dockers, enabling the Dev and test environments (self-service) on developers and testers laptops thus eliminating the need to set up dedicated servers. As these environments can be created on-demand (self-service), the time spent in collaboration and communication between stakeholders (and hence cost) is reduced to a bare minimum.

In addition, the waste associated with utilization of developers and testers involved in setting up environments and fixing related configuration management issues is also optimized. DevOps approach ensures that environment setup and configuration management activities are automated, and developers only have to focus on coding and testers on testing activities, and hence, proper utilization of Dev and QA resources.

Defects

The following are some of the defects that are difficult to reproduce/debug and a considerable amount of time spent could be minimized with the help of the DevOps approach:

• “The functionality worked on my system” – At some point, we would have come across developers or testing staff speaking as mentioned above. These types of defects are primarily related to configuration management issues and are, at times, difficult to debug.
• Obsolete data: Many a time, developers and testing staff test the functionality based on cooked up data. However, with changing business scenarios, nature of data changes along with associated rules. This is where functionality which was tested enough still fails in production with the real-time business data.

The above defects really add no value to the end product and why should a customer pay for developers/testers working on fixing the above defects? These defects are merely waste which could be avoided. Defects such as those mentioned above could be minimized (and hence, related costs) with the help of some of the following continuous testing techniques:

• Service virtualization: The QA staff gets involved in writing automated tests right from the beginning of the project based on service virtualization concepts.
• Comprehensive automated tests.
• Automated test database creation: This technique takes the data from production at regular intervals, masks or changes the customer sensitive data and creates the test database.

Conclusion

Software development from DevOps is changing the way that software is developed and deployed. IT enterprises need to start adapting the DevOps way of software development to provide value addition to the customers and be in sync with the changing technology landscape.

Call Evoke Technologies at +1 (937) 202-4161 (Select Option 2 for Sales) or find out more about how simplified solutions for everyday challenges can be at your fingertips now.

Author

Ajitesh Kumar Shukla was a Principal Architect at Evoke Technologies. He used to head the Architecture and Governance initiatives at Evoke. Ajitesh was responsible for enabling enterprise-wide adoption of leading-edge technologies and related practices, including, implementation of relevant tools and frameworks. He also spearheaded the DevOps, Big Data and Analytics practice at Evoke.