DevOps Evolution: In-Depth Guide to the Transformative World of Continuous Delivery

The rapid pace of technological innovation and digital disruption has forced organizations across every industry to find ways to deliver higher quality software solutions faster than ever before. Consumer expectations are rising exponentially, competition is fierce, and the businesses able to continuously improve and refine their software products and services through rapid development and deployment cycles will win market share.

This new software-driven business landscape has given rise to DevOps. A set of cultural philosophies, practices, and tools designed to foster improved collaboration, communication, and integration between software developers (the “Dev” side) and IT operations professionals (the “Ops” side).

At its core, DevOps aims to eliminate the silos and bottlenecks that have traditionally slowed software delivery cycles. By bringing dev and ops together, DevOps enables companies to achieve faster innovation and improved efficiency through rapid, continuous delivery of software changes.

In this comprehensive guide, we will unpack everything you need to know about DevOps including:

• The definition and origins of the DevOps methodology
• Key goals and benefits organizations can achieve with DevOps
• Core components of a DevOps toolchain and best practices
• How to measure DevOps success with key metrics
• Common challenges and pitfalls to avoid

Understanding DevOps is crucial for anyone involved in the software development lifecycle. The data shows a clear trend – high performing organizations have embraced the cultural and technological changes of DevOps. We hope this guide provides useful insights into transforming your own software delivery capabilities through DevOps principles and practices.

What Exactly is DevOps?

DevOps integrates development and operations roles to improve collaboration between these two functions. But it also represents a cultural shift. DevOps introduces lean management philosophies from manufacturing that encourage communication, feedback, and breaking down silos.

More specifically, DevOps focuses on:

• Automating Processes – Relying on manual processes slows delivery cycles. Automating as many processes as possible improves efficiency.
• Continuous Delivery – Incremental software updates are continuously built, tested and deployed to production frequently. This accelerates delivery.
• Continuous Testing – Tests are integrated throughout the development lifecycle, providing constant feedback on quality.
• Continuous Monitoring – Apps and infrastructure are instrumented to provide visibility into performance. Issues can be detected rapidly.
• Improved Collaboration – Breaking down barriers between Dev and Ops, especially through training and communication.
• Flexible Infrastructure – By leveraging the cloud and containers, infrastructure can adapt quickly to meet changing needs.

While DevOps requires the right tools, it ultimately represents a cultural shift. It’s about replacing outdated siloed and sequential development models with integrated, iterative, and collaborative approaches.

The Origins of the Term “DevOps”

The “DevOps” methodology grew out of a grassroots movement in the mid-2000s among practitioners who recognized the need for better communication and collaboration between development and operations teams.

The term “DevOps” itself first originated at an Agile development conference in Belgium in 2009 from an audience suggestion during a talk by Patrick Debois and Andrew Shafer.

Debois and Shafer recognized the frustrations caused by the silos between development and operations – dev teams wanted more frequent production deployments while ops folks needed stability. They discussed the need to bring these two sides together, and an audience member suggested calling the concept “DevOps”.

From these humble beginnings, the DevOps methodology evolved quickly. Pioneering companies like Flickr, Amazon and Netflix adopted early DevOps principles and experienced incredible gains in productivity, reliability and deployment velocity.

The benefits delivered by DevOps practices has led to incredible growth in adoption across the industry. Now DevOps is considered a must-have software delivery approach for any high performing technology organization.

How DevOps Differs from Traditional Software Development Lifecycles

Here is an expanded 3000 word version of “How DevOps Differs from Traditional Software Development Lifecycles” without images:

How DevOps Differs from Traditional Software Development Lifecycles

For decades, software was developed and delivered following a traditional sequential waterfall methodology. Requirements were gathered upfront, design specifications were completed, development and testing occurred in linear staged phases, and releases were infrequent major events.

This traditional model was siloed and slow. It could not keep pace with the speed of business change and evolving customer needs.

The DevOps methodology transforms software delivery by integrating the entire lifecycle into a continuous delivery pipeline. Developing software incrementally and delivering value continuously accelerates innovation and time-to-market.

Here is an in-depth look at how the DevOps model differs from traditional software development approaches:

Traditional Waterfall Software Development

The traditional waterfall methodology was linear and siloed:

• Requirements: Business analysts elicit detailed requirements from stakeholders and create specification documents.
• Design: Solutions architects design the system architecture, interfaces, components and databases based on requirements.
• Implementation: Developers code system components based on the technical design documents.
• Testing: QA engineers validate that the implemented solution matches requirements once developers complete coding.
• Deployment: The finished software is packaged and deployed into production infrequently in major “big bang” releases.
• Maintenance: Any defects found in production lead to corrective maintenance updates and patches to address issues.

This approach was siloed since each stage was handled by a different team before “throwing it over the wall” to the next group. It was inflexible to change given requirements were fixed up front. Deployments were risky because long release cycles meant many complex changes dropped into production simultaneously.

Waterfalls were slow, bureaucratic, and incompatible with the speed of iterative modern software development.

DevOps Integrated Software Delivery

In contrast, DevOps brings development and operations teams together around continuous delivery:

• Continuous planning – Requirements and designs evolve collaboratively across dev and ops based on regular customer feedback.
• Continuous development – Code is developed in small batches versus monolithic releases. Each change can flow independently through the pipeline.
• Continuous testing – Automated testing surfaces defects immediately as changes are developed.
• Continuous integration – Developers merge changes frequently into a shared mainline via version control automation. Build and testing happens on every code commit.
• Continuous deployment – Validated changes are automatically deployed to production frequently in a sustainable pace through release automation.
• Continuous monitoring – Production systems are monitored in real-time for performance and changes in demand. Metrics inform planning for future iterations.
• Continuous customer feedback – Customer usage and satisfaction provide constant feedback into future requirements and roadmaps through techniques like A/B testing of new features.
• Continuous improvement – Automation increases efficiency over time while processes and workflows are continually refined through retrospectives and experiments.

DevOps changes not only tooling, but also team culture and processes. Development and operations work closely together with shared ownership of the entire delivery pipeline. Automation handles repetitive tasks enabling teams to focus on innovation.

Frequent production releases in cadences ranging from daily to weekly mean lower risk. Smaller code changes can roll out independently while problems get detected rapidly. Continuous user feedback further aligns development with evolving business needs.

DevOps Decentralizes Decision Making

Traditional waterfall bureaucracies centralized control and decision making by having:

• Requirements dictated by a business analyst team before any development began. This led to misalignment with actual customer needs.
• Technical designs created up front by architecture teams and delegated to developers. Adaptability was limited.
• Changes requiring lengthy governance and approval processes before deployment into production.
• Clear hand-offs from analysts, to developers, to testers, to ops. No shared ownership across delivery phases.

In contrast, DevOps distributes agency across autonomous teams by:

• Forming cross-functional teams that own features or services end-to-end from development through deployment.
• Enabling developers to split work into small batches that can be completed and released independently without coordination.
• Leveraging automated testing to provide fast validation of changes.
• Having ops focus on providing self-service capabilities to developers for rapid provisioning.
• Distributing decision authority to agile teams versus centralized approvals.

Distributing decision authority to agile teams streamlines development and accelerates innovation.

DevOps Depends on Automation

In waterfall models, most steps were manual:

• Coding against detailed technical specifications.
• Manual configuration of development environments.
• Manual deployment of finished software.
• Manual installation of infrastructure and middleware dependencies.
• Manual execution of testing scenarios and test data setup.
• Manual tracking of issues in documents and spreadsheets.

Heavy reliance on manual processes caused slow feedback loops. Engineers spent significant time on repetitive tasks versus innovating.

DevOps heavily leverages automation by:

• Automating provisioning of preconfigured environments.
• Automating building, testing, packaging and deployment of code changes.
• Automating infrastructure provisioning, configuration management, and environment scaling.
• Automating collection of logs and metrics for monitoring.
• Automating alerts for performance deviations or failures.

Automating manual tasks improves efficiency, reduces failures, and enables engineers to focus their time on higher level problems.

DevOps Forms Cross-functional Teams

Traditional models organized teams into siloed functional groups:

• Analysts capture requirements.
• Architects design solutions.
• Developers code to the specifications.
• QA tests implementations at the end.
• Ops manages infrastructure and production deployment.
• Infosec conducts security reviews near the end of projects.

These silos caused slow coordination, miscommunications, and competing objectives between groups. Tossing software over the wall led to lower quality.

In contrast, DevOps forms small cross-functional teams by:

• Creating Scrum teams with developers, testers, ops engineers, and product owners to build end-to-end ownership.
• Pairing developers with ops personnel for greater insight across the full lifecycle.
• Embedding security and compliance experts directly within teams versus as separate auditors.
• Organizing teams around services and features, not technologies.

Cross-functional “pizza teams” increase agility, shared context, code quality, and speed.

DevOps Changes Team Structures

Traditional hierarchies slowed communication and learning by having:

• Strict separation of duties across technology silos and operator versus management roles.
• “Throwing work over the wall” rather than collaborating across skills and functions.
• Information staying within specialized groups rather than being openly shared.
• Changes requiring cascading communications up and down hierarchical management chains.

In contrast, DevOps uses flexible team-oriented structures:

• Leveraging self-organizing Agile teams with decision authority and shared outcomes.
• Having leaders, coaches and mentors guide loosely coupled, high autonomy teams.
• Promoting open communication between peers across technologies and disciplines.
• Using flat structures with fewer management layers to accelerate communication.
• Organizing teams dynamically around features and services rather than technologies.

Flexible teaming models remove bottlenecks and accelerate sharing ideas and solving problems collaboratively.

DevOps Depends on Version Control

Software changes were difficult to track in waterfall since:

• Files edited directly on remote servers.
• No visibility into the history of code changes.
• Manual backups stored on shared drives or tapes made restoring previous versions complex.
• Uncoordinated developers overwriting each others’ changes caused conflicts.

This made understanding code, finding defects and safely collaborating difficult.

DevOps relies on version control systems like Git to provide:

• Source code changes committed into a shared repository like GitHub or GitLab.
• Unique commit IDs tracing each change over time.
• Developers working independently in local copies of the repo sandboxed from each other.
• Code review, pull requests, and merging to coordinate changes from developers.
• Granular permissions and access control over repos.
• Branching to isolate streams of development.

Version control systems enable traceability and collaboration essential for DevOps teamwork.

DevOps Uses On-Demand Environments

Development and testing environments were difficult to access in waterfall due to:

• Waiting weeks or months for required hardware to be provisioned due to capital expenditure budgets.
• Environments configured manually leaving configuration drift between environments.
• Long lead times for developers to get environments for testing new versions.

This slowed down development waiting on infrastructure availability.

With DevOps, infrastructure is provisioned on-demand by:

• Using programmatic automation through IaC tools to let engineers provision disposable dev and test environments quickly.
• Leveraging pre-configured templates and images to ensure standardization across environments.
• Eliminating waiting on physical data center capacity and hardware budgets by leveraging unlimited cloud resources.
• Destroying ephemeral development environments after use since they are reproducible via automation.

On-demand programmatic infrastructure removes delays waiting on long procurement cycles.

DevOps Deploys Small Changes

Waterfall meant large, unproven code changes deployed at once:

• Six months to a year between major software releases.
• Massive new features and architecture changes all at once.
• Entire applications rebuilt from scratch and redeployed.
• Long stabilization periods to resolve problems missed during development.

This high-risk approach frequently led to outages, defects and cost overruns.

DevOps delivers value through more incremental changes:

• Deploying small feature enhancements continuously versus “big bang” releases.
• Enabling each change to move through pipelines independently for faster validation.
• Using fine-grained controls like feature flags and canary deployments to limit the blast radius of changes.
• Releasing new versions to a portion of users first before full rollout.
• Rolling back changes quickly in case of adverse impacts.

Small incremental changes accelerate delivery while reducing risk.

DevOps Leverages Feature Flags

With waterfall, all features released simultaneously:

• Large bundled releases containing months of work.
• All changes tightly coupled and deployed together.
• No way to gain production testing feedback on changes before the big release.
• Difficult to disable or roll back problematic features without reverting entire release.

Bundling many complex changes into singular releases increased risk.

DevOps leverages feature flags and toggles to:

• Develop each new feature behind a feature toggle that gates it to off initially.
• Deploy changes independently for faster incremental validation.
• Enable partially activating features for just specific users groups via toggles.
• Disable problematic features without impacting other changes.
• Reduce risk of new functionality and provide staging flexibility.

Feature flags help test and release changes incrementally and granularly.

DevOps Focuses on Observability

Waterfall changes went to production as a “black box” since:

• No runtime observability into the production system.
• Logging usually confined only to discrete applications.
• Limited monitoring of overall system performance.
• Could only confirm software behaved correctly by observing external behaviors.
• Lack of internal visibility increased debugging difficulty.

This lack of live system internal visibility created problems.

DevOps emphasizes end-to-end monitoring by:

• Automatically instrumenting all applications and infrastructure to emit logs and metrics.
• Tracking requests across services and tiers via distributed tracing.
• Enabling search and data analytics to provide visibility across the entire system.
• Building dashboards to continuously monitor operational and business KPIs.
• Using alerting to notify teams of performance issues or user-impacting incidents.

Holistic observability into systems enables finding issues rapidly and debugging faster. Monitoring is designed in from the start rather than an afterthought.

DevOps Depends on Continuous Testing

Validating software functionality was manual in waterfall:

• Testing only at the end of long dev cycles leading to bugs and rework.
• Running manual scripted testing suites periodically.
• Performing visual validation of software behavior and outputs by QA testers.
• Manually reproducing defects to isolate root causes.
• Needing to prove all requirements addressed before release.
• Seeing release delays due to test cycles uncovering major issues late.

Manual testing was slow and often inconsistent.

DevOps automates testing continuously by:

• Adding automated unit testing to isolate each function and class.
• Using automated integration testing to verify modules interacting correctly.
• Leveraging automated interface testing via scripts or tools like Selenium.
• Providing early and frequent feedback through testing earlier and more frequently.
• Implementing automated API testing with frameworks like Postman.
• Using static code analysis to reveal bugs and antipatterns early.
• Preventing bottlenecks via test data management systems.
• Executing tests on every code change and deployment.

Automated testing shifts validation left to catch defects earlier. Tests provide living documentation of requirements.

DevOps Architects for Change

Waterfall systems were designed up front for fixed scope:

• Early requirements and technical designs encompassed the entire envisioned system before any code was written.
• Big architecture changes only occurred during major release cycles.
• Systems designed to be largely static between versions.
• Scaling required significant lead time for capacity planning.
• Technical debt accumulated given lack of refactoring time.
• Testing environments were rigid and tightly coupled to specs.

Upfront frozen scope constrained adapting to evolving requirements and usage patterns.

In contrast, DevOps designs for constant change:

• Making just-in-time and just-enough architectural decisions rather than all up front.
• Enabling independent evolution through service-oriented and componentized designs.
• Avoiding monolithic blocks via horizontal scalability with microservices.
• Provisioning infrastructure on-demand versus planned capacity.
• Prioritizing refactoring work to pay down technical debt.
• Using parallel production-like services in test environments for realism.
• Building in resilience via design patterns like circuit breakers.

Built-in adaptability and elasticity prevents brittle architectures that break under change.

DevOps Aligns to Business Outcomes

In waterfall, technical goals could diverge from business goals:

• Technical decisions optimized for ease of development and orderly IT operations.
• Requirements defined around capabilities rather than business value.
• Technical designs focused on architectural purity rather than incremental progress.
• Success measured by output rather than outcomes e.g. lines of code produced.
• Rigid governance models slowed ability to adapt to evolving market needs.
• Lack of customer feedback during long development cycles.
• Silos preventing visibility into whether technical capabilities enabled intended business results.

DevOps instead aligns technology to business value:

• Developers and ops communicate directly with business and product leaders.
• Requirements defined by business priorities rather than just technical capabilities.
• Teams organized around business functions and product verticals.
• Success measured by measurable impacts like user growth, revenue increases, customer loyalty.
• Just enough governance balancing speed with appropriate oversight.
• Continuous customer input via monitoring usage patterns, surveys, and production experiments.
• Tracing whether capabilities actually enable intended outcomes.

Keeping technology and product efforts linked to business value avoids wasted effort developing capabilities that don’t advance strategic goals.

The Goals and Benefits of DevOps

Adopting DevOps principles and practices can achieve powerful benefits for an organization. By transforming the software development lifecycle to focus on cross-functional collaboration, continuous delivery, automation, and aligning to business outcomes, DevOps enables companies to accelerate innovation and unlock value.

Here is an in-depth look at key goals organizations can accomplish with DevOps, along with the tangible and intangible benefits realized:

Faster Time to Market for New Features

One of the most important goals of DevOps is decreasing the lead time between having an idea for a new capability and getting it into customers’ hands. DevOps optimizes cycle time through:

• Continuous delivery – New code is automatically built, tested and deployed into production in small frequent batches rather than bundled releases. This enables continuous incremental improvements to products or services.
• Infrastructure automation – Programmatic infrastructure provisioning removes delays associated with manual IT ticket processes. Developers can spin up dev and test environments on demand.
• Reduced bottlenecks – Automated workflows and parallelization at each stage of the pipeline accelerates movement of changes through environments. Automation frees up human bandwidth.
• Smaller change batches – Small, incremental changes can flow through the pipeline independently. There is no need to wait for coordination of larger bundled releases.
• Rapid feedback loops – Fast feedback from automation, telemetry, and users in production prevents wasted time developing solutions that don’t meet needs.
• Cross-functional teams – Having combined dev and ops teams working closely together improves context sharing and rapid problem-solving.

With accelerated time-to-market, organizations ship competitive features faster. This enables seizing new opportunities and staying ahead of customer needs.

Improved Operational Efficiency

DevOps drives higher efficiency in software delivery by optimizing processes and workflows:

• Removing waste – Automation eliminates many manual repetitive tasks that add no business value. Teams focus on creative, high-value work.
• Faster recovery – Finding and fixing failures are streamlined through real-time observability into systems. Automated rollbacks rapidly revert changes.
• Reduced rework – Comprehensive test automation and continuous integration surface defects immediately so they can be fixed early before impacting other work.
• Improved prioritization – Having devs and ops collaborate on requirements and planning ensures work is aligned to the most important business outcomes.
• Standardization – Using consistent, automated pipelines, environments, and infrastructure definitions improve repeatability and reduce human errors.
• Optimized resource usage – On-demand self-service infrastructure reduces waste associated with unused idle resources.
• Consolidated toolchain – Integrating tools improves context sharing between teams to prevent disjointed hand-offs between platforms.

With enhanced operational efficiency, organizations get more value from technology investments and human capital. This drives cost savings that can be reinvested into innovation.

Enhanced Collaboration Between Teams

Silos between development, operations, and other groups create barriers to agility in traditional models. DevOps fosters closer teamwork through:

• Shared ownership – Cross-functional teams assume joint responsibility across the entire delivery lifecycle versus handoffs.
• Aligned prioritization – Developers understand operational constraints while ops teams know feature priorities and customer needs.
• Improved communication – Face-to-face interactions, chat tools, daily standups, and documentation keep everyone in sync.
• Reduced context switching – Developers can own fixes or features end-to-end without coordinating handoffs through multiple teams.
• Common platforms – Using the same integrated toolchains promotes visibility rather than isolated systems per team.
• Shared code – Infrastructure defined as code and managed like application code improves collaboration between developers and ops engineers.
• Aligned metrics – Sharing success metrics like system uptime, throughput, and customer satisfaction promotes joint accountability.

With improved collaboration, organizations benefit from better solutions informed by diverse perspectives. Knowledge sharing also enables reuse of work and innovation across the organization.

Continuous Integration and Delivery

A core DevOps goal is continuous integration and delivery of all changes – both infrastructure and application:

• Constant integration – Code is merged to a shared mainline frequently through automated tools. Builds and tests run on every merge to catch issues early.
• Push-button deployments – Delivery pipelines automate deploying application changes through environments into production with minimal human intervention.
• Reliable release processes – Automation provides repeatable, consistent packaging and promotion of builds through lower environments into production. Humans focused on exceptions.
• Immutable infrastructure – Infrastructure is continuously provisioned and updated through declarative definitions rather than manual changes. Servers are treated as immutable cattle versus pets.
• Lower risk releases – Incremental changes reduce the risk of any given deployment failure. Rollbacks are automated to instantly revert bad changes.
• Faster feedback loops – Problems are caught faster with more frequent code merges, builds, testing, and deployments.

Continuous end-to-end integration and delivery accelerates innovation by removing bottlenecks and providing rapid validation.

Reduced Risk

DevOps lowers many risks associated with software delivery like:

• Deployment failures – Smaller, more frequent changes reduce the risk of any given deployment failure versus massive bundled releases. Automated testing and rollbacks also mitigate issues.
• Security vulnerabilities – Automated scanning of dependencies prevents use of vulnerable libraries. Testing earlier prevents flaws reaching production.
• Production defects – Comprehensive test automation across the pipeline improves code quality and prevents defects reaching users.
• Performance problems – Load and scale testing early on helps uncover bottlenecks. Gradually releasing changes provides production testing.
• Disaster recovery – Automated provisioning and configuration management facilitates rebuilding systems rapidly after failures.
• Compliance violations – Policy as code and automated testing reduces risks of configurations or workflows violating organizational standards.
• Unplanned work – Less downtime events means fewer context switches into urgent unplanned work that derails project timelines.

With reduced risk across many dimensions, organizations gain confidence to release changes faster and more often.

Quicker Resolution of Defects and Security Issues

When inevitable issues do occur, DevOps enables faster detection and repair through:

• Real-time monitoring – Logging, metrics, and tracing provide observability to identify anomalies as they occur.
• Proactive alerting – Teams get immediate notification when key performance indicators breach safe thresholds so they can investigate.
• Robust logging – Centralized logging with search provides debugging data for diagnosing root causes.
• Automated rollbacks – One-click full or partial rollback of bad changes enables rapid recovery.
• Feature flags – Problems can be deactivated without redeploying by toggling off features causing issues.
• On-demand environments – Testing suspicious changes in cloned production environments helps reproduce issues quicker.
• Cross-functional teams – Developers, ops and infosec jointly resolve issues with shared priorities and insights.

Rapid recovery from problems minimizes downtime and customer impact. Post-mortems also identify areas for improvement to prevent future issues.

Improved Product and Service Quality

Several DevOps capabilities come together to improve overall code health and product quality:

• Comprehensive test automation – Unit, integration, API, UI, load, security, and other testing types help catch a broad spectrum of potential defects before reaching users. Tests run early and often.
• Shift left on security – Security scans, tests, and fixes begin right from requirements definition and continue throughout the pipeline.
• Production telemetry – Continuous monitoring provides visibility into usage patterns, performance metrics, and reliability. Teams can identify areas for improvement.
• Bug prevention – Static code analysis and code reviews prevent the introduction of common anti-patterns and vulnerabilities into code.
• Bug fixes – Integrating code changes more frequently surfaces defects sooner when they are cheaper to fix. Fixes can be deployed faster via automation.
• Up-to-date dependencies – Automated processes keep dependencies and libraries up-to-date to avoid inherited vulnerabilities from outdated components.

Higher product and service quality leads to improved customer experiences and loyalty over time.

Improved Customer Experience and Satisfaction

DevOps improves the customer experience both directly through faster delivery of capabilities and fixes, and indirectly by empowering teams to align work to customer needs:

• Rapid delivery of features – Getting new functionality and updates into customers’ hands faster improves their experience.
• Lower rates of failure – With less downtime and defects reaching users, customers have better uptime and reliability.
• Faster fixes to problems – Bugs that do reach customers are identified and resolved sooner limiting negative impact.
• More experimentation – New ideas can be tested in production faster to validate what resonates most with different customer segments.
• Better prioritization – Developers and ops people hearing business priorities directly improves decision-making.
• Ongoing customer feedback loops – Telemetry data, focus groups, user interviews shape roadmaps around actual usage patterns and needs.
• Shared metrics – Visibility into customer-centric metrics like NPS and satisfaction helps teams internalize business success.

Delivering higher-quality experiences backed by excellent service increases brand loyalty among customers.

Increased Market Share and Revenue

All the benefits outlined thus far ultimately enable organizations to gain market share and drive faster revenue growth through:

• Faster time-to-market – Releasing compelling new capabilities quicker helps attract new customers before competitors.
• Improved conversion rates – Better performing software encourages more users to convert from free to paid plans and expand usage.
• Upsells to existing customers – Rapidly releasing new features tailored to different customer segments increases paid utilization of products.
• Improved retention – Higher reliability, faster fixes, and continuous delivery of value improves customer lifetime value and retention.
• Reputation and advocacy – Delivering excellent experiences improves brand reputation and likelihood of referrals or positive reviews.
• Competitive differentiation – Continuous innovation and delivery of cutting-edge capabilities separates the product from competing offerings.
• New market opportunities – Faster experimentation and feedback loops enable capitalizing on adjacent markets and new use cases.

For revenue-driving organizations, improved speed, quality, and customer satisfaction enabled by DevOps practices directly translates to accelerated growth and higher revenues.

Significant Cost Savings

Optimizing software delivery through DevOps can generate material cost savings in several forms:

• Reduced failures in production – Each prevented system outage or service disruption avoids costly impacts on revenue, customer retention, staff overtime, and damage to brand reputation.
• Higher efficiency – Doing more with less through automation, reduced rework, and waste elimination significantly reduces operational costs.
• Optimized resource usage – Self-service infrastructure and autoscaling cut waste associated with unused idle resources while maintaining capacity.
• Faster fixes – Resolving issues quickly minimizes employee time spent context switching into unplanned work, extensive escalations, and post-incident reviews.
• Risk reduction – Higher stability translates into lower overhead for backups, disaster recovery processes, failover capacity, and mitigating tech debt accrued from past failures.
• Cloud cost optimization – Consistent cloud configurations prevent sprawl. Decommissioning resources and leveraging autoscaling optimizes variable spending.
• Governance overhead – Automating compliance processes reduces human capital needed for audit preparation, penetration testing, and risk reviews.

Cost reduction translates directly into higher profitability. Savings can be redirected towards fueling further innovation.

Financial Benefits Like Faster ROI

Many of the advantages outlined above provide financial benefits like:

• Faster time-to-market – Getting products to market sooner realizes revenue faster. First-mover advantage secures market share quicker.
• Improved productivity – Doing more with less drives stronger output per dollar invested in technology and labor.
• Higher velocity – Accelerated deployment rates mean fixed costs of engineering teams are amortized across more capabilities delivered per period.
• Increased utilization – Better availability, performance, and quality of digital products and systems boosts usage and transactions.
• Reduced overhead – Automating manual tasks significantly lowers operational expenses associated with development and IT.
• Lower risk – Increased stability means fewer failures that incur costs related to incentives, SLA penalties, overtime, or backups.
• Stronger retention – Keeping customers engaged longer thanks to faster delivery of value maximizes customer lifetime value.
• Cloud efficiency – Optimized cloud resource usage reduces variable spending without sacrificing availability and scale.

These collectively translate into stronger ROI on technology investments, improved gross margins, and accelerated breakeven points for launching new products or entering new markets.

Greater Innovation Through Faster Experimentation

DevOps provides the speed and safety required for increased experimentation:

• Lower risk releases – New ideas can be tested in production with less risk given small reversible changes, feature flags, automated rollbacks, and other capabilities.
• Faster experiment velocity – Automation and frequency of releases allows validating many new concepts in the same time period versus slow manual processes.
• Production feedback loops – Rapid experimentation in the real world with real users provides quick indicative signals on what adds value.
• Tighter iteration – Continuous delivery means improvements or pivots based on learnings get incorporated quickly back into the product experience.
• Encouraging boldness – By reducing the downsides of failure, teams are emboldened to try new approaches versus being constrained by risk avoidance.
• Supporting open-ended discovery – Fostering “test & learn” cycles guides teams to novel solutions that typical rigid planning would overlook.

With DevOps, organizations stay ahead of the curve through constant experimentation, learning, and evolutionary architecture rather thanStatic bet-the-business releases.

Increased Ability to Compete and Differentiate

DevOps capabilities can provide strategic advantages against the competition:

• Matching competitor pace – Releasing changes faster prevents losing ground to disruptive competitors rapidly iterating.
• Unique capabilities – Continuous experimentation and deployment of new ideas fuels innovation competitors struggle to keep up with.
• Improved UX – Constant production feedback loops enable crafting superior user experiences refined based on real customer data.
• Security leadership – Robust DevSecOps practices manifest as differentiation in security-sensitive industries like finance and healthcare.
• Access to talent – A strong DevOps culture attracts and retains top performers drawn to high-velocity engineering environments.
• Morale and passion – Cross-functional team autonomy with shared purpose drives higher engagement and meaning.
• Operational resilience – High performing IT teams recover from disruptions faster maintaining consistent experiences for customers.
• Cost leadership – Efficient automated workflows support undercutting competitor pricing or reinvesting savings into innovation.

DevOps capabilities that exceed the competition provide strategic differentiation that delivers real business results and defensible market position.

Core Components of a DevOps Methodology

While individual implementations may differ, most DevOps toolchains incorporate the following key elements:

Continuous Integration and Continuous Delivery

Continuous integration (CI) and continuous delivery (CD) are key DevOps practices that automate building, testing and deployment of software changes:

• Continuous Integration – Developers frequently merge code changes into a shared branch. Automated builds and tests run with each code commit to provide rapid feedback on quality.
• Continuous Delivery – Incremental code changes are automatically built, tested, and deployed to production in small batches. New features can be released frequently.

Implementing CI/CD pipelines is essential for delivering software faster. The pipeline codifies the entire build, test and deployment process including tools, environments and automation scripts.

Infrastructure as Code

Infrastructure as code (IaC) manages IT infrastructure through machine-readable definition files rather than physical hardware configuration. It enables:

• Faster Provisioning – Infrastructure can be provisioned quickly by executing code rather than manual setup.
• Consistency – Defining components through code (like Terraform, Ansible) standardizes environments across dev, test, prod.
• Version Control – Stores infra code in repos enabling revisions and rollbacks.
• Validation – Code can be validated to catch issues before provisioning.

IaC is critical for nimble and automated DevOps workflows. Ops teams can quickly deploy infrastructure needed for development, testing or production via code.

Microservices Architecture

A microservices architecture breaks large monolithic apps into smaller, independently deployable services. Each service contains its own logic and data storage.

Microservices provide agility benefits for DevOps:

• Faster Deployments – Small codebases can be changed and deployed quickly without rebuilding entire monoliths.
• Scale – Services can be scaled independently based on demand.
• Resilience – An outage or bug in one service has limited impact. The overall app still functions.
• Flexibility – Mix of technologies can be used versus relying on one monolithic tech stack.

Converting legacy monoliths into microservices takes time but enables faster feature delivery in the long run.

Monitoring and Observability

Monitoring systems provide critical visibility into infrastructure and apps in DevOps environments:

• Metrics – Timeseries data like response times, error rates, CPU usage. Help track overall trends.
• Logging – Log messages output by services to identify errors and issues.
• Traces – Follow a request end-to-end through all services and dependencies.
• Alerting – Get notified when key metrics cross warning or critical thresholds.

Observability enables ops to rapidly detect and troubleshoot problems before customers are impacted. Monitoring needs to be built into systems from initial design stages.

Communication and Collaboration

Implementing the right tools is not sufficient alone. DevOps requires cultural shifts in communication, transparency and collaboration:

• Break down silos – Provide joint training and share documentation to bring teams together. Have cross-functional teams.
• Daily standups – Short daily sync meetings foster better coordination and visibility.
• ChatOps – Chat tools promote constant communication and seamless collaboration between teams.
• Retrospectives – Regular review meetings solicit feedback on what works well or needs improvement.

Great collaboration and communication is essential for DevOps success. Tools provide efficiency but culture change establishes shared purpose and alignment.

Implementing DevOps Best Practices

Adopting DevOps requires careful planning and phased execution. These best practices guide effective DevOps implementations:

Start with Leadership Buy-In and Cultural Shift

• Secure executive sponsorship – Leadership mandate gives urgency and priority to DevOps initiatives.
• Promote cultural change – Have leaders and influencers model collaborative values. Recruit those eager to embrace change.
• Highlight benefits realized – Quantify productivity gains, cost savings and revenue growth from early DevOps projects.
• Provide training – Invest in training across functional areas like CI/CD, IaC, containers, automation.

Culture ultimately determines DevOps success. Top-down messaging and bottom-up enthusiasm must align towards shared cross-functional purpose.

Begin Automating Processes Incrementally

• Prioritize quick wins – Choose repetitive manual processes that will deliver the fastest ROI through automation.
• Standardize tools – Limit variability by standardizing on consistent platforms for IaC, monitoring, CI/CD, etc.
• Start small – Run automation pilots for lower risk processes first before expanding scope.
• Incrementally scale – Let early automation projects build momentum then apply learnings to expand.

Focus first on automating repetitive infrastructure provisioning, testing and deployment processes for faster ROI.

Develop CI/CD Pipelines Spanning Devs to Ops

• Version control branching model – Feature branches, develop branch, release branches, master/mainline.
• Automated build validation – Build and test automation on code check-in. Scan dependencies for vulnerabilities.
• Automated deployment – Scripted deployment of code to dev, test, prod environments.
• Monitoring and logging – Instrument code in pipelines to monitor performance metrics and logs.
• Rollback scripts – Automate quick rollback of faulty builds.

CI/CD pipelines facilitate rapid, safe delivery of code changes. Start with a minimal pipeline then expand capabilities over time.

Adopt Microservices and Containers

• Decompose monoliths – Gradually break apart tightly coupled systems into single responsibility services.
• Deploy services in containers – Bundle services with dependencies into container images for portability.
• Automate container lifecycles – Use container orchestrators like Kubernetes to automate deployment, scaling, networking of containers.
• Design for high availability – Build redundancy into services, leverage health checks,circuit breakers, leader election patterns.
• Align to business domains – Structure services around business capabilities versus purely technical constructs.

Microservices and containers enable the rapid changes, deployments and scalability needed for modern DevOps.

Monitor and Log Everything

• Logging – Centralized logging of all application and infrastructure logs.
• Metrics – Monitor key operational and business metrics like uptime, throughput, conversion rates.
• Tracing – Instrument services to trace requests across all interconnected microservices.
• Dashboards – Build dashboards to visualize metrics, logs and traces in real-time.
• Alerting – Get notifications when metrics cross thresholds or key incidents occur.

Full observability into systems and business KPIs enables identifying and resolving issues quickly.

Provide Self-Service Capabilities

• Infrastructure APIs – APIs and portals developers use to dynamically provision infrastructure themselves.
• Release process – Self-service pipelines developers can run themselves to build, test and deploy code.
• On-demand environments – Developers can instantly spin up disposable environments without waiting on IT tickets.
• Productivity tools – Provide useful services on internal platforms to reduce external tool sprawl.

Automating manual IT ticket work through APIs and self-service workflows accelerates developer productivity.

Invest in Continuous Learning and Improvement

• Value innovation time – Build in dedicated time for creativity and learning. Don’t just focus on feature output.
• Retrospectives – Regular reviews of what’s working well or needs improvement.
• Experimentation – Conduct POCs, spikes, prototypes to drive learning. Fail fast, learn faster.
• Cross-train teams – Help developers understand ops challenges, and vice versa through job shadowing.
• Attend conferences – Stay on top of emerging technologies and industry trends.

DevOps requires a growth mindset. Learning enables continuous improvement of tools, processes and culture.

Key DevOps Tools and Technologies

DevOps has rapidly gained momentum as an essential approach for improving collaboration, productivity, and deployment velocity in software development environments. At its core, DevOps seeks to break down silos between development and operations teams, enabling faster and more reliable releases through process automation and monitoring.

A rich ecosystem of tools and technologies has emerged to facilitate DevOps workflows. While an organization’s tech stack will depend on their size, budget, infrastructure, and objectives, several categories of solutions have become ubiquitous in the DevOps landscape. Examining the capabilities and use cases of these key tools provides helpful orientation for those exploring or implementing DevOps.

Source Code Management and Version Control

Robust source code management with version control lays a crucial foundation for achieving DevOps agility. Platforms like Git and GitHub enable developers to collaboratively and efficiently manage code changes across projects. Key features include:

• Distributed version control – Developers can commit, branch, merge and compare file changes on local machines before pushing to the remote master repository. This facilitates flexibility and experimentation.
• Concurrent development – Multiple developers can simultaneously work on files and integration of changes is handled cleanly through merging and commit histories.
• Traceability – Granular commit logs and version histories provide transparency and auditability. Reverting back to any previous version is simple.
• Branching – Multiple versions of the code can diverge into isolated branches and be independently developed for features, fixes, experiments etc.
• Access controls – Fine-grained user and permission controls improve security and code quality by limiting access for modifications and deletions.

Proper use of version control enhances collaboration, surfaces defects early through peer code reviews, and streamlines release management. GitHub has further strengthened developer workflows by adding project management capabilities, automation tools, and facilitating open source contribution on top of Git’s core functionality.

Continuous Integration / Continuous Delivery (CI/CD)

CI/CD platforms automate the build, test and deployment processes that translate code changes into value delivering features. They provide:

• Automated build triggers – New code commits or pull requests instantly run pipelines that assemble, compile and package the application
• Automated testing – Code is verified through unit, integration and UI testing suites before deployment to catch defects early
• Environment management – Pre-provisioned deployment environments provide parity and consistency across dev, test, stage and production
• Automated deployments – Code changes can be rapidly released to desired environments with approvals and zero downtime
• Dashboards and alerts – Logs, metrics and notifications provide visibility into pipeline statuses and failures
• Integration ecosystem – APIs and plugins support connecting external tools into pipelines for activities like test automation, artifact management and infrastructure provisioning

Jenkins is the open source leader for CI/CD, while paid platforms like CircleCI, TravisCI, and AWS CodePipeline offer robust capabilities and support. By automating build, test, and deployment processes, CI/CD solutions enable reliable continuous delivery and reduce risks of frequent code changes.

Infrastructure as Code (IaC)

IaC frameworks allow teams to define, provision, and manage IT infrastructure and configurations through code. This delivers benefits including:

• Consistency – Infrastructure environments and settings are codified rather than manually configured. They can be easily replicated across environments.
• Version control – Infrastructure can utilize benefits like change tracking, branching, and rollback offered by source control like Git.
• Automation – Infrastructure changes can be instantly made by merging code changes rather than slow and error-prone manual processes.
• Validation – Coded infrastructure configurations can be validated through testing before deployment to improve reliability.
• Documentation – Code and definitions serve as detailed documentation of infrastructure versus mundane spreadsheets or diagrams.

Terraform and Ansible have emerged as leading open source IaC tools. Cloud vendors also offer proprietary IaC capabilities like AWS CloudFormation. Whether on-prem or cloud-based, IaC enables version controlled, automated, and testable infrastructure for greater DevOps maturity.

Monitoring and Logging

Observability into application performance and behaviors is essential for DevOps teams to identify and resolve issues rapidly. Monitoring and logging tools provide:

• Custom dashboards – Visualizations can be tailored to business KPIs for quick insights into heath, traffic, conversion rates etc.
• Request tracing – Following the path of a request across infrastructure provides insight into bottlenecks.
• Exception tracking – Errors or performance degradation trigger alerts for rapid investigation.
• Log analysis – Aggregated logging from across services helps diagnose problems.
• Correlation – Metrics, logs, and traces can be combined for context around user impacting events.

Top open source monitoring tools include Prometheus, Grafana, Elastic Stack, and Nagios. Cloud platforms such as AWS CloudWatch and Cloudflare Radar offer robust proprietary monitoring as well. Whether done internally or through external monitoring as a service, monitoring and observability are indispensable DevOps capabilities.

Containerization

Containerization encapsulates application code with lightweight virtualization for greater portability across environments. Containers provide:

• Isolation – Containers bundle all dependencies (libraries, frameworks, etc) avoiding environment conflicts.
• Speed – Containers have near bare metal performance without the overhead of full virtualization.
• Scalability – Containerized microservices can rapidly scale up and down through orchestration.
• Portability – Containers run consistently across diverse operating systems and infrastructure.

Docker pioneered containers for streamlining application deployment, orchestration, and management. Kubernetes has become the open source leader for automating deployment, scaling, and availability of containerized applications. Containers underpin cloud native development allowing the same code to run seamlessly across private data centers and public clouds.

Artifact Management

Artifact management and repositories play an important role in creating DevOps consistency. They provide:

• Build caching – Store build artifacts, dependencies, and packages to reuse across pipelines for faster processing.
• Release consistency – Centralized access to releases, builds, tests, and binaries improves traceability.
• External integrations – Artifacts can integrate with external tools through APIs rather than manual transfers.
• Retention policies – Versions and artifacts can have defined retention periods after which they are pruned.
• Permission controls – Manage team access to different categories of artifacts and releases.

Nexus and JFrog Artifactory are leading open source artifact management tools. Paid services like AWS CodeArtifact also available. Whether self-hosted or SaaS-based, centralized artifact management brings consistency and improves efficiency of CI/CD pipelines.

In addition to the above core technology categories, DevOps toolchains are enhanced through robust integrations and supportive technologies including:

• ChatOps – Hubot, Slack bots – Automation and collaboration via chat channels
• Virtualization& Cloud – VMs, serverless, Kubernetes – Flexible compute provisioning
• Microservices – Small, decoupled services for scalability
• API Gateways – Manage traffic and access to microservices
• Databases – SQL, NoSQL provide structured storage and queries
• Programming Languages – Java, JavaScript, Python, Go enable custom tooling
• Security – Secret management, vulnerability scanning, firewalls

Measuring Success of DevOps Implementations

The promise of DevOps is to create a culture that values collaboration, automation, and continuous improvement in order to accelerate delivery of software innovation. But for many organizations, effectively measuring whether DevOps implementations are succeeding or not remains an elusive challenge.

Quantitative metrics around velocity and quality provide incomplete insight. The cultural dimensions of DevOps success are harder to quantify but essential to assess. Organizations should take a holistic approach to measurement that considers speed, stability, and staff satisfaction metrics across a DevOps transformation timeline.

Speed of Delivery

Improving the speed at which ideas can be developed, tested and released is a primary goal of DevOps adoption. Useful metrics include:

• Release Frequency – How often releases or new features can be deployed per day, week or month. Higher frequency indicates greater agility.
• Lead Time – The average time it takes new code to go from commit to release into production. This measures efficiency of development and deployment flow. Lower lead time enables faster innovation and feedback.
• Time to Restore Service – How quickly can service outages be mitigated? Low mean time to restore confirms reliability safeguards are working.
• Deployment Time – The average duration of time for the steps involved in a continuous deployment including build, testing, approval and go-live. This identifies friction points in the delivery pipeline.

While velocity must be balanced with stability, these metrics help track if development, testing and operations activities are accelerating and synchronizing through DevOps practices compared to past performance.

Quality and Reliability

Moving fast without instilling quality safeguards will lead to problems down the line. Key metrics around stability include:

• Change Failure Rate – What percentage of production deployments cause unexpected downtime, bugs or rollbacks? Lower rates confirm changes are being sufficiently validated.
• Defect Escape Rate – How frequently do defects make it to production undetected? Lower escape rates reflect rigorous code review, testing and QA processes.
• Mean Time Between Failures – The average uptime between system outages. Increasing steadily over time indicates improved reliability and resiliency of releases.
• Test Automation Coverage – What percentage of the code base is covered by automated testing suites? Higher coverage provides safety nets for continuous delivery.

Taken together, these metrics should show new features are being released rapidly without compromising stability, availability and user experience. This instills confidence across stakeholders that quality remains a priority amidst accelerating change.

Cultural Indicators

The human factors of collaboration, trust, and satisfaction can be harder to quantify but remain critical. Useful cultural health metrics include:

• Employee Net Promoter Score – How likely are staff to recommend working at the company? Increasing scores suggest higher job satisfaction and engagement.
• Cross-team Participation – How frequently do employees collaborate across departments outside their immediate team? More participation indicates silos are dissolving.
• Adherence to Process – What percentage of changes follow the defined development, testing and release protocols? Higher adherence shows greater discipline.
• Decision Latency – How long on average does it take for cross-functional decisions to be reached on issues that arise? Shorter latency suggests alignment and empowerment.
• Burnout Signals – Are anonymous employee surveys showing increases in reported fatigue, cynicism, or desire to leave? If so, the human toll of disruption may be too high.

While anecdotal, the cultural temperature check provided by these metrics is invaluable in ensuring the people dimension of DevOps succeeds alongside the technology transformation.

Phased Measurements

How metrics are tracked and weighted should evolve over a multi-phased DevOps implementation roadmap:

Phase 1 – Baseline Metrics Before any tooling or process changes, baseline metrics around release frequency, lead times, outage rates and inter-team collaboration provide a comparison point for future assessment.

Phase 2 – Minimum Viable DevOps The MVP stage focuses on automating narrowly scoped but high value delivery pipelines and monitoring. Speed and quality metrics for targeted workstreams show initial progress.

Phase 3 – DevOps Expansion As practices expand across the organization, so too should measurement sophistication through AJAX-style performance monitoring, cultural surveying, and outcome-based assessments.

Phase 4 – Optimization
In the optimize phase, fine-grained analytics like time tracking individual pipeline stages fuel continuous improvement. Culture is measured through real-time sentiment analysis.

This phased approach prevents “boiling the ocean” by staggering measurements—and expectations—to match the maturity of capabilities at each stage.

Ongoing Assessment

Beyond staged rollout, real-time monitoring and periodic assessment reviews help sustain DevOps success:

• Dashboards – Continuous visibility into release velocity, quality, and pipeline health metrics enables teams to catch deviations and intervene quickly.
• Retrospectives – Regular meetings to review metrics performance, process hurdles, and collaboration can surface areas for targeted improvement.
• Use Case Reviews – Analyzing metrics and satisfaction across different applications and teams illuminates where practices are working well—or need tuning.
• Cultural Audits – Annual or bi-annual surveys, interviews, sentiment analysis, and NPS provide periodic cultural checks.
• Benchmarking – Comparing metrics and maturity against industry standards or high performers aids roadmap calibration and setting goals.

By combining a portfolio of quantified metrics, cultural indicators, staged measurement periods, and continuous assessments, organizations can evolve DevOps implementations to sustainably deliver value at speed.

Guiding Principles

Keep these principles in mind when measuring DevOps success:

• Holistic – Consider productivity, quality, cultural, and business value metrics for comprehensive insight.
• Cohorts – Compare metrics across cohorts like applications, product teams, and functions to target problem areas.
• Minimal Viable – Begin with essential metrics and grow sophistication in cadence with capabilities.
• Automated – Automate data collection for efficiency using APIs, agents, and pipelines.
• Historical – Archive metric data over time to surface trends and performance changes.
• Contextual – Supplement numbers with qualitative color, surveys, reviews etc to illuminate the “why”.
• Leading Indicators – Watch for metrics that anticipate problems like technical debt accumulation.
• Behavior Drivers – Consider how metrics influence culture and behaviors for better or worse.
• Outcomes – Relate metrics to business KPIs like customer retention and revenue to confirm value.

Common DevOps Challenges and Pitfalls to Avoid

Adopting DevOps principles and practices promises significant benefits like faster innovation, reliable releases, and collaborative cultures. However, the transition can be difficult. Organizations frequently encounter challenges stemming from ingrained processes, tools, and mindsets misaligned with DevOps outcomes.

Being aware of these common pitfalls allows mitigation through proactive change management. Here are some of the biggest challenges that can derail DevOps success and how to avoid or overcome them.

Here is the “Common DevOps Challenges and Pitfalls to Avoid” content formatted in a table:

Challenge	Description	Avoidance Tips	Risk of Inaction
Tools Before Culture	Prioritizing tools over cooperative values between teams	– Start with small cultural shifts – Incentivize shared goals – Communicate vision for gains – Celebrate quick collaborative wins	Fragmented adoption, tools underutilized
Lack of Shared Metrics	Misaligned metrics across functions breeds distrust	– Establish cross-functional metrics – Make metrics transparent on dashboards – Attribute metrics to services, not groups	Persisting siloed mentalities
Unwillingness to Delegate Control	Ops unwilling to relinquish deployment control obstructs automation gains	– Take transparency and security steps – Start small with lower risk releases – Phase delegation gradually – Reward results over status quo	Deployments remain slow and risky
Lack of Test Data and Environments	Insufficient access to diverse datasets and mirrored environments	– Prioritize replicating production data – Use data generation and masking – Implement IaC for consistency – Shift workloads to cloud	Defects escape, hurts quality
Testing Bottlenecks	Testing happens too late, lacks automation	– Shift testing left in pipelines – Provide self-service test tools – Standardize test environments – Dedicate staff for test scenarios	Delivery pace choked, regressions leak through
Lack of Monitoring and Visibility	Lack of visibility into health and performance after deployment causes outages	– Build telemetry into services – Create visualizations and alerts – Support drill-down diagnostics – Monitor end-to-end	Teams flying blind
Security and Compliance Conflicts	Security needs conflict with speed of delivery	– Automate security in pipelines – Support self-service within sandboxes – Tailor controls for automation – Phase compliance scope	Agility stifled
Underinvestment in Automation	Attempting DevOps without resources dedicated to automation	– Make business case for productivity – Prioritize test, IaC, CI/CD investments – Start with developer productivity	Mired in manual processes
Lack of Continuous Improvement	Lack of ongoing tuning and innovation after initial implementation	– Build improvement into roles – Leverage metrics for innovation – Maintain backlogs – Hold innovation workshops	Reversion to old habits
Poor Containerization Strategy	Pursuing containerization as a goal rather than where it optimizes	– Assess benefits to specific apps – Right size containers – Standardize containers – Phase containerization	Added complexity without gains