Как принимаешь решение какие задачи взять?

Принятие решения о выборе задач: Методология приоритизации

Этот вопрос раскрывает вашу систему мышления, умение расставлять приоритеты и понимание связи между аналитикой и бизнесом. Хороший Product Analyst должен работать стратегически, а не только выполнять задачи подряд. Разберём систематический подход к выбору задач.

Фреймворк 1: Impact vs Effort (Воздействие vs Усилия)

Популярный и интуитивный подход:

import pandas as pd
import matplotlib.pyplot as plt

# Оценим задачи по двум критериям
tasks = pd.DataFrame({
    'task_name': [
        'Анализ чёрна выписываемых юзеров',
        'Дашборд по клиентским сегментам',
        'Баг-фикс в скрипте сбора данных',
        'Квартальный анализ конверсии',
        'Эксперимент с новой кнопкой',
        'Документация по метрикам'
    ],
    'business_impact': [9, 8, 7, 10, 8, 4],      # 1-10: насколько важно для бизнеса
    'effort_required': [8, 6, 2, 10, 4, 3]       # 1-10: сколько часов/дней работы
})

# Вычисляем эффективность
tasks['efficiency'] = tasks['business_impact'] / tasks['effort_required']
tasks = tasks.sort_values('efficiency', ascending=False)

print("=== ОЦЕНКА ЗАДАЧ ===")
print(tasks.to_string())
print("\n=== РЕЙТИНГ ПО ЭФФЕКТИВНОСТИ ===")
for idx, row in tasks.iterrows():
    print(f"{row['task_name']:40s} → {row['efficiency']:.2f}")

# Визуализация
fig, ax = plt.subplots(figsize=(12, 8))
for idx, row in tasks.iterrows():
    color = 'green' if row['efficiency'] > 2 else 'orange' if row['efficiency'] > 1 else 'red'
    size = row['business_impact'] * 50
    ax.scatter(row['effort_required'], row['business_impact'], s=size, alpha=0.6, color=color)
    ax.annotate(row['task_name'], (row['effort_required'], row['business_impact']), 
                fontsize=9, ha='center')

ax.set_xlabel('Effort Required (hours)')
ax.set_ylabel('Business Impact (1-10)')
ax.set_title('Impact vs Effort Matrix')
ax.grid(True, alpha=0.3)
ax.axhline(y=5, color='gray', linestyle='--', alpha=0.5)
ax.axvline(x=5, color='gray', linestyle='--', alpha=0.5)

ax.text(7, 9, 'Quick Wins ✓', fontsize=10, color='green', fontweight='bold')
ax.text(2, 9, 'Do First', fontsize=10, color='green', fontweight='bold')
ax.text(7, 2, 'Time Sink ⚠️', fontsize=10, color='red', fontweight='bold')
ax.text(2, 2, 'Avoid ✗', fontsize=10, color='red', fontweight='bold')

plt.tight_layout()
plt.show()

Фреймворк 2: RICE (Reach, Impact, Confidence, Effort)

Более сложный и точный метод, используемый в Intercom и других компаниях:

from dataclasses import dataclass
from typing import List

@dataclass
class Task:
    name: str
    reach: int          # Сколько юзеров затронет (месячно)
    impact: int         # Влияние на каждого юзера (1-3: 0.25x, 0.5x, 1x, 2x, 3x)
    confidence: float   # Уверенность в оценке (0-1: 100%, 75%, 50%)
    effort: int         # Человеко-часов

def calculate_rice_score(task: Task) -> float:
    """Рассчитать RICE score"""
    return (task.reach * task.impact * task.confidence) / task.effort

# Примеры задач
tasks_rice = [
    Task(
        name='Анализ чёрна юзеров',
        reach=5000,          # Затрагивает 5000 активных юзеров месячно
        impact=3,            # 3x влияние (выявим и вернём их)
        confidence=0.9,      # 90% уверены в гипотезе
        effort=40            # 5 дней работы (40 часов)
    ),
    Task(
        name='Дашборд по сегментам',
        reach=100,           # Используют аналитики (100 месячно внутри)
        impact=2,            # 2x влияние (улучшит скорость анализа)
        confidence=0.8,      # 80% уверены
        effort=80            # 10 дней работы
    ),
    Task(
        name='Баг в скрипте сбора',
        reach=50000,         # Все юзеры подвержены
        impact=1,            # 1x (данные неправильные, надо исправить)
        confidence=0.95,     # 95% это баг
        effort=4             # 30 минут - 1 час
    ),
    Task(
        name='Новое интеграционное API',
        reach=20000,         # Потенциально 20к новых юзеров
        impact=2,            # 2x (новый большой интеграционный партнёр)
        confidence=0.5,      # 50% пока не знаем точную потребность
        effort=200           # Много работы
    ),
]

# Рассчитываем scores
for task in tasks_rice:
    score = calculate_rice_score(task)
    print(f"{task.name:30s}")
    print(f"  Reach: {task.reach:,} | Impact: {task.impact}x | Confidence: {task.confidence:.0%} | Effort: {task.effort}h")
    print(f"  RICE Score: {score:.2f}\n")

# Сортируем по score
tasks_rice.sort(key=calculate_rice_score, reverse=True)
print("\n=== ПРИОРИТЕТ (по RICE) ===")
for i, task in enumerate(tasks_rice, 1):
    print(f"{i}. {task.name} (score: {calculate_rice_score(task):.2f})")

Фреймворк 3: Kano Model (Модель Кано)

Категоризирует требования по их влиянию на удовлетворённость:

from enum import Enum

class RequirementType(Enum):
    HYGIENE = "Гигиена"           # Basic requirements - absence causes dissatisfaction
    PERFORMER = "Исполнение"      # Linear - more = better satisfaction
    DELIGHTER = "Услада"           # Non-linear - surprising positive impact

def categorize_by_kano(task_name: str, description: str) -> tuple[RequirementType, str]:
    """Категоризировать задачу по Kano"""
    
    kano_tasks = {
        'Баг в скрипте сбора': (
            RequirementType.HYGIENE,
            'Баг = система не работает. Это базовое требование. Отсутствие = недовольство'
        ),
        'Дашборд по сегментам': (
            RequirementType.PERFORMER,
            'Больше дашбордов = лучше работает команда. Линейное усиление'
        ),
        'Exp результаты в слаке': (
            RequirementType.DELIGHTER,
            'Неожиданный удобный способ - может очень радовать, но не критично'
        ),
    }
    
    return kano_tasks.get(task_name, (RequirementType.PERFORMER, 'Unknown'))

# Примеры
tasks_kano = [
    ('Баг в скрипте сбора', 'Критический баг'),
    ('Дашборд по сегментам', 'Удобство работы'),
    ('Результаты экспериментов в Slack', 'Приятный бонус'),
    ('Правильная временная зона в отчётах', 'Корректность данных'),
    ('Авто-отправка отчётов партнёрам', 'Приятный бонус'),
]

print("=== КЛАССИФИКАЦИЯ ПО KANO MODEL ===")
for task_name, desc in tasks_kano:
    req_type, explanation = categorize_by_kano(task_name, desc)
    print(f"{task_name:40s} → {req_type.value:15s} ({explanation})")

print("\n=== РЕКОМЕНДАЦИЯ ПО ПРИОРИТЕТУ ===")
print("1. HYGIENE TASKS (делай первыми) - без них система ломается")
print("2. PERFORMER TASKS (делай чаще) - улучшают качество работы")
print("3. DELIGHTER TASKS (делай когда есть время) - приятные бонусы")

Фреймворк 4: MoSCoW Prioritization

Разделение на категории Must/Should/Could/Won't:

class PriorityLevel(Enum):
    MUST = "Must Have"        # Критично, без этого не запускаемся
    SHOULD = "Should Have"    # Важно, но можно отложить
    COULD = "Could Have"      # Было бы хорошо, но не обязательно
    WONT = "Won't Have"       # Не делаем в этом спринте

def moscow_prioritization(tasks_list: List[str]) -> dict:
    """Классифицировать задачи по MoSCoW"""
    
    classification = {
        'Must': [
            'Баг в скрипте сбора данных',
            'Исправить неправильный расчёт конверсии',
            'Добавить отсутствующие метрики в дашборд'
        ],
        'Should': [
            'Дашборд по клиентским сегментам',
            'Анализ причин чёрна юзеров',
            'Автоматизация еженедельного отчёта'
        ],
        'Could': [
            'Красивая визуализация в метрик',
            'Интеграция результатов в Slack',
            'Экспорт данных в Google Sheets'
        ],
        'Wont': [
            'Разработка собственной BI системы',
            'Интеграция с 10+ источниками данных',
            'Machine Learning для прогноза'
        ]
    }
    
    return classification

result = moscow_prioritization([])
for priority, tasks in result.items():
    print(f"\n=== {priority} ===")
    for task in tasks:
        print(f"  • {task}")

Фреймворк 5: Матрица Айзенхауэра (Urgency vs Importance)

def eisenhower_matrix(task: str, urgent: bool, important: bool) -> str:
    """
    Определить квадрант Eisenhower
    """
    if important and urgent:
        return "Квадрант 1: ДЕЛАЙ СЕЙЧАС (Crisis)"
    elif important and not urgent:
        return "Квадрант 2: ПЛАНИРУЙ (Strategic)"
    elif not important and urgent:
        return "Квадрант 3: ДЕЛЕГИРУЙ (Distraction)"
    else:
        return "Квадрант 4: ИЗБЕГАЙ (Time waste)"

# Примеры
tasks_eisenhower = [
    ('Баг в продакшене - юзеры теряют данные', True, True),
    ('Квартальный анализ продуктовых метрик', False, True),
    ('Срочная просьба из маркетинга про малую выборку', True, False),
    ('Подписка на Twitter уведомления о метриках', False, False),
]

print("=== МАТРИЦА АЙЗЕНХАУЭРА ===")
for task, urgent, important in tasks_eisenhower:
    quadrant = eisenhower_matrix(task, urgent, important)
    print(f"{task:50s}")
    print(f"  {quadrant}\n")

Практический процесс выбора (День за днём)

from datetime import datetime, timedelta

class TaskSelector:
    def __init__(self, team_capacity_hours: int = 40):
        self.capacity = team_capacity_hours
        self.weekly_schedule = []
    
    def select_weekly_tasks(self, all_tasks: List[Task]) -> List[Task]:
        """
        Выбрать задачи на неделю
        """
        # Шаг 1: Отфильтруем по MUST
        must_have = [t for t in all_tasks if t.priority == 'MUST']
        must_hours = sum(t.effort for t in must_have)
        
        if must_hours > self.capacity:
            print(f"⚠️ MUST tasks требуют {must_hours}h, а у нас только {self.capacity}h")
            return must_have  # Делаем только MUST
        
        remaining_capacity = self.capacity - must_hours
        
        # Шаг 2: Добавляем SHOULD по приоритету (RICE score)
        should_have = [t for t in all_tasks if t.priority == 'SHOULD']
        should_have.sort(key=lambda t: t.rice_score, reverse=True)
        
        selected_should = []
        for task in should_have:
            if remaining_capacity >= task.effort:
                selected_should.append(task)
                remaining_capacity -= task.effort
        
        # Шаг 3: Если ещё место, добавляем COULD
        could_have = [t for t in all_tasks if t.priority == 'COULD']
        could_have.sort(key=lambda t: t.rice_score, reverse=True)
        
        selected_could = []
        for task in could_have:
            if remaining_capacity >= task.effort:
                selected_could.append(task)
                remaining_capacity -= task.effort
        
        # Итоговый список
        selected = must_have + selected_should + selected_could
        
        print(f"=== НЕДЕЛЯ СПЛАНИРОВАНА ===")
        print(f"Пропускная способность: {self.capacity}h")
        print(f"\nMUST: {len(must_have)} задач ({sum(t.effort for t in must_have)}h)")
        print(f"SHOULD: {len(selected_should)} задач ({sum(t.effort for t in selected_should)}h)")
        print(f"COULD: {len(selected_could)} задач ({sum(t.effort for t in selected_could)}h)")
        print(f"\nОставшая ёмкость: {remaining_capacity}h")
        
        return selected
    
    def daily_check_in(self, selected_tasks: List[Task], day_of_week: str):
        """
        Ежедневная проверка прогресса и переоценка
        """
        print(f"\n=== ПОНЕДЕЛЬНИК. ЕЖЕДНЕВНАЯ ПРОВЕРКА ===")
        print("1. Есть ли блокирующие проблемы? (bugs, data issues)")
        print("2. Изменились ли приоритеты бизнеса?")
        print("3. Всё ли на трэке?")
        print("4. Нужна ли переоценка задач на эту неделю?")
        print("\n→ Если 'yes' на любой вопрос - переоцениваем приоритеты")

Мой личный процесс (Interview answer)

Когда передо мной стоит выбор задач, я следую такой системе:

1. АНАЛИЗ:
   - Какова цель (business goal)?
   - Какой impact этой задачи?
   - Сколько времени требуется?
   → Считаю efficiency ratio: impact/effort

2. КАТЕГОРИЗАЦИЯ:
   - Это blocking issue (MUST)?
   - Это strategic improvement (SHOULD)?
   - Это nice-to-have (COULD)?
   → Группирую по приоритету

3. ПЛАНИРОВАНИЕ:
   - Берусь за MUST все сразу
   - Затем максимизирую SHOULD по ROI (impact/effort)
   - Заполняю оставшееся время на COULD

4. АДАПТАЦИЯ:
   - Каждый день проверяю: изменились ли приоритеты?
   - Есть ли срочные issues?
   - Нужна ли переоценка?

5. ЦЕЛОСТНОСТЬ:
   - Связна ли эта задача с другими проектами?
   - Может ли она заблокировать других?
   - Есть ли синергия с текущей работой?

Красные флаги (Anti-patterns)

def identify_red_flags(task_request):
    """
    Признаки плохой задачи, которую не нужно брать
    """
    red_flags = {
        'нечётко поставленная': 'task.description is vague',
        'нет metrics': 'not clear how to measure success',
        'слишком большая': 'effort > 40 hours',
        'срочная, но низкий impact': 'urgent but low business value',
        'много dependencies': 'blocked by other teams',
        'moving target': 'requirements keep changing',
    }
    
    print("🚩 RED FLAGS для этой задачи:")
    for flag_name, condition in red_flags.items():
        if condition in str(task_request):
            print(f"  ⚠️ {flag_name}")