AI DevOps Automation Platform

How I turned an expert‑only infrastructure tool into something engineers could pick up on day one, without taking any power away.

The story in 30 seconds

🔒 NDA case study. The client, product name, brand, screens and numbers on this page have been changed or recreated. The problems, my process and my design decisions are real.

A powerful cloud automation platform was losing people at three moments: setting up a service, checking its health, and getting unstuck. I researched how engineers actually worked, then redesigned those moments around one idea: reduce, prevent, explain.

The result was a guided setup flow, a monitoring view that answers questions instead of listing data, and an in‑product assistant that earns trust by showing its work.

3× Faster

Service setup in moderated test runs.

4 Short steps

Instead of one crowded configuration screen.

Training-Free UX

New engineers deployed on day one, without shadowing.

Confidential

Confidential

Due to client confidentiality, real product screens and internal architecture cannot be displayed. This case study focuses on UX thinking, product decisions, and problem-solving.

01 · The tool everyone needed and nobody enjoyed

A growing B2B company had built a low-code platform that lets engineering teams ship cloud infrastructure with security and compliance baked in. Under the hood it was impressive. On the surface it felt like a cockpit: dense forms, raw configuration boxes and dashboards that showed everything at once.

Senior engineers had learned to live with it. New hires needed weeks of shadowing. And every mistake, like a mistyped image name or a secret pasted in plain text, only surfaced after a deploy failed.

The ask was simple to say and hard to do: make it easier without making it weaker.

02 · Where I came in

I joined as the product designer embedded with the platform's engineering and product leads, working across two time zones. I owned the experience end to end:

• planning and running the research
• mapping the infrastructure workflows
• redesigning service setup, monitoring and in‑product help
• prototyping and testing with engineers
• laying the foundations of a shared design system

I wasn't a DevOps engineer, so my first job was to learn the domain well enough to ask good questions.

03 · Listening before drawing

I interviewed senior engineers who set up and run customer environments every day, then ran a full‑day workshop with the product team to map core tasks and agree on priorities. Afterwards I went deep on the one flow that came up in every conversation: adding a new service.

Six themes kept repeating:

• Hunting for inputs: values live in spreadsheets, old services and chat threads
• Late, vague errors: mistakes appear after deploy, far from the cause
• Everything feels equally important: rare options sit next to essential ones
• Trust needs visibility: automation is welcome only when it explains itself
• Dashboards without answers: lots of data, little direction
• Help lives elsewhere: troubleshooting means leaving the platform

That gave the team three principles to design against: reduce, prevent, explain.

04 · Three moments that hurt the most

Instead of polishing every screen, I focused on the three moments where engineers lost the most time and confidence.

• Setting up a service: one long page, no guidance, feedback only when it was too late
• Checking health: monitoring that showed data, not decisions
• Getting unstuck: help that lived in other tools and other people's heads

Everything else in this story comes back to these three moments.

05 · Decision 1: Break the wall of fields

I split service setup into four short steps: Source, Runtime, Config and Review.

Then I sorted every field into one of three tiers, so people only see what matters right now:

• Always visible: what's required to deploy
• Suggested: pre‑filled with sensible defaults, still editable
• On demand: advanced options, collapsed until needed

The choices behind the new flow

• Pick, don't type. Image tags, secrets and config values are chosen from what actually exists, which removes a whole class of typos.
• Form and YAML stay in sync. Experts worried about losing control, so they can switch to YAML at any point and the two stay identical.
• Check before deploy. A live checklist confirms prerequisites, and every warning comes with a one‑click fix.
• Safe by default. Plain‑text secrets, missing limits and quota overruns are caught while you type.

The trade‑off I argued for: a few more clicks for experts in exchange for far fewer failed deploys. In testing, experts didn't mind once YAML stayed one click away.

Result: in moderated test runs, setup became roughly three times faster, and the most common mistakes stopped reaching deploy.

06 · Decision 2: Show the answer, not the data

The old monitoring view was a wall of charts. I reorganised it around one question: what needs my attention right now?

• Four headline numbers: availability, services at risk, latency and spend
• A health heatmap that turns hours of metrics into one scan
• A "what changed" feed that links each problem to its likely cause, such as a deploy
• Deep‑dive tools one click away instead of on the main screen

Engineers could tell in seconds whether something was wrong, and where to look next.

07 · Decision 3: Bring help to where the problem is

Engineers often left the platform to search docs, open tickets or ask a colleague. I designed an assistant that opens as a drawer inside the page you're on, already aware of the service and environment.

I designed it around trust:

• It shows what it checked before giving an answer
• Proposed changes appear as a clear diff
• Nothing runs without approval, every change can be undone, and everything is logged

Looking further: from assistant to agents

The same patterns became the foundation for a bigger vision: AI agents that plan and carry out multi‑step DevOps work.

I structured that experience as goal → plan → steps → review, so people always see where an agent is, what it will do next, and when to step in. Conversation stays the main interface, but every action is visible and reversible.

08 · What changed

• Faster, safer service setup with far fewer failed deploys
• New engineers productive without weeks of shadowing
• Monitoring that points to the problem instead of burying it
• In‑product help that cut the back‑and‑forth across tools
• A shared design language the team now extends to other modules

The product team signed off the redesign for build, and it became the reference for how new modules are designed.

09 · What I'm taking with me

• Automation earns trust by explaining itself. Showing what the system will do mattered as much as doing it.
• Experts want clarity too. Simplifying choices helped senior engineers as much as newcomers.
• Hide depth, don't remove it. Progressive disclosure kept the power without the noise.
• Design next to engineering. Weekly reviews with engineers kept every idea buildable.

Good UX in DevOps isn't about removing power. It's about making complexity feel manageable.

Next up: testing with real customer teams, micro‑interactions, and extending the design system to every module.

Create a free website with Framer, the website builder loved by startups, designers and agencies.