Before you start

• An API token: create one at https://portal.testapp.io/profile/tokens
• Your App ID: open your app in the portal (https://portal.testapp.io/apps), go to Integrations → Releases, pick any tool, and copy the App ID from the setup panel.

Option 1: Upload with ta-cli (easiest)

Install ta-cli once:

curl -Ls https://github.com/testappio/cli/releases/latest/download/install | bash

Android

cd android && ./gradlew assembleRelease && cd ..
ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=android --apk=android/app/build/outputs/apk/release/app-release.apk --git_release_notes=true --notify=true --source="React Native"

Release signing is covered in the React Native docs: https://reactnative.dev/docs/signed-apk-android

iOS

Testers can only install an IPA signed with an Ad Hoc or Development profile that includes their devices. Archive and export the IPA from Xcode (Product > Archive > Distribute App > Ad Hoc) or with fastlane, then upload it:

ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=ios --ipa=/path/to/YourApp.ipa --git_release_notes=true --notify=true --source="React Native"

Option 2: Upload with the fastlane plugin

Already using fastlane? The TestApp.io plugin builds on the same ta-cli upload and fits into your existing lanes. It needs Ruby 3.0 or newer. See the fastlane plugin guide for every option.

Install the plugin from your project root (create the fastlane folder first with fastlane init if you don't have one):

fastlane add_plugin testappio

Add two lanes to fastlane/Fastfile. Lanes run inside the fastlane folder, so file paths start with ../. Replace YourApp with your Xcode workspace and scheme names:

lane :beta_android do
  sh("cd ../android && ./gradlew assembleRelease")

  upload_to_testappio(
    api_token:         ENV["TESTAPPIO_API_TOKEN"],
    app_id:            ENV["TESTAPPIO_APP_ID"],
    release:           "android",
    apk_file:          "../android/app/build/outputs/apk/release/app-release.apk",
    git_release_notes: true,
    notify:            true
  )
end

lane :beta_ios do
  build_app(
    workspace:     "../ios/YourApp.xcworkspace",
    scheme:        "YourApp",
    export_method: "ad-hoc"
  )

  upload_to_testappio(
    api_token:         ENV["TESTAPPIO_API_TOKEN"],
    app_id:            ENV["TESTAPPIO_APP_ID"],
    release:           "ios",
    ipa_file:          lane_context[SharedValues::IPA_OUTPUT_PATH],
    git_release_notes: true,
    notify:            true
  )
end

Run a lane with fastlane beta_android or fastlane beta_ios. To upload both files at once, use release: "both" and pass apk_file and ipa_file. The plugin marks the upload as coming from fastlane for you, so there is no source option to set. Signing for iOS is covered in Setup iOS Project for Fastlane.

In CI

Run the same commands as the last step of your pipeline and store the token and App ID as secret variables. We have guides for GitHub Actions, GitLab CI/CD, Bitbucket Pipelines, Codemagic, Bitrise, CircleCI, Jenkins, Azure Pipelines and Xcode Cloud.

Tip: Once your pipeline uploads a build, team members using the TestApp.io mobile app receive a push notification and can install the build with a single tap. You can also create share links to distribute builds to external testers and clients.

Need help? Contact us. we're happy to assist!

Before you start

• An API token: create one at https://portal.testapp.io/profile/tokens
• Your App ID: open your app in the portal (https://portal.testapp.io/apps), go to Integrations → Releases, pick any tool, and copy the App ID from the setup panel.

Option 1: Upload with ta-cli (easiest)

Install ta-cli once:

curl -Ls https://github.com/testappio/cli/releases/latest/download/install | bash

Android

flutter build apk --release
ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=android --apk=build/app/outputs/flutter-apk/app-release.apk --git_release_notes=true --notify=true --source="Flutter"

TestApp.io installs APK files. An App Bundle (.aab) is for the Play Store and cannot be installed directly on a device, so build an APK for testing.

iOS

Testers can only install an IPA signed with an Ad Hoc or Development profile that includes their devices. Signing setup is covered in the Flutter docs: https://docs.flutter.dev/deployment/ios

flutter build ipa --release --export-method ad-hoc
ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=ios --ipa=build/ios/ipa/YourApp.ipa --git_release_notes=true --notify=true --source="Flutter"

Replace YourApp.ipa with the file name Flutter prints at the end of the build.

Both platforms in one upload

ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=both --apk=build/app/outputs/flutter-apk/app-release.apk --ipa=build/ios/ipa/YourApp.ipa --notify=true --source="Flutter"

Option 2: Upload with the fastlane plugin

Already using fastlane? The TestApp.io plugin builds on the same ta-cli upload and fits into your existing lanes. It needs Ruby 3.0 or newer. See the fastlane plugin guide for every option.

Install the plugin from your Flutter project root (create the fastlane folder first with fastlane init if you don't have one):

fastlane add_plugin testappio

Add two lanes to fastlane/Fastfile. Lanes run inside the fastlane folder, so file paths start with ../:

lane :beta_android do
  sh("cd .. && flutter build apk --release")

  upload_to_testappio(
    api_token:         ENV["TESTAPPIO_API_TOKEN"],
    app_id:            ENV["TESTAPPIO_APP_ID"],
    release:           "android",
    apk_file:          "../build/app/outputs/flutter-apk/app-release.apk",
    git_release_notes: true,
    notify:            true
  )
end

lane :beta_ios do
  sh("cd .. && flutter build ipa --release --export-method ad-hoc")

  upload_to_testappio(
    api_token:         ENV["TESTAPPIO_API_TOKEN"],
    app_id:            ENV["TESTAPPIO_APP_ID"],
    release:           "ios",
    ipa_file:          "../build/ios/ipa/YourApp.ipa",
    git_release_notes: true,
    notify:            true
  )
end

Run a lane with fastlane beta_android or fastlane beta_ios. To upload both files at once, use release: "both" and pass apk_file and ipa_file. The plugin marks the upload as coming from fastlane for you, so there is no source option to set. Signing for iOS is covered in Setup iOS Project for Fastlane.

In CI

Run the same commands as the last step of your pipeline and store the token and App ID as secret variables. We have guides for GitHub Actions, GitLab CI/CD, Bitbucket Pipelines, Codemagic, Bitrise, CircleCI, Jenkins, Azure Pipelines and Xcode Cloud.

Tip: Once your pipeline uploads a build, team members using the TestApp.io mobile app receive a push notification and can install the build with a single tap. You can also create share links to distribute builds to external testers and clients.

Need help? Contact us. we're happy to assist!

Before you start

• An API token: create one at https://portal.testapp.io/profile/tokens
• Your App ID: open your app in the portal (https://portal.testapp.io/apps), go to Integrations → Releases, pick any tool, and copy the App ID from the setup panel.
• A pipeline that already builds your APK or IPA.

You can upload with ta-cli (the quickest way) or with the fastlane plugin if you already use fastlane. Step 1 applies to both.

1. Add repository variables

In Bitbucket, go to Repository settings > Pipelines > Repository variables and add:

• TESTAPPIO_API_TOKEN: your API token. Tick Secured so it is masked in logs.
• TESTAPPIO_APP_ID: your App ID.

2. Option 1: Upload with ta-cli (easiest)

Android

Add an upload step after your build step. The build step must list the APK under artifacts so the upload step can read it.

pipelines:
  branches:
    main:
      - step:
          name: Build APK
          # use the Android build image and commands you already have
          script:
            - ./gradlew assembleRelease
          artifacts:
            - app/build/outputs/apk/release/*.apk
      - step:
          name: Upload to TestApp.io
          script:
            - export INSTALL_DIR=$BITBUCKET_CLONE_DIR
            - curl -Ls https://github.com/testappio/cli/releases/latest/download/install | bash
            - $BITBUCKET_CLONE_DIR/ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=android --apk=app/build/outputs/apk/release/app-release.apk --git_release_notes=true --git_commit_id=true --notify=true --source="Bitbucket"

iOS

Building an IPA needs macOS. Bitbucket's hosted build machines run Linux, so the iOS build runs on a self-hosted macOS runner (https://support.atlassian.com/bitbucket-cloud/docs/runners/). The upload step is the same; only the file flags change:

      - step:
          name: Upload to TestApp.io
          runs-on:
            - self.hosted
            - macos
          script:
            - export INSTALL_DIR=$BITBUCKET_CLONE_DIR
            - curl -Ls https://github.com/testappio/cli/releases/latest/download/install | bash
            - $BITBUCKET_CLONE_DIR/ta-cli publish --api_token=$TESTAPPIO_API_TOKEN --app_id=$TESTAPPIO_APP_ID --release=ios --ipa=build/MyApp.ipa --git_release_notes=true --git_commit_id=true --notify=true --source="Bitbucket"

The IPA must be signed with an Ad Hoc or Development profile so it can be installed on test devices.

3. Option 2: Upload with the fastlane plugin

Already using fastlane? The TestApp.io plugin does the same upload from a lane. It needs Ruby 3.0 or newer. See the fastlane plugin guide for every option.

Create a Gemfile in your repository like this, then run bundle exec fastlane add_plugin testappio once on your machine (it creates fastlane/Pluginfile). Commit the Gemfile and the fastlane folder:

source "https://rubygems.org"
gem "fastlane"

plugins_path = File.join(File.dirname(__FILE__), "fastlane", "Pluginfile")
eval_gemfile(plugins_path) if File.exist?(plugins_path)

Add a lane to fastlane/Fastfile. Lanes run inside the fastlane folder, so file paths start with ../:

lane :upload_android do
  upload_to_testappio(
    api_token:         ENV["TESTAPPIO_API_TOKEN"],
    app_id:            ENV["TESTAPPIO_APP_ID"],
    release:           "android",
    apk_file:          "../app/build/outputs/apk/release/app-release.apk",
    git_release_notes: true,
    git_commit_id:     true,
    notify:            true
  )
end

Then replace the upload step in your pipeline with one that runs the lane:

      - step:
          name: Upload to TestApp.io
          image: ruby:3.3
          script:
            - bundle install
            - bundle exec fastlane upload_android

For iOS, use the same step on the self-hosted macOS runner (add the runs-on lines shown above) and a lane that passes release: "ios" and ipa_file: "../build/MyApp.ipa". The plugin marks the upload as coming from fastlane for you, so there is no source option to set.

ta-cli options

• --release: android, ios or both (pass both --apk and --ipa).
• --release_notes="...": notes shown to testers.
• --git_release_notes=true: use the last commit message as the notes.
• --git_commit_id=true: add the last commit ID to the notes.
• --notify=true: notify your team members about the new release.
• --archive_latest_release=true: archive the previous latest release once this one is uploaded.

See https://help.testapp.io/ta-cli/ for every ta-cli option.

Tip: Once your pipeline uploads a build, team members using the TestApp.io mobile app receive a push notification and can install the build with a single tap. You can also create share links to distribute builds to external testers and clients.

Need help? Contact us. we're happy to assist!

Inviting Team Members

Owners and Admins can invite new members from either the Members tab or the Invites tab under Team.

1. Navigate to Team → Members (or Team → Invites).
2. Click the Invite Member button.
3. Enter one or more email addresses. You can paste multiple emails separated by spaces, commas, or line breaks (up to 20 per invite). Alternatively, leave the email field empty to generate a shareable invite URL.
4. Select at least one app to grant the invitee access to.
5. Choose whether to invite them as a Member (with a specific role) or as a Guest.
6. If inviting as a Member, select a role: Admin, Developer, or Tester.
7. Optionally add a personal message (up to 200 characters).
8. Optionally check Notify me by email when accepting to receive a confirmation when the invitee joins.
9. Click Send Invite.

The invitee receives an email with a link to join your team. If they do not have a TestApp.io account yet, they will be prompted to sign up. Once they accept, they are automatically added to the team with the assigned role.

Roles and Permissions

TestApp.io has five roles. Each role defines what a team member can see and do across your workspace.

Detailed Permissions Matrix

Managing Members

Viewing Your Team

Go to Team → Members to see a list of all team members. The table displays each member’s name, role, status, number of apps, last activity, and join date. You can filter members by role, status, or other criteria using the Filter button.

Changing a Member’s Role

1. Go to Team → Members.
2. Find the member and click the three-dot menu (⋯) on their row.
3. Select Edit Role.
4. Choose the new role and click Change.

Managing a Member’s Apps

Owners and Admins can control which apps a member has access to:

1. Go to Team → Members.
2. Click the three-dot menu (⋯) on the member’s row.
3. Select Manage Apps.
4. Add or remove apps from the member’s access list.

Removing a Member

1. Go to Team → Members.
2. Click the three-dot menu (⋯) on the member’s row.
3. Select Remove.
4. Confirm the removal.

Managing Pending Invites

Go to Team → Invites to see all pending and accepted invitations. From here you can:

• Edit an invite to change the assigned apps or role.
• Copy the invite link to share it manually.
• Withdraw an invite to revoke it before the recipient accepts.

Downloading iOS UDIDs

From the Team → Members tab, click the Download iOS UDIDs button to export a .deviceids file containing all registered iOS device identifiers from your team. Upload this file to your Apple Developer Account to register devices for ad-hoc distribution.

The Guest Role

Guests are ideal for external testers, clients, or stakeholders who need access to specific apps without seeing internal team details:

• Guests can only access apps they were explicitly invited to.
• They cannot view the team member list, team settings, or other apps.
• Guests do not count toward your team’s member limit. you can invite as many as you need.
• Both email and URL invite methods work for Guests.

Best Practices

Related Articles

• Team Members and Roles
• Transferring Team Ownership
• Notification Settings and Email Preferences
• Getting Started with TestApp.io
• Export iOS UDIDs

Need help? Contact us. we’re happy to assist!

Download the App

The TestApp.io app is available on both platforms:

• iOS: Download on the App Store
• Android: Get it on Google Play

Sign In

Open the app and sign in using the same account you use on the portal. You can sign in with:

• Email and password
• Google
• Apple (iOS only)

If you don't have an account yet, you can create one directly in the app. Once signed in, the app will remember your last login method for faster access next time.

Join Your Team

After signing in, you need to be part of a team to see apps and releases. There are two ways to join:

• Accept an invitation: If a team admin has invited you, you'll see a pending invitation in the Notifications tab. Tap it to accept and join the team.
• Switch teams: If you belong to multiple teams, use the Team option in the side menu to switch between them.

Once you've joined a team, the dashboard will show your apps, recent releases, and team activity.

Browse Apps and Releases

From the dashboard, tap Apps to see all the apps your team is testing. Each app shows its name, platform (iOS or Android), and the number of active releases.

Tap an app to open its detail view, which has several tabs:

• Releases: All uploaded builds, sorted by date. You can filter by platform or status.
• Tasks: QA tasks assigned to this app. Filter by status, assignee, or priority.
• Comments: All feedback submitted by the team on this app's releases.
• Activity: A chronological feed of everything that happened on this app.

Install a Build

Tap any release to open its details. From there you can install the build directly to your device.

Android

On Android, tap the Install button on the release card. The app will:

1. Check that your device allows installations from unknown sources (if not, it will guide you to enable this permission).
2. Download the APK with a visible progress bar.
3. Open the system installer so you can confirm and complete the installation.

Once installed, the button changes to Open, letting you launch the app directly.

iOS

On iOS, the app displays a QR code or an install link. Scan the QR code with your camera or tap the link to begin installation through the standard iOS provisioning flow.

Note: iOS installations require that your device's UDID is registered in the app's provisioning profile. If installation fails, ask your team admin to add your device.

Receive Push Notifications

When a new release is uploaded, you'll receive a push notification on your phone. Tapping the notification takes you directly to the release so you can install it right away.

Push notifications are also sent for:

• New task assignments
• Comments on releases you're involved with
• Team activity updates

You can customize which notifications you receive in Settings → Notification Preferences.

Work on Tasks

If your team uses task management, you'll see tasks assigned to you in the app. Open any app and go to the Tasks tab to see:

• Tasks assigned to you or the whole team
• Task status (new, in progress, blocked, done)
• Priority and linked releases

You can update task status directly from the app. mark tasks as in progress, blocked, or done as you test. If a task is linked to a specific release, tap through to install and test that build.

Tasks synced from Jira or Linear will also appear here, with a link back to the original ticket.

Share Feedback

Found a bug or want to share feedback? Open the release and go to the Comments tab:

1. Tap the comment button to open the feedback form.
2. Write your feedback describing what you found.
3. Attach screenshots, screen recordings, or any other images and videos from your device.
4. Submit your comment.

Attachments upload in the background, so you can keep testing while files are being processed. Your team will see the comment with all attachments in both the app and the portal.

Compare Versions

Need to check if a bug exists in a previous build? The Releases tab shows your complete version history. You can:

• Install any previous release to roll back and verify issues.
• Compare behavior between versions by switching between builds.
• Filter releases by platform to find the specific build you need.

This is especially useful for regression testing. install the old build, reproduce the issue, then install the new build to confirm the fix.

Dashboard and Navigation

The app uses a side menu (accessible from the top-left icon) for navigation:

• Dashboard: Quick overview of your team's testing activity, top apps, and recent releases.
• Apps: Browse all apps you have access to.
• Team: View team members and pending invitations, and switch between teams.
• Notifications: See all alerts and pending team invitations. The bell icon shows your unread count.
• Settings: Manage your profile, notification preferences, theme (light/dark/system), and device information.

Related Articles

• Share Links: Distribute to External Testers
• Getting Started with TestApp.io. Portal setup guide
• Task Management
• Troubleshooting: Parsing the Package
• How Do I Get the UDID of an iOS Device?

Need help? Contact us and we'll get back to you shortly.

What Is a Version?

A version represents a single release cycle of your app (for example, v2.1.0). It brings together all the work needed to ship that release: the tasks your team is working on, the builds uploaded for testing, quality metrics like blocker counts, and the launches that track store submissions.

Creating a Version

1. Open your app in TestApp.io.
2. Navigate to the Versions tab.
3. Click New Version.
4. Enter a version name (e.g., v2.1.0 or Sprint 14 Release).
5. Your version is created in Planning status, ready for you to start defining scope.

Version Statuses

Each version moves through a defined lifecycle. Here is what each status means:

• Planning. You are defining the scope of this release. Create and link tasks, outline what will be included, and set goals. No builds are expected yet.
• Development. Active coding is underway. Your team is working on the tasks linked to this version, and builds are starting to be created and uploaded.
• Testing. QA is in progress. Builds are being distributed to testers, feedback is being collected, and blockers are being reported and resolved.
• Ready, All blockers have been resolved, and the version is cleared for release. This status signals that the build is approved to ship.
• Released, The version has been shipped to one or more stores. Your launches track the details of each store submission.
• Archived, The version is no longer active. Archived versions are preserved for historical reference but are hidden from day-to-day views.

The Version Dashboard

Every version has a dashboard with five tabs that give you full visibility into the release:

Overview

A summary of the version's current state. See the current status, key metrics at a glance, and a high-level snapshot of progress across tasks, builds, and quality.

Planning

View and manage all tasks linked to this version. This is where you define what work needs to be completed before the version ships.

Releases

Browse all builds that have been uploaded for this version. Each build includes its upload date, platform, and distribution details. This tab gives you a clear history of every build your team has tested.

Quality

Track the quality health of your version. See the current blocker count, test completion rates, and other quality metrics. This tab helps you decide whether the version is ready to ship.

Settings

Configure version-level settings such as the version name and other properties specific to this release.

Moving Through the Lifecycle

Advancing a version through its lifecycle is straightforward:

1. Open the version you want to update.
2. Click the current status indicator.
3. Select the next status in the lifecycle.
4. The change is applied immediately and recorded in the audit trail.

Quality Gates

TestApp.io enforces quality gates to prevent premature releases:

• Open blockers prevent moving to Ready. If any blocker is still unresolved, the version cannot be advanced to the Ready status. This ensures that known critical issues are addressed before you approve the release.
• Resolve all blockers first, then move the version to Ready when your team is confident the build is ready to ship.

Tips for Managing Versions

• Create your version early in the release cycle, even during planning, so all related tasks and builds are linked from the start.
• Use the Planning tab to connect tasks so your team has a clear view of what is in scope.
• Monitor the Quality tab regularly during testing to stay ahead of blockers.
• Once released, review the version dashboard for a complete record of the release cycle before archiving.

Need help? Contact us and we'll get back to you shortly.

Four Ways to Create Tasks

TestApp.io gives you four distinct methods for creating tasks, each suited to different workflows:

1. Manual Creation

The most direct approach. From your app's Tasks tab:

1. Click the New Task button.
2. Enter a title that clearly describes what needs to be done or tested.
3. Add a description with detailed steps, expected behavior, or reproduction instructions.
4. Set the priority level (Low, Normal, High, Critical, or Blocker).
5. Assign one or more team members to the task.
6. Optionally, link a release to associate the task with a specific build.
7. Set a due date if the task is time-sensitive.

2. Report Blocker

When you encounter a critical issue during testing, you can report it as a blocker. This creates a task with the priority automatically set to Blocker. You can report blockers from the release detail page using the Report Blocker button. For full details, see Blocker Tracking: Report and Resolve Critical Issues.

3. Pull from Integration

If your team uses project management tools such as JIRA or Linear, you can pull existing issues into TestApp.io as tasks. This is useful when your development team has already logged issues that need QA attention. The imported tasks maintain a link back to the original issue.

4. Auto-Sync from Integration

When two-way sync is enabled with JIRA or Linear, new issues created in those tools automatically appear as tasks in TestApp.io. This eliminates the need to manually import issues and keeps both systems in sync.

Task Properties

Every task in TestApp.io has the following properties:

• Title: A short, descriptive name for the task.
• Description: Detailed information, steps to reproduce, expected behavior, or testing instructions.
• Priority: Five levels that indicate urgency:
  • Low: Nice-to-test items, minor improvements.
  • Normal: Standard QA tasks and routine checks.
  • High: Important issues that should be addressed soon.
  • Critical: Severe issues that significantly impact functionality.
  • Blocker: Must-fix issues that prevent a release from shipping.
• Status: Tracks progress through four stages. Open, In Progress, Done, and Closed.
• Assignees: One or more team members responsible for the task. Multiple assignees are supported for collaborative testing.
• Release Link: Associates the task with a specific build, so you know which version the task applies to.
• Due Date: An optional deadline for task completion.

Views: Kanban Board and Table

TestApp.io offers two ways to view your tasks:

Kanban Board

The default view organizes tasks into columns by status (Open, In Progress, Done, Closed). You can drag and drop task cards between columns to update their status instantly. The Kanban board gives you a visual overview of work distribution and progress at a glance.

Table View

The table view presents tasks in a sortable, spreadsheet-like format. Each row is a task, and columns display properties such as title, priority, status, assignee, and due date. Click any column header to sort by that property. The table view is ideal when you need to scan a large number of tasks quickly or export a structured overview.

Filtering Tasks

Both views support filtering to help you find exactly what you need:

• By Status: Show only Open tasks, only In Progress tasks, or any combination.
• By Priority: Filter to see only Blockers and Critical tasks, for example.
• By Assignee: View tasks assigned to a specific team member or to yourself.
• By Linked Release: See only tasks associated with a particular build.

Task Detail Page

Click on any task to open its detail page, which includes:

• Full Description: The complete task description with all context and instructions.
• Comments Thread: A conversation thread where team members can discuss the task, ask questions, or provide updates.
• Attachments: Upload screenshots, screen recordings, logs, or any files relevant to the task.
• Activity Log: A chronological record of all changes made to the task. status updates, reassignments, priority changes, and more.

Need help? Contact us. we're happy to assist!

What Is the Leaderboard?

The Leaderboard is a gamification feature built into TestApp.io that rewards team participation. As you and your teammates perform actions across the platform. uploading releases, creating tasks, resolving blockers, and more. you earn points. These points are tallied and displayed on a leaderboard so everyone can see who is contributing the most.

It is designed to encourage engagement, recognize active team members, and make the testing and release process more enjoyable.

How Points Are Earned

Different actions earn different point values. Higher-impact actions are worth more points, rewarding the work that moves your project forward. Here are the types of actions that earn points:

• Connecting an integration. Link tools like Jira, Linear, Slack, or other project management tools to your TestApp.io workspace.
• Uploading a release. Upload a new build for distribution and testing. This is one of the highest-value actions.
• Creating a task. Log a new task for your team to track and resolve.
• Resolving a blocker. Close out a blocker that was preventing a release from moving forward.
• Adding comments. Participate in discussions on releases and tasks by posting comments.
• Other team actions. Various additional activities throughout the platform also contribute to your score.

Point values vary by action type. Actions that have a bigger impact on your team's workflow. like uploading a release or resolving a blocker. earn more points than lighter actions like adding a comment.

Viewing the Leaderboard

The leaderboard is displayed on your Home Dashboard in the TestApp.io portal. When you log in, you will see the Leaderboard widget showing the top contributors on your team.

The leaderboard displays:

• Team member names and avatars.
• Total points earned.
• Ranking position among teammates.

This gives you a quick snapshot of who has been most active and how your own contributions compare.

Real-Time Point Updates

Points update in real time as you work. When you upload a release, resolve a blocker, or perform any point-earning action, your score changes immediately. There is no delay or batch processing. you see the result of your contribution right away.

This real-time feedback loop makes it satisfying to complete tasks and encourages consistent participation throughout the day.

Why the Leaderboard Matters

The leaderboard serves several purposes for your team:

• Encourages engagement: Seeing your score rise motivates continued participation across the platform.
• Recognizes contributors: Team members who go above and beyond get visible recognition for their efforts.
• Makes QA enjoyable: A little friendly competition can make repetitive testing workflows feel more rewarding.
• Promotes best practices: By rewarding actions like resolving blockers and adding comments, the system encourages thorough, communicative workflows.

Tips

• Check the leaderboard regularly: Visit your Home Dashboard to see where you stand and celebrate teammates who are leading the way.
• Earn points naturally: The best way to climb the leaderboard is simply to do your work thoroughly. upload builds, log tasks, resolve blockers, and participate in discussions.
• Use it in retrospectives: The leaderboard can provide useful data for sprint retrospectives, showing team activity levels and participation trends.

Tip: Testers can also use the TestApp.io mobile app (iOS / Android) to install builds and receive push notifications for new releases.

Related Articles

• Home Dashboard
• Activity Feed
• Task Management

Need help? Contact us and we'll get back to you shortly.

Why use External Storage?

• Data location. Choose where your files are kept (Amazon S3 lets you pick the AWS region).
• Company policy. Some teams must keep build artifacts in an account they control.
• Retention and access. You set your own retention, logging and billing on the bucket.

Plan requirement

External Storage is available on the Pro plan. On Free and Starter, the Add New button is disabled. See testapp.io/pricing for plan details.

If your team downgrades to a plan without External Storage, or a payment fails, your external storages are set to Inactive.

Supported providers

• Amazon S3
• Google Cloud Storage
• Wasabi
• DigitalOcean Spaces
• Vultr Object Storage
• IBM Cloud Object Storage
• Backblaze B2 (beta)

For every provider you enter an access key and a secret for an S3-compatible API. For Google Cloud Storage, use an HMAC key (Cloud Storage "interoperability" access key), not a service account JSON file.

TestApp.io creates the bucket for you. You do not enter a bucket name. The bucket is named testappio- followed by a random ID. You can see it on the storage card in the Portal.

Only Amazon S3 lets you choose the region. For the other providers TestApp.io uses a fixed region, shown as Region when you edit the storage.

Amazon S3

Choose a region

When you pick Amazon S3, a Region list appears. Your bucket is created in the region you choose. You cannot change the region later. To use another region, add a new storage.

The list covers the standard AWS regions. GovCloud and China regions are not supported.

Opt-in regions

AWS keeps some regions turned off until you enable them. The Portal marks these with "opt-in". Enable the region in your AWS account first: Account settings > AWS Regions. If you do not, bucket creation fails.

Opt-in regions: Africa (Cape Town), Asia Pacific (Hong Kong, Taipei, Hyderabad, Jakarta, Melbourne, Malaysia, New Zealand, Thailand), Canada West (Calgary), Europe (Zurich, Milan, Spain), Israel (Tel Aviv), Middle East (Bahrain, UAE) and Mexico (Central).

Create an IAM user and policy

Create a dedicated IAM user for TestApp.io and an access key for it. Attach a policy like the one below. It limits the user to buckets whose names start with testappio-, which is the name TestApp.io gives the buckets it creates.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "TestAppIoBuckets",
      "Effect": "Allow",
      "Action": [
        "s3:CreateBucket",
        "s3:DeleteBucket",
        "s3:ListBucket",
        "s3:ListBucketMultipartUploads",
        "s3:GetBucketLocation",
        "s3:PutBucketOwnershipControls",
        "s3:PutBucketPublicAccessBlock"
      ],
      "Resource": "arn:aws:s3:::testappio-*"
    },
    {
      "Sid": "TestAppIoObjects",
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:PutObjectAcl",
        "s3:GetObject",
        "s3:DeleteObject",
        "s3:AbortMultipartUpload",
        "s3:ListMultipartUploadParts"
      ],
      "Resource": "arn:aws:s3:::testappio-*/*"
    }
  ]
}

What each permission is for:

• s3:CreateBucket: creates the bucket when you add the storage.
• s3:PutBucketOwnershipControls and s3:PutBucketPublicAccessBlock: set up the bucket so uploads work (see below).
• s3:PutObject and s3:PutObjectAcl: upload builds and attachments as public-read objects. They also upload the check file.
• s3:DeleteObject: delete the check file, and delete builds when you delete a release or app.
• s3:ListBucket, s3:GetBucketLocation and s3:GetObject: check access when you update credentials or reactivate a storage, and read objects.
• s3:ListBucketMultipartUploads, s3:ListMultipartUploadParts and s3:AbortMultipartUpload: large builds are uploaded in parts.
• s3:DeleteBucket: removes the bucket when you remove the storage in the Portal.

If you already have an older policy, the two new permissions are s3:PutBucketOwnershipControls and s3:PutBucketPublicAccessBlock.

What TestApp.io changes on the bucket, and why

New Amazon S3 buckets reject object ACLs and block all public access by default. TestApp.io stores builds as public-read objects so that install links work for your testers. So right after it creates the bucket, TestApp.io changes these settings on that bucket only:

• Object Ownership: set to "Bucket owner preferred".
• Block Public Access: the two ACL options are turned off ("Block public access to buckets and objects granted through new access control lists (ACLs)" and "...through any access control lists (ACLs)").
• Block Public Access, kept on: the two policy options stay on. Public bucket policies remain blocked.

Then TestApp.io uploads a small file named testappio-storage-check.txt with a public-read ACL, and deletes it right away. This proves real uploads will work. If you see this file in the bucket, it is safe to delete.

If any step fails, TestApp.io deletes the bucket it just created, so nothing is left behind, and shows an error.

Uploaded builds and attachments are public-read objects. Anyone who has a file's URL can download it. The bucket itself cannot be listed publicly.

Account-level Block Public Access

AWS also has a Block Public Access setting for the whole account, and organizations can add policies on top. If either blocks public ACLs, bucket-level changes are not enough and connecting fails with the "Amazon S3 rejected a test upload" error (see Troubleshooting). To fix it, open S3 > Block Public Access settings for this account and turn off the two ACL options. You can leave the two policy options on. Then add the storage again.

Set up External Storage

1. Sign in to the TestApp.io Portal and open Team, then the Storage tab. You need permission to manage storage.
2. Click Add New. The Add Storage panel opens.
3. Select a Provider.
4. For Amazon S3, select a Region.
5. Enter the Key and the Secret. Each must be at least 10 characters.
6. Click Add. TestApp.io creates the bucket and checks it. This can take several seconds.
7. When it succeeds, you see "Storage successfully added" and the storage appears under External Storage Providers with the status Active.

There is no separate Validate button. The checks run when you click Add.

To use the storage, select it in the Storage field when you create an app. New builds and attachments for that app go to your bucket.

You cannot add the same key twice. If an active storage already uses the key, you see "You already created a storage with this key".

Manage your storage

On the storage card, click the three-dot menu, then Edit or Remove.

Deactivate and reactivate

In Edit, open the Status tab, choose Active or Inactive, and click Update. While a storage is inactive, it cannot be used for new apps or releases, and existing apps and releases that use it are not accessible. Your data stays in your bucket. Reactivating needs a plan that includes External Storage.

TestApp.io can also set a storage to Inactive on its own, for example when your plan changes or when it loses access to the bucket. Hover over the Inactive badge to see the reason.

Update credentials

In Edit, open the Credentials tab, enter the new Access Key and Secret Key, and click Update. TestApp.io first checks that the new key can access the bucket. If the storage was inactive and the check passes, it becomes active again.

The new key needs the same permissions as the old one.

The region, endpoint and bucket cannot be edited. They are shown read-only.

Remove a storage

Click Remove, then Yes, Remove. This cannot be undone. Removing a storage:

• deletes the bucket and everything in it, using your key (the key needs s3:DeleteBucket and s3:DeleteObject), and
• deletes every app that uses this storage, with its releases and attachments.

The dialog shows how many apps and releases will be removed. If you want to keep your files, copy them out of the bucket first. Deactivating instead of removing keeps everything in place.

Troubleshooting

These are the messages you may see in the Add Storage panel.

"You need to upgrade your team's plan to use this feature"

Your plan does not include External Storage. Upgrade to Pro.

"Unable to create bucket, please check the key/secret again and make sure that this key has the permission to create & delete bucket, upload, read, list and delete objects in [region] region"

The key is wrong, or the policy does not allow s3:CreateBucket. For an opt-in region, the message continues: "[region] is an opt-in region, so you must also enable the region in your AWS account (Account settings > AWS Regions) before using it". Enable the region and try again.

"Unable to prepare the bucket in [region] region, please make sure that this key also has the s3:PutBucketOwnershipControls and s3:PutBucketPublicAccessBlock permissions..."

The key could create the bucket but cannot change its ownership or public access settings. Add the two permissions from the policy above. TestApp.io has already removed the new bucket, so you can try again.

"Amazon S3 rejected a test upload that is publicly readable in [region] region, so uploads would fail..."

Block Public Access is on for the whole AWS account, or an organization policy forbids public ACLs. See "Account-level Block Public Access" above. Also check that the key has s3:PutObject, s3:PutObjectAcl and s3:DeleteObject.

"Unable to configure the bucket in [region] region, please try again. If this keeps happening, contact us"

The setup failed for a reason other than permissions. Try again. If it keeps happening, contact us.

"Unsupported AWS region" or "This storage provider does not support choosing a region"

Pick a region from the list. Only Amazon S3 supports choosing a region.

"Unable to access bucket with provided credentials..."

Shown when you update credentials. The new key cannot access the bucket. Check the key, the secret and the policy.

"Unable to delete bucket, please check the key/secret again and make sure that this key has the permission to delete [bucket] bucket..."

Shown when you remove a storage. Make sure the key still has s3:DeleteBucket and s3:DeleteObject on the bucket. If you already deleted the bucket in your cloud account, contact us.

"This storage is inactive. Please activate it before use."

Open Team > Storage, click Edit and set the status to Active. If it cannot be reactivated, update the credentials.

Installs or downloads return "Access Denied"

Someone may have changed the bucket's Block Public Access or Object Ownership settings, or turned on account-level Block Public Access after setup. Restore the settings described above.

Security notes

• Use a dedicated IAM user or key for TestApp.io. Do not reuse keys from other services.
• Scope the policy to testappio-* buckets, as shown above.
• TestApp.io stores your key and secret so it can upload and manage files. The Portal never shows the secret again.
• Rotate the key from time to time. Use Edit > Credentials to give TestApp.io the new one.
• Files are public-read, so anyone with a file's URL can download it. Do not store anything in these buckets that must stay private.
• Turn on access logging on the bucket if you want an audit trail.

Need help? Contact us and we'll get back to you shortly.

Where to Find the Activity Feed

To access the Activity Feed, navigate to any app in your TestApp.io portal and click the Activity tab in the sidebar. Each app has its own dedicated feed, so you see only the activity relevant to that project.

What Shows Up in the Feed

The Activity Feed captures a wide range of team actions, including:

• Release uploads, When a teammate uploads a new build, it appears in the feed with version details.
• Task creation and updates. New tasks, status changes, assignments, and completions are all tracked.
• Blocker reports and resolutions. See when blockers are raised and when they get resolved.
• Version status changes. Track when a release moves through different statuses.
• Integration sync events. Activity from connected tools like Jira or Linear appears here automatically.
• Comments and mentions. Comments posted on releases and tasks show up in the feed, along with any @mentions.

Interacting with Activity Items

The Activity Feed is not just a read-only log. You can interact directly with any item in the stream.

Reply to Activity

Click Reply on any activity item to add a comment directly in context. This is useful for asking quick questions about a release or acknowledging a completed task without navigating away from the feed.

@Mention Teammates

Type @ followed by a teammate's name to mention them. They will receive a notification, making it easy to pull someone into a conversation or flag something for their attention. For example, you might reply to a release upload with @Sarah can you test this on Android 14?

Add Emoji Reactions

React to any activity item with an emoji. Reactions are a quick, lightweight way to acknowledge an update without adding a full comment. Use them to signal approval, celebrate a milestone, or simply let your team know you have seen an update.

Real-Time Updates

The Activity Feed updates in real time. When a teammate uploads a release, creates a task, or posts a comment, the new activity appears in your feed instantly, no page refresh needed. This makes the feed a reliable, always-current view of what is happening across your app.

Tips for Using the Activity Feed

• Morning standup catch-ups: Open the Activity Feed at the start of your day to see what happened overnight. It gives you a quick summary of all team actions without needing to check multiple pages.
• Track release progress: Use the feed to follow a release from upload through testing to completion. Every status change and comment is captured in one place.
• Stay in the loop on mentions: Keep an eye on the feed for @mentions directed at you. This is how teammates flag items that need your attention.
• Use reactions to reduce noise: Instead of writing "looks good" or "got it," drop a quick emoji reaction to acknowledge without cluttering the feed.

Related Articles

• Comments: Replies, Reactions, Mentions, and Attachments
• Task Management

Need help? Contact us. we're happy to assist!

What Is What's New?

What's New is a built-in feature update feed inside the TestApp.io portal. It provides a chronological list of new features, improvements, bug fixes, and platform updates. Think of it as a changelog that lives right inside your workspace, so you do not need to check external blogs or release notes pages.

How to Access What's New

To open the What's New feed:

1. Log in to the TestApp.io portal.
2. Look at the top navigation bar (the header area).
3. Click the gift/present icon in the navigation.
4. The What's New panel opens, showing the latest updates.

The icon may show a badge or indicator when there are new, unread updates waiting for you.

Browsing Updates

The What's New feed presents updates in a scrollable list, organized by date with the most recent items at the top. Each entry typically includes:

• Feature name or title, A clear label describing the update.
• Description, A brief explanation of what changed, what is new, or what was improved.
• Date, When the update was released.

Scroll through the list to catch up on everything that has changed since your last visit.

Rating Features

Your feedback matters. Each item in the What's New feed includes an option to rate the feature. you can indicate whether the update was helpful or not helpful.

This feedback goes directly to the TestApp.io team and helps prioritize future improvements. If a feature is particularly useful to your workflow, rating it positively helps signal that similar enhancements are valuable.

Mark as Read

As you review items in the What's New feed, you can mark them as read to keep your list clean. Dismissing items you have already reviewed ensures that the next time you open the feed, you can quickly spot genuinely new updates without scrolling past items you have already seen.

Tips

• Check regularly: Make it a habit to open What's New periodically, even weekly. New features are released frequently, and staying current helps you take advantage of capabilities that could streamline your workflow.
• Share with your team: When you spot a feature that would benefit your team, let them know. A quick message in your team chat pointing to a new capability can improve everyone's experience.
• Provide feedback: Take a moment to rate features. Your input directly influences what gets built next, so your ratings help shape the platform to better fit your needs.
• Explore new features immediately: When you see an update that looks useful, try it right away while the context is fresh. This is the fastest way to integrate new capabilities into your daily workflow.

Related Articles

• Home Dashboard
• Playbooks

Tip: Testers can also use the TestApp.io mobile app (iOS / Android) to install builds and receive push notifications for new releases.

Need help? Contact us and we'll get back to you shortly.

1. Sign Up

Head to portal.testapp.io and create your account. You can sign up with your email address or use an existing Google account for faster onboarding. Once signed in, you will land on the home dashboard.

2. Create Your Team

Your team is the workspace where all your apps, releases, and tasks live. To create one:

1. Click Create Team from the onboarding prompt or the sidebar.
2. Give your team a name (e.g., your company or project name).
3. Invite team members by entering their email addresses. They will receive an invitation to join your workspace.

3. Create Your First App

With your team in place, create an app entry for each mobile project you want to test:

1. Click Create App from the Apps section in the sidebar.
2. Enter a name for your app.
3. Select the platform: iOS, Android, or Both. Choosing Both creates a unified app entry that accepts IPA files for iOS and APK files for Android.

Once created, you will be taken to the app overview page where you can upload builds, manage releases, and track tasks.

4. Upload Your First Release

Uploading a build to TestApp.io is straightforward:

1. Navigate to your app and open the Releases tab.
2. Drag and drop your build file (IPA for iOS, APK for Android) into the upload area. TestApp.io uses chunked uploads, so even large files transfer reliably.
3. Add release notes describing what changed in this build. Detailed notes help your team know what to test and also power AI task generation later.
4. Click Upload to publish the release.

5. Share with Testers

Once your release is uploaded, share it with your team and external testers. TestApp.io gives you multiple ways to distribute:

• Install Link: Copy the direct install link and send it via email, Slack, or any messaging tool. Testers tap the link on their device to install.
• QR Code: Each release has a scannable QR code. Display it on screen or print it. testers scan with their phone camera to install instantly.
• TestApp.io Mobile App: Have testers download the TestApp.io app (iOS / Android). They will receive push notifications for new releases, install builds with a single tap, work through assigned tasks, and submit feedback with screenshots and videos, all from their phone. See the Mobile App Getting Started guide for details.

6. What's Next

With your first release distributed, explore the full platform:

• Task Management: Create QA tasks, assign them to team members, and track progress on a Kanban board or table view. Learn more about task management.
• Blocker Tracking: Flag critical issues that must be resolved before shipping. Track blocker resolution across all your apps. Learn more about blocker tracking.
• AI Task Generation: Let AI read your release notes and generate targeted QA tasks automatically. Learn more about AI task generation.
• Integrations: Connect project management tools such as JIRA and Linear to sync tasks bidirectionally.
• Home Dashboard: Monitor your team's testing activity, open blockers, and top contributors from a single view. Learn more about the dashboard.

Need help? Contact us. we're happy to assist!

What This Does

The Install feature lets you take an app build that has been uploaded to the TestApp.io portal and install it directly onto a physical device. This is essential for manual testing, QA review, stakeholder demos, and any situation where you need to run a build on real hardware.

Installing from Desktop (QR Code Method)

When you are working on a desktop or laptop computer, the portal uses a QR code to bridge the gap between your screen and your phone.

1. Open the TestApp.io portal on your computer and navigate to the app you want to install.
2. Find the release you want to install. You can access it from two places:
   • Release list: Click the Actions menu dropdown on the release row, then select Install.
   • Release detail page: Open the release and click the Install button.
3. A QR code appears on your screen.
4. Open your phone's camera and scan the QR code.
5. The link opens in the TestApp.io mobile app on your phone.
6. The build installs automatically on your device.

The entire process takes just a few seconds from scan to install.

Installing from Mobile Browser

If you are already browsing the portal on your phone, you can skip the QR code step entirely.

1. Open the release page in your phone's mobile browser.
2. Tap Install on Device.
3. The TestApp.io mobile app opens automatically.
4. The build installs directly to your device.

This is the fastest path when you are already on your phone. one tap and the build starts installing.

Requirements

To install builds from the portal, you need:

• TestApp.io mobile app installed on your device. The mobile app handles the actual installation of builds onto your phone. Without it, the QR code and Install on Device links will not work.
• Access to the app in the TestApp.io portal. You must be a member of the team or have been granted access to the app.

Where to Find the Install Option

Here is a quick reference for where the Install action is available:

• Release list page: Each release row has an Actions dropdown menu. Click it and select Install.
• Release detail page: The Install button is prominently displayed on the page.

Both paths lead to the same result. choose whichever is more convenient based on where you are in the portal.

Tips

• QR codes in meetings: The QR code method is perfect for team meetings and demos. Share your screen with the portal open, click Install, and everyone in the room can scan the QR code to get the build on their own device instantly.
• Bookmark release pages: If you frequently test the same app, bookmark the release list page in your mobile browser for quick access to the latest builds.
• Keep the mobile app updated: Make sure you are running the latest version of the TestApp.io mobile app for the best installation experience.

Troubleshooting

• The QR code does not open the app: Make sure the TestApp.io mobile app is installed on your device. If it is installed but the link still does not open it, try updating the app to the latest version.
• Install on Device button not working: Ensure you are accessing the portal from a mobile browser on the device where you want to install the build.

Other Ways to Install

• TestApp.io Mobile App (iOS / Android). Receive push notifications for new builds and install with a single tap. Testers can also manage tasks and submit feedback from their phone. See the Mobile App Getting Started guide.
• Share Links, For external testers and clients who do not have a TestApp.io account, create public install links with optional password protection. See Share Links.

Related Articles

• Getting Started with TestApp.io
• Activity Feed

Need help? Contact us and we'll get back to you shortly.

This guide walks you through connecting Linear, configuring field mappings, importing issues, migrating tasks, and monitoring sync activity.

1. Connecting Linear to TestApp.io

To get started, you need to authorize TestApp.io to access your Linear workspace via OAuth:

1. In TestApp.io, navigate to Team Settings → Integrations → Linear.
2. Click the “Connect” button next to the Linear integration.
3. You will be redirected to Linear’s OAuth authorization page.
4. Review the permissions requested and click “Authorize”.
5. Once authorized, you will be redirected back to TestApp.io. Your Linear workspace is now connected.

Tip: Only team admins can connect or disconnect integrations. Make sure you have the necessary permissions in both TestApp.io and Linear before proceeding.

2. Selecting Your Linear Team

After connecting, you need to choose which Linear team to sync with:

1. On the Linear integration settings page, you will see a list of available Linear teams from your workspace.
2. Select the team whose issues you want to sync with TestApp.io.
3. Click “Save” to confirm your selection.

This determines which Linear team’s issues will be synced, imported, or migrated within TestApp.io.

3. Configuring Field Mappings

Field mapping lets you define how statuses and priorities translate between TestApp.io and Linear:

Status Mapping

Map each TestApp.io task status to its corresponding Linear status. For example:

• Open (TestApp.io) → Todo (Linear)
• In Progress (TestApp.io) → In Progress (Linear)
• Resolved (TestApp.io) → Done (Linear)

Priority Mapping

Similarly, map priority levels between the two platforms to ensure issues maintain the correct urgency when synced.

To configure mappings:

1. Go to the Field Mapping section in your Linear integration settings.
2. For each TestApp.io status, select the corresponding Linear status from the dropdown.
3. Repeat the process for priority fields.
4. Click “Save Mappings” when finished.

You can update these mappings at any time without disconnecting the integration. See Integration Power Features for more on field mapping management.

4. How 2-Way Sync Works

Once connected and configured, TestApp.io and Linear stay in sync in real time through webhooks:

• Outbound sync: When you create, update, or complete a task in TestApp.io, the corresponding Linear issue is automatically updated.
• Inbound sync: When a team member changes an issue in Linear (status, priority, assignee, comments), the linked TestApp.io task is updated accordingly.

Sync happens automatically. there is nothing additional to configure. Both platforms reflect changes within seconds of an update being made.

Note: Only tasks that are linked between the two systems will sync. Unlinked tasks remain independent.

5. Importing Existing Linear Issues

If your team already has issues in Linear that you want to bring into TestApp.io, use the import feature:

1. In the Linear integration settings, click “Pull Tasks”.
2. Browse the available issues from your selected Linear team.
3. Select the issues you want to import.
4. Click “Import Selected”.

Imported issues become TestApp.io tasks and are automatically linked to their Linear counterparts for ongoing 2-way sync.

6. Migrating Local Tasks to Linear

If you have tasks created locally in TestApp.io that you want to move to Linear:

1. Go to your Linear integration settings and click “Migrate Tasks”.
2. Select the local TestApp.io tasks you want to migrate.
3. Map your TestApp.io statuses to the appropriate Linear statuses (e.g., “Open” → “Todo”).
4. Confirm the migration.

Migrated tasks will be created as new issues in Linear and automatically linked for bidirectional sync going forward.

7. Viewing Sync History

TestApp.io maintains a complete audit trail of all sync events between your workspace and Linear:

1. Navigate to Team Settings → Integrations → Linear → Sync History.
2. You will see a log of every sync event, including:
   • Direction: Whether the sync was inbound (Linear → TestApp.io) or outbound (TestApp.io → Linear).
   • Status: Whether the sync succeeded or failed.
   • Timestamp: When the sync occurred.
   • Error details: If a sync failed, the reason is displayed.
3. For failed syncs, click the “Retry” button to attempt the sync again.

Regularly reviewing sync history helps you catch and resolve any issues before they impact your workflow.

8. Troubleshooting

If you encounter issues with your Linear integration, try the following:

• Sync not working: Verify the integration is enabled (not just connected). You can toggle it on/off in the integration settings without losing your configuration.
• Authorization errors: Disconnect and reconnect the integration by going through the OAuth flow again.
• Missing issues: Ensure you have selected the correct Linear team. Issues from other teams will not appear.
• Failed syncs: Check the sync history for error details and use the retry button. Common causes include permission changes in Linear or network timeouts.
• Field mapping issues: If synced tasks have incorrect statuses, review and update your field mappings.

For more advanced features like toggling integrations, bulk imports, and detailed sync management, see Integration Power Features: Disable, Pull, Migrate, Sync History.

To learn more about how tasks work in TestApp.io, visit our Task Management guide.

Need help? Contact us and we’ll get back to you shortly.

This guide covers the key power features available for both the JIRA and Linear integrations.

1. Enable and Disable Your Integration

Sometimes you need to pause an integration without fully disconnecting it, for example, during a major reorganization or when troubleshooting an issue.

TestApp.io lets you toggle your JIRA or Linear integration on and off:

1. Go to Team Settings → Integrations and select your integration (JIRA or Linear).
2. Use the Enable/Disable toggle to turn the integration on or off.

What happens when you disable:

• All syncing pauses immediately. No changes will flow between TestApp.io and the connected tool.
• Your configuration is fully preserved. field mappings, project/team selection, and all linked tasks remain intact.
• No data is lost. When you re-enable, syncing resumes with your existing settings.

What happens when you re-enable:

• Real-time syncing resumes immediately.
• Any changes made while the integration was disabled will sync on the next update to the affected task.

Tip: Disabling is different from disconnecting. Disconnecting removes the OAuth authorization entirely and requires you to go through the setup process again. Disabling simply pauses sync while keeping everything configured.

2. Pull Tasks: On-Demand Import

The Pull Tasks feature lets you import existing issues from JIRA or Linear into TestApp.io on demand. This is useful when you want to bring over issues that were created before the integration was set up, or when new issues are added to a specific project or team that you want to track in TestApp.io.

How to pull tasks:

1. Navigate to Team Settings → Integrations and select your integration.
2. Click the “Pull Tasks” button.
3. Browse the available issues from your connected JIRA project or Linear team.
4. Select the issues you want to import.
5. Click “Import Selected”.

Imported issues become TestApp.io tasks and are automatically linked to their source issues in JIRA or Linear. Once linked, they participate in real-time bidirectional sync. any future changes in either platform will be reflected in the other.

3. Migrate Tasks: Move Local Tasks to JIRA or Linear

If your team has been creating tasks locally in TestApp.io and now wants to move them into JIRA or Linear, the Migrate Tasks feature handles this seamlessly.

How to migrate tasks:

1. Go to Team Settings → Integrations and select your integration.
2. Click the “Migrate Tasks” button.
3. Select the local TestApp.io tasks you want to migrate.
4. Map your TestApp.io statuses to the corresponding statuses in the target tool:
   • For JIRA: e.g., “Open” → “To Do”, “In Progress” → “In Progress”, “Resolved” → “Done”
   • For Linear: e.g., “Open” → “Todo”, “In Progress” → “In Progress”, “Resolved” → “Done”
5. Review the mapping summary to confirm everything looks correct.
6. Click “Confirm Migration”.

What happens during migration:

• A new issue is created in JIRA or Linear for each selected TestApp.io task.
• The task’s status and priority are mapped according to your field mapping configuration.
• The TestApp.io task is linked to the newly created issue.
• From this point forward, the task participates in real-time 2-way sync.

Note: Migration does not delete the original TestApp.io task. It creates a linked counterpart in your external tool.

4. Sync History: Complete Audit Trail

Every sync event between TestApp.io and your connected JIRA or Linear instance is logged in the Sync History. This gives you full visibility into what is happening with your integration at all times.

How to access sync history:

1. Go to Team Settings → Integrations and select your integration.
2. Click on “Sync History”.

What you will see:

Each sync event entry includes:

• Direction: Whether the sync was inbound (JIRA/Linear → TestApp.io) or outbound (TestApp.io → JIRA/Linear).
• Status: Whether the sync succeeded or failed.
• Timestamp: The exact date and time the sync event occurred.
• Error details: For failed syncs, a description of what went wrong.

Retrying failed syncs:

If a sync event has failed, you can retry it with one click:

1. Find the failed event in the sync history.
2. Review the error details to understand the cause.
3. Click the “Retry” button.
4. TestApp.io will re-attempt the sync.

Common causes of failed syncs include temporary network issues, permission changes in the connected tool, or field mapping mismatches. Reviewing error details usually points you directly to the fix.

5. Field Mapping: Customize at Any Time

Field mapping controls how statuses and priorities translate between TestApp.io and your connected tool. You can update these mappings at any time without disconnecting or disrupting your integration.

How to update field mappings:

1. Go to Team Settings → Integrations and select your integration.
2. Open the Field Mapping section.
3. Adjust the status and priority mappings as needed.
4. Click “Save Mappings”.

Updated mappings take effect immediately for all future sync events. Previously synced tasks are not retroactively updated. they will pick up the new mappings on their next change.

When to update mappings:

• When you add new statuses or priorities in JIRA or Linear.
• When you restructure your workflow in TestApp.io.
• When synced tasks are landing in incorrect statuses.

For detailed setup instructions specific to each integration, see:

• JIRA Integration: Setup and 2-Way Sync
• Linear Integration: Setup and 2-Way Sync

Need help? Contact us and we’ll get back to you shortly.