Streamlining Excellence: Navigating Our Mobile App’s Functional Review Process

In today’s fast-paced world, mobile app development is a constant race to innovate, iterate, and deliver a flawless user experience. To achieve this, a seamless functional review process is essential. In this article, we’ll explore how to streamline this process using a combination of GitHub Actions, and Expo updates, making your development workflow more efficient and reducing the time to market for your mobile apps.

The Importance of a Robust Functional Review Process

Before we dive into the technical details, let’s emphasize the significance of a robust functional review process. This process ensures that your mobile app meets quality standards, is free of critical bugs, and provides a consistent user experience. Failing to establish an effective review process can lead to user dissatisfaction, revenue loss, and damage to your app’s reputation.

Leveraging GitHub Actions for Continuous Integration

GitHub Actions is a powerful tool that allows you to automate various tasks in your software development workflow. By integrating GitHub Actions into your mobile app development process, you can automate build and testing procedures, ensuring that every code change is thoroughly evaluated.

1. Setting up GitHub Actions Workflow: Create a GitHub Actions workflow that triggers every push to the main branch. This workflow should include steps for building the app, running tests, and generating artifacts.
2. Automated Testing: Incorporate automated testing suites into your workflow. This ensures that new code changes don’t introduce critical regressions. Consider using popular testing frameworks like Jest for React Native apps.
3. Code Linting: Include code linting and prettier check tools to maintain code quality. Tools like ESLint and TypeScript can catch potential issues early in the development process.
4. Static Analysis Using external statics analysis check to maintain clean code, and detect duplications and code smells
5. Translations report check if our apps maintains consistency between translations in differents languages
6. QR Code generation for human overview of the task. I’ll explain later in this articles

Expo Updates for Effortless Over-the-Air Updates

Expo is a helpfull tool for React Native development, offering a range of features that simplify the app development process. One standout feature is Over-the-Air (OTA) updates, which allow you to deliver updates to your app without requiring users to download a new version from an app store.

1. Implementing Expo Updates: Configure your app to use Expo updates. This enables you to push critical bug fixes, performance improvements, and new features to users quickly.
2. Version Management: Maintain a clear versioning strategy for your app. Use semantic versioning to ensure consistency and clarity when rolling out updates.
3. Automated the functional review process: integrated with github actions help the team in DaVinci to stay aligned on the development of the product

# 1. Setup node
# 2. Setup Expo
# 3. Load dependencies
# 4. Publish eas update on banch
- name: Publish eas update on branch
  id: preview
  run: |
  yarn workspace <project-name> eas update 
    --branch=${{ github.head_ref }} 
    --message="Preview of branch ${{ github.head_ref }}"
  EAS_UPDATE_URL="<app-bundle-id>://expo-development-client/?url=https://u.expo.dev/<app-identifier-in-expo>&channel-name=${{ github.head_ref }}"
  URL_ENCODED_UPDATE_SCHEME="$(node -e "console.log(encodeURIComponent('$EAS_UPDATE_URL'))")"
  QR_IMG_URL="https://api.qrserver.com/v1/create-qr-code/?size=128x128&data=$URL_ENCODED_UPDATE_SCHEME"
  echo "eas-update-url=$EAS_UPDATE_URL" >> $GITHUB_OUTPUT
  echo "eas-update-url-qr-url=$QR_IMG_URL" >> $GITHUB_OUTPUT
# 5. Comment deployment link with QR code

The Agile process

Our Agile process for introducing new functionalities into production consists of these simple steps:

1. PM & Marketing: Propose and introduce a new service/feature to our app.
2. Project Manager (PM): Decide how to distribute different types of tasks between designers and developers.
3. Designers: With the use of Figma designers create new screens and components for development. Include this information in a story within a Kanban board.
4. Developers: Develop the assigned task. Request another developer to review their code.
5. Designers (Post-Development): Participate in a functional review to ensure that programmers have correctly implemented the task.
6. Pull Request (PR) Process: When a developer opens a Pull Request on our repository, GitHub Actions automatically initiate.
   As part of these actions, a QR code is generated and added to GitHub comments and the corresponding task on the Kanban board.
7. DaVinci App Integration: Designers, using the installed DaVinci app, can scan the QR code to access the build associated with the code in the pull request.
8. Review and Approval: After reviewing the build, designers have the authority to approve the task, marking it as ready for merging into the main branch.

By following these streamlined steps, our Agile process ensures effective collaboration across all’s figures every team in our company, leveraging tools like Figma, GitHub Actions, and the DaVinci app to enhance efficiency and maintain the quality of our software development lifecycle.

The importance of humans in this process

The importance of human supervision during the functional review process cannot be overstated. While automated testing and code analysis tools play a crucial role in identifying potential issues and ensuring code quality, human intervention adds a layer of nuanced understanding and critical evaluation that is irreplaceable.

Incorporating human supervision into the functional review process brings several advantages. Firstly, human reviewers, particularly designers who have an intimate knowledge of the app’s user interface and design principles, can assess the user experience comprehensively.

• They can identify subtleties and nuances that automated tools might overlook, ensuring that the app not only functions correctly but also provides a seamless and intuitive experience for end-users.
• Secondly, human reviewers contribute to the detection of potential design inconsistencies or deviations from the established design guidelines.

This human touch is invaluable in maintaining a cohesive and visually appealing user interface, aligning with the overall user experience strategy.

Furthermore, human supervision ensures that the functionality aligns with the initial design intent and user requirements. Designers can evaluate whether the implemented features meet the project’s design specifications and whether any adjustments are needed to enhance usability or visual aesthetics.

In summary, the inclusion of human supervision in the functional review process acts as a crucial checkpoint to guarantee that the app not only meets technical requirements but also excels in user satisfaction and aligns with the overarching design vision. This blend of automated tools and human expertise creates a robust and comprehensive evaluation process, ultimately leading to the delivery of a high-quality and user-friendly product.

A streamlined functional review process is the backbone of successful mobile app development. This approach not only improves the quality of your app but also accelerates your time to market, giving a competitive edge in the dynamic world of mobile app development.