business-analyst-toolkit

# Business Analyst Toolkit

## Overview

This skill provides structured frameworks and automation tools for business process analysis, requirements documentation, and workflow optimization. It is specifically tailored for **retail**, **supply chain**, and **technology** organizations.

**Core Value:** 60% faster process documentation, 40% reduction in stakeholder alignment time, 50% less time analyzing processes with automation tools

**Target Audience:** Business Analysts, Process Improvement Specialists, Product Managers working in retail, supply chain, or technology sectors

**Industry Focus:** Retail (including e-commerce), Supply Chain, Technology/SaaS


## Core Capabilities

- **Process Discovery & Analysis** - Map current-state operations, identify bottlenecks and inefficiencies
- **Requirements Documentation** - Capture business needs with structured templates and acceptance criteria
- **Process Improvement Design** - Create future-state workflows with measurable benefits
- **Stakeholder Management** - Map influence networks and develop engagement strategies
- **Gap Analysis** - Identify missing elements with severity scoring and recommendations


## Industry-Specific Guidance

### Retail & E-commerce

**Common Processes to Analyze:**
- Order fulfillment and shipping workflows
- Inventory management and replenishment
- Point-of-sale (POS) transaction flows
- Customer returns and exchanges
- Omnichannel experience (online, in-store, mobile)
- Loyalty program operations

**Key Constraints:**
- Peak season scalability (Black Friday, holidays)
- Real-time inventory accuracy requirements
- Payment processing compliance (PCI-DSS)
- Customer experience expectations (speed, convenience)
- Multi-location coordination

**Metrics to Track:**
- Order-to-delivery cycle time
- Inventory turnover rate
- Cart abandonment rate
- Customer satisfaction (NPS, CSAT)
- Return rate and processing time

### Supply Chain

**Common Processes to Analyze:**
- Procurement and vendor management
- Warehouse operations and picking/packing
- Transportation and logistics coordination
- Demand forecasting and planning
- Quality control and inspection
- Reverse logistics and returns

**Key Constraints:**
- Lead time variability from suppliers
- Warehouse capacity limitations
- Transportation cost optimization
- Regulatory compliance (customs, safety)
- Supplier reliability and risk

**Metrics to Track:**
- Perfect order rate
- Inventory days on hand
- Supplier on-time delivery
- Warehouse utilization
- Cost per unit shipped

### Technology / SaaS

**Common Processes to Analyze:**
- Software development lifecycle (SDLC)
- Customer onboarding and provisioning
- Support ticket escalation and resolution
- Feature request intake and prioritization
- Release management and deployment
- Integration and API workflows

**Key Constraints:**
- Technical debt and legacy systems
- Data security and privacy requirements
- Scalability and performance needs
- Integration complexity across platforms
- Rapid feature velocity expectations

**Metrics to Track:**
- Time to first value (TTFV)
- Support ticket resolution time
- System uptime and reliability
- Feature adoption rate
- Customer churn rate


## Methodology Variants

### Agile BA Approach

**When to Use:** Fast-moving environments, iterative delivery, continuous collaboration

**Workflow Adaptations:**
- User stories instead of comprehensive BRDs
- Iterative refinement over upfront documentation
- Continuous stakeholder collaboration
- Sprint-based requirement delivery
- Just-in-time analysis

**Key Artifacts:**
- User stories with acceptance criteria
- Story maps
- Sprint backlog items
- Definition of Done
- Retrospective insights

### Waterfall BA Approach

**When to Use:** Regulated environments, fixed-scope projects, contractual requirements

**Workflow Adaptations:**
- Comprehensive upfront requirements
- Formal sign-off gates
- Detailed BRD and FRS documents
- Structured change control
- Sequential phase delivery

**Key Artifacts:**
- Business Requirements Document (BRD)
- Functional Requirements Specification (FRS)
- Requirements Traceability Matrix (RTM)
- Formal change requests
- Sign-off documentation

### Hybrid Approach

**When to Use:** Most real-world projects, balancing flexibility with structure

**Workflow Adaptations:**
- High-level requirements upfront
- Detailed user stories per sprint
- Flexible scope within fixed timeline
- Iterative stakeholder validation
- Phased delivery with checkpoints

**Key Artifacts:**
- Vision document (high-level)
- Epic definitions
- Detailed user stories (just-in-time)
- Rolling wave planning docs
- Milestone sign-offs


## Common Challenges & Mitigations

| Challenge | Impact | Mitigation Strategy |
|-----------|--------|---------------------|
| **Ambiguous requirements** | Rework, delays | Use structured templates, validate with examples |
| **Conflicting stakeholder priorities** | Scope creep, politics | RACI matrix, executive sponsor alignment |
| **Limited stakeholder availability** | Incomplete analysis | Async documentation, targeted workshops |
| **Tight project timelines** | Quality shortcuts | Prioritize critical requirements, timeboxed analysis |
| **Changing business priorities** | Scope instability | Change control process, impact assessment |
| **Technical constraints unknown upfront** | Late surprises | Early technical feasibility reviews |
| **Legacy system limitations** | Integration complexity | Document constraints, plan workarounds |
| **Organizational resistance to change** | Adoption failures | Stakeholder mapping, change management plan |


## Keywords

business analysis, process mapping, workflow documentation, requirements gathering, process improvement, stakeholder analysis, RACI matrix, process charter, business process modeling, gap analysis, root cause analysis, as-is to-be analysis, process optimization, operational efficiency, change management, business requirements, functional requirements, process documentation, improvement proposals, business case development, retail operations, supply chain, e-commerce, technology, SaaS, omnichannel

---

## Quick Start

**For Process Analysis:**
```bash
# Parse and analyze existing process documentation
python scripts/process_parser.py process-document.md --output analysis.json

# Identify gaps in process documentation
python scripts/gap_analyzer.py --input process.json --format human

# Map stakeholders and generate engagement strategies
python scripts/stakeholder_mapper.py stakeholders.csv --output markdown
```

**For Process Improvement:**
```bash
# Generate improvement plan from gap analysis
python scripts/improvement_planner.py --gaps gaps.json --timeline 12 --output markdown

# Create process charter with objectives and stakeholders
python scripts/charter_builder.py --process "Customer Onboarding" \
  --objectives "Reduce cycle time by 50%" --output markdown

# Calculate KPIs and track metrics
python scripts/kpi_calculator.py executions.csv --baseline baseline.json
```

**For Documentation:**
```bash
# Generate RACI matrix from process definition
python scripts/raci_generator.py process.json --output markdown

# Create process charter from template
cp assets/process-charter-template.md my-process-charter.md
```

---

## Key Workflows

### 1. Process Discovery & Analysis
Understand current-state operations, identify inefficiencies, and document workflows for improvement opportunities.

**Steps:**
1. Gather process documentation and interview stakeholders
2. Parse documentation using `process_parser.py`
3. Analyze workflow for bottlenecks and redundancies
4. Document findings in process charter template

**Output:** Current-state process map with identified improvement areas

### 2. Requirements Documentation
Capture business needs, functional requirements, and acceptance criteria for new initiatives or improvements.

**Steps:**
1. Conduct stakeholder interviews and workshops
2. Document requirements using structured templates
3. Create RACI matrix for role clarity
4. Validate requirements with stakeholders

**Output:** Comprehensive requirements document with stakeholder alignment

### 3. Process Improvement Design
Develop future-state processes with measurable benefits and clear implementation roadmaps.

**Steps:**
1. Analyze current-state pain points
2. Design improved workflow with efficiency gains
3. Create improvement proposal with business case
4. Build stakeholder analysis for change management

**Output:** Actionable improvement proposal ready for approval

### 4. Stakeholder Management
Map influence networks, assess engagement needs, and create communication strategies for successful change adoption.

**Steps:**
1. Identify all stakeholders using stakeholder template
2. Assess power, interest, and support levels
3. Develop targeted engagement strategies
4. Track progress and adjust approach

**Output:** Stakeholder engagement plan with communication schedule

### 5. Evaluation & Lessons Learned
Assess solution effectiveness against original requirements and capture insights for future improvements.

**Steps:**
1. Compare delivered solution against original requirements
2. Measure KPIs using `kpi_calculator.py` against baseline
3. Gather stakeholder feedback on solution adoption
4. Document lessons learned and improvement recommendations
5. Create handoff documentation for operations team

**Output:** Solution evaluation report with benefits realization and lessons learned

**Key Questions to Answer:**
- Did we achieve the stated objectives?
- What was the actual ROI vs projected?
- What would we do differently next time?
- What process improvements emerged during implementation?

---

## Python Tools

### process_parser.py
Parses business process documentation and extracts structured workflow information for analysis and visualization.

**Usage:**
```bash
python scripts/process_parser.py <input-file> [--output json|markdown] [--visualize]
```

**Features:**
- Extract process steps, roles, and decision points from natural language
- Identify workflow bottlenecks and inefficiencies
- Generate JSON output for further analysis
- Create visual process diagrams (when --visualize flag used)
- Calculate complexity metrics and cycle time estimates

**Use Cases:**
- Analyzing legacy process documentation
- Converting unstructured processes to structured formats
- Identifying automation opportunities
- Creating process maps from written descriptions

---

### charter_builder.py
Generates comprehensive process improvement charters from objectives, gap analysis, and stakeholder data.

**Usage:**
```bash
python scripts/charter_builder.py --process PROCESS --objectives OBJECTIVES [OPTIONS]
```

**Features:**
- Create structured process charters with executive summary, scope, and metrics
- Integrate gap analysis results automatically
- Include stakeholder mappings and engagement plans
- Support multiple output formats (markdown, HTML, JSON)
- Calculate project complexity and timeline estimates
- Choose improvement strategy (efficiency, quality, capacity, experience)

**Use Cases:**
- Formalizing process improvement initiatives
- Building business cases for change projects
- Creating executive-ready documentation
- Standardizing charter creation across teams

**Example:**
```bash
python scripts/charter_builder.py --process "Customer Onboarding" \
  --objectives "Reduce cycle time by 50%" \
  --gaps gaps.json --stakeholders stakeholders.json \
  --output markdown
```

---

### stakeholder_mapper.py
Maps stakeholders and generates engagement strategies based on influence and interest analysis.

**Usage:**
```bash
python scripts/stakeholder_mapper.py INPUT [--output json|markdown|mermaid]
```

**Features:**
- Parse stakeholder data from CSV or JSON files
- Calculate influence and interest scores automatically
- Classify stakeholders (Key Players, Keep Satisfied, Keep Informed, Monitor)
- Generate tailored engagement strategies per stakeholder
- Create visual relationship diagrams (Mermaid format)
- Identify communication preferences and impact areas

**Use Cases:**
- Planning change management initiatives
- Building stakeholder engagement plans
- Identifying project champions and resistors
- Creating communication strategies

**Example:**
```bash
python scripts/stakeholder_mapper.py stakeholders.csv --output markdown
python scripts/stakeholder_mapper.py stakeholders.json --output mermaid > diagram.mmd
```

---

### raci_generator.py
Creates RACI (Responsible, Accountable, Consulted, Informed) matrices from process documentation.

**Usage:**
```bash
python scripts/raci_generator.py INPUT [--output json|csv|markdown|html]
```

**Features:**
- Generate RACI matrices from process JSON, CSV, or Markdown
- Validate RACI assignments (one Accountable per activity)
- Support custom RACI templates with predefined assignments
- Identify workload imbalances across roles
- Flag missing assignments and over-allocation
- Multiple output formats for different audiences

**Use Cases:**
- Clarifying roles and responsibilities
- Preventing decision bottlenecks
- Balancing workload across teams
- Establishing clear accountability

**Example:**
```bash
python scripts/raci_generator.py process.json --output markdown
python scripts/raci_generator.py process.csv --template raci-template.csv --validate-only
```

---

### gap_analyzer.py
Identifies gaps and missing elements in process documentation with severity scoring.

**Usage:**
```bash
python scripts/gap_analyzer.py --input INPUT [--format json|human]
```

**Features:**
- Analyze process completeness across 9 dimensions
- Calculate completeness scores (0-100%)
- Flag critical gaps (missing owners, error handling, success criteria)
- Severity classification (critical, high, medium, low)
- Generate actionable recommendations
- Filter by severity threshold

**Use Cases:**
- Quality-checking process documentation
- Identifying high-risk process areas
- Prioritizing documentation improvements
- Pre-implementation validation

**Example:**
```bash
python scripts/gap_analyzer.py --input process.json --format human
python scripts/gap_analyzer.py --input process.json --severity-threshold high --output gaps.json
```

---

### improvement_planner.py
Generates detailed improvement plans from gap analysis with phased implementation roadmaps.

**Usage:**
```bash
python scripts/improvement_planner.py --gaps GAPS [OPTIONS]
```

**Features:**
- Create phased improvement plans from gap analysis results
- Prioritize improvements by impact and effort
- Generate Gantt charts for timeline visualization
- Estimate resource requirements and costs
- Identify dependencies between improvements
- Support custom resource constraints

**Use Cases:**
- Building implementation roadmaps
- Resource planning for improvements
- Creating project timelines
- Prioritizing improvement activities

**Example:**
```bash
python scripts/improvement_planner.py --gaps gaps.json --timeline 12 --output markdown
python scripts/improvement_planner.py --gaps gaps.json --output gantt > timeline.txt
```

---

### kpi_calculator.py
Calculates process KPIs and efficiency metrics from execution data with baseline comparison.

**Usage:**
```bash
python scripts/kpi_calculator.py INPUT [OPTIONS]
```

**Features:**
- Calculate standard process KPIs (cycle time, throughput, error rate, etc.)
- Compare current metrics against baseline targets
- Analyze trends over time periods
- Generate ASCII charts for markdown reports
- Support CSV and JSON input formats
- Export results in multiple formats

**Use Cases:**
- Measuring process performance
- Tracking improvement progress
- Creating executive dashboards
- Validating process changes

**Example:**
```bash
python scripts/kpi_calculator.py executions.csv --baseline baseline.json
python scripts/kpi_calculator.py executions.json --period 30 --output markdown --include-charts
```

---

## References

[Reference documentation will be added in future iterations. Current focus on templates and automation tools.]

---

## Templates

### 1. Process Charter Template
**Location:** `assets/process-charter-template.md`

**Purpose:** Define process scope, objectives, roles, metrics, and implementation plans

**Use Cases:**
- Formalizing existing informal processes
- Launching new business processes
- Process improvement initiatives
- Cross-functional workflow alignment

**Sections:** Executive summary, business context, process details, roles/responsibilities, performance metrics, dependencies, risk assessment, implementation plan, governance

### 2. RACI Matrix Template
**Location:** `assets/raci-matrix-template.md`

**Purpose:** Clarify roles and responsibilities across activities using Responsible, Accountable, Consulted, Informed framework

**Use Cases:**
- Eliminating role confusion in complex projects
- Preventing decision bottlenecks
- Balancing workload across teams
- Establishing clear accountability

**Sections:** Role definitions, activity matrix, workload analysis, communication protocols, validation checklist, escalation paths

### 3. Improvement Proposal Template
**Location:** `assets/improvement-proposal-template.md`

**Purpose:** Build comprehensive business case for process improvements with ROI analysis and implementation roadmap

**Use Cases:**
- Securing budget for process improvements
- Demonstrating value of efficiency initiatives
- Prioritizing improvement opportunities
- Gaining executive approval

**Sections:** Executive summary, current-state analysis, proposed solution, business case (costs/benefits), implementation plan, risk assessment, success metrics, change management

### 4. Stakeholder Analysis Template
**Location:** `assets/stakeholder-analysis-template.md`

**Purpose:** Map stakeholder landscape, assess influence and interests, and develop targeted engagement strategies

**Use Cases:**
- Planning change management approaches
- Building coalition support for initiatives
- Identifying resistance and mitigation strategies
- Creating communication plans

**Sections:** Stakeholder inventory, power-interest grid, detailed profiles, influence network map, engagement plan, support tracking, success metrics

---

## Examples

### Example 1: Process Improvement Initiative

**Scenario:** Customer onboarding takes 15 days with 8% error rate. Goal is to reduce to 7 days with <2% errors.

**Workflow:**
```bash
# Step 1: Analyze current process
python scripts/process_parser.py current-onboarding-process.md --output analysis.json

# Step 2: Create process charter
cp assets/process-charter-template.md onboarding-charter.md
# Edit charter with current metrics and improvement targets

# Step 3: Build improvement proposal
cp assets/improvement-proposal-template.md onboarding-improvement.md
# Complete business case with ROI calculations

# Step 4: Plan stakeholder engagement
cp assets/stakeholder-analysis-template.md onboarding-stakeholders.md
# Map key stakeholders and engagement approach
```

**Expected Outcome:** Executive-ready improvement proposal with 50% cycle time reduction, quantified ROI, and stakeholder buy-in strategy.

**Time Estimate:** 2-3 days for comprehensive analysis and documentation

---

### Example 2: Cross-Functional Workflow Design

**Scenario:** Sales, product, and engineering teams lack clarity on feature request handling. Need to establish clear process with role definitions.

**Workflow:**
```bash
# Step 1: Document current state through interviews
# (Manual step - gather input from all teams)

# Step 2: Create RACI matrix
cp assets/raci-matrix-template.md feature-request-raci.md
# Define who is Responsible, Accountable, Consulted, Informed for each activity

# Step 3: Design new process
cp assets/process-charter-template.md feature-request-process.md
# Document trigger events, steps, inputs/outputs, success criteria

# Step 4: Analyze and validate process structure
python scripts/process_parser.py feature-request-process.md --visualize
# Review workflow for bottlenecks or missing steps

# Step 5: Plan rollout
cp assets/stakeholder-analysis-template.md feature-request-stakeholders.md
# Identify change champions and communication plan
```

**Expected Outcome:** Formalized feature request process with clear accountability, reducing confusion and improving response times by 40%.

**Time Estimate:** 1 week for design, validation, and stakeholder alignment

---

## Integration with Other Skills

**Agile Product Owner Toolkit:** Use RACI matrices and process charters to clarify sprint roles and ceremonies

**OKR Strategist:** Link process improvement KPIs to organizational OKRs and track progress

**UX Research Toolkit:** Incorporate user research findings into process improvement proposals

**RICE Prioritizer:** Score process improvement opportunities using RICE framework for prioritization

---

## Benefits

**Time Savings:**
- 60% faster process documentation using templates vs. starting from scratch
- 40% reduction in stakeholder alignment time through structured RACI approach
- 50% less time analyzing processes with automation tools

**Quality Improvements:**
- Consistent documentation format ensures nothing is missed
- Structured analysis reveals hidden inefficiencies
- Data-driven improvement proposals increase approval rates

**Business Impact:**
- Clear ROI calculations in improvement proposals
- Reduced cycle times through optimized workflows
- Better change adoption through stakeholder management

---

## Best Practices

1. **Start with Current State:** Always document as-is before designing to-be state
2. **Quantify Everything:** Use metrics, not opinions, to justify improvements
3. **Engage Early:** Involve stakeholders from discovery through implementation
4. **Think Incrementally:** Break large improvements into phased rollouts
5. **Validate Assumptions:** Test process designs with end users before full rollout
6. **Measure Results:** Track KPIs post-implementation to prove value

---

## Next Steps

**Getting Started:**
1. Identify a process pain point in your organization
2. Use `process_parser.py` to analyze current documentation
3. Create process charter to formalize scope and objectives
4. Build stakeholder analysis to plan engagement approach

**Advanced Usage:**
- Combine multiple templates for comprehensive initiative planning
- Chain tool outputs into improvement proposals
- Build process repository for organizational knowledge management
- Create standardized playbooks for recurring process types

---

**Documentation:** Full skill guide and workflows available in this file

**Support:** For issues or questions, refer to parent domain guide at `../CLAUDE.md`

**Version:** 1.1.0 | **Last Updated:** 2025-11-27 | **Status:** Production Ready

---

## Version History

| Version | Date | Changes |
|---------|------|---------|
| 1.1.0 | 2025-11-27 | Added retail/supply chain/tech industry focus, methodology variants, common challenges, 5th workflow (Evaluation & Lessons Learned) |
| 1.0.0 | 2025-11-21 | Initial release with 4 workflows and Python tools |