Import Methods Comparison

Choose the right import method for your needs. NirmIQ offers four import methods to handle any document type.

Quick Decision Guide

graph TD
    A[Need to Import Requirements?] --> B{What's your source?}
    B -->|Word Document| C{Is it structured?}
    B -->|Excel/JSON| D{Pre-formatted with exact columns?}
    B -->|Enterprise Tool Export| E{ReqIF file?}
    C -->|Tables/Numbered Lists| F[Intelligent Import]
    C -->|Narrative text| G[AI Import]
    C -->|Already in Excel format| H[Export to Excel first]
    D -->|Yes, matches template| I[Manual Import]
    D -->|No, varied columns| F
    E -->|Yes .reqif| J[ReqIF Import]
    E -->|No| D
    F --> K{Have Basic+ tier?}
    G --> L{Have Advanced+ tier?}
    H --> I
    K -->|Yes| M[Use Intelligent Import]
    K -->|No| N[Upgrade to Basic $49/mo]
    L -->|Yes| O[Use AI Import]
    L -->|No| P{Data privacy required?}
    P -->|Yes| N
    P -->|No| Q[Upgrade to Advanced $99/mo]
    J --> R[All tiers - Advanced users]

    style F fill:#f97316
    style G fill:#0ea5e9
    style I fill:#10b981
    style J fill:#8b5cf6
    style M fill:#f97316
    style O fill:#0ea5e9

---

At a Glance

	📊 Manual Import	🧠 Intelligent Import	🤖 AI Import	🔧 ReqIF Import
Input	Excel (.xlsx) or JSON	Word (.docx) or Excel	Word (.docx)	ReqIF (.reqif)
Tier	All (Free+)	Basic+ ($49/mo)	Advanced+ ($99/mo)	All (Free+)
Speed	Instant	Instant	1-3 minutes	30 sec - 3 min
Accuracy	100%	85-95%	90-95%	100%
Data Privacy	✅ Private	✅ Private	⚠️ Sent to AI API	✅ Private
Time to Prepare	5-60 minutes	None	None	None (if tool exports ReqIF)
Best For	Pre-formatted data	Semi-structured docs	Unstructured narrative	Enterprise integration
User Level	Beginner	Beginner	Intermediate	Advanced

---

Detailed Comparison

Input Format

Manual Import

Required: Pre-formatted Excel with EXACT column names
┌─────────────────────────────────────┐
│ ID     │ Text          │ Type       │
├─────────────────────────────────────┤
│ CR001  │ System shall...│ Customer  │
│ SYS-001│ Subsystem...  │ System    │
└─────────────────────────────────────┘

Columns must match: ID, Text, Type, Status, Version, Parent ID

Intelligent Import (NEW)

Input: Word/Excel with varied structure
┌─────────────────────────────────────┐
│ Req ID │ Description   │ Category   │
├─────────────────────────────────────┤
│ REQ-1  │ System shall...│ Functional│
│ REQ-2  │ Subsystem...  │ Safety    │
└─────────────────────────────────────┘

Pattern recognition maps columns automatically:
"Req ID" → ID, "Description" → Text, "Category" → Type

Also handles Word tables, numbered lists, headings

AI Import

Input: Natural language Word doc
┌─────────────────────────────────────┐
│ 1. Requirements                     │
│                                     │
│ The system shall provide collision  │
│ detection with the following:       │
│   - Scan at 10Hz                   │
│   - Detect within 100m             │
└─────────────────────────────────────┘

AI automatically creates:
CR001, CR001.SYS-001, CR001.SYS-002...

ReqIF Import

Input: Enterprise tool export (.reqif)
┌─────────────────────────────────────┐
│ <?xml version="1.0"?>               │
│ <REQ-IF>                            │
│   <SPEC-OBJECTS>                    │
│     <SPEC-OBJECT IDENTIFIER="REQ1"> │
│       <VALUES>                      │
│         <ATTRIBUTE-VALUE>           │
│           System shall detect...    │
│         </ATTRIBUTE-VALUE>          │
│       </VALUES>                     │
│     </SPEC-OBJECT>                  │
│   </SPEC-OBJECTS>                   │
│ </REQ-IF>                           │
└─────────────────────────────────────┘

Preserves complete hierarchy + metadata
From: IBM DOORS, Jama, Polarion, etc.

---

Processing Flow

Manual Import Flow

You → Format Excel → Upload → ✅ Done
     (5-60 min)      (instant)

Effort: Medium-High
Result: Perfect accuracy

Intelligent Import Flow (NEW)

You → Upload Word/Excel → Review mappings → Adjust if needed → ✅ Done
     (instant)           (instant)          (2-5 min)

Effort: Low
Result: 85-95% accuracy
Bonus: INCOSE compliance checking included

AI Import Flow

You → Upload Word → AI processes → Review → ✅ Done
     (instant)     (1-3 min)       (5 min)

Effort: Low
Result: 90-95% accuracy

ReqIF Import Flow

You → Export from tool → Upload ReqIF → Verify → ✅ Done
     (2-5 min)          (30s-3min)     (2 min)

Effort: Low (if tool supports ReqIF)
Result: 100% accuracy (structure preserved)

---

Use Case Scenarios

Scenario 1: Migrating from Jira

Best Choice: Manual Import ✅

Why:

• Jira exports to Excel already
• Data is structured
• Just need to map columns
• Free, instant

Steps:

1. Export from Jira (5 min)
2. Rename columns to match IntelliSE (2 min)
3. Import (instant)
4. Total: 7 minutes

---

Scenario 2: Customer sends Word doc with tables

Best Choice: Intelligent Import 🧠

Why:

• Document has requirement tables
• Column names vary ("Req ID" not "ID")
• Data must stay private (no AI APIs)
• Basic tier is affordable

Manual Approach:

• Copy tables to Excel: 1 hour
• Rename columns to match template: 30 min
• Import: instant
• Total: 1.5 hours

Intelligent Import Approach:

• Upload Word doc: instant
• Wizard detects tables automatically
• Review column mappings: 5 minutes
• Import: instant
• Total: 5 minutes

Time Saved: 1.4 hours (94% reduction) Privacy: ✅ Data never leaves your server

---

Scenario 3: Customer sends 50-page Narrative Spec

Best Choice: AI Import 🤖

Why:

• Document is narrative text (not tables)
• Manually extracting would take hours
• AI handles hierarchy automatically
• Worth the tier cost

Manual Approach:

• Read doc, extract requirements: 3 hours
• Format in Excel: 1 hour
• Import: instant
• Total: 4 hours

AI Approach:

• Upload doc: 1 minute
• AI processing: 2 minutes
• Review/fix: 15 minutes
• Total: 18 minutes

Time Saved: 3.7 hours (93% reduction)

---

Scenario 4: Weekly RFP Processing

Best Choice: AI Import 🤖 (Essential)

Without AI:

• 4 RFPs/week × 4 hours each = 16 hours/week
• 64 hours/month
• Cost: $6,400/month @ $100/hr

With AI:

• 4 RFPs/week × 20 minutes each = 1.3 hours/week
• 5.3 hours/month
• Cost: $299 (Power tier) + $530 labor = $829/month

Savings: $5,571/month ($66,852/year)

---

Scenario 5: Small Startup Budget

Best Choice: Manual Import ✅

Why:

• Free tier works perfectly
• Requirements are simple
• Can afford time to format
• Learning the tool

Approach:

• Use Excel template
• Format 50 requirements: 30 minutes
• Import: instant
• Cost: $0

---

Scenario 6: Data Privacy Required (Regulated Industry)

Best Choice: Intelligent Import 🧠

Why:

• Data cannot leave company servers
• Customer documents contain sensitive IP
• Regulatory requirements prohibit external AI
• Still need smart extraction (not manual formatting)

Approach:

• Upload Word/Excel: instant
• Pattern matching on your server (no external APIs)
• INCOSE compliance checking included
• Data Privacy: ✅ Guaranteed
• Cost: $49/mo (Basic tier)

---

Scenario 7: Automotive Supplier (Tier 1)

Best Choice: ReqIF Import 🔧

Why:

• OEM (customer) uses IBM DOORS
• Must maintain exact requirement structure
• ISO 26262 / ASPICE compliance required
• Tool interoperability essential

Workflow:

1. Receive 2,000 requirements from OEM via ReqIF
2. Import to IntelliSE (3 minutes)
3. Work on requirements in IntelliSE
4. Export updated ReqIF back to OEM
5. Perfect traceability maintained

Benefits:

• ✅ No manual reformatting
• ✅ 100% hierarchy preservation
• ✅ Audit trail maintained
• ✅ Standards compliant

---

ROI Calculator

Time Value Calculation

Manual Formatting Time:

• Simple requirement: 1-2 minutes
• Complex requirement: 3-5 minutes
• Average: 2.5 minutes per requirement

AI Processing Time:

• Any number of requirements: 1-3 minutes + review
• Review time: ~10% of requirements need fixing
• Average: 0.3 minutes per requirement

Breakeven Analysis

Advanced Tier: $99/month

Saves 2.2 minutes per requirement vs. manual

Breakeven: 45 requirements/month

• If you import 45+ requirements/month via AI
• You save more time than the tier costs
• At $50/hr: 45 req × 2.2 min = 99 minutes = $82.50 saved
• Pays for itself at 54 requirements/month

Power Tier: $299/month

Unlimited AI imports + other features

Breakeven: 135 requirements/month

• Best for teams processing documents weekly
• High-volume RFP/proposal work
• Multiple team members using AI

---

Common Questions

"Should I upgrade just for AI import?"

Upgrade if:

• ✅ You process 2+ Word docs/month
• ✅ Each doc has 50+ requirements
• ✅ Your time is worth $50+/hour
• ✅ You receive unstructured specs regularly

Don't upgrade if:

• ❌ You only import once
• ❌ Your data is already in Excel
• ❌ You're a solo free-tier user learning
• ❌ Requirements are simple/few

"When should I use ReqIF instead of Excel?"

Use ReqIF when:

• ✅ Exchanging requirements with enterprise tools (DOORS, Jama, Polarion)
• ✅ Working with automotive/aerospace/defense suppliers
• ✅ Compliance requires tool-neutral format (ISO 26262, DO-178C, IEC 62304)
• ✅ Need perfect hierarchy preservation across tools
• ✅ Long-term archival (20+ year readability)

Use Excel when:

• ❌ Simple data sharing within your team
• ❌ No enterprise tool integration needed
• ❌ Requirements are flat (no complex hierarchy)
• ❌ Just need human-readable format

"Can I use both methods?"

Yes! Many teams do:

1. AI Import for initial extraction
2. Export to Excel to review
3. Manual Import for final clean version

This gives you:

• Speed of AI
• Accuracy of manual review
• 100% control over final data

"What if AI makes mistakes?"

AI is 90-95% accurate:

• Most requirements perfect
• 5-10% need minor fixes
• Always review before committing

Common AI issues:

• Occasionally misses a requirement
• Might mis-classify type (easy fix)
• Rarely creates wrong hierarchy

Solution:

• Export AI results to Excel
• Review and fix
• Re-import with Manual Import

---

Pricing Tiers

Free ($0/month)

• ❌ No Intelligent Import
• ❌ No AI Import
• ✅ Manual Import unlimited
• ✅ ReqIF Import
• Best for: Learning, small projects

Basic ($49/month)

• ✅ Intelligent Import (Word + Excel)
• ❌ No AI Import
• ✅ Manual Import unlimited
• ✅ ReqIF Import
• ✅ INCOSE compliance checking
• Best for: Small teams, data privacy needs

Advanced ($99/month)

• ✅ Intelligent Import (Word + Excel)
• ✅ AI Import (50 docs/month)
• ✅ Manual Import unlimited
• ✅ ReqIF Import
• Best for: Regular doc conversion, mixed needs

Power ($299/month)

• ✅ Intelligent Import (unlimited)
• ✅ AI Import (unlimited)
• ✅ Manual Import unlimited
• ✅ ReqIF Import
• Best for: High-volume teams

Enterprise (Custom)

• ✅ Everything unlimited
• ✅ Custom AI training
• ✅ Custom synonym dictionaries
• Best for: Large organizations

---

Tips for Success

For Manual Import

✅ Do:

• Use our Excel template as starting point
• Keep column names exactly as required
• Validate data before importing
• Import in small batches to test

❌ Don't:

• Modify column structure
• Leave required fields empty
• Import without reviewing
• Mix different requirement formats

For Intelligent Import (NEW)

✅ Do:

• Use Word tables or Excel spreadsheets
• Include clear column headers
• Use consistent requirement patterns
• Review INCOSE compliance warnings
• Check column mappings before import

❌ Don't:

• Mix tables with narrative text in Word
• Use complex nested tables
• Embed requirements in images
• Skip the mapping review step

Best Practices:

• Tables with headers work best (95% accuracy)
• Numbered lists also work well (80% accuracy)
• If confidence is low, consider AI Import instead

For AI Import

✅ Do:

• Provide clean Word documents
• Include methodology docs for context
• Review AI output before committing
• Use hybrid workflow (AI + manual review)

❌ Don't:

• Expect 100% perfection
• Skip the review step
• Upload poor quality scans
• Forget to check hierarchy

---

Method Summary Table

Feature	Manual Import	Intelligent Import	AI Import	ReqIF Import
Input Format	Excel, JSON	Word, Excel	Word (.docx)	ReqIF (.reqif) XML
Pricing Tier	Free+	Basic+ ($49/mo)	Advanced+ ($99/mo)	Free+
Processing Time	Instant	Instant	1-3 minutes	30s - 3 minutes
Accuracy	100%	85-95%	90-95%	100%
Data Privacy	✅ Private	✅ Private	⚠️ External AI	✅ Private
Hierarchy Support	✅ Perfect	✅ Pattern-detected	✅ AI-detected	✅ Perfect
Column Detection	❌ Manual	✅ Automatic synonyms	N/A	✅ Automatic
INCOSE Validation	❌ No	✅ Yes	❌ No	❌ No
Metadata Preservation	⚠️ Manual mapping	⚠️ Pattern matching	⚠️ Extracted	✅ Full
Tool Compatibility	✅ Universal	✅ Word/Excel	❌ IntelliSE only	✅ Enterprise tools
Standards Compliance	❌ No standard	⚠️ INCOSE	❌ Proprietary	✅ OMG ReqIF 1.2
Best Use Case	Pre-formatted data	Semi-structured docs	Unstructured narrative	Enterprise integration
User Skill Level	Beginner	Beginner	Intermediate	Advanced
Regulatory Support	⚠️ Limited	✅ Data privacy	❌ Not auditable	✅ ISO 26262, DO-178C

---

Related Documentation

• Intelligent Import Guide - Pattern-based import (NEW)
• Full Export/Import Guide
• AI Import Detailed Guide
• ReqIF Advanced Guide
• MATLAB/Simulink Integration - Link requirements to Simulink models
• Requirements Management
• Pricing Plans

---

Need Help Deciding?

Contact us for guidance:

• 📧 madhu.chellappa@gmail.com
• 📚 View video tutorials
• 💬 Get personalized consultation

---

Updated: October 2025