Hyperautomation and Agile Delivery:

How will it impact your team and your flow?

By Chantelle Gallagher, Sr. Business Analyst | Published: May 4, 2023 in Blog

As development organizations assess the potential of using tools to Hyperautomate their time to delivery, at Intelliware we decided to focus on how these changes impact the team as a whole. How does Hyperautomation change the flow of work? How will the role of the Product Owner, Developer, User Experience Analyst, and User Interface Analyst change? To better understand the impact that Hyperautomation can have on the team beyond how code is generated, Intelliware created a cross functional project team to implement a solution that tracks Developer skill sets over time. There are many tools available to help achieve Hyperautomation, including AI/ML, RPA, Platforms as a Service, low code/no code solutions, and code generation. We chose to implement an approach to generate user interface code directly from high-fidelity Figma designs. While working on this project, our team discovered some adjustments were needed to how work flowed, some roles were able to eliminate repetitive and unrewarding work, and we discovered some training opportunities that we didn’t predict.  

Lesson One: Mock-ups before Detailed Requirements. 

Traditionally, the flow of work in an Agile Delivery methodology goes (something) like this: 

  1. Define the high-level functional requirements (call it the Epic level, Feature level, or whatever term your organization prefers) 
  2. Start working on some wireframes, maybe some mock-ups. 
  3. Define and sign off on User Stories that have a medium to high amount of detail on expected behaviour. 
  4. Get signoff on mock-ups, now that you really know for sure what the solution needs to do. 

We found that the following flow works better with Hyperautomation: 

  1. Define the high-level requirements. 
  2. Work on wireframes, then start on mock-ups with a lot of detail. 
  3. Define User Stories with a medium or low amount of detail on expected behaviour. 
  4. Get signoff on User Stories and mock-ups simultaneously. 

Why do we find this change to be useful? The mock-ups that are created by the UX/UI team, in a tool such as Figma, need to be pixel perfect and take advantage of every possible parameter and variable that can be defined for Hyperautomation to work as efficiently as possible. The more precise the information being consumed by the Hyperautomation solution, the less manual effort is required by Developers to update the code and create efficient test. The mock-ups then become the source of testing and developer truth with the User Stories referenced more as a way for the Business to understand what functionality is being delivered and for the Delivery team to understand the definition of done. 

Lesson Two: UX and UI team members need to work closer than ever with Developers.  

When the UI team members are naming elements and components and defining parameters, it is to everyone’s advantage if they work in step with the terminology used in the Developers’ chosen implementation solution. This will result in requirements that are easier to consume by the Hyperautomation tools. Developers in turn can see which information their code needs to be able to absorb and translate, reducing manual coding. Your project will move forward more efficiently. As well, if the work can be completed following not just that team’s best practices, but the corporate best practices (where they exist) the mock-ups and associated code can more easily be re-used in future projects across the company.  

This lesson does mean that more time may be needed to onboard or train new UX and UI team members, to ensure they are familiar with the standards used by the Development team. Similarly, new Developers may need training time with the mock-up tool of choice to know what information can be gleaned from what the UX and UI team have created. This time is well worth the effort as more and more common components are created. This leads us to our third lesson. 

Lesson Three: Focus on Hyperautomation of your foundational components. 

We all know that the first milestone for any Agile project is to build your MVP, or the Minimum Viable Product, that will add value for the client. This goal is even more important when building with Hyperautomation tools.  We found that if you start by defining, then building the components that will be used most often within the project, future work will flow faster.  The project team will be able to deliver value beyond the MVP more quickly once the common building blocks have been created. 

By building a library of Hyperautomation ready mock-ups for foundational components such as headers, footers, search widgets, search result tables, and login pages, future projects and product enhancements can ramp up faster. Best practices, such as accessibility standards, can be baked in, ensuring high quality across the components and in every deliverable, reducing the chance of inconsistencies from different teams. As new standards emerge, the library can be updated proactively. Developers can then deliver more valuable, updated solutions faster, as they can quickly re-run the Hyperautomation scripts to implement these common building blocks. 

Lesson Four: User Story delivery will be higher level, focusing on exceptions and new functionality. 

For the Product Owner, Hyperautomation can mean a change in the order in which stories are defined and prioritized, as well as what each story details. This is particularly true when starting a new project. Currently, without Hyperautomation, the stories in the first few sprints of a project tend to focus on environment set up and then creating the basic building blocks of the solution. For example, there may be the following stories: 

  1. Set up the Dev environment. 
  2. Implement the header and footer. 
  3. Implement the navigation solution including left menu. 
  4. Implement the search function. 
  5. Implement the search results table. 

We have found that once foundational mock-ups have been created and implemented, the stories in the first sprints of a project can begin to deliver greater functionality with less effort. Typically, the stories would focus on: 

  1. Set up the Dev environment. 
  2. Copy the existing mock-ups and implement any design differences.  
  3. Implement the landing page, using the pre-existing components for header, footer, navigation, search, and search results.  
  4. Implement the following changes to the pre-existing search results component. 
  5. Implement the following new function: Validate User 

Product Owners can now focus on creating stories that add value. These new stories may result in new components that can then be added to the Hyperautomation library, adding even more efficiency in the future. 

At Intelliware, our Delivery team members have embraced our Hyperautomation experiences. Hyperautomation takes us beyond implementing code efficiently; it encourages better cross-functional communication, new learning opportunities, faster time to delivery, and a reduction in repetitive tasks for the Business and UX/UI team.  

Contact Intelliware today to learn more about how our Hyperautomation experience can help your team move forward faster.

More recent stories