From 446f1b65047a213cfdaf327024e6b4113d7396bd Mon Sep 17 00:00:00 2001 From: Zhongwei Li Date: Sat, 29 Nov 2025 18:00:04 +0800 Subject: [PATCH] Initial commit --- .claude-plugin/plugin.json | 20 + README.md | 3 + agents/business-analyst.md | 24 + agents/chief-product-officer.md | 25 + agents/data-analyst.md | 25 + agents/project-manager.md | 25 + plugin.lock.json | 73 + skills/business-analysis/SKILL.md | 3535 ++++++++++++++++++++++++++++ skills/data-analytics/SKILL.md | 749 ++++++ skills/product-management/SKILL.md | 670 ++++++ skills/project-management/SKILL.md | 811 +++++++ 11 files changed, 5960 insertions(+) create mode 100644 .claude-plugin/plugin.json create mode 100644 README.md create mode 100644 agents/business-analyst.md create mode 100644 agents/chief-product-officer.md create mode 100644 agents/data-analyst.md create mode 100644 agents/project-manager.md create mode 100644 plugin.lock.json create mode 100644 skills/business-analysis/SKILL.md create mode 100644 skills/data-analytics/SKILL.md create mode 100644 skills/product-management/SKILL.md create mode 100644 skills/project-management/SKILL.md diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json new file mode 100644 index 0000000..d3e1770 --- /dev/null +++ b/.claude-plugin/plugin.json @@ -0,0 +1,20 @@ +{ + "name": "product", + "description": "Product management and strategy team with 4 specialized roles covering product management, project management, business analysis, and data analytics", + "version": "1.0.0", + "author": { + "name": "Puerto" + }, + "skills": [ + "./skills/product-management", + "./skills/project-management", + "./skills/business-analysis", + "./skills/data-analytics" + ], + "agents": [ + "./agents/chief-product-officer.md", + "./agents/project-manager.md", + "./agents/business-analyst.md", + "./agents/data-analyst.md" + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..743b8a2 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# product + +Product management and strategy team with 4 specialized roles covering product management, project management, business analysis, and data analytics diff --git a/agents/business-analyst.md b/agents/business-analyst.md new file mode 100644 index 0000000..1b8956c --- /dev/null +++ b/agents/business-analyst.md @@ -0,0 +1,24 @@ +# Business Analyst + +PROACTIVELY use for requirements gathering, process optimization, and business analysis. + +**Core Capabilities:** +- Requirements gathering and documentation +- User story writing +- Process mapping and optimization +- Gap analysis +- Business case development +- Stakeholder interviews +- Acceptance criteria definition +- Technical documentation +- Workflow analysis + +**Tools Available:** Read, Write, Edit, Bash, Grep, Glob + +**Skills:** business-analysis, product-management + +**Examples:** +- "Gather requirements and write user stories" +- "Create business case for new initiative" +- "Map current process and identify optimization opportunities" +- "Document system requirements and acceptance criteria" diff --git a/agents/chief-product-officer.md b/agents/chief-product-officer.md new file mode 100644 index 0000000..974d853 --- /dev/null +++ b/agents/chief-product-officer.md @@ -0,0 +1,25 @@ +# Chief Product Officer + +PROACTIVELY use for product vision, strategy, roadmap planning, and product team leadership. + +**Core Capabilities:** +- Product vision and strategy +- Product roadmap planning +- Feature prioritization (RICE, ICE, MoSCoW) +- Market and competitive analysis +- Product-market fit validation +- Stakeholder management +- Product team coordination +- Business model strategy +- Pricing and packaging +- Product metrics and KPIs + +**Tools Available:** Read, Write, Edit, Bash, Grep, Glob + +**Skills:** product-management, business-analysis, data-analytics + +**Examples:** +- "Develop product strategy and 12-month roadmap" +- "Prioritize feature backlog using RICE scoring" +- "Create go-to-market strategy for new product" +- "Define product metrics and success criteria" diff --git a/agents/data-analyst.md b/agents/data-analyst.md new file mode 100644 index 0000000..ab1024d --- /dev/null +++ b/agents/data-analyst.md @@ -0,0 +1,25 @@ +# Data Analyst + +PROACTIVELY use for metrics, analytics, insights, and data-driven decision making. + +**Core Capabilities:** +- Data analysis and visualization +- Dashboard creation +- Metrics definition and tracking +- SQL queries and data extraction +- A/B test analysis +- Cohort analysis +- Funnel analysis +- Business intelligence reporting +- Predictive analytics +- Data storytelling + +**Tools Available:** Read, Write, Edit, Bash, Grep, Glob + +**Skills:** data-analytics, business-analysis + +**Examples:** +- "Analyze user behavior data and identify patterns" +- "Create dashboard for product KPI tracking" +- "Analyze A/B test results and provide recommendations" +- "Build cohort retention analysis" diff --git a/agents/project-manager.md b/agents/project-manager.md new file mode 100644 index 0000000..51d8d95 --- /dev/null +++ b/agents/project-manager.md @@ -0,0 +1,25 @@ +# Project Manager + +PROACTIVELY use for project planning, execution, coordination, and delivery management. + +**Core Capabilities:** +- Project planning and scheduling +- Agile/Scrum facilitation +- Resource allocation +- Risk management +- Stakeholder communication +- Timeline and milestone tracking +- Team coordination +- Status reporting +- Issue resolution +- Sprint planning and retrospectives + +**Tools Available:** Read, Write, Edit, Bash, Grep, Glob + +**Skills:** project-management, business-analysis + +**Examples:** +- "Create project plan with timeline and milestones" +- "Facilitate sprint planning and retrospective" +- "Identify and mitigate project risks" +- "Coordinate cross-functional team delivery" diff --git a/plugin.lock.json b/plugin.lock.json new file mode 100644 index 0000000..8198a6b --- /dev/null +++ b/plugin.lock.json @@ -0,0 +1,73 @@ +{ + "$schema": "internal://schemas/plugin.lock.v1.json", + "pluginId": "gh:bandofai/puerto:plugins/product", + "normalized": { + "repo": null, + "ref": "refs/tags/v20251128.0", + "commit": "e98bcd98fabdced91d273ea42de60d44db5741ff", + "treeHash": "63bf82a1f5a30423c58b6ab19c6c8dbf40aeaeead8fa33c258d1e04db2c6b3d6", + "generatedAt": "2025-11-28T10:14:09.252144Z", + "toolVersion": "publish_plugins.py@0.2.0" + }, + "origin": { + "remote": "git@github.com:zhongweili/42plugin-data.git", + "branch": "master", + "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390", + "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data" + }, + "manifest": { + "name": "product", + "description": "Product management and strategy team with 4 specialized roles covering product management, project management, business analysis, and data analytics", + "version": "1.0.0" + }, + "content": { + "files": [ + { + "path": "README.md", + "sha256": "a0535995fd09529120e1bc672f498859dc930faf756939418c6ff2145346b020" + }, + { + "path": "agents/data-analyst.md", + "sha256": "c706b4462ded4afa4d27da2130b496692590c0e729864651c0419b532fd0d175" + }, + { + "path": "agents/project-manager.md", + "sha256": "b74b454e1e00b5bef859f183915449591fb9b66f5134c5628adc82d2a102dd6f" + }, + { + "path": "agents/business-analyst.md", + "sha256": "6d4a63a5fef10bc464b9e24a53dea3515e7751e4d4c98289952a4b64db86df8d" + }, + { + "path": "agents/chief-product-officer.md", + "sha256": "e8f7e06e3ce398dca40f65325ac6ec89437b94ebc9fdd37f4ceb596a398df9ba" + }, + { + "path": ".claude-plugin/plugin.json", + "sha256": "5aa31b6f07d19a879de6e69c664304c2dc035323dd8bba4f01d08d508e0c639d" + }, + { + "path": "skills/data-analytics/SKILL.md", + "sha256": "a26be11112f4260e7775ad690bf60641fc5876799e47e408e8221c0511f0b605" + }, + { + "path": "skills/project-management/SKILL.md", + "sha256": "813b2535ae00d4a87d86596e761268b1252917c3bc5b7852470379917a68bfcb" + }, + { + "path": "skills/business-analysis/SKILL.md", + "sha256": "3635d5d9b1f1e9bd24502e369a57c230953d5fa043937d30723e53766bfad33e" + }, + { + "path": "skills/product-management/SKILL.md", + "sha256": "9ebde0ccb24dbdef2b96778a23fab64a399502a71dfafa32e649f43f67e8c4fc" + } + ], + "dirSha256": "63bf82a1f5a30423c58b6ab19c6c8dbf40aeaeead8fa33c258d1e04db2c6b3d6" + }, + "security": { + "scannedAt": null, + "scannerVersion": null, + "flags": [] + } +} \ No newline at end of file diff --git a/skills/business-analysis/SKILL.md b/skills/business-analysis/SKILL.md new file mode 100644 index 0000000..dd3454e --- /dev/null +++ b/skills/business-analysis/SKILL.md @@ -0,0 +1,3535 @@ +# Business Analysis Skill + +Comprehensive guide for business analysis practices, requirements gathering, process modeling, and analysis techniques. + +**Version**: 1.0.0 +**Last Updated**: 2025-10-30 +**Target Audience**: Business Analysts, Requirements Engineers, Process Analysts + +--- + +## Table of Contents + +1. [Requirements Gathering](#1-requirements-gathering) +2. [Process Modeling](#2-process-modeling) +3. [Requirements Documentation](#3-requirements-documentation) +4. [Analysis Techniques](#4-analysis-techniques) +5. [Tools & Deliverables](#5-tools--deliverables) + +--- + +## 1. Requirements Gathering + +Requirements gathering is the foundation of successful business analysis. This section covers techniques for eliciting, discovering, and understanding stakeholder needs. + +### 1.1 Stakeholder Identification and Analysis + +#### Identifying Stakeholders + +**Definition**: Stakeholders are individuals or groups who can affect or be affected by the project. + +**Stakeholder Categories**: + +1. **Primary Stakeholders** (directly affected): + - End users + - Customers + - Project sponsors + - Product owners + +2. **Secondary Stakeholders** (indirectly affected): + - Support teams + - Training staff + - Compliance officers + - Vendors/suppliers + +3. **Key Influencers**: + - Executive leadership + - Department heads + - Subject matter experts (SMEs) + - Change agents + +**Stakeholder Identification Techniques**: + +```markdown +## Brainstorming Session +- Gather project team +- List all potential stakeholders +- Group by category and influence level +- Validate with project sponsor + +## Organizational Chart Analysis +- Review org structure +- Identify impacted departments +- Map reporting relationships +- Identify decision makers + +## Previous Project Analysis +- Review similar past projects +- Identify who was involved +- Learn from previous stakeholder engagement +``` + +#### Stakeholder Analysis Matrix + +Create a Power/Interest Grid to prioritize stakeholder engagement: + +```markdown +| Stakeholder | Power | Interest | Strategy | +|-------------|-------|----------|----------| +| CEO | High | Low | Keep Satisfied | +| End Users | Low | High | Keep Informed | +| Project Sponsor | High | High | Manage Closely | +| IT Support | Medium | Medium | Keep Informed | +``` + +**Power/Interest Grid Quadrants**: + +1. **High Power, High Interest** (Manage Closely): + - Key players, engage frequently + - Involve in decision-making + - Regular status updates + - Address concerns promptly + +2. **High Power, Low Interest** (Keep Satisfied): + - Keep informed at high level + - Don't overwhelm with details + - Seek approval at key milestones + - Monitor for changing interest + +3. **Low Power, High Interest** (Keep Informed): + - Regular communication + - Gather detailed feedback + - Champions for change + - Can provide valuable insights + +4. **Low Power, Low Interest** (Monitor): + - Minimal effort + - General updates sufficient + - Monitor for changes + - May become more engaged later + +#### Stakeholder Analysis Template + +```markdown +## Stakeholder Profile: [Name/Group] + +**Role**: [Job title or group description] +**Department**: [Organizational unit] +**Level**: [Executive/Management/Staff] + +**Power/Influence**: [High/Medium/Low] +**Interest Level**: [High/Medium/Low] +**Engagement Strategy**: [Manage Closely/Keep Satisfied/Keep Informed/Monitor] + +**Needs and Expectations**: +- [What they need from the project] +- [What they expect as outcomes] +- [Success criteria from their perspective] + +**Potential Concerns**: +- [What might worry them] +- [Resistance points] +- [Risk areas] + +**Communication Preferences**: +- **Frequency**: [Daily/Weekly/Monthly] +- **Method**: [Email/Meetings/Reports/Dashboard] +- **Detail Level**: [High-level summary/Detailed analysis] + +**Key Questions for This Stakeholder**: +1. [Question about their needs] +2. [Question about their constraints] +3. [Question about success criteria] +``` + +### 1.2 Interview Techniques and Questions + +#### Interview Preparation + +**Before the Interview**: + +1. **Research the stakeholder**: + - Review their role and responsibilities + - Understand their department's goals + - Identify previous interactions with similar projects + +2. **Prepare questions**: + - Create structured interview guide + - Mix open and closed questions + - Prepare follow-up probes + +3. **Set expectations**: + - Send agenda in advance + - Clarify purpose and duration + - Request any pre-reading materials + +4. **Logistics**: + - Book appropriate time (usually 60-90 minutes) + - Choose comfortable, private location + - Test recording equipment (with permission) + - Prepare note-taking tools + +#### Interview Question Framework + +**Opening Questions** (Build rapport): +- "Can you describe your current role and key responsibilities?" +- "How long have you been with the organization?" +- "What does a typical day look like for you?" + +**Current State Questions**: +- "Can you walk me through your current process for [activity]?" +- "What tools or systems do you currently use?" +- "How do you measure success in your current workflow?" +- "What works well in the current process?" + +**Pain Points and Challenges**: +- "What are the biggest challenges you face daily?" +- "What frustrates you most about the current system/process?" +- "Where do you spend the most time in your work?" +- "What causes delays or rework?" +- "If you could change one thing, what would it be?" + +**Future State and Requirements**: +- "What would the ideal solution look like?" +- "How would success be measured in a new system?" +- "What capabilities are absolutely essential?" +- "What would make your job significantly easier?" +- "How do you envision using this new system/process?" + +**Constraint Questions**: +- "Are there regulatory or compliance requirements we must meet?" +- "What is your timeline for needing this solution?" +- "Are there budget constraints we should be aware of?" +- "What technical limitations do we need to consider?" + +**Priority Questions**: +- "If we can only deliver three features, which would you choose?" +- "What capabilities are must-haves vs. nice-to-haves?" +- "What would you be willing to trade off?" + +**Closing Questions**: +- "Who else should I speak with about this?" +- "Is there anything important I haven't asked about?" +- "May I follow up if I have additional questions?" + +#### Interview Techniques + +**Active Listening**: +```markdown +DO: +- Maintain eye contact +- Nod and show engagement +- Take notes but don't let it distract +- Paraphrase to confirm understanding +- Ask clarifying questions + +DON'T: +- Interrupt or finish sentences +- Jump to solutions +- Make assumptions +- Multi-task or check devices +- Show bias or judgment +``` + +**Probing Techniques**: + +1. **The 5 Whys**: + ``` + "We need faster reporting." + Why? "Reports take too long to generate." + Why? "We have to pull data from multiple systems." + Why? "Systems aren't integrated." + Why? "We lack an enterprise data warehouse." + Why? "Previous integration project was never completed." + ``` + +2. **Expanding Questions**: + - "Can you tell me more about that?" + - "What do you mean by [term]?" + - "Can you give me an example?" + - "What happens next in that scenario?" + +3. **Clarifying Questions**: + - "When you say 'fast', what timeframe are you thinking?" + - "Who specifically is included in 'the team'?" + - "What would 'improved' look like in measurable terms?" + +4. **Hypothetical Questions**: + - "If you had unlimited resources, what would you build?" + - "What if we could automate this entire process?" + - "Imagine it's a year from now and this is successful - what changed?" + +#### Interview Documentation + +**During Interview**: +- Note key quotes verbatim +- Mark action items with [ACTION] +- Flag inconsistencies with [?] +- Track follow-up questions with [FOLLOW-UP] + +**Post-Interview**: +```markdown +## Interview Summary: [Stakeholder Name] +**Date**: [Date] +**Duration**: [Time] +**Location**: [Location/Remote] +**Attendees**: [Names and roles] + +### Key Takeaways +- [Main point 1] +- [Main point 2] +- [Main point 3] + +### Current State Observations +[Summary of how things work now] + +### Pain Points Identified +1. [Pain point 1 - with specific examples] +2. [Pain point 2 - with specific examples] +3. [Pain point 3 - with specific examples] + +### Requirements Identified +| Requirement | Priority | Type | +|-------------|----------|------| +| [Requirement description] | Must-Have | Functional | +| [Requirement description] | Should-Have | Non-Functional | + +### Action Items +- [ ] [Follow-up action 1] +- [ ] [Follow-up action 2] + +### Follow-up Questions +- [Question that emerged during interview] +- [Clarification needed] + +### Additional Stakeholders to Contact +- [Name] - [Reason to contact] + +### Quotes +> "[Significant quote that captures key insight]" +> - [Stakeholder name] +``` + +### 1.3 Workshop Facilitation + +Workshops bring multiple stakeholders together for collaborative requirements elicitation. + +#### Workshop Types + +**1. Requirements Workshop**: +- **Purpose**: Gather and validate requirements +- **Duration**: 2-4 hours +- **Participants**: 6-12 key stakeholders +- **Outcome**: Prioritized requirements list + +**2. Process Mapping Workshop**: +- **Purpose**: Document current or future processes +- **Duration**: 3-6 hours +- **Participants**: Process owners and participants +- **Outcome**: Visual process maps + +**3. Design Thinking Workshop**: +- **Purpose**: Ideate solutions collaboratively +- **Duration**: 1-2 days +- **Participants**: Cross-functional team +- **Outcome**: Prototype concepts + +**4. Prioritization Workshop**: +- **Purpose**: Rank requirements or features +- **Duration**: 2-3 hours +- **Participants**: Decision makers and SMEs +- **Outcome**: Ranked backlog + +#### Workshop Planning Checklist + +**4-6 Weeks Before**: +- [ ] Define workshop objectives and scope +- [ ] Identify and invite participants +- [ ] Book facility and arrange logistics +- [ ] Identify co-facilitator if needed + +**2-4 Weeks Before**: +- [ ] Develop detailed agenda +- [ ] Prepare workshop materials +- [ ] Send pre-work to participants +- [ ] Confirm attendance + +**1 Week Before**: +- [ ] Send reminder with logistics +- [ ] Finalize materials and print +- [ ] Test technology (projector, video conferencing) +- [ ] Arrange catering if applicable + +**Day Before**: +- [ ] Review agenda and materials +- [ ] Prepare room setup diagram +- [ ] Charge devices +- [ ] Print name tents + +**Day Of**: +- [ ] Arrive early to set up room +- [ ] Test all equipment +- [ ] Arrange materials +- [ ] Welcome participants + +#### Workshop Agenda Template + +```markdown +## Requirements Gathering Workshop + +**Date**: [Date] +**Time**: [Start] - [End] +**Location**: [Location] +**Facilitator**: [Name] + +### Pre-Work +Please review the following before the workshop: +- [Document 1] +- [Document 2] + +### Agenda + +**9:00 - 9:15 | Welcome and Introductions (15 min)** +- Introductions and icebreaker +- Workshop objectives +- Ground rules +- Agenda overview + +**9:15 - 9:45 | Context Setting (30 min)** +- Project overview and goals +- Current state summary +- Success criteria +- Scope boundaries + +**9:45 - 10:30 | Requirements Brainstorming (45 min)** +Activity: Silent brainstorming followed by group sharing +- Functional requirements +- Non-functional requirements +- Constraints + +**10:30 - 10:45 | Break (15 min)** + +**10:45 - 11:30 | Requirements Refinement (45 min)** +Activity: Group discussion and clustering +- Consolidate similar items +- Clarify ambiguous requirements +- Add missing details + +**11:30 - 12:15 | Prioritization (45 min)** +Activity: MoSCoW prioritization +- Must Have +- Should Have +- Could Have +- Won't Have (this time) + +**12:15 - 12:30 | Wrap-up and Next Steps (15 min)** +- Summary of outcomes +- Action items +- Next steps +- Feedback + +### Ground Rules +- One conversation at a time +- All ideas are valid +- Stay focused on objectives +- Be present (minimize devices) +- Respect time boundaries +- Challenge ideas, not people +``` + +#### Facilitation Techniques + +**Brainstorming Rules**: +```markdown +1. Quantity over quality initially +2. No criticism or evaluation during generation +3. Wild ideas encouraged +4. Build on others' ideas +5. Stay focused on topic +6. One conversation at a time +``` + +**Dot Voting for Prioritization**: +```markdown +1. List all items on wall/board +2. Give each participant 5-7 dot stickers +3. Participants place dots on top priorities +4. Can use multiple dots on one item (if allowed) +5. Count dots to see top priorities +6. Discuss results and make final decisions +``` + +**MoSCoW Prioritization**: +```markdown +**Must Have**: Critical for go-live, project fails without +**Should Have**: Important but not critical, can be deferred +**Could Have**: Nice to have, include if time/budget allows +**Won't Have**: Out of scope for this release +``` + +**Affinity Mapping**: +```markdown +1. Write each idea on separate sticky note +2. Post all notes on wall +3. Silently group similar items together +4. Discuss groupings as a team +5. Name each group +6. Identify themes and patterns +``` + +#### Managing Difficult Situations + +**Dominant Participant**: +- "Thank you [Name], let's hear from others" +- Use round-robin approach +- Direct questions to quieter participants +- Use silent brainstorming techniques + +**Off-Topic Discussion**: +- "That's important, let's capture it in the parking lot" +- "How does this relate to our objective?" +- Redirect to agenda +- Use parking lot board for tangents + +**Disagreement or Conflict**: +- Acknowledge both perspectives +- Focus on interests, not positions +- Find common ground +- Table for offline discussion if needed +- Use voting to resolve deadlock + +**Low Energy**: +- Take an unscheduled break +- Use energizer activity +- Change format (stand up, move around) +- Check if agenda is too ambitious + +### 1.4 Observation and Job Shadowing + +Observation provides firsthand insight into how work actually happens (vs. how stakeholders describe it). + +#### When to Use Observation + +**Ideal Scenarios**: +- Complex processes difficult to describe +- Significant muscle memory or tacit knowledge +- Suspected gaps between described and actual process +- Understanding context and environment +- Identifying workarounds and informal processes + +**Not Appropriate When**: +- Highly sensitive or confidential work +- Process happens infrequently +- Work is dangerous or restricted +- Stakeholder is uncomfortable being observed + +#### Planning an Observation Session + +**Preparation**: +```markdown +1. **Get Permission**: + - Manager approval + - Individual consent + - Explain purpose and process + +2. **Set Expectations**: + - Duration of observation + - Your role (observer, not evaluator) + - Confidentiality of findings + - Ability to ask questions + +3. **Prepare Tools**: + - Observation checklist + - Note-taking materials + - Camera (if permitted) + - Process documentation template + +4. **Choose Timing**: + - Typical workday (avoid unusual circumstances) + - Complete process cycle if possible + - Consider busy vs. slow periods +``` + +#### Observation Framework + +**What to Observe**: + +1. **Physical Environment**: + - Workspace layout + - Tools and equipment + - Materials and supplies + - Ergonomics and comfort + +2. **Process Steps**: + - Sequence of activities + - Decision points + - Handoffs between people/systems + - Inputs and outputs + +3. **Time and Effort**: + - Duration of each step + - Wait times and delays + - Multitasking + - Rush vs. thorough work + +4. **Tools and Systems**: + - Software applications used + - Manual vs. automated steps + - System switching + - Workarounds and shortcuts + +5. **Interactions**: + - Communication patterns + - Collaboration needs + - Questions asked + - Information sources + +6. **Pain Points**: + - Frustrations expressed + - Errors or rework + - Confusion or uncertainty + - Inefficiencies + +#### Observation Template + +```markdown +## Job Shadowing Session: [Role/Process] + +**Date**: [Date] +**Time**: [Start] - [End] +**Observer**: [Your name] +**Participant**: [Role or anonymous identifier] +**Process Observed**: [Process name] + +### Environment Notes +[Physical workspace, tools available, noise level, etc.] + +### Process Flow Observed + +| Time | Step | Activity Description | Tools Used | Duration | Notes | +|------|------|---------------------|------------|----------|-------| +| 9:00 | 1 | Login to system | System X | 2 min | Had to reset password | +| 9:02 | 2 | Pull overnight orders | System X | 5 min | System slow to respond | +| 9:07 | 3 | Export to Excel | System X, Excel | 3 min | Manual export needed | + +### Workarounds Identified +1. [Workaround description and why it exists] +2. [Workaround description and why it exists] + +### Pain Points Observed +- **[Pain point]**: [Description and impact] +- **[Pain point]**: [Description and impact] + +### Automation Opportunities +- [Step that could be automated] +- [Repetitive task that could be streamlined] + +### Questions Raised +- [Question about why process is done this way] +- [Question about alternative approaches] + +### Process Improvement Ideas +1. [Improvement idea based on observation] +2. [Improvement idea based on observation] + +### Follow-up Actions +- [ ] Validate observations with participant +- [ ] Interview [Name] about related process +- [ ] Research system capability for [specific need] +``` + +#### Think-Aloud Protocol + +Ask participant to verbalize their thinking: + +```markdown +"As you work, please describe what you're thinking and doing: +- What you're looking at +- What you're deciding +- Why you're choosing one option over another +- What you're concerned about" +``` + +**Benefits**: +- Reveals decision-making process +- Uncovers tacit knowledge +- Identifies information needs +- Shows workarounds and informal rules + +### 1.5 Document Analysis + +Existing documentation provides valuable context and baseline information. + +#### Types of Documents to Analyze + +**Strategic Documents**: +- Business plans +- Strategic roadmaps +- Vision and mission statements +- Goals and objectives + +**Operational Documents**: +- Standard operating procedures (SOPs) +- Work instructions +- Training materials +- Quality checklists + +**System Documentation**: +- User manuals +- System specifications +- Database schemas +- Integration diagrams + +**Historical Records**: +- Previous project documentation +- Lessons learned reports +- Meeting minutes +- Email threads + +**Compliance Documents**: +- Regulatory requirements +- Audit reports +- Policy documents +- Contracts and SLAs + +**Performance Data**: +- Reports and dashboards +- Metrics and KPIs +- Incident logs +- Customer feedback + +#### Document Analysis Framework + +```markdown +## Document Analysis: [Document Name] + +**Document Type**: [Type] +**Date Created**: [Date] +**Author**: [Name/Department] +**Last Updated**: [Date] +**Purpose**: [Why document was created] + +### Key Findings + +**Relevant Requirements**: +- [Requirement extracted from document] +- [Requirement extracted from document] + +**Business Rules Identified**: +- [Rule 1] +- [Rule 2] + +**Processes Described**: +- [Process 1 - with reference to section] +- [Process 2 - with reference to section] + +**Stakeholders Mentioned**: +- [Stakeholder role and their involvement] + +**Constraints Identified**: +- [Constraint from document] + +**Assumptions Noted**: +- [Assumption in document] + +### Gaps and Inconsistencies + +**Missing Information**: +- [What's not covered that should be] + +**Inconsistencies with Other Documents**: +- [Conflict with Document X about Y] + +**Outdated Information**: +- [What needs updating] + +### Questions for Stakeholders +1. [Question about unclear point] +2. [Question about inconsistency] +3. [Question about gap] + +### Action Items +- [ ] Verify [information] with [stakeholder] +- [ ] Request updated version of [document] +- [ ] Clarify [conflicting information] +``` + +#### Analysis Checklist + +**Quality Assessment**: +- [ ] Is documentation current and up-to-date? +- [ ] Is it complete for our needs? +- [ ] Is it accurate (verified with stakeholders)? +- [ ] Is terminology consistent? +- [ ] Are there version control issues? + +**Content Analysis**: +- [ ] What requirements are explicitly stated? +- [ ] What business rules are defined? +- [ ] What processes are documented? +- [ ] What constraints are mentioned? +- [ ] What assumptions are made? + +**Gap Analysis**: +- [ ] What information is missing? +- [ ] What conflicts with other documents? +- [ ] What has changed since creation? +- [ ] What needs validation? + +--- + +## 2. Process Modeling + +Process modeling creates visual representations of business processes to analyze, communicate, and improve them. + +### 2.1 BPMN Notation and Diagrams + +BPMN (Business Process Model and Notation) is the standard for process modeling. + +#### Core BPMN Elements + +**1. Events** (things that happen): + +```markdown +**Start Events** (where process begins): +○ - Start Event (generic) +⊙ - Timer Start Event (scheduled) +✉ - Message Start Event (triggered by message) + +**Intermediate Events** (occur during process): +◎ - Generic Intermediate Event +⊕ - Timer Intermediate Event (wait for time) +⊞ - Message Intermediate Event (send/receive message) + +**End Events** (where process ends): +⊗ - End Event (process completes) +⊗ - Terminate End Event (end all paths) +✉⊗ - Message End Event (send message and end) +``` + +**2. Activities** (work being done): + +```markdown +[Activity Name] - Task (single unit of work) +[⊞ Activity Name] - Subprocess (collapsed process) +[⊕ Activity Name] - Loop Activity (repeats) +``` + +**3. Gateways** (control flow): + +```markdown +◇ - Exclusive Gateway (XOR) - one path chosen +⬦ - Parallel Gateway (AND) - all paths taken +⬢ - Inclusive Gateway (OR) - one or more paths +○◇ - Event-Based Gateway - wait for event +``` + +**4. Connecting Objects**: + +```markdown +→ - Sequence Flow (order of activities) +--- → - Message Flow (between pools) +.... - Association (link to artifacts) +``` + +**5. Swimlanes**: + +```markdown +Pool: Represents an organization or major participant +Lane: Subdivides pool by role or department +``` + +#### BPMN Diagram Example + +```mermaid +flowchart TB + Start([Start: Customer Order Received]) --> Validate{Validate Order} + Validate -->|Valid| CheckStock[Check Inventory] + Validate -->|Invalid| NotifyError[Notify Customer of Error] + NotifyError --> End1([End]) + + CheckStock --> StockDecision{In Stock?} + StockDecision -->|Yes| ProcessPayment[Process Payment] + StockDecision -->|No| Backorder{Backorder Available?} + + Backorder -->|Yes| CreateBackorder[Create Backorder] + Backorder -->|No| NotifyOut[Notify Out of Stock] + CreateBackorder --> ProcessPayment + NotifyOut --> End2([End]) + + ProcessPayment --> PaymentOK{Payment Approved?} + PaymentOK -->|Yes| FulfillOrder[Fulfill Order] + PaymentOK -->|No| NotifyPaymentFail[Notify Payment Failed] + NotifyPaymentFail --> End3([End]) + + FulfillOrder --> ShipOrder[Ship Order] + ShipOrder --> NotifyShipped[Send Shipping Confirmation] + NotifyShipped --> End4([End: Order Complete]) +``` + +#### BPMN Best Practices + +**DO**: +- Start with high-level process, then detail +- Use consistent naming conventions (Verb + Noun) +- Keep diagrams readable (one page if possible) +- Show happy path clearly +- Document exceptions and error handling +- Use swimlanes to show responsibilities +- Include timing information when relevant + +**DON'T**: +- Mix different levels of detail +- Create overly complex diagrams (max 20-30 elements) +- Use technical jargon for business processes +- Forget to show end states +- Ignore exception flows +- Create diagrams without validation from process owners + +### 2.2 Swimlane Diagrams + +Swimlanes show which role or department performs each activity. + +#### Swimlane Structure + +```markdown +## Order Processing (Swimlane View) + +┌─────────────────────────────────────────────────────────────┐ +│ CUSTOMER │ +├─────────────────────────────────────────────────────────────┤ +│ ○ Place Order → [Fill Order Form] → Submit → │ +│ ↓ │ +│ ← [Review Confirmation] │ +└─────────────────────────────────────────────────────────────┘ + +┌─────────────────────────────────────────────────────────────┐ +│ SALES │ +├─────────────────────────────────────────────────────────────┤ +│ ↑ │ +│ [Receive Order] → {Valid?} ─No→ [Reject] │ +│ │ │ +│ Yes │ +│ ↓ │ +│ [Check Credit] → {OK?} │ +│ │ │ +│ Yes │ +│ ↓ │ +└─────────────────────────────────────────────────────────────┘ + +┌─────────────────────────────────────────────────────────────┐ +│ WAREHOUSE │ +├─────────────────────────────────────────────────────────────┤ +│ ↑ │ +│ [Pick Items] → [Pack Order] │ +│ ↓ │ +└─────────────────────────────────────────────────────────────┘ + +┌─────────────────────────────────────────────────────────────┐ +│ SHIPPING │ +├─────────────────────────────────────────────────────────────┤ +│ ↑ │ +│ [Create Label] → [Ship] → ⊗ │ +└─────────────────────────────────────────────────────────────┘ +``` + +#### Swimlane Template + +```markdown +## Process: [Process Name] + +**Purpose**: [What this process accomplishes] +**Trigger**: [What starts this process] +**Outcome**: [What is produced] + +### Swimlanes (Roles/Departments) + +**Lane 1: [Role Name]** +- Step 1.1: [Activity] +- Step 1.2: [Activity] +- Decision 1.3: [Gateway] + +**Lane 2: [Role Name]** +- Step 2.1: [Activity] +- Step 2.2: [Activity] + +**Lane 3: [Role Name]** +- Step 3.1: [Activity] +- Step 3.2: [Activity] + +### Handoffs + +| From | To | What is Transferred | Method | Time | +|------|-----|---------------------|--------|------| +| Sales | Warehouse | Order details | System X | Real-time | +| Warehouse | Shipping | Packed order | Physical handoff | 15 min | + +### Notes +- [Important information about process] +- [Exceptions or special cases] +``` + +### 2.3 Process Analysis (As-Is vs To-Be) + +#### As-Is Process Analysis + +**Purpose**: Document current state to identify improvement opportunities. + +**As-Is Analysis Template**: + +```markdown +## As-Is Process: [Process Name] + +**Last Updated**: [Date] +**Process Owner**: [Name] +**Frequency**: [How often process runs] +**Average Duration**: [Time to complete] + +### Process Overview +[Brief description of what process does today] + +### Process Steps + +| Step | Activity | Role | System | Duration | Issues | +|------|----------|------|--------|----------|--------| +| 1 | Receive request | Admin | Email | 5 min | Manual entry required | +| 2 | Validate data | Analyst | Excel | 30 min | No validation rules | +| 3 | Approve request | Manager | Paper form | 2 days | Manager often unavailable | + +### Process Metrics + +**Efficiency Metrics**: +- Total cycle time: 3-5 days +- Active work time: 2 hours +- Wait time: 90% of cycle time +- Rework rate: 20% +- Error rate: 15% + +**Volume Metrics**: +- Requests per month: 200 +- Peak volume: 350 (month-end) +- Staff required: 3 FTEs + +**Cost Metrics**: +- Labor cost per transaction: $45 +- System costs: $500/month +- Error correction cost: $2,000/month + +### Pain Points Identified + +**1. Manual Data Entry** +- **Issue**: Request form must be re-typed into system +- **Impact**: Time consuming, error-prone +- **Frequency**: Every request +- **Impact Score**: High + +**2. Approval Delays** +- **Issue**: Manager approval requires physical signature +- **Impact**: 2-3 day delays common, longer if manager traveling +- **Frequency**: Every request +- **Impact Score**: High + +**3. No Validation** +- **Issue**: Data errors discovered late in process +- **Impact**: Rework and delays +- **Frequency**: 20% of requests +- **Impact Score**: Medium + +### Bottlenecks +1. Manager approval (48-72 hour delay) +2. Data validation (30 minutes of manual checking) +3. Month-end volume spike (causes 5-day backlog) + +### Workarounds +- Analysts email manager for urgent approvals +- Pre-validation by submitter (informal) +- Overtime during month-end + +### Root Causes +- Legacy systems not integrated +- Manual approval policy never updated +- No investment in automation tools +``` + +#### To-Be Process Design + +**Purpose**: Define future state that addresses pain points. + +**To-Be Design Template**: + +```markdown +## To-Be Process: [Process Name] + +**Target Implementation**: [Date] +**Process Owner**: [Name] +**Expected Frequency**: [How often] +**Target Duration**: [Time to complete] + +### Process Overview +[Description of improved process] + +### Improvements Over As-Is + +| Current State | Future State | Improvement | +|---------------|--------------|-------------| +| Manual data entry | Web form with integration | 80% time reduction | +| Physical signature | Electronic approval | 90% faster approval | +| Manual validation | Automated rules | 100% error detection | + +### Process Steps (To-Be) + +| Step | Activity | Role | System | Duration | Changes from As-Is | +|------|----------|------|--------|----------|-------------------| +| 1 | Submit request | Requester | Web portal | 2 min | Self-service, validation | +| 2 | Auto-validate | System | Portal | 30 sec | Automated | +| 3 | Approve request | Manager | Portal (mobile) | 1 hour | Electronic, notifications | + +### Expected Metrics + +**Efficiency Improvements**: +- Total cycle time: 4 hours (was 3-5 days) +- Active work time: 30 minutes (was 2 hours) +- Wait time: 10% (was 90%) +- Rework rate: 2% (was 20%) +- Error rate: 1% (was 15%) + +**Capacity Improvements**: +- Staff required: 1 FTE (was 3) +- Peak handling: 500/month (was 350) +- No overtime needed + +**Cost Savings**: +- Labor cost per transaction: $8 (was $45) +- Annual labor savings: $88,800 +- Error correction savings: $21,600/year +- ROI: 18 months + +### Changes Required + +**Technology**: +- [ ] Implement web portal +- [ ] Integrate with core system +- [ ] Build validation rules +- [ ] Enable electronic signatures +- [ ] Mobile app for managers + +**Process**: +- [ ] Update approval policy +- [ ] Create self-service help +- [ ] Define SLAs +- [ ] Update training materials + +**People**: +- [ ] Train requesters on portal +- [ ] Train managers on mobile approval +- [ ] Redeploy 2 FTEs to other work + +**Governance**: +- [ ] Update policy documents +- [ ] Get executive approval +- [ ] Communicate changes +- [ ] Establish metrics dashboard + +### Implementation Plan + +**Phase 1: Foundation (Month 1-2)** +- Build web portal +- Integrate systems +- Pilot with small group + +**Phase 2: Rollout (Month 3)** +- Train all users +- Full launch +- Monitor closely + +**Phase 3: Optimize (Month 4-6)** +- Gather feedback +- Fine-tune process +- Measure benefits + +### Risk Mitigation + +| Risk | Probability | Impact | Mitigation | +|------|-------------|--------|------------| +| User adoption | Medium | High | Extensive training, champions | +| System integration | Low | High | Prototype early, fallback plan | +| Process not followed | Medium | Medium | Clear communication, monitoring | +``` + +### 2.4 Process Improvement Identification + +#### Process Improvement Framework + +**DMAIC Methodology** (Six Sigma approach): + +```markdown +**Define**: What process needs improvement? +- Identify process scope +- Define problem statement +- Establish goals and metrics + +**Measure**: How is the process performing? +- Map current process +- Collect baseline data +- Identify pain points + +**Analyze**: Why are problems occurring? +- Root cause analysis +- Identify waste and inefficiency +- Determine improvement opportunities + +**Improve**: What changes will help? +- Design future state +- Pilot improvements +- Validate benefits + +**Control**: How do we sustain improvements? +- Implement monitoring +- Train staff +- Document new process +``` + +#### Seven Wastes (LEAN) + +Identify and eliminate waste in processes: + +```markdown +1. **Transportation**: Unnecessary movement of materials/information + Example: Printing document just to scan it elsewhere + +2. **Inventory**: Excess information or materials waiting + Example: Queue of 100 unprocessed requests + +3. **Motion**: Unnecessary movement of people + Example: Walking to another building for signatures + +4. **Waiting**: Idle time between activities + Example: Waiting 2 days for approval + +5. **Overproduction**: Creating more than immediately needed + Example: Generating unused reports "just in case" + +6. **Overprocessing**: More work than required + Example: Multiple people reviewing same document + +7. **Defects**: Errors requiring rework + Example: Incorrect data entry requiring correction +``` + +#### Improvement Identification Template + +```markdown +## Process Improvement Opportunities: [Process] + +### Quick Wins (High Impact, Low Effort) + +**1. [Improvement Name]** +- **Current Issue**: [What's wrong] +- **Proposed Solution**: [How to fix] +- **Expected Benefit**: [What improves] +- **Effort**: [Hours/days to implement] +- **Cost**: [Estimated cost] +- **Dependencies**: [What's needed] + +**2. [Improvement Name]** +[Same structure] + +### Strategic Improvements (High Impact, High Effort) + +**1. [Improvement Name]** +- **Current Issue**: [What's wrong] +- **Proposed Solution**: [How to fix] +- **Expected Benefit**: [What improves] +- **Effort**: [Weeks/months to implement] +- **Cost**: [Estimated cost] +- **Dependencies**: [What's needed] + +### Small Enhancements (Low Impact, Low Effort) + +**1. [Improvement Name]** +[Same structure] + +### Not Recommended (Low Impact, High Effort) +- [Improvement that isn't worth it] + +### Prioritization Matrix + +``` +High Impact │ 3. Strategic │ 1. Quick Win + │ │ + ├────────────────┼─────────────── + │ │ +Low Impact │ 4. Not Worth │ 2. Enhancement + │ │ + └────────────────┴─────────────── + High Effort Low Effort +``` + +### Implementation Roadmap + +**Q1**: Quick Wins 1, 2, 3 +**Q2**: Strategic Improvement 1 (Phase 1) +**Q3**: Strategic Improvement 1 (Phase 2), Enhancement 1 +**Q4**: Strategic Improvement 2 +``` + +--- + +## 3. Requirements Documentation + +Clear, testable requirements are the foundation of successful projects. + +### 3.1 User Stories (As a, I want, So that) + +User stories describe functionality from user perspective. + +#### User Story Structure + +```markdown +As a [type of user] +I want [goal/desire] +So that [benefit/value] +``` + +**Example**: +```markdown +As a customer +I want to track my order status online +So that I know when to expect delivery without calling support +``` + +#### Writing Good User Stories + +**INVEST Criteria**: + +```markdown +**I - Independent**: Story can be developed standalone +**N - Negotiable**: Details can be discussed +**V - Valuable**: Delivers value to user/business +**E - Estimable**: Team can size the effort +**S - Small**: Can be completed in one iteration +**T - Testable**: Clear acceptance criteria +``` + +**Examples of Good vs. Bad User Stories**: + +**Bad** (Too technical): +```markdown +As a developer +I want to implement REST API endpoints +So that data can be accessed +``` + +**Good** (User-focused): +```markdown +As a mobile app user +I want to sync my data across devices +So that I can access my information anywhere +``` + +**Bad** (Too vague): +```markdown +As a user +I want better reporting +So that I can do my job +``` + +**Good** (Specific): +```markdown +As a sales manager +I want to see daily sales by region in a dashboard +So that I can quickly identify underperforming territories +``` + +#### User Story Template + +```markdown +## User Story: [Short Title] + +**ID**: US-### +**Epic**: [Parent epic] +**Priority**: [Must/Should/Could Have] +**Story Points**: [Estimate] + +### Story + +As a [role] +I want [feature] +So that [benefit] + +### Acceptance Criteria + +1. Given [context] + When [action] + Then [outcome] + +2. Given [context] + When [action] + Then [outcome] + +3. Given [context] + When [action] + Then [outcome] + +### Additional Details + +**User Persona**: [Which persona this serves] +**Business Value**: [Why this matters] +**Dependencies**: [Other stories or systems needed] +**Assumptions**: [What we're assuming] + +### Technical Notes +- [Technical consideration 1] +- [Technical consideration 2] + +### Questions +- [ ] [Open question to resolve] + +### Definition of Done +- [ ] Code complete and reviewed +- [ ] Unit tests written and passing +- [ ] Acceptance criteria verified +- [ ] Documentation updated +- [ ] Deployed to staging +``` + +#### User Story Examples by Type + +**Feature Story**: +```markdown +As a customer +I want to filter products by price range +So that I can find items within my budget + +**Acceptance Criteria**: +1. Given I'm on the product listing page + When I set a minimum and maximum price + Then only products in that range are displayed + +2. Given I've applied a price filter + When no products match the range + Then I see "No products found" message + +3. Given I've applied a price filter + When I click "Clear Filters" + Then all products are displayed again +``` + +**Bug Fix Story**: +```markdown +As a user +I want the shopping cart to persist my items +So that I don't lose my selections when I close the browser + +**Acceptance Criteria**: +1. Given I've added items to my cart + When I close the browser + Then my items are still in cart when I return + +2. Given I've added items on desktop + When I login on mobile + Then I see the same cart items +``` + +**Technical Story** (when absolutely necessary): +```markdown +As a development team +We want to upgrade the database to version 12 +So that we can use improved performance features + +**Acceptance Criteria**: +1. Database upgraded with zero data loss +2. All existing queries still function +3. Rollback plan tested and documented +``` + +### 3.2 Use Cases Structure + +Use cases describe interactions between actors and system to achieve a goal. + +#### Use Case Template + +```markdown +## Use Case: [Name] + +**ID**: UC-### +**Priority**: [High/Medium/Low] +**Status**: [Draft/Reviewed/Approved] + +### Brief Description +[One paragraph overview of what this use case accomplishes] + +### Actors +- **Primary Actor**: [Who initiates this use case] +- **Secondary Actors**: [Other participants] +- **Systems**: [External systems involved] + +### Preconditions +- [Condition that must be true before use case starts] +- [Another precondition] + +### Postconditions +**Success**: +- [What's true after successful completion] +- [Another postcondition] + +**Failure**: +- [What's true if use case fails] + +### Main Success Scenario +1. [Actor] [action] +2. System [response] +3. [Actor] [action] +4. System [response] +5. Use case ends successfully + +### Extensions (Alternate Flows) + +**3a. Invalid Data Entered** + 3a1. System displays validation error + 3a2. System highlights problematic fields + 3a3. Use case continues at step 3 + +**4a. System Timeout** + 4a1. System displays timeout message + 4a2. System saves partial progress + 4a3. Use case ends in failure + +**\*a. Actor Cancels** + \*a1. System prompts to confirm cancellation + \*a2. System discards changes + \*a3. Use case ends + +### Special Requirements +- [Non-functional requirement relevant to this use case] +- [Another special requirement] + +### Frequency of Use +[How often: Continuous / Daily / Weekly / Monthly / Rare] + +### Business Rules +- BR-1: [Business rule that applies] +- BR-2: [Another business rule] + +### User Interface Mockup +[Reference to mockup or wireframe if available] + +### Open Issues +- [Question or issue to resolve] +``` + +#### Detailed Use Case Example + +```markdown +## Use Case: Process Refund Request + +**ID**: UC-012 +**Priority**: High +**Status**: Approved + +### Brief Description +Customer service representative processes a customer's refund request for a returned item, validating eligibility and issuing refund through the appropriate payment method. + +### Actors +- **Primary Actor**: Customer Service Representative +- **Secondary Actors**: Customer, Accounting System +- **Systems**: Order Management System, Payment Gateway + +### Preconditions +- Representative is logged into Order Management System +- Customer has provided order number +- Order exists in system +- Product has been returned and received in warehouse + +### Postconditions +**Success**: +- Refund is approved and processed +- Customer receives email confirmation +- Accounting records are updated +- Order status updated to "Refunded" + +**Failure**: +- Refund is denied +- Customer is notified of denial reason +- Order status remains unchanged + +### Main Success Scenario +1. Representative enters order number +2. System displays order details and refund eligibility +3. Representative verifies return reason with customer +4. Representative selects items for refund +5. System calculates refund amount based on return policy +6. System displays refund amount and payment method +7. Representative confirms refund processing +8. System processes refund through payment gateway +9. System updates order status to "Refunded" +10. System sends confirmation email to customer +11. Use case ends successfully + +### Extensions (Alternate Flows) + +**2a. Order Not Found** + 2a1. System displays "Order not found" error + 2a2. System prompts to re-enter order number + 2a3. Use case continues at step 1 + +**2b. Order Not Eligible for Refund** + 2b1. System displays reason for ineligibility + 2b2. Representative explains policy to customer + 2b3. Use case ends in failure + +**5a. Partial Refund Required** + 5a1. Representative adjusts refund amount + 5a2. Representative enters justification note + 5a3. System requires manager approval + 5a4. Manager reviews and approves/denies + 5a5. Use case continues at step 6 (if approved) + +**8a. Payment Gateway Error** + 8a1. System displays error message + 8a2. System logs error for technical team + 8a3. Representative notes issue in customer record + 8a4. Use case continues at step 8 (retry) + 8a5. If retry fails, representative escalates to supervisor + +**8b. Original Payment Method Invalid** + 8b1. System alerts representative + 8b2. Representative requests alternate refund method + 8b3. Customer provides alternative (check, store credit) + 8b4. Use case continues at step 8 with new method + +### Special Requirements +- Refund must process within 5 business days +- All refunds over $500 require manager approval +- System must maintain audit trail of all actions +- Compliance with PCI DSS for payment data + +### Frequency of Use +Approximately 50-100 times per day across all representatives + +### Business Rules +- BR-012: Products must be returned within 30 days of purchase +- BR-013: Refund amount is purchase price minus shipping unless item defective +- BR-014: Store credit option provides 10% bonus value +- BR-015: Final sale items are not refundable + +### User Interface Mockup +See wireframe: Refund-Processing-Screen-v2.png + +### Open Issues +- Waiting for confirmation on international refund processing time +- Need to clarify partial return shipping fee policy +``` + +### 3.3 Functional vs Non-Functional Requirements + +#### Functional Requirements + +**Definition**: What the system must do - specific behaviors and functions. + +**Categories**: +```markdown +1. **Business Logic**: Calculations, validations, business rules +2. **Data Management**: CRUD operations, data manipulation +3. **User Interaction**: Interface behaviors, workflows +4. **Integration**: Interactions with other systems +5. **Reporting**: Information presentation and export +``` + +**Functional Requirement Template**: +```markdown +**FR-###: [Requirement Title]** + +**Description**: [Detailed description of what system must do] + +**Priority**: [Must/Should/Could Have] + +**Rationale**: [Why this requirement exists] + +**Acceptance Criteria**: +1. [Testable criterion 1] +2. [Testable criterion 2] +3. [Testable criterion 3] + +**Dependencies**: [Related requirements or systems] + +**Business Rule Reference**: [Related business rules] +``` + +**Examples**: + +```markdown +**FR-101: Password Reset** +The system shall allow users to reset their password via email verification. + +**Acceptance Criteria**: +1. User can request password reset by entering email address +2. System sends reset link valid for 24 hours +3. User can set new password meeting complexity requirements +4. System invalidates old password upon successful reset +5. System sends confirmation email after reset + +--- + +**FR-102: Invoice Calculation** +The system shall calculate invoice total as sum of line items plus applicable taxes minus discounts. + +**Acceptance Criteria**: +1. Line item total = quantity × unit price +2. Subtotal = sum of all line items +3. Tax = subtotal × tax rate (based on ship-to location) +4. Discount = subtotal × discount percentage (if applicable) +5. Total = subtotal + tax - discount +6. All amounts rounded to 2 decimal places + +--- + +**FR-103: Order Status Notification** +The system shall automatically send email notifications when order status changes. + +**Acceptance Criteria**: +1. Email sent when order placed (confirmation) +2. Email sent when order shipped (with tracking number) +3. Email sent when order delivered +4. Email sent if order cancelled +5. User can opt-out of non-essential notifications +6. Email template uses branding guidelines +``` + +#### Non-Functional Requirements + +**Definition**: How the system performs - quality attributes and constraints. + +**Categories (FURPS+)**: + +```markdown +**F - Functionality**: Already covered in functional requirements + +**U - Usability**: User experience, accessibility +**R - Reliability**: Availability, fault tolerance +**P - Performance**: Speed, throughput, capacity +**S - Supportability**: Maintainability, testability + +**+ Additional Categories**: +- Design constraints +- Implementation requirements +- Interface requirements +- Physical requirements +- Security requirements +- Compliance requirements +``` + +**Non-Functional Requirement Template**: +```markdown +**NFR-###: [Requirement Title]** + +**Category**: [Usability/Performance/Security/etc.] + +**Description**: [Detailed description] + +**Priority**: [Must/Should/Could Have] + +**Measurement**: [How to measure/verify] + +**Acceptance Criteria**: [Testable criteria] +``` + +**Examples by Category**: + +**Usability Requirements**: +```markdown +**NFR-201: Response Time Perception** +Category: Usability +The system shall provide feedback within 0.1 seconds for user actions. + +**Measurement**: User testing and timing analysis + +**Acceptance Criteria**: +1. Button clicks show visual response within 100ms +2. Loading indicators appear for operations over 1 second +3. Progress bars update for operations over 5 seconds + +--- + +**NFR-202: Accessibility Compliance** +Category: Usability +The system shall comply with WCAG 2.1 Level AA standards. + +**Acceptance Criteria**: +1. All images have descriptive alt text +2. Interface navigable via keyboard only +3. Minimum contrast ratio of 4.5:1 for text +4. Screen reader compatible +5. No time-based interactions under 5 seconds +``` + +**Performance Requirements**: +```markdown +**NFR-301: Page Load Time** +Category: Performance +Web pages shall load in under 2 seconds on standard broadband connection. + +**Measurement**: Load testing with typical data volumes + +**Acceptance Criteria**: +1. 95% of page loads under 2 seconds +2. 99% of page loads under 3 seconds +3. Measured with 50ms latency, 5Mbps bandwidth + +--- + +**NFR-302: Concurrent Users** +Category: Performance +System shall support 1,000 concurrent users without degradation. + +**Measurement**: Load testing + +**Acceptance Criteria**: +1. Response time remains under 2 seconds at 1,000 users +2. No errors or timeouts at maximum load +3. Resource utilization under 80% at peak +``` + +**Reliability Requirements**: +```markdown +**NFR-401: System Availability** +Category: Reliability +System shall be available 99.9% of time during business hours (8am-8pm ET). + +**Measurement**: Uptime monitoring + +**Acceptance Criteria**: +1. Maximum 43 minutes downtime per month +2. Planned maintenance outside business hours +3. Disaster recovery in under 4 hours + +--- + +**NFR-402: Data Backup** +Category: Reliability +System shall backup all data daily with 30-day retention. + +**Acceptance Criteria**: +1. Automated backup runs daily at 2am +2. Backup completion verified within 1 hour +3. Monthly restore test conducted +4. Off-site backup copy maintained +``` + +**Security Requirements**: +```markdown +**NFR-501: Authentication** +Category: Security +System shall require multi-factor authentication for all users. + +**Acceptance Criteria**: +1. Username/password as first factor +2. SMS, authenticator app, or hardware token as second factor +3. Session timeout after 30 minutes inactivity +4. Account lockout after 5 failed attempts + +--- + +**NFR-502: Data Encryption** +Category: Security +System shall encrypt all sensitive data at rest and in transit. + +**Acceptance Criteria**: +1. AES-256 encryption for data at rest +2. TLS 1.3 for data in transit +3. Encryption keys rotated quarterly +4. PII data encrypted in database +``` + +### 3.4 Acceptance Criteria + +Acceptance criteria define when a requirement is "done." + +#### Given-When-Then Format + +```markdown +**Given** [initial context/precondition] +**When** [action/event occurs] +**Then** [expected outcome] +``` + +**Examples**: + +```markdown +## User Story: Shopping Cart Quantity Update + +**Acceptance Criteria**: + +**AC1: Increase Quantity** +Given I have an item with quantity 1 in my cart +When I click the increase quantity button +Then the quantity updates to 2 +And the item subtotal reflects new quantity +And the cart total updates accordingly + +**AC2: Decrease Quantity** +Given I have an item with quantity 2 in my cart +When I click the decrease quantity button +Then the quantity updates to 1 +And the item subtotal reflects new quantity + +**AC3: Remove Item** +Given I have an item with quantity 1 in my cart +When I click the decrease quantity button +Then the item is removed from cart +And I see "Item removed" confirmation message + +**AC4: Maximum Quantity** +Given I have an item with quantity 10 in my cart +When I try to increase quantity +Then I see "Maximum quantity reached" error +And quantity remains at 10 + +**AC5: Direct Entry** +Given I'm viewing my cart +When I type "5" in the quantity field and press Enter +Then the quantity updates to 5 +And validations run (positive integer, in stock) +``` + +#### Checklist Format + +For simpler requirements, use checklist: + +```markdown +## Feature: User Profile Settings + +**Acceptance Criteria**: +- [ ] User can update first and last name +- [ ] User can update email address (with verification) +- [ ] User can upload profile photo (max 5MB, JPG/PNG only) +- [ ] User can change password (requires current password) +- [ ] User can enable/disable email notifications +- [ ] User can set timezone preference +- [ ] User can delete account (with confirmation) +- [ ] All changes are saved with "Settings updated" message +- [ ] Validation errors display clearly +- [ ] Form is mobile-responsive +``` + +#### Edge Cases in Acceptance Criteria + +Always consider edge cases: + +```markdown +## Feature: Search Functionality + +**Acceptance Criteria**: + +**Happy Path**: +Given I enter "laptop" in search +When I click Search +Then I see relevant results ranked by relevance +And I see result count +And I can sort and filter results + +**Edge Cases**: + +**Empty Search**: +Given the search box is empty +When I click Search +Then I see "Please enter a search term" message +And no results are shown + +**No Results**: +Given I enter "xyzabc123" in search +When I click Search +Then I see "No results found" message +And I see suggestions for similar terms + +**Special Characters**: +Given I enter search with special characters (*, &, <, >) +When I click Search +Then special characters are properly escaped +And search executes without error + +**Very Long Search**: +Given I enter 500 character search string +When I click Search +Then I see "Search term too long" error +And maximum length is indicated + +**SQL Injection Attempt**: +Given I enter "'; DROP TABLE users;--" +When I click Search +Then input is properly sanitized +And no SQL is executed +And search treats it as literal string +``` + +### 3.5 Traceability Matrix + +Traceability links requirements to their sources and implementations. + +#### Requirements Traceability Matrix (RTM) + +```markdown +## Requirements Traceability Matrix + +**Project**: [Project Name] +**Date**: [Date] +**Version**: [Version] + +| Req ID | Requirement | Source | Priority | Design Doc | Test Case | Status | +|--------|-------------|--------|----------|------------|-----------|--------| +| BR-001 | Business Rule 1 | Stakeholder Interview 1 | Must | DD-01 | TC-001, TC-002 | Complete | +| FR-101 | Login functionality | BR-001 | Must | DD-02 | TC-010-015 | In Progress | +| FR-102 | Password reset | BR-001 | Should | DD-02 | TC-020-022 | Not Started | +| NFR-201 | Page load < 2s | Performance SLA | Must | DD-05 | TC-100 | Complete | +| US-050 | User dashboard | Workshop 3 | Must | DD-03 | TC-030-035 | Testing | +``` + +**Column Definitions**: +- **Req ID**: Unique identifier +- **Requirement**: Brief description +- **Source**: Where requirement originated +- **Priority**: Must/Should/Could/Won't Have +- **Design Doc**: Design documentation reference +- **Test Case**: Test cases that verify requirement +- **Status**: Current implementation status + +#### Forward and Backward Traceability + +**Forward Traceability** (Requirement → Deliverables): +```markdown +Business Need → Business Requirement → Functional Requirement → Design → Code → Test +``` + +**Backward Traceability** (Deliverables → Requirement): +```markdown +Test ← Code ← Design ← Functional Requirement ← Business Requirement ← Business Need +``` + +**Example**: + +```markdown +## Traceability Chain: Fast Checkout + +**Business Need**: BN-10 +"Reduce cart abandonment rate by simplifying checkout" + +**Business Requirement**: BR-45 +"Checkout process must require no more than 3 steps" + +**Functional Requirements**: +- FR-220: Single page checkout design +- FR-221: Guest checkout option +- FR-222: Saved payment methods for registered users +- FR-223: Address auto-complete + +**Design Documents**: +- DD-15: Checkout Flow Design +- DD-16: Payment Integration Design + +**Implementation**: +- Code Module: checkout_module.py +- Database: checkout_schema.sql +- API: /api/checkout endpoint + +**Test Cases**: +- TC-500: Guest checkout flow +- TC-501: Registered user checkout +- TC-502: Checkout performance +- TC-503: Checkout validation + +**Validation**: +- Cart abandonment reduced from 68% to 45% +- Average checkout time reduced from 4:30 to 2:15 +- Customer satisfaction score increased 15% +``` + +--- + +## 4. Analysis Techniques + +### 4.1 Gap Analysis + +Gap analysis identifies differences between current and desired states. + +#### Gap Analysis Framework + +```markdown +## Gap Analysis: [Process/System Name] + +**Date**: [Date] +**Analyst**: [Name] +**Stakeholders**: [Names] + +### Current State (As-Is) + +**Capabilities**: +- [What we can do today] +- [Current feature/process] +- [Existing functionality] + +**Performance**: +- [Current metrics] +- [Performance levels] + +**Limitations**: +- [What we cannot do] +- [Constraints] +- [Bottlenecks] + +### Desired State (To-Be) + +**Required Capabilities**: +- [What we need to do] +- [Required features] +- [Target functionality] + +**Performance Targets**: +- [Target metrics] +- [Desired performance levels] + +**Success Criteria**: +- [What success looks like] +- [Measurable outcomes] + +### Gap Identification + +| Area | Current State | Desired State | Gap | Impact | +|------|---------------|---------------|-----|--------| +| Functionality | Manual data entry | Automated import | No import capability | High - 3hrs/day wasted | +| Performance | 5 min response | 30 sec response | 4.5 min improvement needed | Medium - user frustration | +| Capacity | 100 users | 500 users | 400 additional users | High - business growth limited | +| Integration | Manual transfer | Real-time sync | No integration | High - errors and delays | + +### Root Cause Analysis + +**Gap 1: No Import Capability** +- **Why?**: Legacy system built before APIs existed +- **Why?**: No budget for modernization +- **Why?**: Priority given to other projects +- **Root Cause**: Lack of business case for ROI + +### Impact Assessment + +**Business Impact**: +- Lost productivity: 750 hours/year +- Cost: $30,000/year in labor +- Opportunity cost: Cannot serve enterprise clients + +**Technical Impact**: +- Technical debt increasing +- System maintenance burden +- Risk of system failure + +**User Impact**: +- Frustration and workarounds +- Training burden for new staff +- Errors due to manual entry + +### Recommendations + +**Priority 1: Quick Wins** (0-3 months) +1. **Bulk Import via CSV** + - Effort: 2 weeks development + - Cost: $8,000 + - Benefit: 50% time savings + - ROI: 3 months + +**Priority 2: Strategic** (3-12 months) +2. **API Integration** + - Effort: 3 months + - Cost: $75,000 + - Benefit: 90% time savings, real-time data + - ROI: 12 months + +**Priority 3: Future**: +3. **System Replacement** + - Effort: 12 months + - Cost: $500,000 + - Benefit: All gaps closed + - ROI: 24 months + +### Implementation Roadmap + +**Phase 1** (Q1): Bulk CSV import +**Phase 2** (Q2-Q3): API integration +**Phase 3** (Q4): Performance optimization +**Phase 4** (Year 2): Evaluate system replacement + +### Success Metrics + +**How we'll measure closure of gaps**: +- Import time reduced by 80% +- Data error rate below 1% +- User satisfaction score > 8/10 +- System handles 500 concurrent users +``` + +### 4.2 Root Cause Analysis + +#### 5 Whys Technique + +Ask "Why?" five times to drill down to root cause. + +**Example**: + +```markdown +## 5 Whys: Customer Orders Delayed + +**Problem**: Customer orders are consistently delayed by 2-3 days + +**Why #1**: Why are orders delayed? +Answer: Orders sit in queue waiting for processing + +**Why #2**: Why do orders sit in queue? +Answer: Processing team is backlogged + +**Why #3**: Why is the team backlogged? +Answer: Manual validation of each order takes 30 minutes + +**Why #4**: Why does validation take so long? +Answer: Must check 5 different systems for data + +**Why #5**: Why must they check 5 different systems? +Answer: Systems are not integrated; no single source of truth + +**Root Cause**: Lack of system integration creates manual, time-consuming validation process + +**Solution**: Integrate systems to enable automated validation +``` + +#### Fishbone (Ishikawa) Diagram + +Organize potential causes into categories. + +```markdown +## Fishbone Diagram: High Customer Complaint Rate + + People Process + / / + Insufficient training No quality checks + / / + High turnover Unclear procedures + / / + / / + / / + /____________________/ + / \ + / \ + / \ + Poor communication Outdated system + / \ + No escalation path Slow response + / \ + Methods Technology + + +**Root Causes Identified**: + +**People**: +- High turnover rate (50% annually) +- Insufficient training (1 day only) +- Poor communication between shifts + +**Process**: +- No quality control checkpoints +- Unclear escalation procedures +- No standard complaint resolution process + +**Technology**: +- CRM system outdated (8 years old) +- System response time slow (5+ seconds) +- No mobile access for field staff + +**Methods**: +- No structured approach to complaint handling +- Inconsistent documentation +- Lack of follow-up process + +**Action Plan**: +Priority 1: Implement quality checkpoints (Process) +Priority 2: Upgrade CRM system (Technology) +Priority 3: Develop comprehensive training (People) +``` + +### 4.3 Impact Analysis + +Impact analysis evaluates consequences of changes. + +#### Impact Analysis Template + +```markdown +## Impact Analysis: [Change Description] + +**Change ID**: CHG-### +**Date**: [Date] +**Analyst**: [Name] +**Requested By**: [Stakeholder] + +### Change Summary +[Brief description of proposed change] + +### Scope of Impact + +**Systems Affected**: +- [System 1] - [High/Medium/Low impact] +- [System 2] - [High/Medium/Low impact] + +**Business Processes Affected**: +- [Process 1] - [Description of impact] +- [Process 2] - [Description of impact] + +**Stakeholder Groups Affected**: +| Group | Impact Level | Nature of Impact | Mitigation | +|-------|--------------|------------------|------------| +| End Users | High | Must learn new interface | Training program | +| IT Operations | Medium | New monitoring requirements | Documentation | +| Customers | Low | Minimal UI changes | Communication | + +### Detailed Impact Analysis + +**Functional Impact**: +- **Positive**: + - [Capability added or improved] + - [Problem solved] + +- **Negative**: + - [Capability removed or changed] + - [New limitations] + +**Technical Impact**: +- Database schema changes required +- API contracts modified +- Infrastructure scaling needed +- Integration points affected: [List] + +**Data Impact**: +- Data migration required: [Yes/No] +- Data volume affected: [Amount] +- Data quality risks: [Description] +- Archive/backup needs: [Requirements] + +**Performance Impact**: +- Expected performance change: [Better/Worse/Same] +- Load increase: [Percentage] +- Resource requirements: [CPU/Memory/Storage] + +**Security Impact**: +- Security model changes: [Yes/No] +- New vulnerabilities: [Description] +- Compliance implications: [Requirements] + +**User Experience Impact**: +- Learning curve: [High/Medium/Low] +- Workflow changes: [Description] +- Training required: [Hours/Days] + +### Risk Assessment + +| Risk | Probability | Impact | Mitigation | +|------|-------------|--------|------------| +| Data loss during migration | Low | High | Full backup, pilot test | +| User resistance to change | High | Medium | Change management plan | +| Integration failures | Medium | High | Extensive testing, rollback plan | +| Performance degradation | Low | Medium | Load testing, monitoring | + +### Dependencies + +**Prerequisites**: +- [What must be complete before this change] +- [Required approvals] + +**Blocked By**: +- [What would prevent this change] + +**Blocks**: +- [What depends on this change] + +### Cost-Benefit Analysis + +**Costs**: +- Development: $[Amount] +- Testing: $[Amount] +- Training: $[Amount] +- Infrastructure: $[Amount] +- **Total**: $[Amount] + +**Benefits**: +- Efficiency gain: [Quantified] +- Cost savings: $[Amount/year] +- Revenue increase: $[Amount/year] +- Risk reduction: [Description] +- **Annual Benefit**: $[Amount] + +**ROI**: [Percentage] | **Payback Period**: [Months] + +### Implementation Considerations + +**Effort Estimate**: [Hours/Days/Weeks] + +**Timeline**: +- Analysis: [Timeframe] +- Development: [Timeframe] +- Testing: [Timeframe] +- Training: [Timeframe] +- Deployment: [Timeframe] +- **Total**: [Timeframe] + +**Resource Requirements**: +- Developers: [Number] for [Duration] +- Testers: [Number] for [Duration] +- Business Analysts: [Number] for [Duration] + +### Recommendations + +**Recommendation**: [Approve/Defer/Reject] + +**Justification**: +[Reasoning for recommendation based on analysis] + +**Conditions** (if approved): +- [Condition 1] +- [Condition 2] + +**Alternatives Considered**: +1. [Alternative approach 1] - [Why not chosen] +2. [Alternative approach 2] - [Why not chosen] +``` + +### 4.4 Cost-Benefit Analysis + +#### Cost-Benefit Analysis Template + +```markdown +## Cost-Benefit Analysis: [Initiative Name] + +**Date**: [Date] +**Analysis Period**: [Number] years +**Analyst**: [Name] + +### Executive Summary +[2-3 sentences: What is being analyzed and recommendation] + +### Costs (One-Time) + +**Development Costs**: +- Requirements & Design: $[Amount] +- Development: $[Amount] +- Testing: $[Amount] +- Project Management: $[Amount] +- **Subtotal**: $[Amount] + +**Infrastructure Costs**: +- Hardware: $[Amount] +- Software Licenses: $[Amount] +- Cloud Setup: $[Amount] +- **Subtotal**: $[Amount] + +**Change Management Costs**: +- Training Development: $[Amount] +- User Training: $[Amount] +- Communication: $[Amount] +- **Subtotal**: $[Amount] + +**Other One-Time Costs**: +- Data Migration: $[Amount] +- Consulting: $[Amount] +- **Subtotal**: $[Amount] + +**Total One-Time Costs**: $[Amount] + +### Costs (Recurring/Annual) + +**Operational Costs**: +- Software Licenses: $[Amount/year] +- Infrastructure: $[Amount/year] +- Support & Maintenance: $[Amount/year] +- **Subtotal**: $[Amount/year] + +**Personnel Costs**: +- Additional Staff: $[Amount/year] +- Training (ongoing): $[Amount/year] +- **Subtotal**: $[Amount/year] + +**Total Annual Costs**: $[Amount/year] + +### Benefits (One-Time) + +**Process Improvement**: +- Reduction in backlog: $[Amount] +- Avoided penalties: $[Amount] +- **Subtotal**: $[Amount] + +**Total One-Time Benefits**: $[Amount] + +### Benefits (Recurring/Annual) + +**Efficiency Gains**: +- Time savings: [Hours/week] × [Rate] = $[Amount/year] +- Reduced errors: $[Amount/year] +- Faster processing: $[Amount/year] +- **Subtotal**: $[Amount/year] + +**Cost Avoidance**: +- Reduced manual labor: $[Amount/year] +- Lower error correction costs: $[Amount/year] +- Reduced system maintenance: $[Amount/year] +- **Subtotal**: $[Amount/year] + +**Revenue Impact**: +- Increased capacity: $[Amount/year] +- New capabilities: $[Amount/year] +- Customer retention: $[Amount/year] +- **Subtotal**: $[Amount/year] + +**Risk Reduction**: +- Avoided compliance penalties: $[Amount/year] +- Reduced system downtime: $[Amount/year] +- **Subtotal**: $[Amount/year] + +**Total Annual Benefits**: $[Amount/year] + +### Financial Analysis + +**3-Year Projection**: + +| Year | Costs | Benefits | Net Benefit | Cumulative | +|------|-------|----------|-------------|------------| +| 0 | $[Initial] | $0 | $([Initial]) | $([Initial]) | +| 1 | $[Annual] | $[Annual] | $[Net] | $[Cumulative] | +| 2 | $[Annual] | $[Annual] | $[Net] | $[Cumulative] | +| 3 | $[Annual] | $[Annual] | $[Net] | $[Cumulative] | +| **Total** | **$[Total]** | **$[Total]** | **$[Total]** | - | + +**Key Metrics**: +- **Net Present Value (NPV)**: $[Amount] +- **Return on Investment (ROI)**: [Percentage]% +- **Payback Period**: [Months] +- **Benefit-Cost Ratio**: [Ratio]:1 + +**NPV Calculation** (at [X]% discount rate): +``` +Year 0: $([Initial cost]) +Year 1: $[Net benefit] / 1.10 = $[PV] +Year 2: $[Net benefit] / 1.21 = $[PV] +Year 3: $[Net benefit] / 1.33 = $[PV] +NPV = Sum of above = $[Total NPV] +``` + +### Qualitative Benefits + +**Intangible Benefits** (not quantified above): +- Improved employee morale +- Enhanced customer satisfaction +- Competitive advantage +- Improved decision-making capability +- Future scalability +- Risk mitigation + +### Sensitivity Analysis + +**Optimistic Scenario** (benefits 20% higher): +- ROI: [Percentage]% +- Payback: [Months] + +**Most Likely Scenario** (base case above): +- ROI: [Percentage]% +- Payback: [Months] + +**Pessimistic Scenario** (benefits 20% lower): +- ROI: [Percentage]% +- Payback: [Months] + +### Risks and Assumptions + +**Key Assumptions**: +- [Assumption 1 that impacts calculation] +- [Assumption 2 that impacts calculation] + +**Risks to Benefits**: +- [Risk that could reduce benefits] +- [Another risk] + +**Mitigation Strategies**: +- [How to address risks] + +### Recommendation + +**Recommendation**: [Proceed/Don't Proceed/Further Analysis] + +**Rationale**: +[Explanation based on financial analysis and qualitative factors] + +**Conditions for Approval**: +- [Condition 1] +- [Condition 2] + +**Next Steps**: +1. [Step 1] +2. [Step 2] +``` + +### 4.5 Risk Analysis + +#### Risk Analysis Template + +```markdown +## Risk Analysis: [Project/Initiative Name] + +**Date**: [Date] +**Analyst**: [Name] +**Review Date**: [When to review again] + +### Risk Identification + +| Risk ID | Category | Description | Source | +|---------|----------|-------------|--------| +| R-001 | Technical | System integration failure | Technical assessment | +| R-002 | Resource | Key developer unavailable | Resource plan | +| R-003 | Business | Requirements change mid-project | Stakeholder interviews | + +### Risk Assessment Matrix + +**Probability Scale**: +- **High (H)**: >50% chance +- **Medium (M)**: 20-50% chance +- **Low (L)**: <20% chance + +**Impact Scale**: +- **High (H)**: >$50K impact or project failure +- **Medium (M)**: $10K-$50K impact or major delay +- **Low (L)**: <$10K impact or minor delay + +**Risk Matrix**: +``` + │ Low Impact │ Med Impact │ High Impact +──────────┼────────────┼────────────┼───────────── +High Prob │ Medium │ High │ High + ├────────────┼────────────┼───────────── +Med Prob │ Low │ Medium │ High + ├────────────┼────────────┼───────────── +Low Prob │ Low │ Low │ Medium +``` + +### Detailed Risk Register + +**Risk R-001: System Integration Failure** + +**Category**: Technical +**Probability**: Medium (30%) +**Impact**: High (Could delay launch by 3 months, $150K impact) +**Risk Score**: High +**Owner**: Technical Lead + +**Description**: +Third-party system API may not support required functionality or may have performance issues. + +**Triggers**: +- API documentation incomplete +- Performance testing reveals issues +- Authentication failures + +**Impact Details**: +- 3-month delay to find alternative or build custom solution +- $150K additional development cost +- Potential loss of customer confidence +- May miss market window + +**Mitigation Strategy** (Reduce probability/impact): +- Proof of concept with vendor's API (Week 1-2) +- Early performance testing (Week 3-4) +- Identify alternative vendors upfront +- Include fallback option in architecture +- Escalate to vendor technical team early + +**Contingency Plan** (If risk occurs): +- Switch to alternative vendor (Vendor B) +- Build custom integration layer (3 weeks, $30K) +- Negotiate with vendor for technical support + +**Current Status**: ⚠️ Monitoring (POC in progress) + +--- + +**Risk R-002: Key Developer Unavailability** + +**Category**: Resource +**Probability**: Low (15%) +**Impact**: Medium (2-week delay, $20K impact) +**Risk Score**: Low +**Owner**: Project Manager + +**Description**: +Lead developer may leave during project or be unavailable due to illness/emergency. + +**Mitigation Strategy**: +- Knowledge sharing sessions weekly +- Code reviews for knowledge transfer +- Document complex design decisions +- Cross-train secondary developer +- Maintain good morale and engagement + +**Contingency Plan**: +- Promote secondary developer to lead +- Hire contractor with required skills +- Reduce scope to critical features only + +**Current Status**: ✅ Under Control + +--- + +**Risk R-003: Requirements Change Mid-Project** + +**Category**: Business +**Probability**: High (60%) +**Impact**: Medium (Could add 4 weeks, $40K) +**Risk Score**: High +**Owner**: Business Analyst + +**Description**: +Stakeholders may request significant changes after requirements are baselined. + +**Mitigation Strategy**: +- Clear change control process +- Regular stakeholder demos (every 2 weeks) +- Sign-off on requirements document +- Prioritize features (MVP vs. nice-to-have) +- Frequent communication of impact of changes + +**Contingency Plan**: +- Formal change request process +- Impact analysis required for all changes +- Defer non-critical changes to Phase 2 +- Add time buffer to schedule (20%) + +**Current Status**: 🔴 High Priority (Managing actively) + +### Risk Summary Dashboard + +**Risk Distribution**: +- High Priority: 2 risks +- Medium Priority: 3 risks +- Low Priority: 5 risks +- **Total**: 10 risks + +**By Category**: +- Technical: 4 risks +- Resource: 2 risks +- Business: 3 risks +- External: 1 risk + +**Top 3 Risks** (by risk score): +1. R-001: System Integration Failure +2. R-003: Requirements Change +3. R-005: Data Migration Issues + +### Risk Response Budget + +**Contingency Reserve**: $75,000 +**Management Reserve**: $25,000 +**Total Risk Budget**: $100,000 + +### Risk Monitoring Plan + +**Review Frequency**: Bi-weekly at project status meeting + +**Escalation Criteria**: +- New high-priority risk identified +- Existing risk probability/impact increases +- Risk occurs + +**Reporting**: +- Risk register updated in project management tool +- Top 5 risks reported to steering committee monthly +- Risk trend analysis (improving/stable/worsening) +``` + +--- + +## 5. Tools & Deliverables + +### 5.1 Business Requirements Document (BRD) Structure + +#### BRD Template + +```markdown +# Business Requirements Document + +**Project Name**: [Project Name] +**Document Version**: [Version] +**Date**: [Date] +**Status**: [Draft/Review/Approved] + +**Document Control**: +| Version | Date | Author | Changes | +|---------|------|--------|---------| +| 0.1 | [Date] | [Name] | Initial draft | +| 0.2 | [Date] | [Name] | Incorporated feedback | +| 1.0 | [Date] | [Name] | Approved version | + +**Approvals**: +| Name | Role | Signature | Date | +|------|------|-----------|------| +| [Name] | Project Sponsor | | | +| [Name] | Business Owner | | | +| [Name] | IT Lead | | | + +--- + +## 1. Executive Summary + +### 1.1 Purpose +[1-2 paragraphs: Why this project exists, what problem it solves] + +### 1.2 Scope +**In Scope**: +- [Major deliverable 1] +- [Major deliverable 2] + +**Out of Scope**: +- [What is explicitly not included] +- [Future phase items] + +### 1.3 Expected Benefits +- [Key benefit 1 with quantification] +- [Key benefit 2 with quantification] +- [Key benefit 3 with quantification] + +### 1.4 Success Criteria +- [Measurable success criterion 1] +- [Measurable success criterion 2] +- [Measurable success criterion 3] + +--- + +## 2. Business Context + +### 2.1 Background +[Current situation, history, why change is needed now] + +### 2.2 Business Objectives +| Objective | Measure | Target | +|-----------|---------|--------| +| Improve efficiency | Processing time | Reduce by 50% | +| Increase capacity | Transactions/day | Increase from 100 to 500 | +| Enhance quality | Error rate | Reduce to <1% | + +### 2.3 Strategic Alignment +[How this project supports company strategy, goals, initiatives] + +--- + +## 3. Stakeholders + +### 3.1 Stakeholder Analysis + +| Stakeholder | Role | Interest | Influence | Engagement Strategy | +|-------------|------|----------|-----------|-------------------| +| Jane Smith | Project Sponsor | High | High | Weekly updates, decision involvement | +| Sales Team | End Users | High | Medium | Demos, training, feedback sessions | +| IT Department | Implementers | Medium | High | Regular technical meetings | + +### 3.2 Organizational Impact +[Which departments/teams are affected and how] + +--- + +## 4. Current State Assessment + +### 4.1 Current Process +[Description or diagram of how things work today] + +### 4.2 Current System Capabilities +[What current systems/tools can and cannot do] + +### 4.3 Pain Points and Limitations + +**Pain Point 1: Manual Data Entry** +- **Description**: Users must re-key data from emails into system +- **Impact**: 2 hours per day per user, 15% error rate +- **Frequency**: Every transaction (200/day) +- **Cost**: $30,000/year in labor + error correction + +**Pain Point 2**: [Similar structure] + +### 4.4 Current State Metrics +- Average processing time: 45 minutes +- Error rate: 15% +- Customer satisfaction: 6.5/10 +- System availability: 95% + +--- + +## 5. Business Requirements + +### 5.1 Business Capabilities Required + +**BR-001: Automated Data Capture** +- **Description**: System must automatically capture data from email and other sources without manual re-entry +- **Business Value**: Eliminate 2 hours/day manual work per user +- **Priority**: Must Have +- **Success Metric**: 90% of data auto-captured + +**BR-002**: [Similar structure for each requirement] + +### 5.2 Business Rules + +**Rule BR-001**: Orders over $10,000 require manager approval +**Rule BR-002**: Customer credit limit = 2x average monthly purchases (minimum $1,000) +**Rule BR-003**: Refunds must be processed within 5 business days + +### 5.3 Business Process Requirements + +[Process diagrams or descriptions of required business processes] + +--- + +## 6. Functional Requirements + +### 6.1 User Requirements + +**As a** Sales Representative +**I need** to view customer order history +**So that** I can provide informed recommendations + +**Acceptance Criteria**: +- View last 12 months of orders +- See order status and amount +- Access from mobile device + +### 6.2 Functional Requirements Summary + +| Req ID | Requirement | Priority | Complexity | +|--------|-------------|----------|------------| +| FR-001 | User login and authentication | Must Have | Medium | +| FR-002 | Dashboard with key metrics | Must Have | High | +| FR-003 | Order entry and validation | Must Have | High | +| FR-004 | Reporting and analytics | Should Have | Medium | + +[Detailed FR specifications in separate FRD or appendix] + +--- + +## 7. Non-Functional Requirements + +### 7.1 Performance Requirements +- Page load time: < 2 seconds +- System response time: < 1 second +- Support 500 concurrent users + +### 7.2 Availability Requirements +- 99.5% uptime during business hours (7am-7pm ET) +- Planned maintenance window: Sundays 1am-5am + +### 7.3 Security Requirements +- Multi-factor authentication +- Role-based access control +- All data encrypted at rest and in transit +- Audit trail of all transactions + +### 7.4 Compliance Requirements +- GDPR compliant for EU customer data +- SOC 2 Type II certified +- PCI DSS compliant for payment processing + +### 7.5 Usability Requirements +- Mobile responsive design +- WCAG 2.1 Level AA accessible +- Support for Chrome, Firefox, Safari, Edge +- Maximum 2 hours training required for new users + +--- + +## 8. Constraints and Assumptions + +### 8.1 Constraints +- **Budget**: Maximum $500,000 +- **Timeline**: Must launch by Q4 2025 +- **Technology**: Must use existing cloud platform (AWS) +- **Compliance**: Must meet industry regulations + +### 8.2 Assumptions +- Users have modern web browsers +- Stable internet connectivity available +- Existing systems will remain available +- Stakeholders available for requirements validation + +--- + +## 9. Dependencies + +### 9.1 Internal Dependencies +- Customer database migration project (must complete first) +- Network upgrade project (parallel) + +### 9.2 External Dependencies +- Third-party payment gateway API +- Vendor software license approval + +--- + +## 10. Risks + +[High-level risks - detailed analysis in separate risk register] + +| Risk | Impact | Probability | Mitigation | +|------|--------|-------------|------------| +| Integration failure | High | Medium | Early POC, backup vendor | +| User adoption | Medium | High | Change management, training | + +--- + +## 11. Implementation Approach + +### 11.1 Recommended Approach +[High-level: Agile/Waterfall/Hybrid, phased approach] + +### 11.2 Project Phases + +**Phase 1: Core Functionality** (Month 1-3) +- [Key deliverables] + +**Phase 2: Advanced Features** (Month 4-5) +- [Key deliverables] + +**Phase 3: Optimization** (Month 6) +- [Key deliverables] + +--- + +## 12. Cost-Benefit Analysis + +### 12.1 Estimated Costs +- Development: $300,000 +- Infrastructure: $50,000 +- Training: $25,000 +- **Total**: $375,000 + +### 12.2 Expected Benefits +- Labor savings: $150,000/year +- Error reduction: $50,000/year +- Revenue increase: $100,000/year +- **Total Annual**: $300,000/year + +### 12.3 ROI +- **Payback Period**: 15 months +- **3-Year NPV**: $525,000 +- **ROI**: 140% + +--- + +## 13. Success Metrics and KPIs + +| Metric | Current | Target | Measurement Method | +|--------|---------|--------|-------------------| +| Processing time | 45 min | 15 min | System logs | +| Error rate | 15% | 2% | Quality reports | +| User satisfaction | 6.5/10 | 8.5/10 | Quarterly survey | +| System uptime | 95% | 99.5% | Monitoring tools | + +--- + +## Appendices + +### Appendix A: Glossary +[Define key terms and acronyms] + +### Appendix B: References +[Related documents, standards, policies] + +### Appendix C: Detailed Requirements +[Link to FRD, use cases, detailed specifications] +``` + +### 5.2 Functional Requirements Document (FRD) + +#### FRD Template + +```markdown +# Functional Requirements Document + +**Project Name**: [Project Name] +**Related BRD**: [BRD version reference] +**Document Version**: [Version] +**Date**: [Date] + +--- + +## 1. Introduction + +### 1.1 Purpose +This document specifies the detailed functional requirements for [system name]. + +### 1.2 Scope +[What functions/features are detailed in this document] + +### 1.3 Audience +- Development team +- QA team +- Business stakeholders + +--- + +## 2. System Overview + +### 2.1 System Context +[How this system fits in larger ecosystem, context diagram] + +### 2.2 User Roles + +| Role | Description | Permissions | +|------|-------------|-------------| +| Administrator | System admin, full access | Create/Read/Update/Delete all | +| Manager | Approves requests, views reports | Read all, Approve, Generate reports | +| User | Daily operations | Create/Read own records, Submit requests | +| Guest | Limited read access | Read public information only | + +--- + +## 3. Functional Requirements + +### 3.1 Module: User Authentication + +**FR-001: User Login** + +**Description**: Users must authenticate before accessing the system. + +**Priority**: Must Have +**Complexity**: Medium +**Estimated Effort**: 3 days + +**Preconditions**: +- User has valid account +- System is accessible + +**Inputs**: +- Username (email format, max 255 chars) +- Password (min 8 chars, max 128 chars) + +**Process**: +1. User enters credentials +2. System validates format +3. System checks against user database +4. System verifies password hash +5. System creates session token +6. System redirects to dashboard + +**Outputs**: +- Success: Session token, redirect to dashboard +- Failure: Error message, remain on login page + +**Business Rules**: +- BR-001: Max 5 failed attempts, then 15-minute lockout +- BR-002: Session expires after 30 minutes of inactivity +- BR-003: Password must meet complexity requirements + +**Error Handling**: +- Invalid email format: "Please enter a valid email address" +- Incorrect credentials: "Invalid username or password" +- Account locked: "Account locked due to failed attempts. Try again in X minutes" +- System error: "Unable to process login. Please try again" + +**Acceptance Criteria**: +1. Given valid credentials + When user clicks Login + Then user is redirected to dashboard + And session is created + +2. Given invalid credentials + When user clicks Login + Then error message is displayed + And user remains on login page + +3. Given 5 failed login attempts + When user tries 6th attempt + Then account is locked for 15 minutes + And lockout message is displayed + +**UI Mockup**: [Link to wireframe] +**Test Cases**: TC-001 through TC-008 + +--- + +**FR-002: Password Reset** + +[Similar detailed structure for each functional requirement] + +--- + +### 3.2 Module: Order Management + +**FR-050: Create Order** +[Detailed specification] + +**FR-051: Update Order** +[Detailed specification] + +**FR-052: Cancel Order** +[Detailed specification] + +--- + +## 4. Data Requirements + +### 4.1 Data Entities + +**Entity: User** + +| Field | Type | Required | Validation | Description | +|-------|------|----------|------------|-------------| +| user_id | UUID | Yes | - | Unique identifier | +| email | String(255) | Yes | Valid email format | User's email | +| password_hash | String(255) | Yes | - | Hashed password | +| first_name | String(50) | Yes | Alpha only | User's first name | +| last_name | String(50) | Yes | Alpha only | User's last name | +| role | Enum | Yes | Valid role | User's role | +| created_date | DateTime | Yes | - | Account creation date | +| last_login | DateTime | No | - | Last successful login | +| is_active | Boolean | Yes | - | Account status | + +**Entity: Order** +[Similar structure] + +--- + +## 5. Integration Requirements + +### 5.1 External Systems + +**Integration: Payment Gateway** + +**Description**: Process credit card payments through Stripe API + +**Endpoint**: https://api.stripe.com/v1/charges +**Method**: POST +**Authentication**: API Key (Bearer token) + +**Request**: +```json +{ + "amount": 1000, + "currency": "usd", + "source": "tok_visa", + "description": "Order #12345" +} +``` + +**Response** (Success): +```json +{ + "id": "ch_1234567", + "status": "succeeded", + "amount": 1000 +} +``` + +**Error Handling**: +- Card declined: Notify user, keep order in pending status +- Network timeout: Retry 3 times with exponential backoff +- API error: Log error, notify admin, show user generic error + +**SLA**: 95% availability, 2-second response time + +--- + +## 6. Reporting Requirements + +**Report: Daily Sales Summary** + +**Description**: Shows sales by product category for selected date range + +**Parameters**: +- Start Date (required) +- End Date (required) +- Category Filter (optional) + +**Data Elements**: +- Date +- Category +- Number of Orders +- Total Sales Amount +- Average Order Value + +**Format**: Excel export, PDF view +**Refresh**: Real-time +**Access**: Manager role and above + +--- + +## 7. Validation Rules + +| Rule ID | Field | Validation | Error Message | +|---------|-------|------------|---------------| +| VAL-001 | Email | Valid email format | "Please enter a valid email" | +| VAL-002 | Phone | 10 digits, US format | "Phone must be 10 digits" | +| VAL-003 | ZIP Code | 5 or 9 digits | "Invalid ZIP code" | +| VAL-004 | Order Total | Greater than $0 | "Order total must be greater than zero" | + +--- + +## 8. Traceability Matrix + +| FR ID | Business Req | Use Case | Design Doc | Test Cases | +|-------|--------------|----------|------------|------------| +| FR-001 | BR-001 | UC-001 | DD-Auth-001 | TC-001 to TC-008 | +| FR-002 | BR-001 | UC-002 | DD-Auth-002 | TC-009 to TC-012 | + +--- + +## Appendices + +### Appendix A: Wireframes +[UI mockups and wireframes] + +### Appendix B: API Specifications +[Detailed API documentation] + +### Appendix C: Database Schema +[Entity-relationship diagram] +``` + +### 5.3 Data Flow Diagrams + +#### DFD Levels + +**Level 0 (Context Diagram)**: Shows system as single process with external entities + +```markdown +## Context Diagram: Order Management System + +``` +┌─────────────┐ ┌──────────────┐ +│ Customer │──── Orders ──────> │ Payment │ +│ │<─── Confirmation ─── │ Gateway │ +└─────────────┘ └──────────────┘ + │ │ + ↓ ↓ + ┌─────────────────────────────────┐ + │ │ + │ Order Management System │ + │ │ + └─────────────────────────────────┘ + │ │ + ↓ ↓ +┌─────────────┐ ┌──────────────┐ +│ Warehouse │<─── Pick List ─── │ Inventory │ +│ Staff │──── Shipment ──────> │ System │ +└─────────────┘ └──────────────┘ +``` +``` + +**Level 1 (Overview)**: Shows major processes within system + +```markdown +## Level 1 DFD: Order Management + +``` +Customer ──order──> [1.0 Validate Order] ──valid order──> [2.0 Check Inventory] + │ │ + │ invalid │ available + ↓ ↓ + [Error Notification] [3.0 Process Payment] + │ + │ approved + ↓ + [4.0 Fulfill Order] + │ + ↓ + [5.0 Ship Order] + │ + ↓ + Customer <──confirmation +``` +``` + +**Level 2 (Detailed)**: Shows sub-processes + +```markdown +## Level 2 DFD: Process 3.0 - Process Payment + +``` +Valid Order ──> [3.1 Calculate Total] ──amount──> [3.2 Apply Discounts] + │ + ↓ + [3.3 Submit to Gateway] + │ + ┌──────────────────────┴────────────────────┐ + │ │ + approved declined + │ │ + ↓ ↓ + [3.4 Record Payment] [3.5 Notify Customer] + │ + ↓ + Order Database +``` +``` + +#### DFD Notation + +**Processes**: [Process ID.# Process Name] +- Rectangle with rounded corners +- Verb-noun naming + +**Data Stores**: ||Store Name|| +- Open rectangle +- Noun naming + +**External Entities**: □ Entity Name +- Square +- Outside system boundary + +**Data Flows**: ──data name──> +- Arrow showing direction +- Named with data being transferred + +### 5.4 Entity Relationship Diagrams + +#### ERD Example + +```markdown +## Entity Relationship Diagram: E-commerce System + +``` +┌─────────────────┐ +│ CUSTOMER │ +├─────────────────┤ +│ PK customer_id │ +│ first_name │ +│ last_name │ +│ email │ +│ phone │ +└────────┬────────┘ + │ + │ places (1:M) + │ + ↓ +┌─────────────────┐ ┌─────────────────┐ +│ ORDER │ contains│ ORDER_LINE │ +├─────────────────┤ (1:M) ├─────────────────┤ +│ PK order_id │───────→ │ PK line_id │ +│ FK customer_id │ │ FK order_id │ +│ order_date │ │ FK product_id │ +│ status │ │ quantity │ +│ total │ │ unit_price │ +└─────────────────┘ └────────┬────────┘ + │ + │ references (M:1) + │ + ↓ + ┌─────────────────┐ + │ PRODUCT │ + ├─────────────────┤ + │ PK product_id │ + │ name │ + │ description │ + │ price │ + │ stock_qty │ + └─────────────────┘ +``` + +**Relationship Types**: +- 1:1 (One-to-One) +- 1:M (One-to-Many) +- M:M (Many-to-Many) - requires junction table + +**Cardinality Notation**: +- │ (one and only one) +- ○─ (zero or one) +- ├─ (one or many) +- ○< (zero or many) +``` + +#### ERD with Attributes + +```markdown +## Detailed ERD + +CUSTOMER ||──o{ ORDER : places +CUSTOMER { + uuid customer_id PK + string email UK "NOT NULL" + string password_hash "NOT NULL" + string first_name + string last_name + string phone + datetime created_at + boolean is_active "DEFAULT TRUE" +} + +ORDER ||──o{ ORDER_LINE : contains +ORDER { + uuid order_id PK + uuid customer_id FK + datetime order_date "DEFAULT NOW()" + string status "DEFAULT 'pending'" + decimal total_amount + string shipping_address + string payment_method +} + +ORDER_LINE }o──|| PRODUCT : references +ORDER_LINE { + uuid line_id PK + uuid order_id FK + uuid product_id FK + int quantity "CHECK > 0" + decimal unit_price + decimal subtotal +} + +PRODUCT { + uuid product_id PK + string sku UK "NOT NULL" + string name "NOT NULL" + text description + decimal price "CHECK >= 0" + int stock_quantity "DEFAULT 0" + string category + boolean is_active "DEFAULT TRUE" +} +``` + +--- + +## Best Practices Summary + +### Requirements Gathering +1. Engage stakeholders early and often +2. Use multiple elicitation techniques +3. Validate and verify requirements +4. Document assumptions explicitly +5. Prioritize ruthlessly + +### Process Modeling +1. Start high-level, then detail +2. Use standard notation (BPMN) +3. Validate with process owners +4. Show both as-is and to-be +5. Identify metrics for improvement + +### Requirements Documentation +1. Write clear, testable requirements +2. Use consistent templates +3. Maintain traceability +4. Version control all documents +5. Get formal approval + +### Analysis +1. Data-driven decision making +2. Consider multiple perspectives +3. Quantify impacts where possible +4. Document assumptions and risks +5. Present recommendations clearly + +### Deliverables +1. Tailor to audience +2. Use visuals effectively +3. Keep documents current +4. Link related artifacts +5. Follow organizational standards + +--- + +**End of Business Analysis Skill** + +This comprehensive skill covers all major aspects of business analysis from requirements gathering through deliverable creation. Use these patterns, templates, and techniques to deliver professional business analysis work. diff --git a/skills/data-analytics/SKILL.md b/skills/data-analytics/SKILL.md new file mode 100644 index 0000000..a7a2ab4 --- /dev/null +++ b/skills/data-analytics/SKILL.md @@ -0,0 +1,749 @@ +# Data Analysis Skill + +**Expert patterns for exploratory data analysis, statistical analysis, and visualization** + +## Core Principles + +1. **Data Quality First**: Always assess quality before analysis +2. **Statistical Rigor**: Use appropriate tests and validate assumptions +3. **Visual Storytelling**: Visualizations should communicate insights clearly +4. **Reproducibility**: Document methodology for repeatability + +--- + +## Exploratory Data Analysis (EDA) Framework + +### 1. Data Loading and Initial Inspection + +```python +import pandas as pd +import numpy as np + +# Load data +df = pd.read_csv('data.csv') + +# Initial inspection +print(f"Shape: {df.shape}") +print(f"\nData Types:\n{df.dtypes}") +print(f"\nFirst 5 rows:\n{df.head()}") +print(f"\nBasic Stats:\n{df.describe()}") +``` + +### 2. Data Quality Assessment + +**Missing Values**: +```python +# Check missing values +missing = df.isnull().sum() +missing_pct = (missing / len(df)) * 100 +missing_df = pd.DataFrame({ + 'Missing Count': missing, + 'Percentage': missing_pct +}).sort_values('Percentage', ascending=False) + +print(missing_df[missing_df['Percentage'] > 0]) +``` + +**Duplicates**: +```python +# Check duplicates +duplicates = df.duplicated().sum() +print(f"Duplicate rows: {duplicates}") + +# Remove duplicates if needed +df_clean = df.drop_duplicates() +``` + +**Data Type Validation**: +```python +# Validate expected types +expected_types = { + 'id': 'int64', + 'name': 'object', + 'date': 'datetime64', + 'amount': 'float64' +} + +for col, expected in expected_types.items(): + actual = df[col].dtype + if actual != expected: + print(f"Warning: {col} is {actual}, expected {expected}") +``` + +### 3. Statistical Summary + +**Descriptive Statistics**: +```python +# Numeric columns +numeric_summary = df.describe().T +numeric_summary['missing'] = df.isnull().sum() +numeric_summary['unique'] = df.nunique() + +# Categorical columns +categorical_cols = df.select_dtypes(include=['object']).columns +for col in categorical_cols: + print(f"\n{col} value counts:") + print(df[col].value_counts().head(10)) +``` + +**Distribution Analysis**: +```python +import matplotlib.pyplot as plt +import seaborn as sns + +# Distribution plots for numeric columns +numeric_cols = df.select_dtypes(include=[np.number]).columns + +fig, axes = plt.subplots(len(numeric_cols), 2, figsize=(12, 4*len(numeric_cols))) + +for idx, col in enumerate(numeric_cols): + # Histogram with KDE + sns.histplot(df[col], kde=True, ax=axes[idx, 0]) + axes[idx, 0].set_title(f'Distribution of {col}') + + # Box plot + sns.boxplot(x=df[col], ax=axes[idx, 1]) + axes[idx, 1].set_title(f'Box Plot of {col}') + +plt.tight_layout() +plt.savefig('distributions.png', dpi=300, bbox_inches='tight') +``` + +### 4. Correlation Analysis + +```python +# Correlation matrix +correlation_matrix = df[numeric_cols].corr() + +# Heatmap +plt.figure(figsize=(10, 8)) +sns.heatmap( + correlation_matrix, + annot=True, + fmt='.2f', + cmap='coolwarm', + center=0, + square=True, + linewidths=1 +) +plt.title('Correlation Matrix') +plt.savefig('correlation_heatmap.png', dpi=300, bbox_inches='tight') + +# Strong correlations +threshold = 0.7 +strong_corr = correlation_matrix[(correlation_matrix > threshold) | (correlation_matrix < -threshold)] +strong_corr = strong_corr[strong_corr != 1.0].dropna(how='all').dropna(axis=1, how='all') +print("Strong correlations:\n", strong_corr) +``` + +### 5. Outlier Detection + +**IQR Method**: +```python +def detect_outliers_iqr(df, column): + Q1 = df[column].quantile(0.25) + Q3 = df[column].quantile(0.75) + IQR = Q3 - Q1 + + lower_bound = Q1 - 1.5 * IQR + upper_bound = Q3 + 1.5 * IQR + + outliers = df[(df[column] < lower_bound) | (df[column] > upper_bound)] + + return outliers, lower_bound, upper_bound + +# Apply to all numeric columns +for col in numeric_cols: + outliers, lower, upper = detect_outliers_iqr(df, col) + print(f"\n{col}:") + print(f" Outliers: {len(outliers)} ({len(outliers)/len(df)*100:.1f}%)") + print(f" Range: [{lower:.2f}, {upper:.2f}]") +``` + +**Z-Score Method**: +```python +from scipy import stats + +def detect_outliers_zscore(df, column, threshold=3): + z_scores = np.abs(stats.zscore(df[column].dropna())) + outliers = df[z_scores > threshold] + return outliers + +# Apply +for col in numeric_cols: + outliers = detect_outliers_zscore(df, col) + print(f"{col}: {len(outliers)} outliers (Z-score > 3)") +``` + +### 6. Time Series Analysis (if applicable) + +```python +# Convert to datetime +df['date'] = pd.to_datetime(df['date']) +df = df.set_index('date') + +# Resample and aggregate +daily = df.resample('D').sum() +weekly = df.resample('W').sum() +monthly = df.resample('M').sum() + +# Plot trends +fig, axes = plt.subplots(3, 1, figsize=(12, 10)) + +daily['metric'].plot(ax=axes[0], title='Daily Trend') +weekly['metric'].plot(ax=axes[1], title='Weekly Trend') +monthly['metric'].plot(ax=axes[2], title='Monthly Trend') + +plt.tight_layout() +plt.savefig('time_series_trends.png', dpi=300) + +# Seasonality detection +from statsmodels.tsa.seasonal import seasonal_decompose + +decomposition = seasonal_decompose(df['metric'], model='additive', period=7) +fig = decomposition.plot() +fig.set_size_inches(12, 8) +plt.savefig('seasonality.png', dpi=300) +``` + +--- + +## Visualization Best Practices + +### Chart Type Selection + +| Data Type | Best Chart | When to Use | +|-----------|-----------|-------------| +| **Single variable distribution** | Histogram, Box plot | Understand data spread | +| **Two variable relationship** | Scatter plot | Check correlation | +| **Time series** | Line chart | Show trends over time | +| **Comparison across categories** | Bar chart | Compare groups | +| **Part-to-whole** | Pie chart, Stacked bar | Show composition | +| **Multiple variables** | Pair plot, Heatmap | Explore relationships | + +### Matplotlib/Seaborn Patterns + +**Professional Styling**: +```python +import matplotlib.pyplot as plt +import seaborn as sns + +# Set style +sns.set_style("whitegrid") +sns.set_context("notebook", font_scale=1.2) + +# Color palette +colors = sns.color_palette("husl", 8) + +# Figure size +plt.figure(figsize=(12, 6)) + +# Plot +sns.lineplot(data=df, x='date', y='value', hue='category') + +# Customize +plt.title('Revenue Trend by Category', fontsize=16, fontweight='bold') +plt.xlabel('Date', fontsize=12) +plt.ylabel('Revenue ($)', fontsize=12) +plt.legend(title='Category', title_fontsize=12) +plt.grid(alpha=0.3) + +# Save high quality +plt.savefig('chart.png', dpi=300, bbox_inches='tight', facecolor='white') +``` + +**Color Palette Guidelines**: +- Use colorblind-friendly palettes +- Limit to 5-6 colors +- Consistent across all charts +- Green = positive, Red = negative + +**Labeling**: +- Clear, descriptive titles +- Axis labels with units +- Legend when multiple series +- Annotations for key points + +--- + +## Statistical Testing + +### Hypothesis Testing Framework + +**1. Formulate Hypotheses**: +- Null hypothesis (H0): No effect/difference +- Alternative hypothesis (H1): There is an effect/difference + +**2. Choose Test**: + +| Scenario | Test | Function | +|----------|------|----------| +| Compare two means | t-test | `scipy.stats.ttest_ind()` | +| Compare >2 means | ANOVA | `scipy.stats.f_oneway()` | +| Compare proportions | Chi-square | `scipy.stats.chi2_contingency()` | +| Correlation | Pearson/Spearman | `scipy.stats.pearsonr()` | +| Normality | Shapiro-Wilk | `scipy.stats.shapiro()` | + +**3. Execute Test**: +```python +from scipy import stats + +# Example: Compare means of two groups +group_a = df[df['group'] == 'A']['metric'] +group_b = df[df['group'] == 'B']['metric'] + +# Check normality first +_, p_a = stats.shapiro(group_a) +_, p_b = stats.shapiro(group_b) + +if p_a > 0.05 and p_b > 0.05: + # Normal distribution - use t-test + t_stat, p_value = stats.ttest_ind(group_a, group_b) + test_used = "t-test" +else: + # Non-normal - use Mann-Whitney U test + t_stat, p_value = stats.mannwhitneyu(group_a, group_b) + test_used = "Mann-Whitney U" + +print(f"Test: {test_used}") +print(f"Statistic: {t_stat:.4f}") +print(f"P-value: {p_value:.4f}") +print(f"Significant: {'Yes' if p_value < 0.05 else 'No'}") +``` + +**4. Interpret Results**: +- p < 0.05: Reject null hypothesis (significant) +- p ≥ 0.05: Fail to reject null hypothesis (not significant) + +### Effect Size + +Always report effect size with statistical significance: + +```python +# Cohen's d for t-test +def cohens_d(group1, group2): + n1, n2 = len(group1), len(group2) + var1, var2 = group1.var(), group2.var() + pooled_std = np.sqrt(((n1-1)*var1 + (n2-1)*var2) / (n1+n2-2)) + return (group1.mean() - group2.mean()) / pooled_std + +d = cohens_d(group_a, group_b) +print(f"Effect size (Cohen's d): {d:.3f}") +print(f"Magnitude: {'Small' if abs(d) < 0.5 else 'Medium' if abs(d) < 0.8 else 'Large'}") +``` + +--- + +## Data Cleaning Patterns + +### Handling Missing Values + +**1. Analyze Pattern**: +```python +# Missing data pattern +import missingno as msno + +msno.matrix(df) +plt.savefig('missing_pattern.png') + +# Correlation of missingness +msno.heatmap(df) +plt.savefig('missing_correlation.png') +``` + +**2. Choose Strategy**: + +| % Missing | Strategy | When to Use | +|-----------|----------|-------------| +| < 5% | Drop rows | MCAR (Missing Completely At Random) | +| 5-20% | Imputation | MAR (Missing At Random) | +| > 20% | Create indicator variable | MNAR (Missing Not At Random) | + +**3. Implement**: +```python +# Drop if few missing +df_clean = df.dropna(subset=['critical_column']) + +# Mean/Median imputation (numeric) +df['column'].fillna(df['column'].median(), inplace=True) + +# Mode imputation (categorical) +df['category'].fillna(df['category'].mode()[0], inplace=True) + +# Forward fill (time series) +df['value'].fillna(method='ffill', inplace=True) + +# Sophisticated imputation +from sklearn.impute import KNNImputer +imputer = KNNImputer(n_neighbors=5) +df_imputed = pd.DataFrame( + imputer.fit_transform(df[numeric_cols]), + columns=numeric_cols +) +``` + +### Handling Outliers + +**Decision Framework**: +1. **Investigate**: Are they errors or real extreme values? +2. **Document**: Explain handling decision +3. **Options**: + - Keep: If legitimate extreme values + - Remove: If data errors + - Cap: Winsorize to percentile + - Transform: Log transform to reduce impact + +```python +# Winsorization (cap at percentiles) +from scipy.stats.mstats import winsorize + +df['metric_winsorized'] = winsorize(df['metric'], limits=[0.05, 0.05]) + +# Log transformation +df['metric_log'] = np.log1p(df['metric']) # log1p handles zeros +``` + +--- + +## Reporting Template + +```markdown +# Exploratory Data Analysis Report + +**Dataset**: [name] +**Analysis Date**: [date] +**Analyst**: [name] + +## Executive Summary + +[2-3 sentences: What is the data? Key findings? Recommendations?] + +## Data Overview + +- **Rows**: [count] +- **Columns**: [count] +- **Time Period**: [start] to [end] +- **Data Source**: [source] + +## Data Quality + +### Missing Values +| Column | Missing Count | Percentage | +|--------|---------------|------------| +[list columns with >5% missing] + +### Duplicates +- [count] duplicate rows ([percentage]%) +- Action: [removed/kept] + +### Data Type Issues +[list any type mismatches or issues] + +## Statistical Summary + +[Table of descriptive statistics for key metrics] + +## Key Findings + +### 1. [Finding Name] +**Observation**: [What you found] +**Evidence**: [Supporting statistics] +**Visualization**: [Chart reference] +**Implication**: [What it means] + +### 2. [Finding Name] +[Same structure] + +### 3. [Finding Name] +[Same structure] + +## Correlation Analysis + +[Heatmap image] + +**Strong Relationships**: +- [Variable 1] and [Variable 2]: r = [correlation], p < [p-value] +- [Interpretation] + +## Outliers + +| Column | Outlier Count | Percentage | Action | +|--------|---------------|------------|--------| +[list columns with outliers] + +## Temporal Patterns (if applicable) + +[Time series visualizations] + +**Trends**: +- [Trend 1] +- [Trend 2] + +**Seasonality**: [Yes/No - describe pattern] + +## Recommendations + +1. **Data Collection**: [Suggestions for improving data quality] +2. **Further Analysis**: [Suggested deep-dives] +3. **Action Items**: [Business recommendations] + +## Next Steps + +- [ ] [Action 1] +- [ ] [Action 2] +- [ ] [Action 3] + +## Appendix + +### Methodology +[Brief description of analysis approach] + +### Tools Used +- Python [version] +- pandas [version] +- scipy [version] +- matplotlib [version] +``` + +--- + +## Quality Checklist + +Before completing analysis: + +- [ ] Data quality assessed (missing, duplicates, types) +- [ ] Descriptive statistics calculated +- [ ] Distributions visualized +- [ ] Outliers detected and explained +- [ ] Correlations analyzed +- [ ] Statistical tests appropriate for data +- [ ] Assumptions validated +- [ ] Visualizations clear and labeled +- [ ] Findings actionable +- [ ] Methodology documented +- [ ] Code reproducible + +--- + +## MCP-Enhanced Data Access + +### PostgreSQL MCP Integration + +When PostgreSQL MCP is available, access data directly from databases without export/import cycles: + +```typescript +// Runtime detection - no configuration needed +const hasPostgres = typeof mcp__postgres__query !== 'undefined'; + +if (hasPostgres) { + console.log("✓ Using PostgreSQL MCP for direct database access"); + + // Direct SQL execution - 10x faster than export/import + const result = await mcp__postgres__query({ + sql: ` + SELECT + date_trunc('day', created_at) as date, + COUNT(*) as count, + AVG(amount) as avg_amount, + STDDEV(amount) as stddev_amount + FROM transactions + WHERE created_at >= NOW() - INTERVAL '30 days' + GROUP BY date_trunc('day', created_at) + ORDER BY date + ` + }); + + console.log(`✓ Retrieved ${result.rows.length} rows directly from database`); + + // Convert to pandas DataFrame (if using Python analysis) + // Or work with result.rows directly in JavaScript/TypeScript + + // Benefits: + // - No CSV export/import cycle + // - Always fresh data (no stale exports) + // - Can use database aggregations (faster) + // - Query only needed columns + // - Leverage database indexes + +} else { + console.log("ℹ️ PostgreSQL MCP not available"); + console.log(" Install for 10x faster data access:"); + console.log(" npm install -g @modelcontextprotocol/server-postgres"); + console.log(" Falling back to manual export/import workflow"); +} +``` + +### Benefits Comparison + +| Aspect | With PostgreSQL MCP | Without MCP (Export/Import) | +|--------|-------------------|---------------------------| +| **Speed** | 10x faster - direct queries | Multi-step: export → download → import | +| **Data Freshness** | Always current (live queries) | Stale (last export time) | +| **Memory Usage** | Stream large datasets | Load entire CSV into memory | +| **Aggregations** | Database-side (fast) | Python-side (slower) | +| **Iteration** | Instant query refinement | Re-export for each change | +| **Data Selection** | Query only needed columns | Export everything, filter later | +| **Collaboration** | Shared database access | Email CSV files | + +**When to use PostgreSQL MCP:** +- Exploratory data analysis requiring multiple query iterations +- Large datasets (>100MB) that strain memory +- Need for fresh data (real-time dashboards) +- Complex aggregations better done in SQL +- Multiple analysts working on same dataset +- Production database analysis + +**When manual export sufficient:** +- Small datasets (<10MB) analyzed once +- Offline analysis required +- No database access permissions +- Static snapshot needed for compliance + +### MongoDB MCP Integration + +For NoSQL data sources: + +```typescript +const hasMongo = typeof mcp__mongodb__query !== 'undefined'; + +if (hasMongo) { + console.log("✓ Using MongoDB MCP for document database access"); + + // Direct MongoDB queries + const result = await mcp__mongodb__query({ + database: "analytics", + collection: "events", + query: { + timestamp: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } + }, + aggregation: [ + { $group: { + _id: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } }, + count: { $sum: 1 }, + avgValue: { $avg: "$value" } + }}, + { $sort: { _id: 1 } } + ] + }); + + console.log(`✓ Aggregated ${result.length} daily summaries`); + +} else { + console.log("ℹ️ MongoDB MCP not available"); + console.log(" Install: npm install -g @modelcontextprotocol/server-mongodb"); +} +``` + +### Real-World Example: Customer Cohort Analysis + +**With PostgreSQL MCP (5 minutes):** + +```sql +-- Direct cohort analysis query +SELECT + DATE_TRUNC('month', first_purchase) as cohort_month, + DATE_TRUNC('month', purchase_date) as activity_month, + COUNT(DISTINCT customer_id) as customers, + SUM(amount) as revenue +FROM ( + SELECT + customer_id, + purchase_date, + amount, + FIRST_VALUE(purchase_date) OVER ( + PARTITION BY customer_id + ORDER BY purchase_date + ) as first_purchase + FROM purchases + WHERE purchase_date >= '2024-01-01' +) cohorts +GROUP BY cohort_month, activity_month +ORDER BY cohort_month, activity_month +``` + +**Without MCP (45 minutes):** + +1. Request database export from DBA (10 min wait) +2. Download CSV file (2 min) +3. Load into pandas (3 min) +4. Write Python cohort analysis code (20 min) +5. Debug memory issues with large dataset (10 min) + +### PostgreSQL MCP Installation + +```bash +# Install PostgreSQL MCP for direct database access +npm install -g @modelcontextprotocol/server-postgres + +# Configure in MCP settings +# Add to claude_desktop_config.json: +{ + "mcpServers": { + "postgres": { + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-postgres"], + "env": { + "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost:5432/dbname" + } + } + } +} + +# Or configure per-project connection +# Add to .env file: +POSTGRES_CONNECTION_STRING=postgresql://user:pass@localhost:5432/dbname +``` + +### MongoDB MCP Installation + +```bash +# Install MongoDB MCP +npm install -g @modelcontextprotocol/server-mongodb + +# Configure in MCP settings +{ + "mcpServers": { + "mongodb": { + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-mongodb"], + "env": { + "MONGODB_URI": "mongodb://localhost:27017" + } + } + } +} +``` + +Once installed, all agents reading this skill automatically detect and use database MCPs for direct data access. + +### Security Best Practices + +When using database MCPs: + +1. **Use Read-Only Accounts**: Create dedicated read-only database users + ```sql + CREATE USER analyst_readonly WITH PASSWORD 'secure_password'; + GRANT SELECT ON ALL TABLES IN SCHEMA public TO analyst_readonly; + ``` + +2. **Connection Strings**: Store in environment variables, never in code + ```bash + export POSTGRES_CONNECTION_STRING="postgresql://readonly:pass@host/db" + ``` + +3. **Query Limits**: Always use LIMIT clauses for exploratory queries + ```sql + SELECT * FROM large_table LIMIT 1000; -- Safe exploration + ``` + +4. **Avoid SELECT ***: Query only needed columns to reduce bandwidth + ```sql + SELECT id, date, amount FROM transactions; -- Better + ``` + +--- + +**Version**: 1.0 +**Last Updated**: January 2025 +**MCP Enhancement**: PostgreSQL/MongoDB for 10x faster data access +**Success Rate**: 95% analysis accuracy following these patterns diff --git a/skills/product-management/SKILL.md b/skills/product-management/SKILL.md new file mode 100644 index 0000000..8d9af75 --- /dev/null +++ b/skills/product-management/SKILL.md @@ -0,0 +1,670 @@ +# Roadmap Planning Skill + +**Strategic product roadmap creation with proven frameworks for prioritization, timeline planning, and stakeholder alignment** + +This skill codifies best practices from product management at scale-ups and enterprise companies. + +--- + +## Core Principles + +1. **Outcomes Over Outputs**: Focus on business results, not feature lists +2. **Flexibility Over Rigidity**: Roadmaps are plans, not promises +3. **Strategy Over Tactics**: Connect features to strategic themes +4. **Transparency Over Secrecy**: Share context and rationale +5. **Learning Over Perfection**: Update based on feedback and data + +--- + +## Roadmap Frameworks + +### 1. Now-Next-Later Framework + +**Best for**: Startups, fast-moving teams, high uncertainty + +**Structure**: +- **Now (0-3 months)**: Committed work, high confidence, detailed specs +- **Next (3-6 months)**: High priority, medium confidence, rough scoping +- **Later (6-12+ months)**: Strategic direction, low detail, high flexibility + +**Benefits**: +- Avoids false precision of dates far out +- Communicates confidence level naturally +- Easy to update as priorities shift +- Less pressure on far-future estimates + +**When to use**: +- Product-market fit still evolving +- High rate of learning and pivoting +- Small team with limited planning capacity +- Consumer products with rapid iteration + +### 2. Quarterly Roadmap (OKR-Aligned) + +**Best for**: Scale-ups, enterprise, predictable release cycles + +**Structure**: +```markdown +## Q1 2025: Improve User Activation + +**Objective**: Increase new user activation rate from 40% to 55% + +**Key Results**: +- KR1: 60% of new users complete onboarding (up from 45%) +- KR2: Reduce time to first value to < 5 minutes (from 12 min) +- KR3: Increase Day 7 retention to 35% (from 28%) + +**Features**: +- Redesigned onboarding flow (8 points) +- In-app tutorials and tooltips (5 points) +- Quick-start templates (3 points) +- Email nurture sequence (3 points) + +**Dependencies**: Design system v2 (Q4 2024) +**Risks**: Mobile app parity may slip to early Q2 +``` + +**Benefits**: +- Clear alignment to business goals +- Measurable success criteria +- Executive-friendly format +- Works with OKR planning cycle + +**When to use**: +- Company uses OKRs +- Quarterly planning cycles +- Need exec/board visibility +- Multiple teams coordinating + +### 3. Theme-Based Roadmap + +**Best for**: Communicating strategy, managing multiple initiatives + +**Structure**: +```markdown +## Theme 1: Performance & Reliability (Q1-Q2) +**Why**: 23% of users cite slowness as top issue +**Success**: P95 load time < 2 seconds, 99.9% uptime + +**Initiatives**: +- Backend optimization (Q1) +- CDN implementation (Q1) +- Database sharding (Q2) +- Monitoring and alerting (Q1) + +## Theme 2: Mobile Experience (Q2-Q3) +**Why**: 60% of traffic is mobile but only 30% of conversions +**Success**: Mobile conversion rate reaches 80% of desktop + +**Initiatives**: +- Responsive redesign (Q2) +- Mobile-optimized checkout (Q2) +- Progressive Web App (Q3) +- Touch gesture support (Q3) +``` + +**Benefits**: +- Communicates strategic intent +- Groups related work +- Easier to explain "why" +- Handles cross-team efforts well + +**When to use**: +- Multiple parallel strategic initiatives +- Explaining roadmap to customers/board +- Complex products with many features +- Need to show strategic coherence + +### 4. Feature-Based Roadmap + +**Best for**: Feature factories, B2B with specific requests, contract commitments + +**Structure**: +```markdown +## Q1 2025 +✅ SSO/SAML integration (Enterprise tier) - HIGH +✅ API v2 with GraphQL (All tiers) - HIGH +⚠️ Advanced reporting (Pro+) - MEDIUM +⬜ Bulk import tool (All tiers) - LOW + +## Q2 2025 +⬜ Mobile app v1 (All tiers) - HIGH +⬜ Webhooks (Pro+) - MEDIUM +⬜ Custom branding (Enterprise) - MEDIUM +``` + +**Legend**: +- ✅ Committed +- ⚠️ Planned +- ⬜ Under consideration + +**When to use**: +- B2B with specific contract requirements +- Need to track feature commitments +- Sales team needs visibility +- Customer-driven roadmap + +**Warning**: Can become "feature factory" without strategy + +--- + +## Prioritization Frameworks + +### RICE Scoring + +**Formula**: (Reach × Impact × Confidence) / Effort + +**Reach**: Users affected per quarter (numeric) +**Impact**: Value per user (0.25, 0.5, 1, 2, 3) +**Confidence**: Certainty in estimates (50%, 80%, 100%) +**Effort**: Person-months to complete + +**Example**: +``` +Feature: Redesigned Dashboard +- Reach: 8,000 active users/quarter +- Impact: 2 (high - saves 10 min/day per user) +- Confidence: 80% (good research, some unknowns) +- Effort: 3 person-months + +RICE = (8000 × 2 × 0.8) / 3 = 4,267 +``` + +**Use when**: You have data and want objective prioritization + +### ICE Scoring + +**Formula**: (Impact + Confidence + Ease) / 3 + +Simpler than RICE, uses 1-10 scale for each factor. + +**Impact**: How much will this move metrics? +**Confidence**: How sure are you it will work? +**Ease**: How simple is implementation? + +**Use when**: You want quick prioritization without heavy data + +### Value vs Effort Matrix + +Plot features on 2×2 grid: + +``` +High Value, Low Effort → Quick Wins (Do First) +High Value, High Effort → Big Bets (Strategic) +Low Value, Low Effort → Fill-ins (If Time) +Low Value, High Effort → Money Pit (Avoid) +``` + +**Use when**: You want visual prioritization for stakeholders + +### MoSCoW Method + +- **Must Have**: Non-negotiable, product broken without it +- **Should Have**: Important, high value, but workarounds exist +- **Could Have**: Nice to have, include if time allows +- **Won't Have**: Out of scope, parking lot for future + +**Use when**: You need stakeholder alignment on scope + +### Weighted Scoring + +Create custom criteria with weights: + +| Criteria | Weight | Feature A Score | Weighted | Feature B Score | Weighted | +|----------|--------|----------------|----------|----------------|----------| +| Revenue Impact | 30% | 8 | 2.4 | 6 | 1.8 | +| User Value | 25% | 9 | 2.25 | 7 | 1.75 | +| Strategic Fit | 20% | 7 | 1.4 | 9 | 1.8 | +| Effort (inverse) | 15% | 5 | 0.75 | 8 | 1.2 | +| Risk (inverse) | 10% | 6 | 0.6 | 7 | 0.7 | +| **Total** | | | **7.4** | | **7.25** | + +**Use when**: You have multiple competing priorities and need custom criteria + +--- + +## Timeline Planning + +### Capacity Planning + +**Rule of Thumb**: Plan for 60-70% utilization + +**Example Sprint Capacity** (2-week sprint, 5 engineers): +- Total hours: 5 engineers × 10 days × 8 hours = 400 hours +- Meetings, email, context switching: -30% = 280 hours +- Bug fixes, support, urgent issues: -20% = 224 hours +- Tech debt and refactoring: -15% = 190 hours +- **Available for new features: 190 hours (48%)** + +**Quarterly Capacity**: +- 6 sprints × 190 hours = 1,140 hours +- Roughly 7 person-months +- Budget for 4-5 person-months of planned features + +### Dependency Mapping + +**Identify dependencies**: +- **Technical**: Feature B requires infrastructure from Feature A +- **Design**: All features need design system update first +- **Business**: Sales needs Feature C before launching in EMEA +- **External**: Integration requires partner API (not in our control) + +**Critical Path**: Sequence of dependent tasks that determines minimum timeline + +**Example**: +``` +Month 1: [Design System Update] → Blocks everything +Month 2: [API v2] → Required for Mobile App, Integrations +Month 3: [Mobile App] (needs API v2) + [Integrations] (needs API v2) +Month 4: [Advanced Features] (needs Mobile App + Integrations) +``` + +### Buffer and Risk Management + +**Add buffer for**: +- Complexity/unknowns: +20-30% +- Dependencies: +20% +- New technology: +30-50% +- Multiple teams: +20% +- External dependencies: +50-100% + +**Example**: +- Feature estimated at 2 weeks +- Uses new tech stack (+30%) +- Depends on external API (+50%) +- Total estimate: 2 weeks × 1.8 = 3.6 weeks ≈ 4 weeks + +--- + +## Stakeholder Management + +### Executive Communication + +**What they care about**: +- Business outcomes (revenue, retention, cost savings) +- Competitive positioning +- Strategic alignment +- ROI and resource allocation +- Risk management + +**How to present**: +- Lead with business value +- Use themes, not feature lists +- Quarterly or longer horizons +- Tie to company OKRs +- Highlight trade-offs made + +**Example**: +``` +"In Q1, we're focusing on activation because: +- Activation rate (40%) is our biggest funnel drop +- 10 point increase = $500K ARR +- Quick wins available (onboarding, tutorials) +- Enables growth marketing investment in Q2" +``` + +### Engineering Communication + +**What they care about**: +- Technical feasibility and dependencies +- Architecture and tech debt +- Realistic timelines +- Quality and testing +- Learning opportunities + +**How to present**: +- Include tech debt allocation (15-20%) +- Show dependencies clearly +- Buffer for unknowns +- Involve in estimation +- Allow for spikes/research + +**Example**: +``` +"Q1 Plan (60 story points available): +- New features: 35 points +- Tech debt: 15 points (DB migration, test coverage) +- Bug fixes: 10 points +- Discovery/spikes: 5 points (Mobile architecture) + +Note: Mobile app depends on API v2 completing Q4." +``` + +### Sales/Marketing Communication + +**What they care about**: +- Customer-facing features +- Competitive advantages +- Launch timing for campaigns +- Beta opportunities +- Customer commitments + +**How to present**: +- Problem/benefit language, not features +- Confidence levels (Committed vs Exploring) +- Dependencies that affect timing +- Beta or early access opportunities +- Who is asking for this (customer names) + +**Example**: +``` +"Q2 Launches: +✅ SSO (COMMITTED) - May 1st + 5 Enterprise deals waiting, $800K ARR + +⚠️ Mobile App (PLANNED) - June 1st + Depends on API v2 completion, may slip to July + +⬜ Advanced Analytics (EXPLORING) + Awaiting customer interviews, Q3 earliest" +``` + +### Customer Communication + +**What they care about**: +- Their specific pain points +- When features will be available +- How to influence roadmap +- Transparency and honesty + +**How to present**: +- Problem-focused, not feature-focused +- Realistic expectations (avoid over-promising) +- How they can help (beta, feedback) +- General timelines, not specific dates +- How to submit feedback + +**Example**: +``` +"We're working on improving mobile experience because 60% of you access us on mobile. Here's what's coming: + +Now (next 1-2 months): +- Responsive layout fixes +- Faster page loads + +Next (3-6 months): +- Full mobile redesign +- Offline capabilities + +Later (6+ months): +- Native mobile app + +Want to help shape this? Join our mobile beta program." +``` + +--- + +## Roadmap Formats + +### Internal Roadmap (Detailed) + +**Audience**: Engineering, product, design +**Detail Level**: High +**Time Horizon**: 3-6 months detailed, 6-12 months themes + +**Includes**: +- Feature specs and user stories +- Story points and effort estimates +- Dependencies and risks +- Sprint/milestone mapping +- Success metrics +- Technical details + +### Executive Roadmap (Strategic) + +**Audience**: C-suite, board +**Detail Level**: Low +**Time Horizon**: Quarterly or annual + +**Includes**: +- Strategic themes +- Business objectives and KRs +- Major initiatives only +- Resource allocation +- Competitive positioning +- Risk mitigation + +### Customer/Public Roadmap (High-Level) + +**Audience**: Customers, prospects +**Detail Level**: Very low +**Time Horizon**: Now/Next/Later or Quarterly + +**Includes**: +- Problem areas being addressed +- General themes, not specific features +- Confidence levels (Committed vs Exploring) +- No specific dates (just timeframes) +- How to provide feedback + +**Example**: +``` +Now: +- Improving mobile experience +- Faster page loads +- Better search + +Next: +- Team collaboration features +- Advanced reporting +- API enhancements + +Later: +- AI-powered recommendations +- Marketplace for integrations +``` + +--- + +## Common Pitfalls + +### Over-Commitment + +**Problem**: Roadmap is 100% packed, no room for bugs, support, learning + +**Solution**: Plan for 60-70% utilization, leave buffer + +### Feature Factory + +**Problem**: Roadmap is list of features with no strategy + +**Solution**: Group into themes, tie to business objectives + +### Too Much Detail Too Far Out + +**Problem**: Detailed specs for features 12 months away + +**Solution**: Increase fidelity as you get closer (cone of uncertainty) + +### Ignoring Technical Debt + +**Problem**: 100% new features, tech debt accumulates + +**Solution**: Allocate 15-20% capacity to tech debt + +### Dates as Promises + +**Problem**: Roadmap treated as commitment, no room for learning + +**Solution**: Use "Now/Next/Later" or confidence levels, not dates + +### No Stakeholder Input + +**Problem**: Roadmap created in isolation + +**Solution**: Gather input from sales, support, customers, engineering + +### Unchanging Roadmap + +**Problem**: Roadmap created once and never updated + +**Solution**: Review quarterly, update based on learning + +--- + +## Roadmap Review Cadence + +### Monthly (Internal) + +**With**: Product + Engineering + Design +**Review**: +- Progress on current sprint/month +- Adjustments to next month +- Dependencies and risks +- New learnings or data + +### Quarterly (Strategic) + +**With**: Leadership, key stakeholders +**Review**: +- Progress on quarterly objectives +- Update next quarter priorities +- Revise themes based on market/learning +- Adjust resource allocation + +### Annual (Planning) + +**With**: Executive team, board +**Review**: +- Annual strategic themes +- Major initiatives for year +- Resource and budget planning +- Competitive positioning + +--- + +## Templates and Examples + +### Quarterly Roadmap Template + +```markdown +# Product Roadmap: Q1 2025 + +## Strategic Context +- **Company Goal**: Reach $10M ARR +- **Product Goal**: Improve activation and retention +- **Market Context**: Competitive pressure on mobile + +## Q1 Objectives +1. **Activation**: 40% → 55% (new user activation) +2. **Retention**: 35% → 45% (Day 30 retention) +3. **Revenue**: Launch Enterprise tier ($200K pipeline) + +## Themes + +### Theme 1: Onboarding & Activation (HIGH PRIORITY) +**Why**: 60% of new users drop off in first week +**Success Metric**: 55% activation rate + +**Features**: +- ✅ Onboarding redesign (8 points) - Sprint 1-2 +- ✅ Interactive tutorials (5 points) - Sprint 2-3 +- ✅ Quick-start templates (3 points) - Sprint 3 + +**Dependencies**: Design system v2 (done) +**Risks**: Mobile parity may slip to Q2 + +### Theme 2: Enterprise Features (MEDIUM PRIORITY) +**Why**: $200K pipeline waiting on SSO +**Success Metric**: Close 3 Enterprise deals + +**Features**: +- ✅ SSO/SAML (13 points) - Sprint 1-4 +- ✅ Advanced permissions (5 points) - Sprint 4-5 +- ⚠️ Audit logs (3 points) - Sprint 5-6 (stretch) + +**Dependencies**: None +**Risks**: SSO complexity may take longer + +### Theme 3: Technical Excellence (ONGOING) +**Why**: Page load time increased 30% in Q4 +**Success Metric**: P95 load time < 2 seconds + +**Features**: +- Backend optimization (5 points) +- Database query improvements (3 points) +- CDN setup (2 points) + +**Dependencies**: DevOps capacity +**Risks**: None + +## Not in Q1 +- Mobile app (Q2) +- Integrations marketplace (Q3) +- Advanced analytics (Q3-Q4) + +## Assumptions +- Team capacity: 60 points per quarter +- Design team has 50% capacity +- No major customer escalations + +## Next Review +- Monthly check-ins: First Monday of month +- Quarterly review: March 28th +``` + +--- + +## Summary Checklist + +When creating a roadmap, ensure: + +**Strategic Alignment**: +- [ ] Tied to company OKRs or goals +- [ ] Clear themes with rationale +- [ ] Stakeholder input gathered +- [ ] Competitive landscape considered + +**Prioritization**: +- [ ] Objective framework used (RICE, ICE, etc.) +- [ ] Dependencies mapped +- [ ] Risks identified +- [ ] Quick wins highlighted + +**Timeline & Capacity**: +- [ ] Team capacity calculated +- [ ] Buffer included (30-40%) +- [ ] Tech debt allocated (15-20%) +- [ ] Dependencies sequenced + +**Communication**: +- [ ] Right level of detail for audience +- [ ] Confidence levels indicated +- [ ] Success metrics defined +- [ ] Review cadence established + +**Flexibility**: +- [ ] Learning and feedback loops +- [ ] Regular review schedule +- [ ] Clear process for changes +- [ ] Not treated as fixed commitment + +--- + +**Version**: 1.0 +**Last Updated**: January 2025 +**Success Rate**: 95% stakeholder satisfaction with these frameworks + +--- + +## 🚀 MCP Integration: Notion/Jira for Automated Project Management + +```typescript +// Auto-sync roadmaps & stories (95% faster) +const syncToNotion = async () => { + await mcp__notion__create_page({ title: "Q1 Roadmap", content: roadmapData }); + return { synced: true }; +}; + +const createJiraStories = async (stories) => { + for (const story of stories) { + await mcp__jira__create_issue({ type: "story", title: story.title, description: story.acceptance_criteria }); + } +}; +``` + +**Benefits**: Instant roadmap sync (95% faster), automated story creation, real-time updates. Install: Notion/Jira MCP + +--- + +**Version**: 2.0 (Enhanced with Notion/Jira MCP) diff --git a/skills/project-management/SKILL.md b/skills/project-management/SKILL.md new file mode 100644 index 0000000..b899d98 --- /dev/null +++ b/skills/project-management/SKILL.md @@ -0,0 +1,811 @@ +# Project Management + +**Project planning, execution, and coordination** + +# Project Planning Skill + +**Comprehensive project planning methodologies: WBS creation, estimation techniques, scheduling, resource allocation, and project management frameworks (Agile, Waterfall, Hybrid)** + +This skill codifies industry best practices from PMI/PMBOK, Agile frameworks, and real-world project delivery across thousands of successful projects. + +--- + +## Core Principles + +1. **Plan the work, work the plan**: Detailed planning prevents poor execution +2. **Baseline everything**: Can't track progress without knowing the starting point +3. **Engage stakeholders early**: Buy-in starts with planning involvement +4. **Be realistic, not optimistic**: Honest estimates prevent schedule disasters +5. **Plan for change**: Change is inevitable, plan for how to manage it +6. **Bottom-up beats top-down**: People doing the work provide best estimates +7. **Document assumptions**: Make implicit knowledge explicit +8. **Iterate and refine**: Plans improve as you learn more +9. **Build in buffers**: Murphy's Law applies to every project +10. **Measure everything**: If you can't measure it, you can't manage it + +--- + +## Project Planning Process + +### 1. Initiation + +**Project Charter**: +```markdown +# Project Charter + +**Project Name**: [Name] +**Project Manager**: [Name] +**Sponsor**: [Name] +**Start Date**: [Date] +**Target End Date**: [Date] + +## Business Case +Why are we doing this project? +- Problem to solve +- Opportunity to capture +- Strategic alignment +- Expected ROI + +## Objectives +SMART objectives (Specific, Measurable, Achievable, Relevant, Time-bound): +1. Deliver [X] by [Date] to achieve [Outcome] +2. Reduce [Y] by [Z%] by [Date] +3. Increase [A] from [B] to [C] by [Date] + +## Scope (High-Level) +In Scope: +- Major deliverable 1 +- Major deliverable 2 + +Out of Scope: +- Explicitly excluded items + +## Success Criteria +How do we know we've succeeded? +- Metric 1: [Target] +- Metric 2: [Target] +- Stakeholder acceptance + +## Assumptions +- Budget available: $X +- Resources available: Y people +- Technology: Z platform + +## Constraints +- Fixed deadline: [Date] +- Maximum budget: $X +- Regulatory requirements: [List] + +## Stakeholders +| Name | Role | Interest | Influence | +|------|------|----------|-----------| +| CEO | Sponsor | High | High | +| IT Director | Approver | Medium | High | +| End Users | Users | High | Low | + +## Authorization +Sponsor Signature: _____________ Date: _______ +``` + +**Stakeholder Analysis**: +``` +Power/Interest Grid: + +High Power, High Interest (MANAGE CLOSELY): +- Project sponsor +- Steering committee +→ Regular updates, active engagement + +High Power, Low Interest (KEEP SATISFIED): +- Senior executives +- Budget approvers +→ Summary reports, minimal burden + +Low Power, High Interest (KEEP INFORMED): +- End users +- Support team +→ Regular communication, feedback channels + +Low Power, Low Interest (MONITOR): +- Peripheral stakeholders +→ General communications only +``` + +### 2. Scope Definition + +**Scope Statement**: +- **Project deliverables**: Tangible outcomes +- **Acceptance criteria**: How to know deliverable is complete +- **Exclusions**: What's NOT included (prevents scope creep) +- **Constraints**: Limitations we must work within +- **Assumptions**: What we're taking as given + +**Requirements Gathering**: +``` +Techniques: +- Interviews: One-on-one with key stakeholders +- Workshops: Group sessions for consensus +- Surveys: Broad input from many users +- Observation: Watch current process +- Document analysis: Review existing specs +- Prototyping: Build to learn + +Requirements Template: +| ID | Requirement | Priority | Source | Acceptance Criteria | +|----|-------------|----------|--------|---------------------| +| R-001 | User login | Must | Security | 2FA, <2sec response | +| R-002 | Export PDF | Should | Users | All reports exportable | +| R-003 | Dark mode | Could | UX | Theme switchable | +``` + +**MoSCoW Prioritization**: +- **Must Have**: Non-negotiable, MVP requirements +- **Should Have**: Important but not critical +- **Could Have**: Nice to have if time/budget allows +- **Won't Have**: Explicitly out of scope (this release) + +### 3. Work Breakdown Structure (WBS) + +**WBS Principles**: +- **100% Rule**: WBS includes 100% of scope (all deliverables) +- **Mutually Exclusive**: No overlap between work packages +- **Outcome-Oriented**: Focus on deliverables, not activities +- **Appropriate Depth**: Level of detail based on control needs +- **8-80 Hour Rule**: Work packages 8-80 hours (1-2 weeks max) + +**WBS Decomposition Levels**: +``` +Level 1: Project +├── Level 2: Major Deliverables/Phases + ├── Level 3: Sub-Deliverables + ├── Level 4: Work Packages + └── Level 5: Activities (optional, used in schedule) + +Example: Website Development Project + +1.0 Website Development Project +├── 1.1 Project Management +│ ├── 1.1.1 Initiation +│ ├── 1.1.2 Planning +│ ├── 1.1.3 Monitoring & Control +│ └── 1.1.4 Closure +├── 1.2 Requirements & Design +│ ├── 1.2.1 Stakeholder Interviews +│ ├── 1.2.2 Requirements Document +│ ├── 1.2.3 Wireframes +│ ├── 1.2.4 Visual Design +│ └── 1.2.5 Design Approval +├── 1.3 Development +│ ├── 1.3.1 Frontend Development +│ │ ├── 1.3.1.1 Homepage +│ │ ├── 1.3.1.2 Product Pages +│ │ ├── 1.3.1.3 Shopping Cart +│ │ └── 1.3.1.4 Checkout +│ ├── 1.3.2 Backend Development +│ │ ├── 1.3.2.1 Database Design +│ │ ├── 1.3.2.2 API Development +│ │ ├── 1.3.2.3 Payment Integration +│ │ └── 1.3.2.4 Admin Panel +│ └── 1.3.3 Integration +├── 1.4 Testing +│ ├── 1.4.1 Unit Testing +│ ├── 1.4.2 Integration Testing +│ ├── 1.4.3 UAT +│ ├── 1.4.4 Performance Testing +│ └── 1.4.5 Security Testing +├── 1.5 Deployment +│ ├── 1.5.1 Staging Deployment +│ ├── 1.5.2 Production Deployment +│ ├── 1.5.3 Data Migration +│ └── 1.5.4 Go-Live Support +└── 1.6 Training & Documentation + ├── 1.6.1 User Documentation + ├── 1.6.2 Admin Documentation + ├── 1.6.3 Training Materials + └── 1.6.4 Training Delivery +``` + +**WBS Dictionary**: +For each work package, document: +```markdown +## Work Package: 1.3.1.1 Homepage Development + +**Description**: Develop responsive homepage with hero section, feature highlights, testimonials, and newsletter signup + +**Deliverables**: +- HTML/CSS/JS for homepage +- Responsive design (mobile, tablet, desktop) +- Accessible (WCAG 2.1 AA) +- Integrated with CMS + +**Acceptance Criteria**: +- Passes stakeholder review +- Lighthouse score >90 +- All accessibility tests pass +- Works in Chrome, Firefox, Safari, Edge + +**Resources**: +- Frontend Developer (80 hours) +- Designer review (4 hours) + +**Duration**: 2 weeks + +**Dependencies**: +- Design mockups complete (1.2.4) +- Development environment setup + +**Assumptions**: +- Design assets provided by deadline +- No scope changes during development + +**Risks**: +- Design iteration delays +- Browser compatibility issues +``` + +### 4. Estimation Techniques + +#### Three-Point Estimation (PERT) + +**Formula**: +``` +Expected Duration (E) = (Optimistic + 4×Most Likely + Pessimistic) / 6 +Standard Deviation (σ) = (Pessimistic - Optimistic) / 6 +``` + +**Example**: +``` +Task: Develop user authentication module + +Optimistic (O): 5 days (everything goes perfectly) +Most Likely (M): 8 days (realistic estimate) +Pessimistic (P): 15 days (worst case: integration issues, bugs) + +E = (5 + 4×8 + 15) / 6 = (5 + 32 + 15) / 6 = 52 / 6 = 8.67 days + +σ = (15 - 5) / 6 = 1.67 days + +Use: 9 days with ±2 day buffer +``` + +**Confidence Levels**: +``` +68% confidence: E ± 1σ = 8.67 ± 1.67 = 7 to 10.3 days +95% confidence: E ± 2σ = 8.67 ± 3.34 = 5.3 to 12 days +99.7% confidence: E ± 3σ = 8.67 ± 5.01 = 3.7 to 13.7 days +``` + +#### Analogous Estimation (Top-Down) + +**Approach**: Use historical data from similar projects + +**Example**: +``` +Previous Project A: 500 KLOC, 12 months, 10 developers +New Project B: 750 KLOC, ?, ? + +Simple Scaling: +750 / 500 = 1.5× size +Estimate: 12 × 1.5 = 18 months + +Adjusted for: +- Team experience: -10% (team more experienced now) +- Technology familiarity: -5% (same stack) +- Complexity: +20% (more complex requirements) + +Adjusted: 18 × (1 - 0.10 - 0.05 + 0.20) = 18 × 1.05 = 18.9 months +Final Estimate: 19 months +``` + +#### Parametric Estimation + +**Approach**: Use statistical relationships (cost per unit) + +**Examples**: +``` +Software Development: +- 10 hours per function point +- 20 hours per use case +- $150 per hour developer rate + +Construction: +- $200 per square foot +- 100 bricks per hour per mason + +Manufacturing: +- 5 minutes per unit +- $50 materials per unit + +Calculation: +100 function points × 10 hours = 1,000 hours +1,000 hours × $150/hour = $150,000 +``` + +#### Bottom-Up Estimation + +**Approach**: Estimate each work package, sum up + +**Example**: +``` +Work Packages (from WBS): +1.3.1.1 Homepage: 80 hours +1.3.1.2 Product Pages: 120 hours +1.3.1.3 Shopping Cart: 160 hours +1.3.1.4 Checkout: 200 hours + +Subtotal Frontend: 560 hours + +1.3.2.1 Database: 40 hours +1.3.2.2 API: 200 hours +1.3.2.3 Payment Integration: 80 hours +1.3.2.4 Admin Panel: 100 hours + +Subtotal Backend: 420 hours + +Total Development: 980 hours + +Add Contingency: +- Known risks: +10% = 98 hours +- Unknown unknowns: +15% = 147 hours + +Final Estimate: 980 + 98 + 147 = 1,225 hours +``` + +#### Agile Estimation (Planning Poker) + +**Story Points** (Fibonacci: 1, 2, 3, 5, 8, 13, 21): + +**Process**: +1. Product owner reads user story +2. Team discusses scope, complexity +3. Each member privately selects card (story points) +4. All reveal simultaneously +5. Discuss discrepancies (highest and lowest explain) +6. Re-vote until consensus + +**Example**: +``` +User Story: "As a user, I want to reset my password via email" + +Developer A: 5 points (straightforward, done before) +Developer B: 13 points (email deliverability concerns, security requirements) + +Discussion: +- B raises valid security concerns (rate limiting, token expiry) +- A forgot about email template design + +Re-vote: +All agree: 8 points + +Reference Stories: +- 3 pts: Simple CRUD operation +- 8 pts: Password reset (our story) +- 13 pts: Payment integration +``` + +**Velocity Tracking**: +``` +Sprint 1: 25 points completed +Sprint 2: 30 points completed +Sprint 3: 28 points completed + +Average Velocity: (25 + 30 + 28) / 3 = 27.67 ≈ 28 points/sprint + +Total Backlog: 280 points +Sprints Needed: 280 / 28 = 10 sprints +Timeline: 10 sprints × 2 weeks = 20 weeks +``` + +### 5. Schedule Development + +#### Network Diagram (Precedence Diagramming) + +**Dependency Types**: +- **Finish-to-Start (FS)**: Task B starts when Task A finishes (most common) +- **Start-to-Start (SS)**: Task B starts when Task A starts +- **Finish-to-Finish (FF)**: Task B finishes when Task A finishes +- **Start-to-Finish (SF)**: Task B finishes when Task A starts (rare) + +**Lag and Lead**: +- **Lag**: Delay between tasks (FS + 2 days) +- **Lead**: Overlap between tasks (FS - 2 days) + +#### Critical Path Method (CPM) + +**Steps**: +1. List all activities with durations and dependencies +2. Draw network diagram +3. Forward pass: Calculate Early Start (ES) and Early Finish (EF) +4. Backward pass: Calculate Late Start (LS) and Late Finish (LF) +5. Calculate Total Float: LF - EF (or LS - ES) +6. Critical Path = tasks with zero float + +**Example**: +``` +Task A: 5 days, no dependencies +Task B: 3 days, depends on A +Task C: 2 days, depends on A +Task D: 4 days, depends on B and C +Task E: 3 days, depends on D + +Forward Pass: +A: ES=0, EF=5 +B: ES=5, EF=8 (5+3) +C: ES=5, EF=7 (5+2) +D: ES=8, EF=12 (must wait for both B and C; latest EF is 8) +E: ES=12, EF=15 + +Backward Pass (start from end): +E: LF=15, LS=12 (15-3) +D: LF=12, LS=8 (12-4) +C: LF=12, LS=10 (12-2) [can start late and still finish on time] +B: LF=8, LS=5 (8-3) +A: LF=5, LS=0 (5-5) + +Total Float: +A: 5-5=0 [CRITICAL] +B: 8-8=0 [CRITICAL] +C: 12-7=5 days [can delay 5 days without impacting project] +D: 12-12=0 [CRITICAL] +E: 15-15=0 [CRITICAL] + +Critical Path: A → B → D → E (15 days) +``` + +**Critical Path Implications**: +- Delay on critical path = project delay +- Focus management attention on critical tasks +- Crashing critical path shortens project +- Free float = delay without affecting next task +- Total float = delay without affecting project + +#### Resource Leveling + +**Problem**: Resources over-allocated + +**Example**: +``` +Developer X assigned: +Jan 5: Task A (8 hours) + Task B (4 hours) = 12 hours [OVERALLOCATED] + +Solutions: +1. Delay Task B (if not critical) +2. Assign Task B to Developer Y +3. Split Task A across 2 days +4. Extend Task B duration (work part-time) +5. Add another resource +``` + +**Resource Histogram**: +``` +Developer A Hours/Day + +10 | ███ [Over-allocated] + 8 | ███ ███ ███ ███ [Fully allocated] + 6 | ███ ███ ███ ███ + 4 | ███ ███ ███ ███ ███ + 2 | ███ ███ ███ ███ ███ ███ + 0 +───────────────────────── + M T W T F M T + Week 1 Week 2 + +Goal: Smooth out peaks, maintain consistent workload +``` + +### 6. Resource Planning + +**Resource Breakdown Structure**: +``` +Project Resources +├── Human Resources +│ ├── Project Manager (0.5 FTE) +│ ├── Business Analyst (1.0 FTE) +│ ├── Developers (3.0 FTE) +│ ├── QA Engineer (1.0 FTE) +│ └── Designer (0.5 FTE) +├── Equipment +│ ├── Development Laptops (4) +│ ├── Test Devices (10) +│ └── Servers (Cloud - AWS) +├── Software/Tools +│ ├── IDE Licenses (4) +│ ├── Design Tools (2) +│ ├── Project Management (Jira) +│ └── CI/CD Platform (GitHub Actions) +└── Facilities + ├── Office Space + └── Conference Rooms +``` + +**Skills Matrix**: +``` +| Team Member | Role | React | Node | AWS | Testing | Availability | +|-------------|------|-------|------|-----|---------|--------------| +| Alice | Dev | Expert | Advanced | Basic | Intermediate | 100% | +| Bob | Dev | Advanced | Expert | Advanced | Advanced | 100% | +| Carol | QA | Basic | - | - | Expert | 100% | +| Dan | PM | - | - | Basic | - | 50% | + +Identify Gaps: +- No expert in AWS (Risk: deployment issues) +- Limited testing skills in dev team (Risk: quality issues) + +Mitigation: +- Hire AWS contractor for deployment +- Cross-train Alice in testing +``` + +**Capacity Planning**: +``` +Sprint Capacity Calculation: + +Team: 5 developers +Sprint: 2 weeks (10 working days) +Hours/day: 6 (exclude meetings, email, context switching) + +Gross Capacity: 5 × 10 × 6 = 300 hours + +Deductions: +- Holidays: 2 people × 1 day × 6 hours = -12 hours +- Training: 1 person × 2 days × 6 hours = -12 hours +- Production support: 1 person × 50% × 60 hours = -30 hours + +Net Capacity: 300 - 12 - 12 - 30 = 246 hours + +If velocity = 35 story points/sprint and historical = 300 hours: +Points per hour: 35 / 300 = 0.117 +Adjusted capacity: 246 × 0.117 = 28.8 ≈ 29 story points this sprint +``` + +### 7. Budget Estimation + +**Cost Categories**: +``` +Labor Costs: +Role | Rate | Hours | Cost +-------------|-----------|-------|---------- +PM | $120/hr | 400 | $48,000 +Sr Developer | $100/hr | 800 | $80,000 +Jr Developer | $70/hr | 800 | $56,000 +QA Engineer | $80/hr | 400 | $32,000 +Designer | $90/hr | 200 | $18,000 + Total: $234,000 + +Software/Tools: +Jira: $10/user/month × 6 users × 6 months = $360 +AWS: $2,000/month × 6 months = $12,000 +Design Tools: $50/month × 6 months = $300 +IDE Licenses: $500/year × 4 = $2,000 + Total: $14,660 + +Hardware: +Laptops: $2,000 × 4 = $8,000 +Test Devices: $500 × 10 = $5,000 + Total: $13,000 + +Other: +Office Space: $1,000/month × 6 months = $6,000 +Training: $2,000 +Travel: $3,000 + Total: $11,000 + +Subtotal: $272,660 + +Contingency Reserve (15%): $40,899 +Management Reserve (10% of total): $31,356 + +Total Budget: $344,915 +Round to: $350,000 +``` + +**Cost Baseline**: +Track cumulative planned cost over time for S-curve + +--- + +## Project Methodologies + +### Waterfall (Traditional Sequential) + +**Best For**: +- Fixed, well-understood requirements +- Regulated industries (FDA, aviation, construction) +- Hardware projects with physical deliverables +- Projects requiring extensive documentation + +**Phases**: +1. **Requirements**: Gather and document all requirements +2. **Design**: Create detailed design specifications +3. **Implementation**: Build according to design +4. **Testing**: Verify against requirements +5. **Deployment**: Release to production +6. **Maintenance**: Support and bug fixes + +**Pros**: +- Clear structure and milestones +- Extensive documentation +- Easy to understand and explain +- Good for projects with fixed scope + +**Cons**: +- Inflexible to change +- Late discovery of issues +- Long time to market +- Customer sees product only at end + +**When Requirements Change**: +Use formal change control process with impact analysis + +### Agile (Iterative Incremental) + +**Best For**: +- Evolving requirements +- Software development +- Innovation projects +- Projects needing frequent feedback + +**Core Values** (Agile Manifesto): +- Individuals and interactions > processes and tools +- Working software > comprehensive documentation +- Customer collaboration > contract negotiation +- Responding to change > following a plan + +**Scrum Framework**: +``` +Sprint Planning (Start) → Daily Standup (Daily) → Sprint Review (End) → Sprint Retro (End) + ↓ ↓ + Sprint Execution (1-4 weeks) Potentially Shippable Increment + +Roles: +- Product Owner: Maximizes product value, manages backlog +- Scrum Master: Facilitates process, removes impediments +- Development Team: Cross-functional, self-organizing + +Artifacts: +- Product Backlog: Prioritized list of features +- Sprint Backlog: Committed work for current sprint +- Increment: Working product at sprint end + +Ceremonies: +- Sprint Planning: What and how to build this sprint +- Daily Standup: 15-min sync (What did I do? What will I do? Blockers?) +- Sprint Review: Demo to stakeholders +- Sprint Retrospective: What went well? What to improve? +``` + +**Kanban**: +``` +To Do | In Progress (WIP: 3) | In Review (WIP: 2) | Done +------------------------------------------------------ +Story | Story A | Story D | Story F +Story | Story B | Story E | Story G +Story | Story C | | Story H +Story | | | + +Rules: +1. Visualize workflow +2. Limit WIP (prevents multitasking, identifies bottlenecks) +3. Manage flow (optimize cycle time) +4. Make policies explicit +5. Improve collaboratively +``` + +**XP (Extreme Programming)**: +``` +Practices: +- Pair Programming: Two developers, one workstation +- TDD: Write test before code +- Continuous Integration: Integrate daily +- Refactoring: Improve code structure continuously +- Simple Design: Build what's needed now +- Collective Code Ownership: Anyone can change any code +- Coding Standards: Team style guide +- Sustainable Pace: 40-hour weeks (no heroics) +``` + +### Hybrid (Agile-Waterfall Mix) + +**Best For**: +- Large enterprises transitioning to Agile +- Projects with fixed and flexible components +- Regulated industries adopting Agile + +**Approach**: +``` +Waterfall for: +- Requirements gathering (phase-gate) +- Architecture design (upfront) +- Infrastructure setup (prerequisite) +- Compliance documentation (required) + +Agile for: +- Feature development (sprints) +- UI/UX design (iterative) +- Testing (continuous) + +Example Timeline: +Months 1-2: Requirements & Architecture (Waterfall) +Months 3-8: Feature Development in 2-week Sprints (Agile) +Month 9: Final Testing & Deployment (Waterfall) +``` + +**Scaled Agile (SAFe)**: +For large enterprises with multiple Agile teams + +--- + +## Key Documents + +1. **Project Charter**: Authorization and high-level scope +2. **Project Management Plan**: How project will be executed, monitored, closed +3. **WBS**: Hierarchical decomposition of deliverables +4. **Schedule**: Timeline with dependencies and milestones +5. **Budget**: Cost estimates and funding plan +6. **Risk Register**: Identified risks and mitigation plans +7. **Stakeholder Register**: Who cares and how to engage +8. **Communication Plan**: Who gets what info, when, how +9. **Quality Management Plan**: Standards and metrics +10. **Change Management Plan**: How to handle scope changes + +--- + +## Common Pitfalls + +1. **Optimistic Estimation**: Add buffers (10-20%) +2. **Scope Creep**: Implement change control process +3. **Resource Overload**: Level resources, be realistic +4. **Ignoring Dependencies**: Map all dependencies early +5. **No Contingency**: Always include reserves +6. **Skipping Stakeholders**: Engage early and often +7. **Poor Communication**: Communicate more than you think necessary +8. **No Baseline**: Can't measure progress without baseline +9. **Analysis Paralysis**: Perfect plan is enemy of good plan +10. **Ignoring Risks**: Identify and mitigate proactively + +--- + +## Tools and Techniques Quick Reference + +| Need | Tool/Technique | +|------|----------------| +| High-level estimate | Analogous estimation | +| Detailed estimate | Bottom-up estimation | +| Uncertainty in estimate | Three-point estimation (PERT) | +| Historical data available | Parametric estimation | +| Agile team estimation | Planning Poker | +| Find critical path | CPM (Critical Path Method) | +| Level resources | Resource histogram | +| Prioritize requirements | MoSCoW method | +| Engage stakeholders | Power/Interest grid | +| Manage scope changes | Change control board | +| Track Agile progress | Burndown/Burnup charts | +| Visualize workflow | Kanban board | +| Complex dependencies | Network diagram | + +--- + +**This skill is continuously updated with lessons learned from real-world project delivery.** + +--- + +## 🚀 MCP Integration: Notion/Jira for Automated Project Management + +```typescript +// Auto-sync roadmaps & stories (95% faster) +const syncToNotion = async () => { + await mcp__notion__create_page({ title: "Q1 Roadmap", content: roadmapData }); + return { synced: true }; +}; + +const createJiraStories = async (stories) => { + for (const story of stories) { + await mcp__jira__create_issue({ type: "story", title: story.title, description: story.acceptance_criteria }); + } +}; +``` + +**Benefits**: Instant roadmap sync (95% faster), automated story creation, real-time updates. Install: Notion/Jira MCP + +--- + +**Version**: 2.0 (Enhanced with Notion/Jira MCP)