--- # === CORE IDENTITY === name: business-analyst-toolkit title: Business Analyst Toolkit description: Business process analysis, requirements documentation, and workflow optimization for retail, supply chain, and technology organizations domain: product subdomain: product-team-general # === WEBSITE DISPLAY === difficulty: intermediate time-saved: "60% faster process documentation, 40% faster stakeholder alignment" frequency: "Weekly for active BA projects" use-cases: - Retail operations process optimization (inventory, fulfillment, POS) - Supply chain workflow analysis and improvement - Technology platform requirements and integration documentation - E-commerce checkout and customer journey mapping - Omnichannel retail process design # === RELATIONSHIPS === related-agents: [] related-skills: [] related-commands: [] orchestrated-by: [] # === TECHNICAL === dependencies: scripts: [] references: [] assets: [] compatibility: python-version: 3.8+ platforms: [macos, linux, windows] tech-stack: [Python 3.8+, Markdown] # === EXAMPLES === examples: - title: Example Usage input: "TODO: Add example input for business-analyst-toolkit" output: "TODO: Add expected output" # === ANALYTICS === stats: downloads: 0 stars: 0 rating: 0.0 reviews: 0 # === VERSIONING === version: v1.1.0 author: Claude Skills Library contributors: [] created: 2025-11-21 updated: 2025-11-27 license: MIT # === DISCOVERABILITY === tags: [analyst, business, design, product, toolkit, retail, supply-chain, technology] featured: false verified: true --- # 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 [--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 |