Design for DevOps – Best Practices

Without good design practices, a DevOps implementation has no hope of delivering on its promise of accelerating innovation with high quality and scale.

Anyone who has been a designer knows that good design for DevOps is easier said than done. My blog, “7 Pillars of DevOps,” identified seven essential best practices areas that make up successful DevOps. One of the seven pillars is Design for DevOps. The blog explains that the pillars are not silos, but rather foundations that need to be kept in balance. It also can be said that a good design goes a long way to make up for shortcomings in the other pillars.

This is true for any number of designs, including designs for legacy, greenfield or brownfield products. It is true for platform projects, feature enhancements or repairs. It is true for enterprise three-tier applications or multilayer products. And it is true whether the developers are using Agile, Waterfall or ITIL processes.

In every case, a designer faces tough challenges and is expected to balance conflicting goals. Designers are expected to rapidly drive down the work backlog, yet produce quality products that avoid costly rejections and rollbacks. In addition, there is pressure to increase the percentage of effort spent on creative content over corrective content and do so with limited time and resources. These conflicting goals constitute tall responsibilities. If not supported with best practices, the overall design experience is a cauldron of stress and fast route to burnout.

The following best practices improve the design experience and products of design in a way that is streamlined for the DevOps pipeline:

Designers must thoroughly understand customer use cases

Usability, reliability, scaling, availability, testability and supportability are more important than individual features! Quality over quantity is recommended. Designs that anticipate actual customer usage are the most successful.

The culture needs to support designers

Leaders must support the designers with motivation, mentoring and training. No designer can be expected to know everything. It’s OK for designers to make some mistakes if lessons are learned and improvement quickly follows. Good DevOps practices including continuous monitoring and quick remediation are examples of practices which help minimize the impact of any mistakes.

Design coding practices are critical:

• Products are architected to support modular independent packaging, testing and releases. In other words, the product itself is partitioned into modules with minimal dependencies between modules. In this way the modules can be built, tested and released without requiring the entire product to be built, tested and released all at once.
• Where possible, applications are architected as modular, immutable microservices ready for deployment in cloud infrastructures, in accordance with the tenets of 12-factor immutable non-monolithic apps, rather than monolithic mutable architectures.
• Software code changes are pre-checked using peer code reviews prior to commit to the integration/trunk branch.
• Software changes are integrated in a private environment together with the most recent integration branch version and tested using functional testing prior to committing the software changes to the integration/trunk branch.
• Developers commit their code changes regularly, at least once per day.

Good DevOps design practices support QA:

• Understand the QA process.
• Software code changes are pre-checked with unit tests prior to commit to the integration/trunk branch.
• Software source code changes are pre-checked with Static Analysis tools prior to commit to the integration branch. Static analysis tools are used to ensure the modified source code does not introduce critical software faults such as memory leaks, uninitialized variables, and array-boundary problems.
• Software code changes are pre-checked with dynamic analysis and regression tests prior to commit to the integration/trunk branch to ensure the software performance has not degraded.

Good DevOps design practices support Ops:

• Understand delivery and deployment pipeline processes.
• Software features are tagged with software switches (i.e. feature tags or toggles) during check-in to enable selective feature level testing, promotion and reverts.
• Automated test cases are checked-in to the integration branch at the same time code changes are checked-in. Evidence that the tests passed are included with the check-in.
• Tests are conducted in a pre-flight test environment that is a close facsimile of the production environment.

Supporting tools are needed to realize Design for DevOps practices:

• Elastic infrastructures that can be easily orchestrated, created and released as needed to support designers tasks on-demand with minimal delay.
• Design, code management, monitoring and test tools readily available and scalable with minimal delay.
• Monitoring tools that track application process performance and report the results to designers in easily consumable formats without delay.

Design for DevOps Summary

What do you think? Do you agree the above are important best practices for DevOps design? Are there others you recommend?

While DevOps implemented with all seven pillars provides a strong foundation for long-term enterprise business improvements, it is important to understand DevOps is not an island. Enterprises implementing DevOps should be aware that DevOps interoperates with other IT systems and practices. Enterprises are well-advised to choose tool-agnostic IT partners that can provide solutions that best suit the needs of each unique enterprise and can integrate and evolve DevOps together with all of their IT systems.

— Marc Hornbeek