Project Management migration

Migrate from Runrun.it to Jira

Field-level mapping, validation, and rollback between Runrun.it and Jira. We move data and schema; workflows are rebuilt natively in Jira.

Runrun.it logo

Runrun.it

Source

Jira

Destination

Jira logo

Compatibility

80%

8 of 10

objects map 1:1 between Runrun.it and Jira.

Complexity

CModerate

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Runrun.it to Jira is a platform-native migration that restructures how work is organized. Runrun.it uses a flat Kanban-stage model per Project with time tracking embedded directly in Tasks; Jira uses Issue types (Bug, Story, Task, Epic) with configurable Workflow statuses and separates time tracking into a Logs tab on each Issue. We map Runrun.it Projects to Jira Projects, Tasks to Jira Issues with appropriate type assignment, Kanban stage names to Jira Workflow statuses, and time entries to Jira worklog fields or a custom time-tracking schema configured before migration. Runrun.it's two-step document upload—API record creation followed by S3 file push—requires us to handle both steps so that attachments arrive as live links in Jira rather than broken records. Workflows, automations, AI reports, and the Kanban board layout do not migrate as configuration; we deliver a written inventory of these for your admin to rebuild in Jira's native workflow designer. Kanban stages configured per Project in Runrun.it map to Jira Workflow status values scoped to each Project's Issue type.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

Runrun.it logo

Runrun.it

What's pushing teams away

  • Users report glitches including unresponsive features and visual bugs that disrupt daily efficiency, appearing across multiple review platforms.
  • The lack of a native mobile application makes it difficult for remote workers to access and update tasks outside of desktop browsers.
  • Creating tasks and marking them complete requires excessive clicking, with users noting the overhead consumes time better spent on actual work.
  • Structural flexibility is limited once the platform is configured, with users unable to keep part of a team on a free plan while others upgrade.
  • Time tracking features have known issues including accuracy problems that frustrate teams relying on Runrun.it for billable hour reporting.

Choosing

Jira logo

Jira

What's pulling them in

  • Industry-standard tool with deep Git integration and sprint reporting that engineering teams already know, reducing onboarding friction for new hires.
  • Highly customizable workflows and status schemes let business teams model complex approval chains without writing code.
  • Strong ecosystem of Atlassian Marketplace apps means specialized capabilities like time tracking or portfolio management are one install away.
  • Free tier with up to 10 users and unlimited issues gives small teams a no-cost entry point to validate the platform before committing budget.
  • Visibility features — boards, backlog grooming, sprint reports, and dashboards — give leadership a shared view of what is planned, in progress, blocked, and done.

Object mapping

How Runrun.it objects map to Jira

Each row shows how a Runrun.it object lands in Jira, including any object-level transformations, lookup resolution, or schema-design dependencies.

Typical mapping — final map is confirmed during the sample migration step.

Runrun.it

Project

maps to

Jira

Project

1:1
Fully supported

Runrun.it Projects map directly to Jira Projects. The Project name, description, start date, and end date migrate as Project metadata. We create Jira Projects in the destination instance before any Issue migration so that parent-project references are satisfied at insert time. Jira Projects require a Project key (e.g., PROJ) that is derived from the Runrun.it project name if not pre-configured by the customer's admin.

Runrun.it

Task

maps to

Jira

Issue (Task, Bug, Story, Epic)

1:1
Fully supported

Runrun.it Tasks map to Jira Issues. We assign Issue types based on Task metadata: Tasks with bug-related labels or status indicators map to Jira Bug; Tasks marked as deliverables or user-facing work map to Jira Story; general work items map to Jira Task; and epics or top-level milestones map to Jira Epic. The Runrun.it task priority, due date, estimated hours, and actual hours migrate to Jira Priority, Due Date, and custom time-tracking fields. The Kanban stage name becomes the initial Jira status by resolving it against the destination Project's Workflow statuses.

Runrun.it

Kanban Stage

maps to

Jira

Workflow Status

lossy
Fully supported

Runrun.it Kanban stages are free-form and configurable per Project. Jira Workflow statuses are defined per Project and Issue type combination. We inventory every distinct stage name across all Runrun.it Projects during discovery, map each to a corresponding Jira status (To Do, In Progress, In Review, Done, Blocked), and configure the Jira Workflow with matching transitions before Issue migration begins. Stages that have no Jira equivalent go to a reconciliation list for the admin to define.

Runrun.it

Time Entry

maps to

Jira

Worklog (or custom time field)

lossy
Fully supported

Runrun.it time entries track date, duration, and optional notes against Tasks. Jira stores worklogs on each Issue via the worklog field or in the Logs tab. We migrate time entries as Jira worklog entries linked to the parent Issue, preserving date, duration, and description. If Jira's native worklog is insufficient for billing workflows, we create custom fields (Time Entry Date, Duration, Billable flag) during schema setup and populate those instead. Duration rounding is explicit: we convert Runrun.it's duration format to Jira's time-tracking units to avoid silent rounding differences.

Runrun.it

Document

maps to

Jira

Attachment

1:1
Fully supported

Runrun.it's two-step document upload requires us to POST to the document creation endpoint first, then push the file to the returned Amazon S3 presigned URL. We handle both steps during migration. The file is downloaded from S3, re-uploaded to Jira as an Issue Attachment via the Jira REST API, and linked to the parent Issue. If the S3 bucket credentials are unavailable or expired, we flag the document record as broken-link and deliver a list of unresolved attachments for the customer to re-upload manually.

Runrun.it

User/Member

maps to

Jira

User

1:1
Fully supported

Runrun.it Users with roles, email addresses, and hourly rates map to Jira Users. We resolve Jira Users by email match against the destination instance's user directory. Any Runrun.it User without a matching Jira User is placed in a reconciliation queue for the customer's Jira admin to provision before record migration resumes. Hourly rate maps to a custom field on the User record if billing visibility is required in Jira.

Runrun.it

Custom Field

maps to

Jira

Custom Field

1:1
Fully supported

Runrun.it custom fields on Tasks use field_label in the API and are configurable per Project. We migrate custom field definitions and values as Jira custom fields of equivalent type (text, number, date, select, multi-select). Jira Cloud requires custom fields to be created in the destination instance before data import; we create them via the Jira REST API before migration and map field values per Issue. Custom fields that do not map to a Jira field type (e.g., complex structured data) are stored as JSON in a text custom field and flagged for the admin's review.

Runrun.it

Tag

maps to

Jira

Label

1:1
Fully supported

Runrun.it tags_data arrays on Tasks map to Jira Labels. Labels are added to Issues via the Jira Labels REST API during migration. Jira Labels are project-scoped by default; we apply labels consistently across Issues regardless of project context so that the tagging taxonomy from Runrun.it is preserved. Jira's label storage limit is respected per Issue.

Runrun.it

Attachment (URL-based)

maps to

Jira

Attachment (URL-based)

1:1
Fully supported

Runrun.it attachments of type URL (link-based, not file-based) migrate as Jira remote issue links via the remotelinks API endpoint. The attachable_type and attachable_id relationship is preserved by linking the remote URL to the correct Jira Issue. If the remote URL is inaccessible at migration time, the link is logged as broken and delivered in a remediation list.

Runrun.it

Comment

maps to

Jira

Comment

1:1
Fully supported

Runrun.it comments are attached to Tasks. The API documentation does not expose a dedicated Comments endpoint, so we verify comment accessibility during discovery scoping. If comments are accessible via the Tasks endpoint or a related sub-resource, we migrate them as Jira Comments on the corresponding Issue, preserving author, timestamp, and body text. If comments are not accessible via API, we flag this gap in the discovery report and the customer decides whether to export manually or skip comment migration.

Gotchas + challenges

What specifically takes care here

Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.

Runrun.it logo

Runrun.it gotchas

High

Two-step document upload requires S3 coordination

Medium

No documented API rate limits

Medium

No mobile app means no mobile-only data

Low

Time tracking data requires currency and rounding alignment

Jira logo

Jira gotchas

High

Unsupported workflow validators silently skipped during migration

High

Custom fields converted to flat text labels when migrating to non-Jira platforms

Medium

Historical status-change timestamps lost when exporting without a Marketplace plugin

Medium

Attachment import failures from oversized files and JQL reference corruption

Medium

Points-based API rate limits enforced on Jira Cloud apps from March 2026

Pair-specific challenges

  • Runrun.it's two-step document upload requires S3 coordination

    Runrun.it uploads documents via a two-step flow: first POSTing to /api/v1.0/tasks/:task_id/documents to create the record, then uploading the file to an Amazon S3 presigned URL returned in the response. If we migrate only the document record without the actual file, attachments arrive as broken links in Jira. We handle both steps, download the file from S3, and push it to Jira as an Issue Attachment. If the S3 bucket credentials are invalid or expired, we flag each unresolved document with the original S3 URL and deliver a manual re-upload list to the customer.

  • Jira's API rate limits constrain batch migration throughput

    Jira Cloud enforces per-user rate limits on the REST API (typically 0-10 requests per second depending on tier). We implement exponential backoff with jitter and monitor for 429 responses to adjust pacing dynamically. For large migrations (over 50,000 Issues), we chunk requests into batches and alternate between API endpoints to distribute load. Runrun.it's undocumented rate limits compound the planning challenge: we use conservative initial pacing and calibrate based on observed 429 frequency.

  • Kanban stage names may not match Jira workflow statuses

    Runrun.it allows free-form Kanban stage names per Project, meaning two Projects can have stages named 'Review' and 'Em Revisao' (Portuguese) with different meanings. Jira Workflow statuses are shared across Issue types within a Project. We inventory all unique stage names during discovery, map them to Jira statuses that exist in the target workflow, and flag unmapped stages for the customer's Jira admin to add to the workflow before migration. Stage ordering is preserved via the Jira status category (To Do, In Progress, Done) where possible.

  • Jira's time tracking model differs from Runrun.it's embedded model

    Runrun.it embeds time tracking directly in Tasks with estimated hours, actual hours, and billable flags visible on the Task record. Jira separates time tracking into a Worklog tab on each Issue. We migrate time entries as Jira worklog entries, but Jira's native time tracking does not support billable hour categorization at the worklog level without a third-party app like Tempo. If the customer requires billable hour reporting, we pre-configure custom fields (Billable flag, Billing Rate) on the Issue schema before migration and map Runrun.it's billable flag into those fields.

  • Comments may not be accessible via Runrun.it API

    Runrun.it's public API documentation does not define a dedicated Comments endpoint. Comments may be accessible as a sub-resource of the Tasks endpoint or may not be accessible via API at all. We verify comment accessibility during discovery. If comments are inaccessible, we flag this gap and provide the customer with a manual export option (CSV or screen-scrape) to capture comment history before migration. We do not extract comments via unofficial or unsupported endpoints.

Migration approach

Six steps for a successful Runrun.it to Jira data migration

  1. Discovery and environment assessment

    We audit the Runrun.it instance for all Projects, Tasks, Time Entries, Documents, Users, Kanban stage names, custom field definitions, and tag taxonomy. We verify comment accessibility via the API and test S3 bucket credentials for document retrieval. We inventory Jira Cloud API rate limits for the destination instance's tier and confirm whether the destination is Jira Cloud or Jira Data Center. The discovery output is a written migration scope that lists all source objects, destination Jira Projects and Issue types to be created, and any unmapped elements requiring admin action before migration begins.

  2. Jira schema pre-configuration

    We configure the Jira destination before any data migration. This includes creating Jira Projects with appropriate keys, defining Issue types per Project, creating custom fields matching Runrun.it's custom field schema (including billable flag fields if required), and configuring the Workflow with status values that cover all Runrun.it Kanban stage names. The Workflow is configured in a Jira Sandbox or development instance first, then deployed to the production Jira Cloud instance. This step ensures the target schema exists and is validated before record migration begins.

  3. Sandbox migration and reconciliation

    We run a full migration into the Jira Sandbox environment using production-like data volume. The customer's Jira admin reviews the imported Issues, validates that Kanban stage mapping is correct, spot-checks time entries against the Runrun.it source, and confirms that document attachments are live links rather than broken records. Any mapping corrections—custom field type mismatches, status gaps, or document retrieval failures—are resolved in this phase before the production migration window opens.

  4. User provisioning and owner reconciliation

    We extract every Runrun.it User referenced on Tasks and Time Entries and match them by email against the Jira destination instance's User table. Any User without a matching Jira account is placed in a reconciliation queue. The customer's Jira admin provisions missing users (active or inactive depending on whether the Runrun.it user is still active) before production migration resumes. Owner assignments on Tasks migrate as Jira Issue Assignee once the User reconciliation is complete.

  5. Production migration in dependency order

    We execute production migration in this sequence: Jira Projects (created first), Jira Users (validated), Jira Issues (Tasks mapped from Runrun.it Tasks with Issue type assignment and status from Kanban stage), Time Entries (as Jira worklog entries linked to parent Issues), Attachments (via S3 retrieval and Jira Attachment API), and Comments (if accessible via API). Each phase emits a row-count reconciliation report showing source count, destination count, and error count before the next phase begins.

  6. Cutover, validation, and workflow rebuild handoff

    We freeze Runrun.it writes during cutover, run a delta migration for any records modified during the migration window, then enable Jira as the system of record. We deliver a written inventory of Runrun.it Kanban board configurations, AI report definitions, and any automation or workflow logic for the customer's Jira admin to rebuild in Jira's native workflow designer. We do not rebuild Runrun.it automations as Jira automations or Jira ScriptRunner scripts within the migration scope. We support a five-business-day hypercare window for reconciliation issues raised by the team post-cutover.

Platform deep dives

Context on both ends of the pair

Runrun.it logo

Runrun.it

Source

Strengths

  • Integrated time tracking embedded directly into Tasks with billable hour reporting for service teams.
  • Kanban-based workflow visualization with configurable stages per Project.
  • AI-enabled productivity reports and dashboards for manager-level visibility into team performance.
  • Built by Managers for Managers, with a focus on project cost control and hour-based billing.

Weaknesses

  • No native mobile application, limiting remote access for teams without consistent desktop availability.
  • Users report visual glitches and UI bugs that disrupt daily productivity workflows.
  • Task creation and completion require excessive clicking, adding friction for high-volume users.
  • Limited structural flexibility once the platform is configured, with constraints on mixing free and paid users.
Jira logo

Jira

Destination

Strengths

  • Deeply customizable workflows and status schemes with no hard limits on workflow complexity or number of custom statuses.
  • Strong agile ceremony support: sprint planning, backlog grooming, velocity tracking, and burndown charts for Scrum teams.
  • Industry-standard developer tool with native Git integration linking commits, pull requests, and deployments to issues.
  • Large Atlassian Marketplace with thousands of plugins extending time tracking, portfolio management, and reporting capabilities.
  • Free tier available for up to 10 users with unlimited issues, enabling evaluation before committing to a paid plan.

Weaknesses

  • Excessive configurability creates a steep learning curve; cross-team consistency is hard to maintain without strict governance.
  • Performance degrades with large backlogs, complex custom fields, and heavily nested issue hierarchies.
  • Reporting requires additional configuration or paid plugins; out-of-the-box analytics are limited for business users.
  • Jira lacks native sprint management, requiring Jira Software for true agile team features.
  • Teams outside engineering resist adoption due to UI complexity, leaving the all-in-one promise unfulfilled for cross-functional organizations.

Complexity grading

How hard is this migration?

Moderate Project Management migration. 4 of 8 objects need a mapping; the rest are 1:1.

C

Overall complexity

Moderate migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Runrun.it and Jira.

  • Object compatibility

    C

    4 of 8 objects need a mapping; the rest are 1:1.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    8-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    Runrun.it: Not publicly documented.

  • Data volume sensitivity

    B

    Runrun.it doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your Runrun.it to Jira migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about Runrun.it to Jira data migrations

Answers to the questions buyers ask most during Runrun.it to Jira migration scoping. Not seeing yours? Book a call.

Can't find your answer?

Walk through your Runrun.it to Jira migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Migrations under 10,000 Tasks and 500 Projects with no complex custom field dependencies complete in three to five weeks. Migrations with extensive custom field schemas, large document volumes, multiple Kanban workflows to map, or a Jira Data Center destination move to six to ten weeks because of Jira API rate-limit handling, custom field pre-configuration, and Kanban stage reconciliation. Jira Cloud migrations run faster than Data Center because the REST API is the primary ingestion path; Data Center migrations may require database-level ingestion for large datasets.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Runrun.it.
Land in Jira, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day