Skip to main content

Export & Import

NirmIQ provides powerful export and import capabilities to help you share, backup, and migrate your requirements data.

Import Methods Overview​

NirmIQ offers four import methods to suit your needs:

MethodBest ForTierData Privacy
📊 Manual ImportPre-formatted Excel/JSONFree+✅ Private
🧠 Intelligent ImportWord/Excel with varied columnsBasic+ ($49)✅ Private
🤖 AI ImportUnstructured narrative docsAdvanced+ ($99)⚠️ External API
🔧 ReqIF ImportEnterprise tool integrationFree+✅ Private

📚 See Import Methods Comparison for detailed decision guide

Import Methods in Detail​

📊 Manual Import (Standard Feature)​

What it is: Import pre-formatted Excel or JSON files directly into your project.

Best for:

  • ✅ Migrating from other requirements tools
  • ✅ Restoring from backups
  • ✅ Importing data you've already structured
  • ✅ Quick, predictable imports

Key Benefits:

  • Free - No AI tokens used, available on all tiers
  • Fast - Imports complete in seconds
  • 100% Accurate - Your data exactly as you formatted it
  • Full Control - You decide the structure and hierarchy

What you need:

  • Excel file with columns: ID, Text, Type, Status, Version, Parent ID
  • OR JSON file with requirements array
  • Data must be pre-formatted by you

Example Use Case:

You're migrating 200 requirements from Jira:
1. Export from Jira to Excel
2. Format columns to match IntelliSE
3. Import via Manual Import
4. ✅ Done in 30 seconds

🧠 Intelligent Import (Basic Tier Feature) - NEW​

What it is: Upload Word or Excel documents and the wizard automatically detects requirements using pattern recognition - no AI required, your data stays completely private.

Best for:

  • 🔒 When data privacy is required (regulated industries)
  • 📊 Word documents with tables or numbered lists
  • 📋 Excel files with non-standard column names
  • 💰 Cost-effective alternative to AI import

Key Benefits:

  • Data Privacy - No external AI APIs, data stays on your server
  • Automatic Column Detection - Recognizes 50+ column name synonyms
  • INCOSE Compliance - Validates requirements against industry standards
  • Confidence Scoring - Shows extraction reliability
  • Affordable - Available on Basic tier ($49/mo)

What it handles:

  • Word tables with requirement data (95% confidence)
  • Numbered/bulleted requirement lists (80% confidence)
  • Heading-based structures (85% confidence)
  • Excel with varied column names ("Req ID", "Description", etc.)

Example Use Case:

Customer sends requirements.docx with tables:
┌────────┬─────────────────────┬───────────┐
│ Req ID │ Description         │ Category  │
├────────┼─────────────────────┼───────────┤
│ REQ-01 │ System shall...     │ Functional│
└────────┴─────────────────────┴───────────┘

1. Upload to Intelligent Import
2. Wizard detects: "Req ID" → ID, "Description" → Text
3. Review INCOSE compliance warnings
4. Import with confidence
✅ Done in 2 minutes, data never leaves your server

📚 See Intelligent Import Guide for detailed instructions

🤖 AI-Powered Import (Advanced Feature)​

What it is: Upload a Word document and AI automatically extracts, structures, and organizes requirements.

Best for:

  • 🚀 Converting legacy Word documents
  • 🚀 Parsing customer requirement specifications
  • 🚀 Processing RFPs, RFQs, or SOWs
  • 🚀 When you don't want to manually format data

Key Benefits:

  • Intelligent Parsing - AI reads natural language and extracts requirements
  • Automatic Hierarchy - AI determines parent-child relationships
  • Time-Saving - Converts documents in minutes vs. hours of manual work
  • Context-Aware - Can use your methodology documents to guide parsing
  • Type Detection - AI classifies requirement types automatically

What you need:

  • Word document (.docx) with requirements in natural language
  • Optional: Methodology document for better accuracy
  • Advanced tier subscription or higher

Example Use Case:

Customer sends 50-page requirements.docx:
1. Upload to AI Import
2. AI extracts 300 requirements
3. AI creates CR → SYS → SUB hierarchy automatically
4. Review and fix any issues (usually 5-10%)
5. ✅ Done in 5 minutes vs. 3-4 hours manual work

ROI: $50 tier saves you 4 hours @ $100/hr = $400 value

Side-by-Side Comparison​

Feature📊 Manual Import🧠 Intelligent Import🤖 AI Import
Input FormatExcel (.xlsx) or JSONWord (.docx) or ExcelWord (.docx)
Data StructureMust be pre-formattedSemi-structured (tables, lists)Natural language text
Column DetectionManual (exact names)Automatic (50+ synonyms)N/A
Hierarchy CreationYou create manuallyPattern-detectedAI detects automatically
INCOSE Validation❌ No✅ Yes❌ No
Processing TimeSecondsSeconds1-3 minutes
Accuracy100% (your data)85-95% (pattern-based)90-95% (AI review needed)
Data Privacy✅ 100% Private✅ 100% Private⚠️ Sent to AI API
CostFree, all tiersBasic tier ($49/mo)Advanced+ tier ($99/mo)
Best UsePre-formatted dataSemi-structured docsUnstructured narrative
Quota LimitsUnlimitedUnlimitedDaily AI limits apply

When to Use Each Method​

Use Manual Import When:​

  • ✅ Migrating from another tool - Jira, Excel, or other systems with structured exports
  • ✅ Restoring backups - Re-importing previously exported data
  • ✅ You have time to format - Data is already organized or you prefer control
  • ✅ 100% accuracy required - No room for interpretation errors
  • ✅ Free tier user - Don't have Intelligent or AI import access
  • ✅ Small datasets - Formatting 10-50 requirements is quick

Use Intelligent Import When:​

  • 🧠 Data privacy is critical - Regulated industries, sensitive IP
  • 🧠 Word tables - Documents with requirement tables (non-standard columns)
  • 🧠 Excel with varied columns - "Req ID", "Description", "Category" etc.
  • 🧠 Numbered requirement lists - 1.0, 1.1, 1.1.1 format
  • 🧠 INCOSE compliance needed - Want requirements validated against standards
  • 🧠 Cost-conscious - Basic tier ($49) vs Advanced ($99)

Use AI Import When:​

  • 🤖 Unstructured narrative - Pure prose without clear structure
  • 🤖 Legacy documentation - Converting old Word docs with mixed formats
  • 🤖 Customer deliverables - RFPs, RFQs, specifications in Word format
  • 🤖 Complex hierarchy - Let AI figure out deep parent-child relationships
  • 🤖 No patterns to detect - Document has no tables, lists, or numbering
  • 🤖 Data privacy not a concern - OK sending to external AI API

Real-World ROI Examples​

Example 1: Startup (Free Tier)​

Scenario: 50 requirements from Excel template

Manual Import:

  • Time: 2 minutes (format Excel template)
  • Cost: $0
  • ✅ Best choice: Quick and free

AI Import:

  • Not available on Free tier
  • ❌ Not applicable

Example 2: Small Business (Basic Tier - $49/mo)​

Scenario: Customer sends 20-page Word document with tables

Manual Import:

  • Time: 3-4 hours (read doc, extract requirements, format in Excel)
  • Cost: $0 (but significant time cost)

Intelligent Import:

  • Time: 20 minutes (upload, review mappings, import)
  • Cost: $49/mo (Basic tier)
  • Data Privacy: ✅ Stays private
  • 💰 ROI: Save 3.5 hours @ $50/hr = $175 value per import

AI Import:

  • Not available on Basic tier
  • Must upgrade to Advanced ($99/mo)
  • ⚠️ Decision: If doc is unstructured narrative, upgrade to Advanced

Example 3: Engineering Team (Advanced Tier - $99/mo)​

Scenario: Converting 10 legacy spec documents (200 pages total)

Manual Import:

  • Time: 40+ hours of engineer time
  • Cost: $4,000 (40 hrs × $100/hr labor)

AI Import:

  • Time: 2-3 hours (upload + review)
  • Cost: $99/mo + 3 hrs review = $99 + $300 = $399
  • 💰 ROI: Save $3,601 (90% cost reduction)
  • ✅ Best choice: Massive time savings

Example 4: Enterprise (Power/Enterprise Tier)​

Scenario: Processing monthly RFPs from multiple customers

Manual Import:

  • Time: 80 hours/month
  • Cost: $8,000/month in labor

AI Import:

  • Time: 8 hours/month (review only)
  • Cost: $299/mo tier + $800 labor = $1,099
  • 💰 ROI: Save $6,901/month ($82,812/year)
  • ✅ Best choice: Essential for high-volume work

Value Proposition: Why AI Import is Worth It​

Time Savings​

Manual formatting is tedious:

  • Read document → Extract requirement → Type into Excel → Set hierarchy → Repeat 100+ times
  • Average: 2-3 minutes per requirement
  • 100 requirements = 3-5 hours of monotonous work

AI import is automatic:

  • Upload document → AI processes → Review results
  • Same 100 requirements = 5-10 minutes

Time saved: 2.5-4.5 hours per 100 requirements

Accuracy & Intelligence​

AI Features You Can't Get Manually:

  1. Automatic Hierarchy Detection - AI understands document structure and nesting
  2. Type Classification - AI determines if requirement is Functional, Safety, Performance, etc.
  3. Parent-Child Linking - AI creates relationships based on context
  4. Smart Numbering - AI applies your hierarchy scheme automatically
  5. Methodology Awareness - Can learn from your best practices documents

Example:

Input (Word Document):
"The collision detection system shall:
1. Scan at 10Hz
2. Detect objects within 100m
3. Alert driver within 2.5 seconds"

AI Output:
CR001: "The collision detection system requirements"
├─ CR001.SYS-001: "Scan at 10Hz"
├─ CR001.SYS-002: "Detect objects within 100m"
└─ CR001.SYS-003: "Alert driver within 2.5 seconds"

Manual would require you to:
- Identify this is a parent with 3 children
- Create CR001 manually
- Create each SYS requirement
- Link them correctly
- Repeat for every section

Cost Justification by Tier​

Advanced Tier ($99/mo):

  • Includes 50 AI document imports/month
  • If you save just 2 hours on 1 import/week = 8 hrs/month
  • At $50/hr labor rate = $400 value
  • ROI: 4x return on investment

Power Tier ($299/mo):

  • Includes unlimited AI imports
  • High-volume teams processing 10+ documents/month
  • Saves 40+ hours/month easily
  • At $100/hr labor rate = $4,000+ value
  • ROI: 13x return on investment

Hybrid Workflow (Best of Both Worlds)​

Many teams use both methods together:

Step 1: AI Import - Let AI do the heavy lifting

Upload customer_requirements.docx
→ AI extracts 200 requirements
→ Creates hierarchy automatically

Step 2: Export to Excel - Review AI work

Export to Excel
→ Review AI classifications
→ Fix any mistakes (typically 5-10%)
→ Add missing metadata

Step 3: Manual Import - Perfect results

Import cleaned Excel file
→ 100% accurate
→ Complete control

Result: 80% time savings with 100% accuracy

Tier Comparison: Import Access​

TierManual ImportIntelligent ImportAI ImportBest For
Free✅ Unlimited❌ No❌ NoLearning, small projects
Basic ($49)✅ Unlimited✅ Unlimited❌ NoData privacy, semi-structured docs
Advanced ($99)✅ Unlimited✅ Unlimited✅ 50 docs/moRegular doc conversions
Power ($299)✅ Unlimited✅ Unlimited✅ UnlimitedHigh-volume processing
Enterprise✅ Unlimited✅ Unlimited✅ UnlimitedMission-critical work

💡 Upgrade Recommendation:

  • Need data privacy + smart import? → Basic tier ($49)
  • Processing unstructured docs? → Advanced tier ($99)
  • Processing 5+ Word docs/week? → Power tier essential
  • Enterprise features needed? → Contact sales

Getting Started​

With Manual Import (All Tiers)​

  1. Prepare your Excel or JSON file with exact column names
  2. Go to Project → Import Requirements...
  3. Select format and upload
  4. ✅ Done!

📚 See detailed instructions below in the "Importing Requirements" section

With Intelligent Import (Basic+ Tiers) - NEW​

  1. Prepare your Word (.docx) or Excel (.xlsx) file
  2. Go to Project → Import with Wizard
  3. Upload your document
  4. Review detected columns and mappings
  5. Check INCOSE compliance warnings
  6. Click Import
  7. ✅ Done!

📚 See Intelligent Import Guide for detailed instructions

With AI Import (Advanced+ Tiers)​

  1. Prepare your Word document (.docx)
  2. Go to Project → AI-Powered Document Import
  3. Upload requirements doc (and optional methodology doc)
  4. Wait for AI processing (1-3 minutes)
  5. Review imported requirements
  6. ✅ Done!

📚 See AI Import Guide for detailed instructions

With ReqIF Import (All Tiers - Advanced Users)​

  1. Export ReqIF file from your enterprise tool (IBM DOORS, Jama, Polarion, etc.)
  2. Go to Project → Import Requirements...
  3. Select ReqIF (.reqif) format
  4. Upload .reqif file
  5. Wait for processing (30s-3 minutes)
  6. ✅ Done!

📚 See ReqIF Advanced Guide for detailed instructions

Exporting Requirements​

You can export your project requirements in multiple formats to suit different needs.

Export Formats​

Excel (.xlsx)​

Export your requirements to a Microsoft Excel spreadsheet for easy sharing and analysis.

How to Export:

  1. Open your project
  2. Click Project → Export → Export to Excel (.xlsx)
  3. Your file will be downloaded automatically

Excel Format:

  • ID: Requirement custom ID (e.g., CR001, SYS-001)
  • Type: Requirement type
  • Text: Full requirement text
  • Status: Current status (Draft, Active, etc.)
  • Version: Version number
  • Parent ID: Parent requirement ID (if applicable)
  • Jira Link: Associated Jira ticket (if configured)

Best For:

  • Sharing with stakeholders who prefer spreadsheets
  • Data analysis and filtering
  • Creating custom reports
  • Archiving requirements

PDF​

Generate a professional PDF document of your requirements for formal documentation.

How to Export:

  1. Open your project
  2. Click Project → Export → Export to PDF
  3. Your PDF will be downloaded automatically

PDF Includes:

  • Project name and generation date
  • Table with: ID, Type, Text (truncated), Status, Version
  • Clean, professional formatting
  • IntelliSE branding

Best For:

  • Formal documentation
  • Review meetings
  • Regulatory submissions
  • Read-only distribution
  • Printing

JSON (Full Project)​

Export the complete project data in JSON format for backup or migration.

How to Export:

  1. Open your project
  2. Click Project → Export → Export to JSON (Full Project)
  3. Your JSON file will be downloaded

JSON Structure:

{
  "project": {
    "name": "Project Name",
    "description": "Project description",
    "exported_at": "2025-10-10T12:00:00.000Z"
  },
  "requirements": [
    {
      "custom_id": "CR001",
      "text": "Requirement text",
      "type": "Customer Request",
      "status": "Draft",
      "version": "1.0",
      "parent_custom_id": null,
      "jira_link": null
    }
  ]
}

Best For:

  • Complete project backups
  • Migrating between IntelliSE instances
  • Programmatic access to data
  • Version control (Git)
  • Automation and scripting

ReqIF (.reqif) - Advanced​

Advanced Feature

ReqIF export is designed for advanced users who need to integrate with enterprise requirements management tools like IBM DOORS, Jama Connect, PTC Integrity, Siemens Polarion, and other OMG ReqIF-compliant systems.

For simpler exports, use Excel or JSON formats above.

How to Export:

  1. Open your project
  2. Click Project → Export → Export to ReqIF (.reqif)
  3. Your ReqIF file will be downloaded

ReqIF Includes:

  • OMG ReqIF 1.2 compliant XML structure
  • Complete requirement hierarchy (parent-child relationships)
  • All requirement attributes (ID, text, type, status, version)
  • Metadata (project name, export timestamp, tool info)
  • Valid XML structure compatible with enterprise tools

Best For:

  • Exchanging requirements with customers using different tools
  • Automotive/Aerospace/Defense supplier collaboration
  • Regulatory compliance (ISO 26262, DO-178C, IEC 62304, ASPICE)
  • Long-term archival (tool-neutral format)
  • Migration from/to IBM DOORS, Jama, Polarion, PTC Integrity

📚 See ReqIF Advanced Guide for detailed documentation

Importing Requirements​

Import requirements from Excel or JSON files to quickly populate your projects.

Import from Excel​

Import requirements from a properly formatted Excel spreadsheet.

How to Import:

  1. Open your project
  2. Click Project → Import Requirements...
  3. Select Excel (.xlsx) format
  4. Click the file input and select your .xlsx file
  5. Wait for the import to complete

Required Excel Columns:

  • ID (or custom_id): Unique identifier
  • Text (or text): Requirement description
  • Type (or type): Requirement type
  • Status (or status): Status (optional, defaults to "Draft")
  • Version (or version): Version number (optional, defaults to "1.0")
  • Parent ID (or parent_custom_id): Parent requirement (optional)

Example Excel:

IDTextTypeStatusVersionParent ID
CR001System shall...Customer RequestDraft1.0
CR001.SYS-001The system shall...System RequirementDraft1.0CR001

Tips:

  • Column names are case-insensitive
  • Can use either "ID" or "custom_id" format
  • Parent ID can be empty for root requirements
  • Invalid rows will be skipped with console errors

Import from JSON​

Import requirements from a JSON file (exported from IntelliSE or custom-created).

How to Import:

  1. Open your project
  2. Click Project → Import Requirements...
  3. Select JSON format
  4. Click the file input and select your .json file
  5. Wait for the import to complete

Required JSON Format:

{
  "requirements": [
    {
      "custom_id": "CR001",
      "text": "Requirement description",
      "type": "Customer Request",
      "status": "Draft",
      "version": "1.0",
      "parent_custom_id": null,
      "jira_link": ""
    }
  ]
}

Tips:

  • JSON must contain a "requirements" array
  • Each requirement must have: custom_id, text
  • Optional fields will use defaults
  • Invalid requirements will be skipped

Import from ReqIF - Advanced​

Advanced Feature

ReqIF import is designed for advanced users who need to import requirements from enterprise tools like IBM DOORS, Jama Connect, PTC Integrity, Siemens Polarion, and other OMG ReqIF-compliant systems.

For simpler imports, use Excel or JSON formats above.

How to Import:

  1. Export ReqIF file from your source tool (DOORS, Jama, Polarion, etc.)
  2. Open your IntelliSE project
  3. Click Project → Import Requirements...
  4. Select ReqIF (.reqif) format
  5. Upload your .reqif file
  6. Wait for processing (30 seconds to 3 minutes depending on size)
  7. Review imported requirements

What Gets Imported:

  • ✅ Requirement ID (from LONG-NAME or ID attribute)
  • ✅ Requirement text (from text attributes)
  • ✅ Type classification (from SPEC-OBJECT-TYPE)
  • ✅ Status (from status attributes or inferred)
  • ✅ Version number (from version attributes or default 1.0)
  • ✅ Complete hierarchy (parent-child relationships from SPEC-HIERARCHY)

Supported Sources:

  • IBM DOORS Classic (via ReqIF export plugin)
  • IBM DOORS Next (native ReqIF support)
  • Jama Connect
  • PTC Integrity
  • Siemens Polarion
  • Any OMG ReqIF 1.0, 1.1, or 1.2 compliant tool

Limitations:

  • Rich text (XHTML) converted to plain text
  • Custom attributes not in IntelliSE schema are skipped
  • Embedded objects (.reqifz) not yet supported
  • Complex relations simplified to parent-child only

📚 See ReqIF Advanced Guide for detailed documentation and troubleshooting

Use Cases​

Backup and Restore​

  1. Backup: Export to JSON regularly
  2. Store: Save JSON files in version control or cloud storage
  3. Restore: Import JSON file to recreate project

Migration​

  1. Export from old system to Excel
  2. Format Excel to match IntelliSE columns
  3. Import into new IntelliSE project

Collaboration​

  1. Export to Excel for stakeholder review
  2. Stakeholders add comments/changes in Excel
  3. Review changes and manually update in IntelliSE

Reporting​

  1. Export to PDF for formal documentation
  2. Export to Excel for custom analysis
  3. Use Excel pivot tables and charts

Enterprise Integration (ReqIF)​

  1. Receive requirements from customer via ReqIF (from DOORS, Jama, etc.)
  2. Import to IntelliSE for development work
  3. Export updated requirements back to customer via ReqIF
  4. Maintain perfect traceability and compliance

Format Comparison​

FeatureExcelPDFJSONReqIF
File Extension.xlsx.pdf.json.reqif
Human Readable✅ Yes✅ Yes⚠️ Technical❌ XML
Editable✅ Yes❌ No✅ Yes✅ Yes (in tools)
Import Support✅ Yes❌ No✅ Yes✅ Yes
Hierarchy Preserved⚠️ Via Parent ID❌ No✅ Perfect✅ Perfect
Metadata⚠️ Limited⚠️ Limited✅ Full✅ Full
Tool Compatibility✅ Universal✅ Universal❌ IntelliSE only✅ Enterprise tools
Standards Compliance❌ None❌ None❌ None✅ OMG ReqIF 1.2
Best ForSharing, AnalysisDocumentationBackupsEnterprise integration
User LevelBeginnerBeginnerIntermediateAdvanced

Quick Selection Guide:

  • Need to share with stakeholders? → Excel or PDF
  • Need to backup your project? → JSON
  • Need enterprise tool integration? → ReqIF
  • Need regulatory compliance? → ReqIF
  • Just getting started? → Excel

Limitations​

Import Limitations​

  • Duplicate IDs: If a requirement with the same custom_id exists, import will fail for that row
  • Invalid Types: Type must match hierarchy configuration
  • Parent References: Parent ID must exist before importing child
  • File Size: Large files (>1000 requirements) may take time to import

Export Limitations​

  • PDF Text: Long requirement text is truncated in PDF (first 100 characters)
  • Hierarchy: Exported files don't include hierarchy configuration
  • FMEA: FMEA data is not included in requirement exports

Best Practices​

For Excel Export/Import​

✅ DO:

  • Use the exported Excel as a template for imports
  • Keep column names consistent
  • Include Parent ID for hierarchical relationships
  • Validate data before importing

❌ DON'T:

  • Don't rename required columns
  • Don't leave ID column empty
  • Don't import without reviewing data first
  • Don't modify the Excel structure drastically

For JSON Backup​

✅ DO:

  • Export to JSON before major changes
  • Store JSON files in version control
  • Use descriptive filenames with dates
  • Test restoration periodically

❌ DON'T:

  • Don't rely on JSON as only backup
  • Don't manually edit JSON without validation
  • Don't skip versioning your backups

For PDF Documentation​

✅ DO:

  • Generate PDFs for milestone reviews
  • Use PDF for regulatory submissions
  • Archive PDFs with project versions
  • Include in documentation packages

❌ DON'T:

  • Don't use PDF as editable format
  • Don't expect full text in PDF tables
  • Don't use PDF for data analysis

Troubleshooting​

Import Fails​

Problem: Import completes but no requirements added

Solutions:

  • Check console for errors (F12 → Console tab)
  • Verify Excel column names match requirements
  • Ensure requirement types match your hierarchy
  • Check for duplicate IDs

Excel Format Issues​

Problem: Excel file won't import

Solutions:

  • Save as .xlsx format (not .xls)
  • Remove formulas, use only values
  • Check for hidden rows/columns
  • Ensure no merged cells

Parent Relationship Errors​

Problem: Parent-child relationships not working

Solutions:

  • Import parents before children
  • Use exact parent custom_id
  • Leave Parent ID empty for root requirements
  • Check for typos in parent references

PDF Too Large​

Problem: PDF generation fails or is very large

Solutions:

  • Export in batches (filter by type first)
  • Reduce number of requirements
  • Use Excel for large datasets

Need Help?​