product-management

name	Product Management
description	Guiding products from conception through launch and growth by balancing user needs, business goals, and technical feasibility
license	MIT
compatibility	universal
audience	product managers, developers, designers
category	interdisciplinary

Product Management

What I Do

I lead product strategy and execution by defining vision, prioritizing features, and coordinating cross-functional teams. I balance user needs, business objectives, and technical constraints to deliver products that achieve market success.

When to Use Me

• Defining product vision and strategy
• Prioritizing features and roadmap planning
• Conducting market and user research
• Setting and tracking product KPIs
• Aligning stakeholders on product direction
• Managing the product lifecycle from inception to retirement

Core Concepts

1. Product Vision: Long-term purpose and direction
2. User Personas: Target user archetypes
3. Jobs to be Done: Tasks users hire products to accomplish
4. Prioritization Frameworks: RICE, MoSCoW, Kano, Value vs Effort
5. OKRs: Objectives and Key Results for goal setting
6. Product-Market Fit: Validating product-market alignment
7. Lean Product Development: Build-Measure-Learn cycles
8. A/B Testing: Data-driven feature validation
9. Roadmapping: Communicating strategy and progress
10. North Star Metric: Primary growth metric alignment

Code Examples

Product Strategy Builder

class ProductStrategy {
  constructor() {
    this.vision = null;
    this.objectives = [];
    this.targetUsers = [];
    this.competitors = [];
    this.differentators = [];
  }
  
  setVision(vision) {
    this.vision = {
      statement: vision,
      timeframe: '3-5 years',
      validated: false,
      stakeholderSignoff: []
    };
    return this;
  }
  
  addObjective(objective) {
    const objectiveNode = {
      id: this.generateId(),
      title: objective.title,
      keyResults: objective.keyResults?.map(kr => ({
        id: this.generateId(),
        description: kr,
        target: kr.target,
        current: kr.current || 0,
        unit: kr. || ,
        : 
      })),
      : ,
      : objective.,
      : []
    };
    
    ..(objectiveNode);
     ;
  }
  
  () {
    . = personas.( ({
      : .(),
      : p.,
      : p.,
      : p.,
      : p.,
      : p.,
      : p.?.( ({
        : j.,
        : j.,
        : j.,
        : j.
      })),
      : p. || 
    }));
    
     ;
  }
  
  () {
     ..( ({
      ...competitor,
      : competitor. || [],
      : competitor. || [],
      : competitor. || ,
      : competitor.,
      : .(competitor),
      : .(competitor)
    }));
  }
  
  () {
     .
      .( 
        competitor..( 
          user..( p.(s))
        )
      )
      .( );
  }
  
  () {
     .
      .( 
        competitor..( 
          user..( g.(w))
        )
      )
      .( );
  }
  
  () {
     {
      : .,
      : .,
      : .,
      : .(),
      : .,
      : .()
    };
  }
  
  () {
     ..( ({
      : user.,
      : user.?.[]?. || ,
      : user..(, ),
      : user..(, ),
      : ..(
        user..( 
          d.?.( p.(a))
        )
      )
    }));
  }
}

Feature Prioritizer

class FeaturePrioritizer {
  constructor() {
    this.features = [];
    this.criteria = [];
  }
  
  addFeature(feature) {
    const scoredFeature = {
      ...feature,
      scores: {},
      weightedScore: 0,
      rank: null
    };
    
    this.features.push(scoredFeature);
    return this;
  }
  
  setCriteria(criteria) {
    this.criteria = criteria.map(c => ({
      name: c.name,
      weight: c.weight || 1,
      scale: c.scale || { min: 1, max: 10 },
      evaluate: c.evaluate
    }));
    
    return this;
  }
  
  prioritize(method = 'rice') {
    switch (method) {
      case 'rice':
        return this.();
       :
         .();
       :
         .();
       :
         .();
      :
         .();
    }
  }
  
  () {
     ..( {
       reach = .(feature, );
       impact = .(feature, );
       confidence = .(feature, );
       effort = .(feature, );
      
       {
        ...feature,
        : {
          reach,
          impact,
          confidence,
          effort,
          : (reach * impact * confidence) / effort
        }
      };
    }).( b.. - a..);
  }
  
  () {
     scores = {
      : { : , : , :  },
      : { : , : , : , : , :  },
      : { : , : , :  },
      : { : , : , :  }
    };
    
     scores[criterion]?.[feature[criterion]] || feature[criterion] || ;
  }
  
  () {
     categories = {
      : [],
      : [],
      : [],
      : []
    };
    
     sorted = [....].( 
      (b. || ) - (a. || )
    );
    
     totalValue = sorted.( sum + (f. || ), );
     mustHaveThreshold = totalValue * ;
     shouldHaveThreshold = totalValue * ;
    
     cumulative = ;
    sorted.( {
      cumulative += feature. || ;
      
       (cumulative <= mustHaveThreshold) {
        categories..({ ...feature, :  });
      }   (cumulative <= shouldHaveThreshold) {
        categories..({ ...feature, :  });
      }   (feature. <= ) {
        categories..({ ...feature, :  });
      }  {
        categories..({ ...feature, :  });
      }
    });
    
     categories;
  }
  
  () {
     ..( {
       assessment = {
        : .(feature),
        : .(feature),
        : .(feature),
        : .(feature),
        : .(feature)
      };
      
       category = .(assessment)
        .( b[] - a[])[][];
      
       {
        ...feature,
        : category,
        : .(assessment),
        : .(category)
      };
    });
  }
  
  () {
     (
      (assessment. * ) +
      assessment. -
      (assessment. * )
    );
  }
  
  () {
     priorities = {
      : ,
      : ,
      : ,
      : ,
      : 
    };
     priorities[category];
  }
}

Roadmap Generator

class RoadmapGenerator {
  constructor() {
    this.initiatives = [];
    this.quarters = [];
    this.themes = [];
  }
  
  addInitiative(initiative) {
    this.initiatives.push({
      id: this.generateId(),
      ...initiative,
      status: 'planned',
      progress: 0,
      dependencies: initiative.dependsOn || [],
      risks: initiative.risks || [],
      metrics: initiative.successMetrics || []
    });
    return this;
  }
  
  setQuarters(quarters) {
    this.quarters = quarters.map(q => ({
      id: q.id,
      name: q.name,
      start: q.startDate,
      end: q.endDate,
      objectives: q.objectives || [],
      capacity: q.capacity || 100,
      : ,
      : []
    }));
     ;
  }
  
  () {
    . = themes.( ({
      : t.,
      : t.,
      : t. || ,
      : t.,
      : t.
    }));
     ;
  }
  
  () {
     sorted = [....].( 
      (b. || ) - (a. || )
    );
    
    ..( {
       remainingCapacity = quarter. - quarter.;
      
      sorted
        .( !i. && i. <= remainingCapacity)
        .( {
          initiative. = quarter.;
          initiative. = quarter.;
          initiative. = quarter.;
          quarter..(initiative);
          quarter. += initiative.;
        });
    });
    
     {
      : .,
      : ..( !i.),
      : ..( ({
        : q.,
        : q.,
        : q.,
        : q. / q.
      }))
    };
  }
  
  () {
     assignments = .();
    
     timeline = assignments..( ({
      : quarter.,
      : ,
      : ,
      : quarter..( ({
        : init.,
        : init.,
        : .(init.),
        : .(init),
        : init.. >  ?  : ,
        : init.,
        : init. || 
      }))
    }));
    
     {
      : ,
      : ,
      timeline,
      : .,
      : .(),
      : {
        : ,
        : ,
        : 
      }
    };
  }
  
  () {
     ..( t. === themeId)?. || ;
  }
  
  () {
     start =  (initiative.);
     end =  (initiative.);
     .((end - start) / ( *  *  * ));
  }
  
  () {
     {
      : .,
      : .,
      : .(),
      : .(),
      : .()
    };
  }
  
  () {
     (!.?.)  ;
    
     total = ..( {
       (kr. === )  sum;
       sum + .(, (kr. / kr.) * );
    }, );
    
     .(total / ..);
  }
  
  () {
     progress = .();
     trend = .();
    
     (progress >=  && trend >= )  ;
     (progress >=  && trend >= )  ;
     (progress < )  ;
     ;
  }
}

Best Practices

1. Start with clear problem definition, not solutions
2. Deeply understand user needs through research
3. Prioritize based on value and strategic alignment
4. Communicate vision and progress consistently
5. Make data-driven decisions when possible
6. Balance short-term wins with long-term strategy
7. Build and maintain cross-functional relationships
8. Iterate quickly and validate assumptions
9. Set clear success metrics before launching
10. Continuously gather and act on feedback