DevOps Imperative for Enterprise Apps like PLM – Part 3

In Part 1, I wrote about how implementing shorter deployment cycle is imperative for companies like AutoX (i.e.  companies like Ford, Toyota's and Airbus) and for PLM vendors (i.e. companies like Dassault Systèmes and Siemens PLM).  And implementing DevOps practices is the way to achieve these shorter cycles.

In Part 2, I wrote about how to achieve the seemingly impossible dream of dream of major version upgrade PLM version in a Auto company in one month and minor version upgrades in a week. What features PLM vendors should add to support this kind fast deployment cycles ?

In this part, I plan to write what changes PLM Customers like AutoX (i.e. companies like Ford, Toyota, Airbus, etc) have to do in their way of working to achieve fast PLM updates.

DevOps for PLM is imperative for AutoX to reduce the maintenance, upgrade and enhancement costs of PLM at the same time taking maximum advantage of new PLM features in day-to-day work.

I am assuming you (Reader) are the AutoX company.

Point 1 : Understand that you are a 'software company' now. (whether you like it or not)

 For you it is actually more complex situation than traditional software company because you have to 'integrate' software into your own workflow. So think about how you will manage source code of your software (configuration management), compiled executables/binaries, release cycles, code integration, feature/bug life cycles, version management, deployment management etc.

Even though you are a software company, you are not probably developing your own software product and you are not a company doing projects for others. You are somewhat like a 'systems integrator'. You have your own unique set of challenges. Unfortunately software literature is usually focused on 'products' or 'projects'. There are very few references available.

Point 2 :You will have to customize the PLM and other Enterprise software for your own needs. Out of The Box (OOTB) will not give you competitive advantage that you need.

1. These customization will be done by your own team, PLM vendor, or some third party development company.
2. You have to integrate code from multiple sources. These code-bases may be delivered at different intervals, with different technology stacks.
3. These code bases will have complex dependencies (sometimes circular dependencies).
4. Compiling these code-bases and deploying them in production is a complex task.
5. Tracking the deployment metrics and production performance is required.

'delivering' this code in production is a 'complex pipeline' of activities. Treat this as an 'assembly line' for software. DevOps is at its core about managing this 'assembly line' for software.

It is possible to apply the 'assembly line' concepts from manufacturing application (coming from Kanban, Toyoto Production System, Theory of Constraints etc etc) to this software assembly line and thereby improve the efficiency of this assembly line

1. Think about dependencies. Identify and break circular dependencies.
2. Treat whole program as 'system' and apply 'systems engineer' concepts to streamline workflows
3. Apply concepts like controlling WIP, reducing batch sizes etc. The features not yet delivered to end user is 'inventory'. Features underdevelopment is 'Work In Progress' inventory. Time Boxed Sprints of SCRUM is essentially controlling WIP and reducing batch size.

So where to start ?

1. Define configuration management tools and practices.
1. Which configuration management tool will be used in-house. Which tools will be used by your vendors
2. Add every customization in configuration management. (including build scripts, database schema migration scripts, deployment scripts etc etc)
3. Define how the code-base delivered by vendor, will be merged in your configuration management tool
4. Define configuration management practices in such a way that you can identify what is changed between version easily.
2. Mandate that the vendor has to deliver 'automated test scripts' along with source code (and not just test results).
1. Major bottle neck in DevOps implementations is lack of automated testing scripts.  
2. If you need to test manually all new features/bug fixes, then the deployment cycle (i.e. your batch size of features increase a lot)
3. Overall not having 'automated tests' reduces efficiency of DevOps implementation
3. Define Integration Pipeline
1. How the code will be merged ?
2. How it will be compiled and executable created ?
3. How it will be 'staged' on a test environment ?
4. How automated tests will run ?
5. How automatic deployment will happen ?
6. Every single step in integration pipeline will be 'managed' in your configuration management system.
7. Once code delivered by vendor (or released by your in-house team), entire integration process should take less than 1 week.
4. Define Integration and release cadence.
1. Make sure integration and release cycles are as short as possible.
2. Make sure that 'deployment downtime' should be as less as possible. Use newer cloud deployment tools like creating on demand Virtual machines, using Docker containers etc. 
5. Define a 'sane' agile change management process. 
1. Make sure 'change management' is part of Integration pipeline.
2. When projects/companies move from Water Fall to Agile (especially with code developed by vendor), biggest confusion is about managing 'change requests'.  
6.  Measure everything in production
1. Use tools like 'fluentd', 'TICK stack', ELK stack to collect metrics from production deployments.
2. Create dashboards which show this production metrics to your team.
3. Share the dashboards with your development team. Let them see how the applications they developed are performing in production.
4. To facilitate this data collection in production, define design/coding practices which will push the data to these systems.
7. In case of mixed deployment (part desktop, part server) define and implement how 'automatic' deployment/upgrade of desktop parts will be done along with server parts
1. PLM systems require integration with CAD/CAM/CAE applications and customization of  those applications.
2. DevOps implementation will require pushing changes in production for these applications as well. An automatic update mechanism will be of tremendous help.
3. Building metrics and bug/crash reporting inside these customization will increase the efficiency even more.

This list is just my initial thoughts. I will keep updating it. :-)

Please share your feedback.