4.0 AI-Accelerated DevOps & Platform Engineering
Overview
This module shifts focus from feature development to the software delivery pipeline and platform. You'll apply AI to DevOps and infrastructure, addressing friction removal and acceleration of flow in the engineering process itself.
Core Themes:
- Infrastructure as Code with AI assistance
- CI/CD pipeline creation and automation
- Eliminating toil and friction in delivery
- Building automation and tooling with AI
What You'll Do
You'll build automation and tooling that drastically reduces the "time to deliver" — one-click deployments, CI/CD pipelines, or internal developer tools — with AI doing most of the heavy lifting.
This module emphasizes Liatrio's ethos of removing toil and enabling flow in systems.
Primary Capabilities You'll Develop
Infrastructure as Code & Environment Automation
Use AI to generate infrastructure-as-code scripts:
- Terraform, CloudFormation, or similar IaC
- Cloud resource configuration
- CI/CD pipeline definitions
- Monitoring and observability setup
Treat environment setup as another code generation task.
CI/CD Pipeline Creation with AI
Design and implement automated pipelines:
- Pipeline definitions (GitHub Actions, Jenkins, etc.)
- Build, test, and deployment automation
- AI-generated test scripts and deployment logic
- Optimization for faster feedback loops
Focus on accelerating flow through automation.
Lean Process Improvement & Tooling
Identify and eliminate friction points:
- Environment setup delays
- Manual testing bottlenecks
- Slow approval processes
- Knowledge sharing gaps
Build small tools or bots to address these — with AI doing the implementation.
What is Infrastructure as Code?
If you've spent the last two modules writing application code with AI, this module asks you to point that same skill at a different target: infrastructure.
Traditionally, setting up servers, databases, and networks means clicking through cloud consoles — manual work that's hard to reproduce, review, or undo. Infrastructure as Code (IaC) replaces that with declarative configuration files that describe what your cloud environment should look like. A tool like Terraform reads those files and creates, updates, or destroys cloud resources to match.
The mental model:
| Concept | Application Code Analogy |
|---|---|
| Resource block | A class or component — declares one piece of infrastructure (an S3 bucket, a database, a load balancer) |
| State file | A database of what Terraform has created — how it knows what exists and what needs to change |
| Plan | A dry run / diff — shows what will change before anything happens |
| Apply | Deploying — Terraform makes the changes for real |
| Destroy | Tearing it all down — deletes everything Terraform created |
You don't need to memorize this. The point is that infrastructure follows the same write → review → apply loop you've been using for code.
This module is about using AI to accelerate infrastructure work — even (especially) if you've never written Terraform or a Dockerfile before. Ask Claude to explain concepts, generate starter configurations, and help you debug. That's the point.
If something doesn't make sense, ask Claude to explain it. Prompts like "explain what this Terraform resource block does" or "what is a Docker image vs a container?" are exactly how you should be working.
Environment Access
You'll need a cloud environment to deploy to. You are not restricted to any particular provider — if you'd prefer to use GCP, Cloudflare, Vercel, or any other platform, go for it.
That said, Liatrio has accounts on the following environments available for participants who want to use them:
Liatrio-Provided Environments
| Environment | Access |
|---|---|
| AWS (liatrio-forge account) | Log in to the AWS SSO Portal with your Liatrio Google account. Select the liatrio-forge account. |
| Azure (sandbox account) | Ask in #liatrio-forge for sandbox access. |
| Vercel (Liatrio's standard platform) | See the Vercel docs to get started. |
Use AI to help you install and configure whichever CLI tools your chosen provider requires.
These are shared environments. Tear down any infrastructure you create when you're done, including emptying and deleting any S3 buckets you created during the program. If you're using Terraform, use terraform destroy and follow the S3 cleanup steps under Destroying Your Resources below.
Naming Conventions for Shared Environments
These guardrails (naming, the Terraform workflow, and state management) apply when you deploy into the shared Liatrio cloud accounts above. If you're on Vercel or your own account, treat them as good practice rather than requirements.
Multiple forgers deploy into the same accounts. Without consistent naming, resources collide — someone's S3 bucket overwrites another's, or two people create the same IAM role. Follow these rules to keep things clean.
The Pattern
{resource-type}-forge-{your-identifier}-{purpose}
Examples:
| Resource | Good Name | Why |
|---|---|---|
| S3 bucket | s3-forge-jdoe-artifacts | Globally unique, clearly owned |
| ECS cluster | ecs-forge-asmith-petclinic | Identifies owner and project |
| Azure resource group | rg-forge-mjones-pipeline | Follows Azure rg- convention |
| IAM role | role-forge-jdoe-deploy | Won't clash with other forgers |
Rules of Thumb
- Always include your identifier — use your name, GitHub handle, or initials. This is the suffix that prevents collisions.
- Keep total length under 40 characters — Some AWS resources cap at 63 characters, but S3 bucket names are global and IAM role names get embedded in ARNs. Shorter is safer.
- Lowercase letters, numbers, and hyphens only — No underscores, no camelCase. This is the safest character set across AWS, Azure, and GCP.
- No generic names — Names like
dev-bucket,test-cluster, ormy-appwill collide with another forger. If it doesn't contain your identifier, rename it. - Tag everything — Add a
forgertag (or label in GCP) with your name and aprojecttag with your app name. Tags make cleanup and cost tracking possible.
# Terraform example — always tag your resources
resource "aws_s3_bucket" "artifacts" {
bucket = "s3-forge-jworkman-artifacts"
tags = {
forger = "jworkman"
project = "petclinic"
module = "4"
}
}
Some resources — S3 buckets, Azure Storage accounts, GCP project IDs — must be unique across the entire cloud provider, not just your account. Your identifier suffix handles this, but double-check before applying if you get a "name already exists" error.
Terraform Workflow: Plan Before You Apply
In a shared account, a careless terraform apply can modify or destroy someone else's resources. Always review what Terraform intends to do before letting it act.
The Safe Workflow
# 1. Format your code (catches syntax issues early)
terraform fmt
# 2. Validate configuration (checks for errors without touching the cloud)
terraform validate
# 3. Preview what will change — READ THIS OUTPUT CAREFULLY
terraform plan
# 4. Only after reviewing the plan, apply the changes
terraform apply
What to Look For in terraform plan
The plan output shows three types of changes — pay attention to each:
| Symbol | Meaning | Risk Level |
|---|---|---|
+ (green) | Resource will be created | Low — but verify the name follows conventions |
~ (yellow) | Resource will be modified in-place | Medium — confirm it's your resource |
- (red) | Resource will be destroyed | High — make sure it's not someone else's |
When terraform apply prompts you to confirm, read the summary line. If you see resources being destroyed or modified that you don't recognize, type no and investigate. In a shared account, Terraform will happily destroy resources it didn't create if your state file or configuration drifts.
Destroying Your Resources
Before you tear down your infrastructure (see Clean Up Your Resources above), make sure you're only destroying your own resources:
# Preview what will be destroyed — verify it's only YOUR resources
terraform plan -destroy
# Only after reviewing, tear it down
terraform destroy
If you're unsure whether a resource is yours, check its tags or name for your identifier before proceeding.
S3 bucket cleanup: Buckets must be empty before they can be deleted. Don't assume terraform destroy removed every bucket, especially buckets created manually or used for Terraform state.
-
List buckets in the AWS account you're using for the program:
aws s3 lsLook for your identifier (for example,
s3-forge-jdoe-artifacts) and confirm ownership using names and tags. Only empty and delete buckets you created — this is a shared account. -
Empty each of your buckets. This permanently deletes its contents, so save anything you need first.
-
Non-versioned buckets: Replace
<bucket>with your bucket name to empty and delete it:aws s3 rb s3://<bucket> --force -
Versioning enabled or suspended: You must delete all object versions and delete markers, not just current objects, or bucket deletion will fail. In the S3 console, select your bucket and choose Empty, which removes versions and delete markers, then choose Delete once empty. The CLI
--forcecommand above does not remove versioned objects.
-
-
Run
aws s3 lsagain to check for any program buckets you still own. Delete your Terraform state bucket last, only afterterraform destroyhas finished and no resources still depend on that state.
Terraform State Management
Terraform tracks what it has created in a state file (terraform.tfstate). This file is how Terraform knows the difference between "create a new bucket" and "that bucket already exists." Mismanaging state is one of the most common infrastructure foot-guns — especially in a shared account.
Rules
-
Never commit state files to Git. Add this to your
.gitignoreimmediately:*.tfstate
*.tfstate.*
.terraform/ -
Use a remote backend. Local state files only exist on your machine. If you lose them, Terraform loses track of what it created — and you'll have orphaned resources in the cloud with no easy way to clean them up. A remote backend stores state in the cloud where it's durable and lockable.
AWS example (S3 + DynamoDB for state locking):
terraform {
backend "s3" {
bucket = "s3-forge-jdoe-tfstate"
key = "petclinic/terraform.tfstate"
region = "us-east-1"
dynamodb_table = "dynamodb-forge-jdoe-tflock"
}
}Note: The S3 bucket and DynamoDB table must exist before you configure the backend. Ask Claude to help you create them.
-
One state file per project, per person. Your state should only manage your resources. If two forgers share a state file, Terraform will try to reconcile both sets of resources — and will destroy anything it doesn't find in the configuration.
Ask Claude: "Explain Terraform state to me like I've never used IaC before. Why does it matter and what happens if I lose it?" — this is exactly the kind of conceptual question AI handles well.
When to Escalate
Infrastructure problems can affect the whole shared account, not just your project. Escalate immediately in #liatrio-forge if:
- You can't delete resources you created (stuck
terraform destroy) - You see unexpected charges or resources you don't recognize in the cloud console
- You get permission errors that seem account-wide, not scoped to your resources
terraform applyis trying to modify or destroy resources that aren't yours- You accidentally deleted someone else's resources
Don't try to fix account-level issues alone. A quick message in Slack can prevent a small mistake from becoming a big one.
If you need help getting access to any of these environments, reach out in #liatrio-forge.
Exercises
Pipeline from Scratch Challenge
Take your application and get it from zero to deployed automatically:
- Write a Deployment Spec describing the target architecture
- Use AI to generate Dockerfiles, Kubernetes manifests, or Terraform scripts
- Create CI/CD workflow files with AI assistance
- Deploy to a test environment
- Debug any issues using AI
If you've never built a pipeline before, don't try to do everything at once. A good progression:
- First: Get a GitHub Actions workflow that builds and tests your app on every push — this requires zero cloud infrastructure
- Then: Add a Dockerfile and get the workflow to build a container image
- Then: Add Terraform to provision a place to run it (e.g., an ECS service, an Azure Web App, or even a simple EC2 instance)
- Finally: Wire the pipeline to deploy automatically on merge to main
Each step is a meaningful deliverable on its own. Ask Claude to help you with any step — try "Generate a GitHub Actions workflow that builds and tests a Spring Boot Maven project" as a starting point.
Friction Hunt & Automation Sprint
- Identify top sources of friction in your development workflow
- Choose one issue to solve
- Build a solution using AI:
- Automation script for environment setup
- Test data generator
- Internal chatbot for documentation search
- Self-healing infrastructure script
- Cover it in one of your weekly demos — no separate presentation, just fold it into the Demo Your Pipeline recording below
Demo Your Pipeline
Record a demo (5-10 minutes) showing:
- Your automated pipeline in action
- The infrastructure code you generated
- How AI helped you build it
- Any friction you eliminated
Post it to #liatrio-forge-demos as one of your twice-weekly demos — this is also where you cover the friction point from the Friction Hunt exercise above.
Deliverables
By the end of the DevOps & Platform Module, you should have:
| Artifact | Description |
|---|---|
| Spec docs | Specifications for pipeline/infrastructure — kept in your repo |
| Task breakdowns | How you decomposed the work — kept in your repo |
| PR links | Infrastructure code (Terraform, CI/CD config, etc.) — live in GitHub |
| Test output | Proof of successful build/deployment runs — kept in your repo |
| Demo recording | Walkthrough of your pipeline, approach, and friction eliminated — posted to #liatrio-forge-demos |
| Short retro | What changed — focus on friction removal and flow acceleration — kept in your repo |
Everything except the demo recording just needs to be up to date in your repo and available if a facilitator asks to see it — there's no formal drop box.
Exit Criteria
You can move to the Capstone Module when you have:
Built a working pipeline or Infrastructure-as-Code deployment slice.
Your pipeline should automatically build, test, and deploy your application. You should have eliminated at least one source of friction and be able to demonstrate the improvement in a #liatrio-forge-demos post.
What You'll Learn
By completing this module, you'll have experienced:
- Compressing weeks of infrastructure work into hours
- Friction removal — eliminating toil through automation
- Acceleration of flow — faster feedback, faster delivery
- Using AI for operations, not just development
You've essentially created an internal developer platform prototype where the software lifecycle is automated with AI.