How to Set Up 2-Way JIRA Sync for Mobile App Testing

If your QA workflow involves JIRA for issue tracking and a separate tool for mobile app distribution and testing, you already know the pain: duplicate tickets, stale statuses, and that constant nagging feeling that something slipped through the cracks. You update a bug in JIRA, but your tester never sees the change. A tester marks something as resolved in the testing tool, but the developer's JIRA board still shows it open.

This disconnect is not just annoying. It costs real time. Every manual copy-paste, every "hey, did you update the ticket?" Slack message, every missed status change adds friction to a process that should be seamless.

TestApp.io's JIRA integration solves this with genuine 2-way, real-time sync. Changes flow in both directions automatically. No middleware, no Zapier workarounds, no cron jobs. Here is how to set it up from scratch, and how to get the most out of it once it is running.

What the Integration Actually Does

Before diving into setup, here is a clear picture of what you get:

• Bidirectional sync via webhooks — When a task changes in JIRA (status, priority, assignee, comments), that change appears in TestApp.io within seconds. The reverse is also true. Edit a task in TestApp.io, and JIRA updates automatically.
• Field mapping — Map your JIRA statuses and priorities to TestApp.io equivalents. Your "In Progress" in JIRA can map to "Testing" in TestApp.io, or whatever makes sense for your workflow.
• Import existing issues — Already have a backlog of JIRA issues? Pull them into TestApp.io without recreating them manually.
• Migrate local tasks — Have tasks in TestApp.io that should live in JIRA? Migrate them with status mapping so nothing gets lost in translation.
• Sync history and audit trail — Every sync event is logged with direction, status, and timestamps. When someone asks "when did this change?" you have the answer.
• Enable/disable without disconnecting — Need to pause sync temporarily? Toggle it off without losing your configuration. Toggle it back on when you are ready.

Step 1: Connect JIRA via OAuth 2.0

The integration uses Atlassian's OAuth 2.0 flow, which means you are not handing over API tokens or service account credentials. Here is how to get started:

Navigate to Integrations

In your TestApp.io dashboard, go to your version's settings and find the Integrations tab. You will see JIRA listed as an available integration.

Authorize with Atlassian

Click Connect on the JIRA integration card. This redirects you to Atlassian's OAuth consent screen. You will need to:

1. Log in with your Atlassian account (if not already signed in)
2. Select the Atlassian site (organization) you want to connect
3. Grant the requested permissions — TestApp.io needs read and write access to your JIRA projects to enable bidirectional sync
4. Click Accept to complete the authorization

Once authorized, you are redirected back to TestApp.io with the connection established. The OAuth token is stored securely and handles refresh automatically, so you will not need to re-authorize unless you explicitly revoke access.

What permissions are required?

The integration requests access to read and write issues, comments, and project metadata. It does not request admin-level permissions for your Atlassian organization. Only the JIRA projects you explicitly select will be accessible.

Step 2: Select Your JIRA Project

After connecting, you need to tell TestApp.io which JIRA project to sync with. This is a one-to-one mapping: one TestApp.io version syncs with one JIRA project.

From the integration settings panel:

1. You will see a dropdown listing all JIRA projects accessible to your Atlassian account
2. Select the project that corresponds to your mobile app
3. Confirm the selection

A few things to keep in mind here:

• Choose the project that your QA team actively works in. If you have separate JIRA projects for iOS and Android, pick the one that aligns with the TestApp.io version you are configuring.
• You can change the connected project later, but doing so will not retroactively sync historical data from the new project. New syncs start from the point of connection.

Step 3: Configure Field Mappings

This is where the integration gets powerful. Field mapping lets you define how statuses and priorities translate between the two systems.

Status Mapping

JIRA and TestApp.io likely use different status names. Maybe your JIRA workflow has "To Do," "In Development," "Code Review," "QA," and "Done." TestApp.io uses statuses that are more QA-focused.

The mapping interface lets you pair each JIRA status with a TestApp.io status. For example:

This mapping works in both directions. When a task moves to "Closed" in TestApp.io, JIRA updates it to "Done" (or whatever you mapped). When a developer moves an issue to "QA" in JIRA, it appears as "In Progress" in TestApp.io.

Priority Mapping

Similarly, map priority levels between the two systems. TestApp.io uses a priority scale of Low, Normal, High, Critical, and Blocker. JIRA typically uses Lowest, Low, Medium, High, and Highest. Set up the mapping that makes sense for your team's conventions:

Take a few minutes to get these mappings right. They form the backbone of how accurately your tasks stay in sync across both systems.

Step 4: Watch Real-Time Sync in Action

Once field mappings are configured, the webhook-based sync is live. Here is what happens in practice:

Changes from JIRA to TestApp.io

A developer updates an issue in JIRA — changes the status from "To Do" to "In Development," adds a comment, or bumps the priority. Within seconds, those changes appear on the corresponding task in TestApp.io. Your QA team sees the update without switching tools or asking for a status update.

Changes from TestApp.io to JIRA

A tester finds a bug during a testing session, updates the task priority to "Blocker," and adds a comment with reproduction steps. That change flows back to JIRA immediately. The developer sees the priority change on their JIRA board without anyone having to ping them.

Conflict handling

What happens if someone edits the same field in both systems simultaneously? The integration uses a last-write-wins approach with the sync history providing full visibility into what changed and when. In practice, true simultaneous edits are rare, but the audit trail ensures nothing is silently overwritten without a record.

Step 5: Import Existing JIRA Issues

Most teams do not start from zero. You probably have an existing backlog of issues in JIRA that relate to your mobile app. Rather than recreating them manually in TestApp.io, use the import feature.

From the integration settings:

1. Click Import Issues (or the equivalent option in the pull tasks interface)
2. Select which issues to import — you can filter by status, label, or other JIRA fields
3. Review the import preview to make sure the field mappings produce the expected results
4. Confirm the import

Imported issues become full TestApp.io tasks with bidirectional sync enabled. Any future changes in either system stay synchronized.

A practical tip: do not import everything blindly. Start with issues that are actively being tested or are in your current sprint. You can always import more later.

Step 6: Migrate Local Tasks to JIRA

The reverse scenario is also common: you have been using TestApp.io's built-in task management and now want those tasks reflected in JIRA. The migration feature handles this.

1. Navigate to the migration option in integration settings
2. Select the local TestApp.io tasks you want to migrate
3. Configure the status mapping for migration — this tells the system how to translate each TestApp.io status to a JIRA status during the one-time migration
4. Run the migration

After migration, those tasks exist in both systems with sync enabled going forward. The original TestApp.io tasks are not deleted; they become synced tasks linked to their JIRA counterparts.

Using the Sync History

The sync history is one of those features you do not think about until you need it — and then you really need it. Every sync event is recorded with:

• Direction — Did the change flow from JIRA to TestApp.io or vice versa?
• Status — Did the sync succeed, fail, or get retried?
• Timestamp — Exactly when did the sync occur?
• Details — What fields changed?

This is invaluable for debugging. If a tester says "I updated the status an hour ago but JIRA still shows the old value," you can check the sync history and see exactly what happened. Failed syncs can be retried directly from the history view.

Troubleshooting Common Sync Issues

Even well-configured integrations occasionally run into hiccups. Here are the most common issues and how to resolve them:

Sync stopped working after a JIRA workflow change

If your JIRA admin modifies the project's workflow (adds new statuses, removes old ones, changes transitions), your field mappings may become stale. When a task moves to a status that is not mapped, the sync cannot determine where to put it.

Fix: Go to integration settings and update your status mappings to include the new JIRA statuses. The sync will resume for any pending changes.

OAuth token expired or revoked

If someone revokes the OAuth grant from the Atlassian side, or if the token expires without a successful refresh, the integration will stop syncing.

Fix: Re-authorize by clicking Connect again in the integration settings. Your existing field mappings and sync history are preserved; only the auth token is refreshed.

Duplicate tasks after import

If you import issues and then also have someone manually create the same tasks, you can end up with duplicates. The integration tracks linked issues by their JIRA issue key, so manually created tasks are not automatically deduplicated.

Fix: Before importing, communicate with your team that JIRA issues are being pulled in automatically. Delete any manually created duplicates after import.

Webhook delivery failures

Network issues or temporary outages can cause webhook deliveries to fail. The sync history will show these as failed events.

Fix: Check the sync history for failed events and use the retry option. If failures persist, verify that your network allows outbound webhook traffic and that no firewall rules are blocking the connection.

Permissions errors on sync

If the Atlassian user who authorized the integration does not have write access to certain JIRA fields or transitions, syncs that try to update those fields will fail.

Fix: Ensure the authorizing user has sufficient permissions in the JIRA project. They need to be able to create issues, edit fields, transition statuses, and add comments.

Tips and Best Practices

After working with teams who run this integration daily, here are some patterns that consistently work well:

• Map statuses thoughtfully. Do not just create a 1:1 mapping because the names look similar. Think about what each status means in context. JIRA's "In Progress" might mean a developer is coding, while TestApp.io's "In Progress" might mean a tester is actively testing. Map them according to workflow, not just labels.
• Use the toggle wisely. When you are doing a large reorganization of your JIRA project (bulk status changes, workflow edits, mass updates), temporarily disable the integration to avoid a flood of sync events. Re-enable it when your changes are stable.
• Review sync history weekly. A quick glance at the sync history every week helps catch any failed syncs before they become stale. It takes 30 seconds and can save hours of confusion.
• Start with one project. If you manage multiple apps, connect one JIRA project first, get comfortable with the workflow, and then expand to others. Trying to set up everything at once usually leads to messy mappings.
• Align on conventions. Make sure your developers (JIRA users) and testers (TestApp.io users) agree on what the mapped statuses and priorities mean. A "Blocker" should mean the same thing in both tools.

Getting Started

The JIRA integration turns two separate tools into a unified workflow. Developers stay in JIRA. Testers stay in TestApp.io. Changes flow automatically, and everyone has the same picture of what is happening.

If you are spending time copying issue details between tools, manually updating statuses, or wondering whether your JIRA board reflects reality, this integration eliminates that overhead.

Set up the connection at portal.testapp.io, and check the help center for additional guides on fine-tuning your integration settings.