Разработчик перестал выходить на связь

Решение

1. Параллельные действия (День 1)

ПЕРВЫЙ ЧАС:

Локальный ответ (team + company)

• Встреча в 30 минут: PM, lead dev, HR
• Факты: Максим не отвечает 2+ дня, критичные задачи на нём
• Решение: параллельное выполнение нескольких путей

ДЕЙСТВИЕ 1: Поиск Максима (HR + PM)

• Попытка 1 (немедленно):

  • Позвонить на номер телефона (не сообщение, звонок)
  • Проверить есть ли IM statusили is he online in Slack
  • Попросить его коллег: "Вы видели Максима? Можете позвонить?"

• Попытка 2 (в течение часа):

  • HR: попытка связаться через emergency contact (if available)
  • Если у него в рабочем контракте есть родственник / emergency contact
  • Осторожный разговор: "Ищем Максима по работе, вы его видели?"

• Попытка 3 (в течение 2 часов):

  • Если есть его адрес: может отправить HR домой? (only if company policy allows)
  • Позвонить в поликлинику / больницу? (only if company policy allows)
  • Это деликатно, но критичная ситуация

• Параллельно:

  • Проверить его банк/карту: он активен в системах? (HR может проверить)?
  • Это может показать норм ли он

ДЕЙСТВИЕ 2: Оценка его задач (lead dev + PM)

• Посмотреть что он был на себе взял
  • Какие коммиты? (последний?)
  • Какие branch'и?
  • Какой % готово?
• Определить: что можно сделать без него, что нельзя
  • Task 1: "Реализовать payment gateway" - 60% готово

    - Статус: branch готов, нужна финализация + тесты
    - Критичность: очень high
    - Сложность переделать: 5-8 часов другому разработчику

• Task 2: "API для analytics" - 20% готово

    - Статус: только design, code не написан
    - Критичность: medium (можно отложить)
    - Сложность: 16+ часов

Матрица:

Task | % done | Criticality | Can transfer? | Effort | Owner
Payment | 60% | Critical | Yes | 8h | Assign to senior
Analytics | 20% | Medium | No | 16h | Postpone
Fixes | 40% | High | Yes | 12h | Assign to mid

ДЕЙСТВИЕ 3: Немедленное перераспределение (lead dev)

• Позвать всю team (срочно, 15 мин)
• Объяснение: "Максим нас потерял, не знаем почему. На всякий case переделываем план"
• Назначить "rescue owners" для критичных задач
  • Task 1 (Payment): assign к senior разработчику

    - Он заберёт branch, поймёт где Максим остановился
    - Продолжит оттуда

• Task 2 (Fixes): assign к mid разработчику
• Остальное: backlog или постарайтесь другие задачи переделать
• Скорость: 15 minutes, not discussion

ДЕЙСТВИЕ 4: Коммуникация с руководством (PM)

• Email в 30 минут:
  • ФГ: "URGENT: Ключевой разработчик потерян, релиз под угрозой"
  • Статус: ищем Максима, переделываем план
  • Опции: (1) найдём его быстро, (2) отложим неmainstream задачи, (3) привлечём помощь
  • Следующий update в 4 часа

ДЕЙСТВИЕ 5: Резервный план (PM + lead)

• Если Максима не найдём в течение дня:
  • Критичные задачи: переделать, даже если неправильно
  • Medium задачи: отложить на phase 2
  • MVP: определить что это (80% feature set), отложить остальное

2. Перераспределение работы в команде

СТРАТЕГИЯ: Triage + Assign + Skip

Шаг 1: Triage задач (30 мин)

Категоризация:

• MUST-HAVE (для релиза):

  • Payment processing
  • User authentication
  • Core API
  • Critical bugs
  • Effort: X часов (можно ли закончить к релизу?)

• NICE-TO-HAVE (фаза 2):

  • Analytics
  • Advanced filtering
  • Performance optimizations
  • Effort: Y часов (откладываем)

• CAN-BE-PARTIAL:

  • Some features might work 80% instead of 100%
  • Documented as known limitation

Пример (типичный app):

MUST:
- Login/registration (8h) - 70% ready by Maxim
- Payment (8h) - 60% ready
- Core data (5h) - 100% ready
- Bug fixes (10h) - 20% ready
- Testing (12h) - 0%
Total MUST: 43 hours

NICE-TO-HAVE:
- Analytics dashboard (16h) -> skip
- Advanced search (8h) -> skip
- Notifications (5h) -> skip
Total skipped: 29 hours

Releasing: MVP with 43 hours of MUST work

Шаг 2: Assign to capable people (1 hour)

Правило: senior gets hardest, junior gets simplest

Senior Dev (best fit for Maxim's code):
- Payment (pickup from his branch) - 8h
- Login continuation (his code) - 8h
Total: 16h (2 days intensive)

Mid-level Dev:
- Bug fixes (can fix from tests) - 12h
- Core data (already done, just verify) - 2h
Total: 14h (2 days)

Junior + QA:
- Testing all (smoke tests, critical paths) - 12h
- Documentation of changes
Total: 12h (1-2 days)

PM:
- Coordinate, communicate
- Cut scope as needed

Шаг 3: Intensive sprint (14 days)

Daily structure:

• 9:00: Standup (15 min) - what did we do, blockers?
• 9:30-13:00: Deep work (no interrupts)
• 13:00-14:00: Lunch
• 14:00-17:00: Deep work
• 17:00-17:30: Sync + status

What NOT to do:

• No new features
• No refactoring
• No meetings except essential
• No support (let it wait)
• Minimal code review (quick approvals for critical path)

What to do:

• Only MUST-HAVE features
• Ship quality code (one shot, no rework)
• Continuous testing
• Communication with all stakeholders

Шаг 4: Risk mitigation

Risks:

1. Senior might not understand Maxim's code

   • Mitigation: code is self-documenting (comments), tests exist
   • He spends 2 hours understanding, then 6 hours modifying

2. Too much work for 2 days

   • Mitigation: cut scope ruthlessly
   • Payment 100% ready? Or partial payment (card only, not bank transfer)?
   • Both ready or choose one?

3. Testing incomplete

   • Mitigation: focus on critical paths only
   • Can do extended testing after release

4. Bugs discovered late

   • Mitigation: continuous testing, not at the end
   • Each piece tested immediately after coding

Шаг 5: Communication (every 4 hours)

Email/Slack every 4 hours:

• What completed
• What's next
• Risks identified
• Timeline prediction
• Any blockers

Example:

2pm: "Payment gateway 80% ready, senior found 3 edge cases, fixing. 
Login 90% ready, testing tomorrow. Still on track for relase."

4pm: "Payment gateway 100% ready and tested. Login tests passed.
Bug fixes 50% done. Timeline: +5 hours for remaining. Release ready by Friday."

3. Защита от подобных рисков в будущем

СИСТЕМНЫЕ РЕШЕНИЯ (не band-aid fixes)

Решение 1: Knowledge distribution (critical)

Проблема: Максим был single point of failure

Решение:

• Pair programming: critical features на двух людей

  • Payment? Пишут senior + mid
  • Оба знают код
  • Если один потеряет связь, другой может continue

• Code documentation:

  • Architecture decisions: записаны
  • Complex logic: комментарии
  • API specs: documented
  • Результат: junior может разобраться

• Wiki/Confluence:

  • How to run project locally?
  • How to deploy?
  • Known issues and workarounds
  • Team can onboard новго человека за часы, не дни

• Code review:

  • Every PR reviewed by 2 people
  • Результат: knowledge распределено
  • Bonus: quality улучшится

Решение 2: Dependency risk management

Identify critical paths:

• Какие features block другие?
• Какие люди на critical path?
• Риск: если потеряем этого человека, что упадёт?

Матрица:

Feature | Owner | Backup | % risk | Mitigation
Payment | Maxim | (none) | HIGH | Pair programming
Auth | Sasha | Vadim | MEDIUM | Vadim knows code
API | Vadim | (none) | HIGH | Distribute knowledge
UI | Anya | Vlad | LOW | Easy to pass

Mitigation for CRITICAL:

• Pair programming
• Extra documentation
• Knowledge sharing sessions

Решение 3: Communication protocol

Daily availability:

• Team slack status: online, offline, in meeting
• If offline >1 hour: tell team where, when back
• Emergency contact: if can't reach, can call your phone

Weekly check-in:

• Standup: "Is everyone OK? Any issues?"
• Open door: can talk to PM if stressed, planning to leave, have problems

Health check (quarterly):

• 1-on-1: how are you? Burnout? Happy? Planning to leave?
• Early warning: if someone might leave, prepare

Решение 4: Contingency planning

Every sprint, identify:

• Who is critical to this sprint?
• What if he/she disappears?
• What's our backup plan?

Practice:

• Once a quarter: simulated outage
  • Pretend senior is gone
  • Can team continue?
  • What breaks?
  • Improve systems

Решение 5: Work distribution

Rule: no single owner

• Every feature: primary owner + backup
• Backup knows 70% of what primary knows
• When primary on vacation: backup takes over

Example:

• Payment: Maxim (primary) + Sasha (backup)
  • Maxim does 70%, Sasha does 30% (tests, docs, edge cases)
  • Sasha understands code, can modify
  • If Maxim gone, Sasha continues

Решение 6: Emergency protocols

If person unreachable >4 hours:

1. HR tries to reach them (emergency contacts)
2. PM assumes they might not return
3. Start knowledge transfer with backup
4. Redistribute critical tasks
5. Adjust timeline

Documentation (every project):

• Password manager: shared credentials for critical services
• Deploy instructions: can anyone deploy?
• API access: multiple people have keys
• Database: backup person can access

Решение 7: Staffing

Hiring:

• Junior+ Senior: at least 1 senior per domain
• Diversity: different perspectives, less risk of knowledge silos
• Growth: juniors learn from seniors

Onboarding:

• First month: pair with senior
• Commit: learn critical features
• Goal: after 3 months, can work independently

Retention:

• Competitive salary
• Learning budget
• Career growth
• Work-life balance (avoid burnout)
• Result: people stay, knowledge stays

Решение 8: Process improvements

Reduce hero culture:

• "We don't celebrate people who work 80 hours"
• "We celebrate people who write code others understand"
• "We celebrate knowledge sharing"

Reduce burnout:

• Monitor workload
• Force vacation: don't work while on PTO
• 40-hour weeks, not 60
• Result: people healthier, less likely to quit or burn out

Automate critical tasks:

• Deployment: CI/CD, anyone can deploy
• Monitoring: alerts, not manual watching
• Testing: automated, not manual
• Result: less dependent on single person

IMMEDIATE PLAN FOR NEXT WEEK

Today (Day 0):
- 30 min: find Maxim (HR + PM)
- 1 hour: triage tasks
- 1 hour: assign to people
- Email ruководству
- Team meeting: new plan

Day 1-2:
- Senior: pickup Maxim's code, continue
- Mid: fix bugs
- Junior+QA: test

Day 3-5:
- Integration
- Complete testing
- Deploy to staging
- Final round of testing

Day 6-7:
- Deploy to production
- Monitor
- Hot fix if needed

After release:
- Find Maxim (where is he?)
- Implement lessons learned
- Knowledge sharing sessions
- Improve processes

Итог

Этот crisis это opportunity для улучшения. Максимов не должно быть в компании. Каждый должен быть заменяемым (не потому что он не ценен, но потому что его знания распределены). Решение: знания в wiki + pair programming + regular communication + cross-training. Тогда потеря одного человека это проблема, но не crisis.