Migrating from TestRail to Testmo: What's Different and How to Make the Switch
TestRail has been the default test management tool for years. It works, teams know it, and there's a lot of institutional knowledge built around its workflows. So why are teams switching to Testmo?
The short answer: TestRail was built for a world of manual waterfall QA, and the automation-first, continuous delivery workflows most teams run today are an awkward fit. Testmo was designed for how teams actually work in 2024.
This guide covers the key differences between TestRail and Testmo, the migration process, and what to expect during the transition.
Key Conceptual Differences
Understanding the differences before migrating prevents confusion when familiar concepts don't map directly.
Test Suite vs. Test Repository
In TestRail, test cases live in test suites, which belong to a specific project. Each project can have multiple suites, but suites can't easily share cases between projects.
In Testmo, test cases live in a test repository — a single folder hierarchy per project. There are no separate "suites" — you use folders and tags to organize cases. You can have as many nested folders as you need.
Migration impact: TestRail's suites become top-level folders in Testmo's repository. If you have "Smoke Tests" and "Regression" as separate suites, they become folders.
Test Plans and Configurations
TestRail's test plans handle multi-configuration testing — the same test suite against Chrome/Firefox/Safari, or against different data sets.
Testmo handles this with run configurations. You create a single run and add configurations to it. The test cases execute once per configuration, and results are shown in a matrix view.
Migration impact: TestRail test plans migrate to Testmo runs with configurations. The data maps cleanly; the workflow is slightly different.
Custom Fields
Both tools support custom fields on test cases and runs. TestRail's custom fields are system-wide by default (appear on all test cases in all projects). Testmo's custom fields are per-project, which is more flexible.
Migration impact: You'll need to recreate custom fields in Testmo and map them during import.
Automation Results
TestRail treats automation as a second-class citizen — you can mark test cases as "automated" and import results via the API, but it's bolted on. Testmo has a dedicated Automation section with its own run history, trend charts, and flakiness detection.
Migration impact: If you're already pushing results to TestRail via API, you'll move that integration to Testmo's CLI/API. This is usually an improvement — Testmo's automation reporting is significantly better.
Milestones
Both tools have milestones. They work similarly: group runs into a named release or sprint, track progress, generate aggregate reports.
Migration impact: Milestones migrate directly — name, description, and dates map cleanly. Associated runs may need manual relinking after import.
Step-by-Step Migration
Step 1: Export from TestRail
TestRail provides CSV export for test cases. Navigate to each suite in your project and export:
- Test cases:
Test Suite → Export → CSV - Test runs (if you want historical run data): TestRail doesn't export runs well — this is one area where you may need to accept that historical run data stays in TestRail for reference.
If you want full fidelity, use the TestRail API to export programmatically:
# Export all cases from a project
curl -u "user@example.com:$TESTRAIL_API_KEY" \
"https://your-instance.testrail.io/index.php?/api/v2/get_cases/1&suite_id=1" \
> testrail-cases.jsonStep 2: Transform the Data
TestRail's CSV format doesn't import directly into Testmo. You'll need a transformation step.
Testmo supports import via CSV with a mapping step in the UI. The fields map as follows:
| TestRail field | Testmo field |
|---|---|
| Title | Title |
| Section | Folder path |
| Type | Type |
| Priority | Priority |
| Estimate | Estimate |
| References | References |
| Steps | Steps (markdown format) |
| Expected Result | Expected Result |
| Preconditions | Preconditions |
| Custom fields | Custom fields (must pre-create) |
Steps in TestRail use a structured format (step + expected result pairs). Testmo's steps are markdown. You'll need to combine them:
Step 1: [action]
Expected: [expected result]
Step 2: [action]
Expected: [expected result]A simple Python script handles this transformation:
import csv
import json
def transform_testrail_to_testmo(input_file, output_file):
with open(input_file) as f:
reader = csv.DictReader(f)
cases = []
for row in reader:
case = {
'title': row.get('Title', ''),
'section': row.get('Section', ''),
'priority': row.get('Priority', 'Medium'),
'steps': f"**Steps:**\n{row.get('Steps', '')}\n\n**Expected:**\n{row.get('Expected Result', '')}",
'preconditions': row.get('Preconditions', ''),
'refs': row.get('References', ''),
}
cases.append(case)
with open(output_file, 'w') as f:
json.dump(cases, f, indent=2)
print(f"Transformed {len(cases)} test cases")
transform_testrail_to_testmo('testrail-export.csv', 'testmo-import.json')Step 3: Import into Testmo
Testmo's import wizard (Repository → Import) walks through field mapping:
- Upload your CSV
- Map TestRail column names to Testmo fields
- Map section/folder paths
- Review and confirm
For large repositories (1000+ cases), do a test import with a small subset first. Fix any mapping issues, then import the full set.
Step 4: Recreate Custom Fields
Before importing, set up custom fields in Testmo that match your TestRail custom fields:
- Go to Project Settings → Custom Fields
- Create fields matching your TestRail types (text, dropdown, checkbox, URL)
- Add these fields to your import mapping
Step 5: Migrate CI Integrations
Replace your TestRail API calls in CI with Testmo CLI calls:
TestRail (before):
# Add run result via TestRail API
curl -u "$TESTRAIL_USER:$TESTRAIL_API_KEY" \
-X POST \
-H "Content-Type: application/json" \
-d "{\"status_id\": 1, \"comment\": \"Test passed\"}" \
"https://instance.testrail.io/api/v2/add_result_for_case/$RUN_ID/$CASE_ID"Testmo (after):
# Submit full run via Testmo CLI
testmo automation:run:submit \
--instance "$TESTMO_INSTANCE" \
--project-id "$TESTMO_PROJECT_ID" \
--name "CI Build #$BUILD_NUMBER" \
--results results/junit.xmlThe Testmo approach is simpler — submit a JUnit XML file rather than making individual API calls per test case. If you're currently maintaining complex TestRail API integrations, this simplification is a benefit.
Step 6: Run Both in Parallel (2–4 Weeks)
Don't cut over immediately. Run TestRail and Testmo in parallel for 2–4 weeks:
- Continue your active TestRail test runs as-is
- Set up Testmo automation integrations and verify results are coming in correctly
- Create one test run in Testmo for a less-critical area and execute it
- Get team members familiar with the Testmo UI before their first real regression cycle
This parallel period catches integration issues and gives your team confidence before the full switch.
What to Expect During Transition
The UI Is Faster
TestRail is slow on large projects — loading a run with 500 cases can take several seconds. Testmo is noticeably faster. Most pages load in under a second. Your team will notice this immediately.
Search Is Better
Testmo's case search works well. TestRail's search has historically been unreliable — you sometimes can't find cases you know exist. In Testmo, searching for a test case by keyword, tag, or custom field value is fast and accurate.
Historical Data Stays in TestRail
You won't be able to see your historical run data from TestRail inside Testmo. The history starts when you start using Testmo. Most teams keep TestRail in read-only mode for a year after migration so they can look up old results if needed.
Your Team Needs 1–2 Days to Ramp Up
Testmo's concepts are familiar enough that anyone who's used TestRail can figure it out quickly. The main adjustment is the different organizational model (repository instead of suites) and the new automation section. Plan for a short orientation session with your QA team before the first live regression cycle in Testmo.
Integrations Need Updating
Any tool that integrates with TestRail needs to be updated: CI pipelines, Jira integrations, Slack notifications, any custom scripts that call the TestRail API. Inventory these before starting the migration so you don't discover missing integrations mid-rollout.
Is the Migration Worth It?
For teams heavily invested in TestRail with large repositories and established workflows, the migration has a real cost. Here's the honest assessment:
Worth switching if:
- You're already running automated tests and want better CI integration and reporting
- TestRail's slowness is affecting your team's productivity
- You're expanding to a new team that hasn't learned TestRail yet
- You're paying per-user TestRail pricing and Testmo's pricing is meaningfully better for your team size
Probably not worth switching if:
- You're on TestRail Cloud with a small team and it's working fine
- Your testing is entirely manual with no automation integration
- You recently did a major TestRail customization and your custom fields are deeply embedded
The teams that benefit most from Testmo are those doing a mix of manual and automated testing who want one system for both, and teams that find TestRail's performance or automation capabilities limiting.
Summary
Migrating from TestRail to Testmo is a medium-effort, high-value project for teams where TestRail's limitations are causing real friction. The conceptual differences are manageable — mostly naming changes and structural reorganization. The migration process takes 2–4 weeks if done carefully, and the parallel running period is worth it to avoid disruption during active regression cycles.
The payoff: a faster, more modern tool with better automation integration, better reporting, and a pricing model that doesn't penalize you for having many projects.