Principles of Product Management: PM Craft Skills Development (Hard and Soft Skill Matrix, Personal Learning Plan)

PM Craft Skills Development (Hard and Soft Skill Matrix, Personal Learning Plan)

PM Craft Skills Development (Hard & Soft Skill Matrix, Personal Learning Plan)

What This Is

Craft skills are the core competencies—both hard (technical, analytical) and soft (leadership, communication)—that separate good PMs from great ones. These skills determine how effectively you discover problems, prioritize solutions, align teams, and drive outcomes. Without deliberate development, even the best product ideas fail due to poor execution, misaligned stakeholders, or weak data fluency.

Real-world example:
At Stripe, a PM leading the Radar fraud detection tool needed to balance hard skills (e.g., analyzing transaction data to identify fraud patterns) with soft skills (e.g., persuading skeptical engineers to prioritize false-positive reductions over new features). The PM’s ability to translate data into narratives and negotiate trade-offs directly impacted Radar’s adoption by merchants.

Key Terms & Frameworks

Hard Skills

• ICE Score: Impact × Confidence × Ease – A lightweight prioritization framework for early-stage ideas.
• Impact: How much this improves a key metric (1-10).
• Confidence: How sure you are about the impact (1-100%).

• Ease: How easy it is to implement (1-10, where 10 = easiest).

• North Star Metric (NSM): The single metric that best captures the core value your product delivers (e.g., Airbnb’s "Nights Booked", Facebook’s "Daily Active Users"). Used to align teams and measure long-term success.

• A/B Test Power Calculation:
  Sample Size = (Z² × p × (1-p)) / (Δ²)

• Z: Z-score (e.g., 1.96 for 95% confidence).
• p: Baseline conversion rate.

• Δ: Minimum detectable effect (e.g., 2% lift).

• SQL for PMs (Basic Queries):

• SELECT COUNT(DISTINCT user_id) FROM events WHERE event_name = 'checkout_start'

• SELECT user_id, COUNT(*) FROM orders GROUP BY user_id HAVING COUNT(*) > 5 (identify power users).

• Technical Fluency (Non-Engineer PMs):

• APIs: How data flows between systems (e.g., REST vs. GraphQL).
• Latency vs. Throughput: Latency = time for 1 request; throughput = requests/second.
• Tech Debt: Shortcuts that slow future development (e.g., hardcoded values, lack of tests).

Soft Skills

• Stakeholder Mapping (RACI):
• Responsible: Does the work.
• Accountable: Owns the outcome.
• Consulted: Provides input.
• Informed: Kept in the loop.

• Example: For a checkout redesign, the PM is Accountable, engineers are Responsible, and customer support is Consulted.

• Influence Without Authority (Cialdini’s 6 Principles):

• Reciprocity: Give before you ask (e.g., share data insights with engineers).
• Social Proof: Show others are doing it (e.g., "Slack’s team did this and saw a 15% lift").
• Authority: Leverage experts (e.g., "Our data scientist validated this hypothesis").
• Consistency: Align with existing commitments (e.g., "This fits our Q3 goal of reducing churn").
• Liking: Build rapport (e.g., 1:1s with engineers before asking for favors).

• Scarcity: Highlight urgency (e.g., "If we don’t ship by EOQ, we’ll miss our OKRs").

• Storytelling for PMs (SCQA Framework):

• Situation: Current state (e.g., "Our onboarding drop-off is 40%").
• Complication: Problem (e.g., "Users don’t understand our value prop").
• Question: Key question (e.g., "How might we simplify onboarding?").

• Answer: Solution (e.g., "Add a 3-step interactive tutorial").

• Negotiation (BATNA):

• Best Alternative To a Negotiated Agreement: Your fallback if talks fail (e.g., "If we can’t get engineering resources, we’ll run a lightweight experiment with a no-code tool").

Step-by-Step: Building Your PM Craft Skills

1. Audit Your Current Skills (Hard & Soft)

• Hard Skills:
• Take a SQL quiz (e.g., StrataScratch) or A/B test simulation (e.g., Evan’s Awesome A/B Tools).
• Rate yourself (1-5) on: Data analysis, technical fluency, prioritization frameworks.
• Soft Skills:
• Ask 3 peers for feedback on: Communication, stakeholder management, conflict resolution.
• Use the Johari Window to identify blind spots.

2. Create a Personal Learning Plan (90-Day Sprints)

• Template:
  | Skill | Current Level | Target Level | Action Items | Success Metric | |---------------------|-------------------|------------------|-------------------------------------------|----------------------------------------| | SQL | 2/5 | 4/5 | Complete 10 StrataScratch problems/week | Can write 3 complex queries in 30 mins | | Stakeholder Mapping | 3/5 | 5/5 | Run a RACI workshop for next project | Stakeholders rate alignment 4+/5 |

• Prioritize using ICE:

• Impact: Will this skill directly improve my product outcomes?
• Confidence: Do I have evidence this is a gap (e.g., feedback, failed projects)?
• Ease: Can I learn this without blocking my day job?

3. Learn by Doing (Apply Immediately)

• Hard Skills:
• Data: Pull a dataset (e.g., user signups) and calculate retention cohorts in Excel/Google Sheets.
• Technical: Shadow an engineer for 1 hour to understand their workflow (e.g., how they debug an API).
• Prioritization: Use RICE to rank your backlog and present to your team.
• Soft Skills:
• Storytelling: Rewrite a feature spec using SCQA and present it to your manager.
• Negotiation: Practice BATNA in your next resource request (e.g., "If we can’t get 2 engineers, we’ll use a no-code tool for a prototype").
• Influence: Use Cialdini’s principles to get buy-in for a controversial idea (e.g., "Our top competitor just launched this—here’s their data").

4. Measure Progress & Iterate

• Hard Skills:
• Track time to complete tasks (e.g., "I used to take 2 hours to analyze retention; now it takes 30 mins").
• Get peer validation (e.g., "Does my SQL query make sense?").
• Soft Skills:
• 360° feedback: Ask stakeholders, "On a scale of 1-5, how clear was my last product review?"
• Self-reflection: After every meeting, ask, "Did I listen more than I talked? Did I influence without authority?"

5. Build a "Craft Portfolio" (For Interviews & Promotions)

• Hard Skills:
• GitHub: Share a Jupyter notebook with exploratory data analysis (e.g., "How user behavior predicts churn").
• Prioritization: Document a RICE/ICE analysis for a real feature (redact sensitive data).
• Soft Skills:
• Case Study: Write a 1-pager on how you aligned stakeholders for a project (use SCQA).
• Feedback: Include peer testimonials (e.g., "PM X’s storytelling helped us secure executive buy-in").

Common Mistakes

PM Interview / Practical Insights

1. "How do you prioritize which skills to develop?"

• Trap: Saying, "I focus on my weaknesses." (Too vague.)
• Better Answer:

  "I use ICE to prioritize skills. For example, if my team struggles with data-driven decisions, I’ll focus on SQL and A/B testing (high impact). If I’m weak at stakeholder alignment, I’ll practice RACI and storytelling (high confidence in improvement). I also ask my manager, ‘What’s the one skill that would make me 10x more effective in my role?’"

  
  

2. "Tell me about a time you influenced without authority."

• Trap: Describing a time you ordered people around (e.g., "I told the engineers to do it").
• Better Answer:

  "I used Cialdini’s principles to get buy-in for a checkout redesign. First, I shared data (Authority) showing a 30% drop-off. Then, I highlighted how Shopify’s checkout (Social Proof) had a similar flow. Finally, I framed it as consistent with our OKRs (Consistency). The engineers agreed to prototype it in a sprint."

  
  

3. "How do you balance hard and soft skills?"

• Trap: Saying, "I focus on both equally." (Unrealistic.)
• Better Answer:

  "I time-box skill development. For example, I spend 2 hours/week on hard skills (e.g., SQL practice) and 1 hour/week on soft skills (e.g., storytelling exercises). I also combine them—e.g., using data (hard skill) to persuade stakeholders (soft skill)."

  
  

4. "What’s your approach to learning technical concepts as a non-engineer PM?"

• Trap: Saying, "I ask engineers to explain everything." (Over-reliant.)
• Better Answer:

  "I learn just enough to be dangerous. For example, to understand APIs, I: 1. Read high-level docs (e.g., Stripe’s API guide).
  2. Shadow an engineer for 30 mins to see how they debug.
  3. Build a simple prototype (e.g., a Zapier automation).
  4. Ask targeted questions (e.g., ‘What’s the difference between REST and GraphQL?’)."

  
  

Quick Check Questions

1. Your team wants to add a feature that increases engagement (DAU +10%) but hurts NPS (-5%). How do you decide?

• Answer: Weigh trade-offs using your North Star Metric (NSM).
• If DAU is your NSM, the feature may be worth it (but monitor long-term retention).
• If NPS is critical (e.g., for a subscription product), the feature is likely a bad idea.
• Next step: Run an A/B test to measure the long-term impact on retention.

2. You’re a PM at a fintech startup. Your CEO wants to launch a "social trading" feature (like Robinhood’s). Your engineers say it’ll take 6 months. How do you respond?

• Answer: Propose an MVP using the "Minimum Lovable Product" (MLP) framework.
• MVP: Basic social feed (e.g., "Trending stocks") with manual curation (no algorithm).
• MLP: Add one "wow" feature (e.g., "Follow top traders") to drive adoption.
• Negotiate scope: Use ICE to prioritize the smallest viable version (e.g., "Can we ship the feed in 2 months and add the algorithm later?").

3. Your data scientist says, "This A/B test result is statistically significant." How do you verify?

• Answer: Check the following:
• Sample size: Did it meet the power calculation?
• Effect size: Is the lift practically significant (e.g., 0.5% lift may not matter)?
• Confidence interval: Does it exclude zero?
• Secondary metrics: Did it hurt other KPIs (e.g., revenue, retention)?

Last-Minute Cram Sheet

1. Hard Skills > Soft Skills? ❌ No—both are critical. Hard skills = insights; soft skills = execution.
2. ICE Score: Impact × Confidence × Ease. Confidence is your certainty (1-100%), not stakeholder buy-in. ⚠️
3. North Star Metric (NSM): The one metric that aligns your team (e.g., "Nights Booked" for Airbnb).
4. RACI: Responsible, Accountable, Consulted, Informed. PMs are usually Accountable.
5. Cialdini’s 6 Principles: Reciprocity, Social Proof, Authority, Consistency, Liking, Scarcity.
6. SCQA Storytelling: Situation, Complication, Question, Answer. Use for specs and stakeholder updates.
7. BATNA: Your backup plan in negotiations (e.g., "If we can’t get engineers, we’ll use a no-code tool").
8. A/B Test Power Calculation: Sample Size = (Z² × p × (1-p)) / (Δ²). Always calculate before running tests.
9. Technical Fluency for PMs: Know APIs, latency vs. throughput, and tech debt—but don’t code.
10. Learning Plan Template: Skill → Current Level → Target Level → Action Items → Success Metric. Update every 90 days.