Project Management migration
Field-level mapping, validation, and rollback between Runrun.it and Jira. We move data and schema; workflows are rebuilt natively in Jira.
Runrun.it
Source
Jira
Destination
Compatibility
8 of 10
objects map 1:1 between Runrun.it and Jira.
Complexity
CModerate
Timeline
3-5 weeks
Overview
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.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
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
Jira
Project
1:1Runrun.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
Jira
Issue (Task, Bug, Story, Epic)
1:1Runrun.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
Jira
Workflow Status
lossyRunrun.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
Jira
Worklog (or custom time field)
lossyRunrun.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
Jira
Attachment
1:1Runrun.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
Jira
User
1:1Runrun.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
Jira
Custom Field
1:1Runrun.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
Jira
Label
1:1Runrun.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)
Jira
Attachment (URL-based)
1:1Runrun.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
Jira
Comment
1:1Runrun.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.
| Runrun.it | Jira | Compatibility | |
|---|---|---|---|
| Project | Project1:1 | Fully supported | |
| Task | Issue (Task, Bug, Story, Epic)1:1 | Fully supported | |
| Kanban Stage | Workflow Statuslossy | Fully supported | |
| Time Entry | Worklog (or custom time field)lossy | Fully supported | |
| Document | Attachment1:1 | Fully supported | |
| User/Member | User1:1 | Fully supported | |
| Custom Field | Custom Field1:1 | Fully supported | |
| Tag | Label1:1 | Fully supported | |
| Attachment (URL-based) | Attachment (URL-based)1:1 | Fully supported | |
| Comment | Comment1:1 | Fully supported |
Gotchas + challenges
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 gotchas
Two-step document upload requires S3 coordination
No documented API rate limits
No mobile app means no mobile-only data
Time tracking data requires currency and rounding alignment
Jira gotchas
Unsupported workflow validators silently skipped during migration
Custom fields converted to flat text labels when migrating to non-Jira platforms
Historical status-change timestamps lost when exporting without a Marketplace plugin
Attachment import failures from oversized files and JQL reference corruption
Points-based API rate limits enforced on Jira Cloud apps from March 2026
Pair-specific challenges
Migration approach
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.
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.
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.
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.
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.
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
Runrun.it
Source
Strengths
Weaknesses
Jira
Destination
Strengths
Weaknesses
Complexity grading
Moderate Project Management migration. 4 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Moderate migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Runrun.it and Jira.
Object compatibility
4 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
Runrun.it: Not publicly documented.
Data volume sensitivity
Runrun.it doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Runrun.it to Jira migration scoping. Not seeing yours? Book a call.
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 consultationAdjacent paths
Other ways to leave Runrun.it
Other ways to arrive at Jira
Same-Project Management migrations
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.