Automation maturity model

Manually deploying and configuring cloud infrastructure is a natural starting point for cloud practitioners. However, as applications mature, maintaining manually deployed infrastructure is unsustainable and is an industry anti-pattern.

The automation maturity model describes three stages in the progression from manual deployments to fully automated infrastructure. Each stage has specific characteristics, benefits, and challenges that organizations must navigate.

Manual deployments

Manual deployments involve human operators creating, configuring, and managing infrastructure resources. Common methods include using cloud provider web consoles, connecting to remote servers via SSH or RDP, and running commands directly on systems.

The following are examples of semi-automated deployments:

Clicking through cloud provider dashboards to create resources
SSHing into servers to install software and configure services
Making configuration changes directly on running systems
Manually scaling resources up or down based on demand
Troubleshooting issues by logging into systems and running diagnostic commands

Manually deploying your infrastructure contains the following risks and challenges:

Lack of version control: No systematic way to track what changes were made, when, or by whom
Human error: Manual processes are prone to typos, missed steps, and inconsistent configurations
Poor repeatability: Difficult to recreate the same environment consistently across different deployments
Hard-to-audit changes: No automatic logging of infrastructure modifications
Difficulty scaling: Manual processes don't scale with team size or infrastructure complexity
Knowledge silos: Critical infrastructure knowledge often exists only in individual team members' heads

Occasionally, manually deploying and configuring your infrastructure makes sense, such as one-time experiments or proof-of-concept work, emergency troubleshooting that requires immediate human intervention, and exploring new cloud services.

Semi-automated deployments

Semi-automated deployments introduce scripting and basic automation tools while still requiring human intervention to execute processes. Instead of manually running individual commands, operators execute scripts that perform deployment and configuration tasks.

The following are examples of semi-automated deployments:

Running bash, Python, or PowerShell scripts to provision infrastructure
Using cloud-init or user-data scripts for server configuration
Employing configuration management tools like Ansible for application setup
Storing scripts in version control systems
Defining infrastructure as code (using declarative configuration files)
Using basic CI/CD pipelines for some deployment tasks
Create application images with code
Immutable infrastructure
Ability to audit cloud logs

Benefits over manual deployments:

Improved repeatability: Scripts can be run multiple times with consistent results
Basic version control: Scripts are stored in repositories, providing change tracking
Reduced human error: Automated script execution eliminates many manual mistakes
Documentation: Scripts serve as executable documentation of deployment processes
Easier scaling: Scripts can be run across multiple environments more efficiently

Fully-automated deployments

Fully-automated deployments use version-controlled infrastructure that is automatically executed through CI/CD systems. Infrastructure changes are implemented through code commits, which trigger automated testing, validation, and deployment processes.

The following are examples of fully-automated deployments:

Automatically triggering deployments through Git commits using tools like GitHub Actions or HCP Terraform
Running automated tests against infrastructure changes
Implementing blue-green or canary deployments
Monitoring and alerting on infrastructure health with tools like Datadog
Self-healing systems that automatically respond to failures like Nomad or auto-scaling groups
Self-service infrastructure

Benefits over semi-automated deployments:

Complete audit trail: Every change is tracked through version control
Automated testing: Automation validates infrastructure changes
Consistent environments: Identical infrastructure across development, staging, and production
Rapid rollback: Easy to revert to previous known-good states
Self-service capabilities: Developers can provision infrastructure without operations team intervention
Compliance and governance: Automated policy enforcement and security scanning

Assess your current state

To determine where your organization currently sits on the maturity model, consider these questions:

Manual Deployment Indicators:

Do you primarily use cloud provider web consoles for infrastructure changes?
Are you frequently SSHing into servers to make configuration changes?
Are infrastructure changes often made without tracking or approval processes?
Do you manually install software and dependencies on servers?
Are you scaling resources up or down manually based on demand?

Semi-Automated Deployment Indicators:

Do you use scripts for most deployment tasks?
Are your scripts stored in a version control system?
Do you still manually execute deployment scripts?
Are you using infrastructure as code tools like Terraform or Ansible?
Do you build application images using tools like Packer or Docker?
Do you use golden images as a base for your applications?
Is there occasional drift between your scripts and the actual infrastructure?

Fully-Automated Deployment Indicators:

Are infrastructure changes made exclusively through code commits?
Do you have automated testing for infrastructure changes?
Can developers self-service infrastructure needs?
Are rollbacks automated and tested regularly?

Next steps

In this section of Process automation, you learned the benefits and tradeoffs of different automation levels, and where your organization is in the model. Visit the following documents to learn specifics on semi and fully-automated deployments. The automation maturity model is part of the Define and automate processes pillar.