def find_golden_hours(team_timezones, workday_start=9, workday_end=17):
    """
    Find overlapping work hours between timezone clusters.

    Args:
        team_timezones: List of timezone offsets (e.g., [-8, -5, 0, 9, 10])
        workday_start: Local start hour (default 9 AM)
        workday_end: Local end hour (default 5 PM)

    Returns:
        List of tuples representing golden hour windows in UTC
    """
    golden_hours = []

    for i, tz1 in enumerate(team_timezones):
        for tz2 in team_timezones[i+1:]:
            # Convert to UTC range
            tz1_start_utc = workday_start - tz1
            tz1_end_utc = workday_end - tz1
            tz2_start_utc = workday_start - tz2
            tz2_end_utc = workday_end - tz2

            # Find overlap
            overlap_start = max(tz1_start_utc, tz2_start_utc)
            overlap_end = min(tz1_end_utc, tz2_end_utc)

            if overlap_start < overlap_end:
                golden_hours.append((overlap_start, overlap_end))

    return sorted(golden_hours)

# Example: San Francisco (-8), London (0), Tokyo (+9)
Lead teams across five or more time zones by adopting async-first communication, scheduling critical decisions with representation from each zone, and rotating meeting times to share inconvenience fairly. This approach respects team well-being while maintaining alignment.

For teams spanning five timezones, you'll often find that the most practical approach is accepting that true universal overlap doesn't exist and optimizing for pairwise overlaps instead.

## Framework Component 2: Time-Blocking by Timezone

Structure your own day around timezone-aware time blocks. This is critical for managers who need to be available for different team segments without destroying their own productivity.

### Recommended Daily Structure (UTC-based)

| Time Block (UTC) | Activity | Purpose |
|------------------|----------|---------|
| 14:00-16:00 | Deep work | Productive hours for strategic work |
| 16:00-17:00 | EMEA collaboration | Overlap with European team |
| 17:00-18:00 | APAC async review | Review overnight updates from Asia |
| 18:00-19:00 | Americas prep | Prepare for US team next day |
| 19:00-20:00 | Admin/Planning | Internal tasks |

Adjust these blocks based on your team's specific timezone distribution. The key insight: batch similar activities together and accept that your schedule will feel unconventional to anyone used to 9-to-5 thinking.

## Framework Component 3: Context-Rich Async Handoffs

When synchronous collaboration is genuinely necessary, make it count by investing heavily in async preparation. A poorly prepared meeting wastes everyone's time; a well-prepared meeting with async pre-work maximizes value.

### Meeting Pre-Work Template

```markdown
## Meeting: [Topic]
**Date:** [Date] at [Time UTC]
**Duration:** [X] minutes
**Required Attendees:** [List]

### Pre-Read Materials
- [Link to document 1]
- [Link to PR/issue 2]

### Pre-Work Required
- [ ] Review [specific item]
- [ ] Comment on [decision thread]
- [ ] Prepare [deliverable for meeting]

### Expected Outcomes
- [Decision needed: X]
- [Alignment on: Y]
- [Plan for: Z]

def generate_sync_rotation(timezone_names, weeks=4):
 """
 Generate a fair rotation for synchronous meeting times.
 Each timezone hosts (accepts inconvenient hours) equally.
 """
 rotation = []
 for week in range(weeks):
 week_schedule = {}
 for i, tz in enumerate(timezone_names):
 # Assign "inconvenient" slot based on rotation
 inconvenience_index = (i + week) % len(timezone_names)
 week_schedule[tz] = inconvenience_index
 rotation.append(week_schedule)
 return rotation

# Example output shows which timezone "hosts" each week
team = ["San Francisco", "New York", "London", "Tokyo", "Sydney"]
schedule = generate_sync_rotation(team, weeks=4)