IT Meetings: How Not to Turn Them Into a Waste of Time

🚫 No clear goal
🚫 Too many participants
🚫 No agenda
🚫 One person talks, others stay silent
🚫 No decisions made
🚫 No follow-up actions

type Meeting struct {
    Duration    time.Duration
    Attendees   []Employee
    HourlyRate  float64
}

func (m *Meeting) CalculateCost() float64 {
    totalCost := 0.0
    for _, employee := range m.Attendees {
        totalCost += employee.HourlyRate * m.Duration.Hours()
    }
    return totalCost
}

// Example: 1-hour meeting with 8 developers ($50/hour)
// Cost: $400
// If meeting is useless = $400 thrown away

**Sprint Planning**
- Goal: Plan work for sprint
- Participants: Team + PO + SM
- Duration: 2 hours per sprint week
- Result: Sprint backlog

**Daily Standup**
- Goal: Team synchronization
- Participants: Development team
- Duration: 15 minutes
- Result: Understanding of progress and blockers

**Sprint Review**
- Goal: Demonstrate results
- Participants: Team + stakeholders
- Duration: 1 hour per sprint week
- Result: Feedback

**Retrospective**
- Goal: Process improvement
- Participants: Development team
- Duration: 45 minutes per sprint week
- Result: Action items for improvements

type MeetingGoal struct {
    Type        string // "decide", "inform", "brainstorm", "coordinate"
    Objective   string // Specific goal
    Success     string // Success criteria
    Deliverable string // Expected output
}

func (mg *MeetingGoal) IsValid() bool {
    return mg.Type != "" && 
           mg.Objective != "" && 
           mg.Success != "" && 
           mg.Deliverable != ""
}

// Bad: "Discuss project"
// Good: "Decide on database choice for project X"

# Meeting: Microservices Architecture Choice
**Date:** January 15, 2025, 2:00-3:00 PM
**Goal:** Decide on architecture for project Y

## Participants (required)
- Alex (architect) - facilitator
- Maria (tech lead) - expert
- Ivan (DevOps) - consultant

## Agenda
1. **Problem context** (10 min) - Alex
2. **Solution options** (20 min) - Maria
   - Monolith vs microservices
   - Technology stack
3. **Risk discussion** (15 min) - all
4. **Decision making** (10 min) - voting
5. **Next steps** (5 min) - action items

## Preparation
- [ ] Alex: prepare context presentation
- [ ] Maria: research architecture options
- [ ] Ivan: assess infrastructure requirements

## Materials
- Project Y technical requirements
- Architecture patterns research
- Budget and time constraints

type Participant struct {
    Name string
    Role string // "decision_maker", "expert", "stakeholder", "observer"
    Required bool
}

func OptimizeParticipants(participants []Participant) []Participant {
    // Rule: maximum 7 people for discussion
    if len(participants) > 7 {
        // Keep only decision_makers and experts
        filtered := []Participant{}
        for _, p := range participants {
            if p.Role == "decision_maker" || p.Role == "expert" {
                filtered = append(filtered, p)
            }
        }
        return filtered
    }
    return participants
}

func RoundRobin(participants []string, question string) []Response {
    responses := []Response{}
    for _, participant := range participants {
        response := askQuestion(participant, question)
        responses = append(responses, response)
    }
    return responses
}

// Each participant speaks in turn
// No one can dominate the conversation

**Discussion structure:**
- Problem presentation: 10 minutes
- Clarifying questions: 5 minutes
- Option generation: 15 minutes
- Pros/cons discussion: 20 minutes
- Decision making: 10 minutes

Solution options:
A) Monolith          ●●●○○ (3 votes)
B) Microservices     ●●●●● (5 votes) ← WINNER
C) Modular monolith  ●●○○○ (2 votes)

# Code Review Meeting Template

**Goal:** Discuss architectural decisions in PR #123
**Time:** 30 minutes
**Participants:** Author + 2 reviewers

## Structure
1. **Context** (5 min) - author explains task
2. **Walkthrough** (15 min) - review key changes
3. **Questions and suggestions** (8 min)
4. **Action items** (2 min)

## Rules
- Focus on code, not personality
- Specific suggestions, not general remarks
- If discussion drags > 5 min - move to separate meeting

type ArchitecturalDecision struct {
    Title       string
    Status      string // "proposed", "accepted", "deprecated"
    Context     string
    Decision    string
    Consequences []string
    Participants []string
    Date        time.Time
}

func (ad *ArchitecturalDecision) DocumentDecision() {
    // Every architectural decision is documented
    // Meeting participants = responsible for decision
}

# Tech Debt Review Meeting

**Frequency:** Monthly
**Goal:** Prioritize technical debt

## Agenda
1. **Current state overview** (10 min)
   - Code quality metrics
   - New feature development time
   - Bug count
   
2. **Top-5 problems** (20 min)
   - Each team presents main pain points
   - Assess productivity impact
   
3. **Work planning** (20 min)
   - Choose 2-3 tasks for next sprint
   - Assign owners
   
4. **Resources and timelines** (10 min)

**Planning:**
- Calendly - automatic scheduling
- When2meet - find common time
- Doodle - polls for time selection

**Running:**
- Zoom/Teams - video calls
- Miro/Mural - interactive boards
- Slido - real-time polls and Q&A

**Documentation:**
- Notion - structured notes
- Confluence - corporate wiki
- Linear - action items and tasks

## Daily Standup - [Date]

### [Participant Name]
**Yesterday:** Finished payment API integration
**Today:** Will write tests for payment system
**Blockers:** No access to test environment

### Action Items
- [ ] DevOps: provide test environment access
- [ ] PM: clarify error handling requirements

## Sprint Retrospective

### 🟢 What went well?
- Good client communication
- Quick technical problem resolution
- Quality test coverage

### 🔴 What could be improved?
- Long code reviews (3+ days)
- Inaccurate task estimates
- Too many context switches

### 💡 Action Items
- [ ] Set code review SLA: 24 hours
- [ ] Conduct estimation session
- [ ] Introduce "focus time" without meetings

type AsyncDecision struct {
    Proposal    string
    Deadline    time.Time
    Votes       map[string]string // participant -> vote
    Discussion  []Comment
    Status      string // "open", "decided", "cancelled"
}

func (ad *AsyncDecision) CanReplace(meeting Meeting) bool {
    // Can replace meeting with async decision if:
    return meeting.Type == "decision" && 
           len(meeting.Attendees) > 5 &&
           meeting.Complexity == "low"
}

**Pre-meeting checklist:**
- [ ] Can this be solved in Slack in 5 minutes?
- [ ] Is all necessary information available?
- [ ] Do we need to decide right now?
- [ ] Are all participants really needed?
- [ ] Is there a clear goal and agenda?

If any answer is "no" - reconsider meeting necessity.

type MeetingMetrics struct {
    Duration        time.Duration
    PlannedDuration time.Duration
    ParticipantCount int
    ActionItems     int
    CompletedActions int
    SatisfactionScore float64 // 1-10
}

func (mm *MeetingMetrics) EfficiencyScore() float64 {
    timeEfficiency := mm.PlannedDuration.Seconds() / mm.Duration.Seconds()
    actionEfficiency := float64(mm.CompletedActions) / float64(mm.ActionItems)
    
    return (timeEfficiency + actionEfficiency + mm.SatisfactionScore/10) / 3
}

**Rate the meeting (1-5):**
- Was the goal achieved? ⭐⭐⭐⭐⭐
- Was time respected? ⭐⭐⭐⭐○
- Were all participants needed? ⭐⭐⭐○○
- Did you get value? ⭐⭐⭐⭐⭐

**What can be improved?**
"Materials should have been sent in advance for review"

# Team Meeting Charter

## Our principles
1. **Time is a resource:** every minute counts
2. **Preparation is mandatory:** no prep = no participation
3. **Focus on results:** every meeting should solve something
4. **Equal participation:** every voice matters
5. **Action-oriented:** decisions become actions

## Our rules
- Start on time, end on time
- Phones on silent
- One speaks - others listen
- Questions relevant to meeting topic
- Summary within 24 hours after meeting

## Our roles
- Anyone can become facilitator
- Role rotation every month
- Feedback is welcome

type MeetingSkills struct {
    Facilitation    int // 1-10
    TimeManagement  int
    Conflict        int
    DecisionMaking  int
}

func (ms *MeetingSkills) TrainingPlan() []string {
    plan := []string{}
    
    if ms.Facilitation < 7 {
        plan = append(plan, "Facilitation workshop")
    }
    if ms.Conflict < 6 {
        plan = append(plan, "Conflict resolution training")
    }
    
    return plan
}

# Additional resources:
- "Death by Meeting" - Patrick Lencioni - https://www.tablegroup.com/books/death-by-meeting/
- "The Surprising Science of Meetings" - HBR - https://hbr.org/2015/07/the-surprising-science-of-meetings
- Facilitation techniques - Liberating Structures - https://www.liberatingstructures.com/
- Meeting templates - Atlassian Team Playbook - https://www.atlassian.com/team-playbook/plays