Shipping updates to our iOS and Android applications is an important, coordinated multi-step process that requires numerous stakeholders to be involved. In this post, we'll detail how we use Microsoft Power Automate to better orchestrate our app release workflow.
The Problem
Attempts had been made previously to document the steps required for a release including activities such as briefing change management, creating new builds of the application and sourcing App Store metadata like screenshots and release notes. This had been done in internal wikis and knowledge bases, but we always found that the documentation quickly became outdated or people weren't sure where to find it.
Often critical steps in the release workflow were missed, there was no easy way to visualise how the release process was tracking and there was frequent confusion about who needed to sign off on what. Additionally, there was also a lot of manual follow-up required to prompt stakeholders to provide the information we required or obtain their sign-off for release. There was also limited audit tracking in the event we needed to follow up with someone about an approval.
Since we also make use of a mobile backend-for-frontend (BFF) - effectively an API for the mobile app - it's important that the app developers know that it has been deployed and has passed our quality assurance activities prior to the apps being submitted for review.
Our Solution
We've now been successfully using a Microsoft Power Automate (formerly Microsoft Flow) workflow to orchestrate our release process, automatically seeking approval from the relevant stakeholders.
The workflow takes care of notifying app developers once this is complete, alerting them that they can create app release builds and to submit the update for review. It also gives us a visualisation as to how each release is progressing.
The process of creating app builds and deploying the BFF is automated where possible via our separate continuous delivery and integration pipelines.
For those that aren’t familiar with Power Automate, it’s a tool provided by Microsoft to automate repeating tasks or business processes. Flows start with a trigger that can be automatic (eg. a form being submitted) or manually invoked by a user, and they can then use a number of out-of-the-box connectors to perform actions.
We decided to explore using Power Automate as a way to coordinate approvals and better document the manual steps required within our release workflow because it's a tool that was already available to us at AGL, and it’s deeply integrated within the Microsoft ecosystem that we rely on heavily.
So how does it work for us? Before creating a release, we identify and document the following key pieces of information such as:
- App version number
- Summary of changes included in the release (formal release notes are provided later, this is just a summary for internal use only)
- Feature flags to be enabled for the release
- Developer(s) that will be managing the release - typically we have one rotating developer from each platform
- Start and end dates that we’re going to target for the release
- Some Jira admin information, such as the fix version number
Once compiled, this information is entered into a Microsoft Form that kicks off our Power Automate workflow. We then worked through our existing, documented release process to identify what actions should form part of our Automate workflow. Some became approval tasks in the Microsoft Teams Approvals app, while others turned into Flow bot tasks to post messages and adaptive cards automatically to our release channel on Microsoft Teams.
For example, where we’d previously have to chase release notes from the relevant stakeholders they now automatically receive an alert in Microsoft Teams asking them to provide the notes or screenshots. Once provided, they are uploaded and then sent to the relevant stakeholders for use in the app submission process.
Each step clearly articulates what is expected to be done before the task is approved, so stakeholders can be sure that all required steps are followed.
It’s important to note that while most of our release tasks are automated using our continuous integration pipelines, some manual tasks and approvals remain. Over time we hope to continue refining our release workflow and incorporate further automations to reduce the number of manual interactions, particularly when it comes to tasks related to Jira and app submission.
Limitations
While we’re happy with the initial flow, there’s a number of issues we’ve run into while building and using it. Firstly, there’s no Microsoft-endorsed way to edit the pipeline as code. Instead, you’ll need to use the web user interface to make any changes that are required or use the newer AI capabilities that Microsoft have recently added to Power Automate.
For straightforward, simple pipelines this is probably acceptable - but we’ve run into buggy behaviour with the UI numerous times while trying to make changes to our pipeline. It’s worth noting however that there are now a few third-party apps that have jumped in to fill this gap and allow you to edit pipelines as JSON with various degrees of success.
There are also limited ways to obtain information from people once a flow has commenced. For our purposes, we need to capture the information and then store it in flow variables that can be used later on. We’re working around this for now by using the approval task, and capturing the response as a variable.
And lastly the flow that we have today isn’t particularly well-suited to doing platform-specific releases, such as hot fixes. For that we have a more light-weight process that doesn’t require the full flow to run, but moving forward we’re looking at ways that we can also support these types of releases with Power Automate.
Results
Since rolling out the flow, we’ve significantly reduced the confusion around our release process while streamlining the process to gather the information we require for the update submission process. We no longer have any issues with steps being missed, and the team members managing the release know exactly what needs to be done and when.
Because of the workflow and detailed steps and approvals, it's also enabled us to now shuffle the release coordinator role between people in the team, something we'd previously struggled to do because of the intricate knowledge required.
While our flow might not have all the same capabilities that newer release management tools such as Runway offer, for us the deep integration with the Microsoft ecosystem is something that has served us well.
One added benefit is that because flows also show you the time duration of each task, we’re also able to easily identify bottlenecks in our process and implement changes to optimise and address them where we can.
