IBM
2026
Release Orchestrator for Z
Collapsing a twelve-step mainframe release into something one person can hold in their head. A release manager's all-in-one tool to scheduling and deploying complex releases to international bank mainframes reliably

Overview
Making financial data easier to understand
Release Orchestrator for Z is a coordination layer that schedules, sequences, and governs when and in what order mainframe z/OS application deployments happen. This tool connects the teams, approvals, and compliance evidence that make a release safe to ship.
This product is designed to provide a clear understanding of what will run, in what order (dependency-aware sequencing), to which environment, and with what outcome evidence for audits.
Release confidence — ensuring deployments are not just automated, but fully transparent, predictable, auditable and repeatable.


Release Orchestrator is the tool for IBM's code deployment workflow and supports deploying, testing, and monitoring functions
Situation
How do we design a tool that allows the user to organize, schedule, test, and deploy complex releases with confidence?
Today there is no single system that coordinates a mainframe release across multiple application teams. Scheduling is manual, dependency ordering lives in someone’s head, approvals happen in email, and the compliance evidence trail is pieced together after the fact, meaning releases are slower, riskier, and harder to audit than they need to be.
Complex deployments across teams introduce new problems:
Problem #1
No centralized release coordination
Problem #2
No process for teams to contribute
Problem #3
Critical aspects such as ordering, dependencies, configuration resolution, and evidence generation remain implicit—spread across artifacts and learned behavior rather than presented as a single, deterministic flow.
Result: Reduced confidence in large releases

Research
Designing for the client's needs and future wants
To better understand where friction exists in deploying releases onto the mainframes for the major banks, we held two workshops with our internal and external stakeholders to ask questions to better understand the problems they are facing at work. Our team designed a quick demo using IBM Bob to talk through what could exist in the product, what features would be helpful, and who these features would be used by at their companies.


Outlined personas to ground product workflows
Problem mapping and prototyping
Our team outlined the problem areas shared by the stakeholders and deeper research performed by the user researchers to gain an understanding of opportunities. We then pivoted to designing different versions of possible product directions that we built in a demo to share and get feedback.

ZDAC & ZDC Workshop with Citibank, JPMorgan, and General Electric
Through interviews and workflow analysis, I identified recurring patterns in how users reviewed balances, tracked transactions, and navigated everyday financial tasks. The biggest issue wasn’t financial complexity itself — it was uncertainty. Users often stopped to compare balances, reopen transaction details, or rescan multiple sections before taking action. Similar visual weight across the interface made it difficult to quickly identify what mattered most.

...I like this <Deb2 DevOps Experience for z/OS> and the only thing that I don't like.... is the fact that it is different license product... this could be a part of Db2...

Interview participant
GE release manager
We have a different way we structure our packages so we will need a product that supports different workflows.

Interview participant
Bank IT employee
Our deployments can get very complex very quickly and it has been even harder since we had a corporate restructuring.... We have many teams working on different parts of our quarterly releases so finding any errors and locating who owns which part of the deployment has been a major issue.

Interview participant
Bank IT employee
Planning
Designing complexity and modularity
At IBM, I served as a user researcher and designer, helping to research, design, and develop the Release Orchestrator product end-to-end. Working with developers and project managers, I synthesized AI mockups, code, and README files to create a list of requirements for the product with multiple users and build the information architecture for version 1.0.

1. First generated prototype used to share with stakeholders for idea buy-in 2. Code examples of content needed to define deployments 3. Lowfi sketches of output from Wazi Deploy to incorporate into Release Orchestrator for language consistency
Testing with the information architecture
Before moving into high-fidelity designs, I tested early interaction flows using low-fidelity paper prototypes. These quick sessions helped validate navigation patterns, layout hierarchy, and task completion behavior before investing time into polished UI design.

Integrating multiple user needs
Another part of the product was to add a user management feature for each company's Release Orchestrator manager controls. Based on conversations with our product stakeholders and our internal developers, we designed 3 user profiles: admin, viewer, and contributor.

Results
Centering release confidence in a fully branded product
This tool was release in September 2026 for users of Wazi Deploy like UBS, Principal Bank, and General Electric, JPMorgan, and Citibank. The tool connects Wazi Deploy tools to a company's mainframe IT workflow and builds a more transparent and adaptable interface for plannning releases that would otherwise be hidden inside the mind of one individual.





Design to AI developer handoff
Typically, for a product, Design would build the flows in Figma and annotate them to hand off the screens and configurations for the front-end developers to read and work from. However, because of the speed of work and the leanness of the team, we could not use the typical workflow.

Because of the complexity of the project, I began to design a new process for developing with AI using the design tools that existed. Upon investigation, the current prototype was too complex (and so inefficient) for IBM Bob to read and build on for future iterations.

I then began to test which workflow would be the most efficient and provide the best output that aligns with the Carbon design system and is scalable for the development team.
Figma file configuration:

Created functional prototype links for each of the workflows starting from the same screen with multiple outcomes such as dialog boxes, notifications, and navigation tabs. These links were later fed into IBM Bob and the IBM Spec Builder
The workflows:

Test 1: Figma prototype link + MCPs into IBM Bob

Test 2: MCPs, Figma link, and Spec Builder documentation into IBM Bob

The AI tool to fine-tune AI: IBM Spec Builder
Using existing Figma prototype links and Carbon brand system data for AI to break down and create documentation based on each workflow
Building guardrails for consistent, reliable output: Workflow description, functions, features, and experiences

PDF Documents created by IBM Spec Builder for AI and developer use (.md file is created for AI to more efficiently digest)
The new workflow
The current process for developing products with IBM's AI (Bob) used Figma MCP, IBM's Carbon MCP, and a Figma prototype link, but the output was still not completely Carbon-compliant, which could cause some confusion when building further upon the product in later versions or lose confidence because of a lack of IBM's brand identity.

Reflection
Looking back and moving forward: integrating AI in the design grading process
Building efficiency in the design-to-dev team handoff experience
The Spec Builder + Figma handoff process improved Bob's design-interpretation accuracy by 60% and increased token efficiency by 33%, a measurable improvement to the design-to-code pipeline itself, not just the product it shipped.
One thing I am looking to improve on: designing an evaluation tool for testing a product across multiple users
A difficult part of this project was designing for the needs of so many possible users and juggling the kinds of information and actions they would need access to with Release Orchestrator. Ideally we would have focused user testing group of people with these different job responisbilties test the product and evaluate, however with such a fast turn around time we were limited in our number os rounds of user testing. With this constraint, I build an evaluate tool using IBM Bob with the user persona information from our research team and the Mural board I created of the different ways we could evaluate each of the worklfows. The tool is still being refined, but is a step in the direction towards utilizing AI in aiding designers.

Video showing IBM's Bob evaluating each workflow with the testing questions created in the research phase, and assigning a percentage grade for each of our 4 personas




