How to Avoid Burnout as a Senior Engineer in 2026 – 7 Tactics That Saved Our Team's Mental Health

import os
import json
import requests
from datetime import datetime, timedelta
from dotenv import load_dotenv
import logging

load_dotenv()

GITHUB_TOKEN = os.getenv(\"GITHUB_TOKEN\")
PAGERDUTY_TOKEN = os.getenv(\"PAGERDUTY_TOKEN\")
SLACK_TOKEN = os.getenv(\"SLACK_TOKEN\")
ORG_NAME = os.getenv(\"GITHUB_ORG\")
PD_SCHEDULE_ID = os.getenv(\"PD_SCHEDULE_ID\")
SLACK_CHANNEL = os.getenv(\"SLACK_CHANNEL\")

logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(levelname)s - %(message)s\")
logger = logging.getLogger(__name__)

GITHUB_HEADERS = {\"Authorization\": f\"token {GITHUB_TOKEN}\", \"Accept\": \"application/vnd.github.v3+json\"}
SLACK_HEADERS = {\"Authorization\": f\"Bearer {SLACK_TOKEN}\", \"Content-type\": \"application/json\"}

def get_github_toil(org_name, token):
    \"\"\"Fetch unplanned work from GitHub: issues labeled 'unplanned', PRs opened after hours, CI reruns.\"\"\"
    headers = {\"Authorization\": f\"token {token}\", \"Accept\": \"application/vnd.github.v3+json\"}
    toil_hours = 0
    # Get all repos in org
    repos_url = f\"https://api.github.com/orgs/{org_name}/repos\"
    try:
        repos_resp = requests.get(repos_url, headers=headers, params={\"per_page\": 100})
        repos_resp.raise_for_status()
        repos = repos_resp.json()
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to fetch repos: {e}\")
        return 0

    for repo in repos:
        repo_name = repo[\"name\"]
        # Fetch unplanned issues closed in last 7 days
        issues_url = f\"https://api.github.com/repos/{org_name}/{repo_name}/issues\"
        params = {\"labels\": \"unplanned\", \"state\": \"closed\", \"since\": (datetime.utcnow() - timedelta(days=7)).isoformat(), \"per_page\": 100}
        try:
            issues_resp = requests.get(issues_url, headers=headers, params=params)
            issues_resp.raise_for_status()
            issues = issues_resp.json()
        except requests.exceptions.RequestException as e:
            logger.error(f\"Failed to fetch issues for {repo_name}: {e}\")
            continue
        # Estimate 2 hours per unplanned issue
        toil_hours += len(issues) * 2

        # Fetch PRs opened between 18:00 and 08:00 UTC
        prs_url = f\"https://api.github.com/repos/{org_name}/{repo_name}/pulls\"
        pr_params = {\"state\": \"all\", \"sort\": \"created\", \"direction\": \"desc\", \"per_page\": 100}
        try:
            prs_resp = requests.get(prs_url, headers=headers, params=pr_params)
            prs_resp.raise_for_status()
            prs = prs_resp.json()
        except requests.exceptions.RequestException as e:
            logger.error(f\"Failed to fetch PRs for {repo_name}: {e}\")
            continue
        for pr in prs:
            created_at = datetime.strptime(pr[\"created_at\"], \"%Y-%m-%dT%H:%M:%SZ\")
            if created_at.hour >= 18 or created_at.hour < 8:
                # Estimate 3 hours per after-hours PR
                toil_hours += 3
    return toil_hours

def get_pagerduty_toil(schedule_id, token):
    \"\"\"Fetch on-call toil: after-hours pages, incident response time.\"\"\"
    headers = {\"Authorization\": f\"Token token={token}\", \"Accept\": \"application/vnd.pagerduty+json;version=2\"}
    toil_hours = 0
    # Get incidents for last 7 days
    since = (datetime.utcnow() - timedelta(days=7)).isoformat()
    incidents_url = f\"https://api.pagerduty.com/incidents\"
    params = {\"since\": since, \"schedule_ids[]\": schedule_id, \"status\": \"resolved\", \"per_page\": 100}
    try:
        resp = requests.get(incidents_url, headers=headers, params=params)
        resp.raise_for_status()
        incidents = resp.json()[\"incidents\"]
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to fetch PagerDuty incidents: {e}\")
        return 0

    for incident in incidents:
        # Calculate time from triggered to resolved
        triggered = datetime.strptime(incident[\"triggered_at\"], \"%Y-%m-%dT%H:%M:%SZ\")
        resolved = datetime.strptime(incident[\"resolved_at\"], \"%Y-%m-%dT%H:%M:%SZ\")
        duration = (resolved - triggered).total_seconds() / 3600  # hours
        # Add 1 hour for post-incident review
        toil_hours += duration + 1
    return toil_hours

def get_slack_toil(channel, token):
    \"\"\"Fetch Slack toil: notification volume, after-hours messages.\"\"\"
    headers = {\"Authorization\": f\"Bearer {token}\", \"Content-type\": \"application/json\"}
    toil_hours = 0
    # Get messages from last 7 days
    oldest = int((datetime.utcnow() - timedelta(days=7)).timestamp())
    messages_url = \"https://slack.com/api/conversations.history\"
    params = {\"channel\": channel, \"oldest\": oldest, \"per_page\": 100}
    try:
        resp = requests.get(messages_url, headers=headers, params=params)
        resp.raise_for_status()
        messages = resp.json()[\"messages\"]
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to fetch Slack messages: {e}\")
        return 0

    for msg in messages:
        # Count messages sent between 18:00 and 08:00 UTC
        msg_time = datetime.fromtimestamp(float(msg[\"ts\"]))
        if msg_time.hour >= 18 or msg_time.hour < 8:
            # Estimate 5 minutes per after-hours message to respond
            toil_hours += 5 / 60
    return toil_hours

def calculate_metrics(github_toil, pd_toil, slack_toil):
    \"\"\"Calculate total toil and generate report.\"\"\"
    total_toil = github_toil + pd_toil + slack_toil
    report = f\"\"\"Toil Audit Report (Last 7 Days)
================================
GitHub Toil: {github_toil:.2f} hours
PagerDuty Toil: {pd_toil:.2f} hours
Slack Toil: {slack_toil:.2f} hours
Total Toil: {total_toil:.2f} hours
\"\"\"
    return report

if __name__ == \"__main__\":
    github_toil = get_github_toil(ORG_NAME, GITHUB_TOKEN)
    pd_toil = get_pagerduty_toil(PD_SCHEDULE_ID, PAGERDUTY_TOKEN)
    slack_toil = get_slack_toil(SLACK_CHANNEL, SLACK_TOKEN)
    report = calculate_metrics(github_toil, pd_toil, slack_toil)
    print(report)
    # Post to Slack
    try:
        slack_resp = requests.post(
            \"https://slack.com/api/chat.postMessage\",
            headers=SLACK_HEADERS,
            json={\"channel\": SLACK_CHANNEL, \"text\": report}
        )
        slack_resp.raise_for_status()
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to post report to Slack: {e}\")

const { WebClient } = require('@slack/web-api');
const { google } = require('googleapis');
const dotenv = require('dotenv');
const cron = require('node-cron');
const fs = require('fs');

dotenv.config();

const slackClient = new WebClient(process.env.SLACK_BOT_TOKEN);
const calendar = google.calendar({ version: 'v3', auth: new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.GOOGLE_REDIRECT_URI
)});

// Load Google OAuth tokens
const tokens = JSON.parse(fs.readFileSync('google-tokens.json', 'utf8'));
calendar.context._options.auth.setCredentials(tokens);

const FOCUS_LABEL = 'Focus Block';
const CHECK_INTERVAL = '*/15 * * * *'; // Every 15 minutes

async function getFocusBlocks(userId) {
  // Fetch user's calendar events for next 24 hours labeled Focus Block
  const now = new Date();
  const end = new Date(now.getTime() + 24 * 60 * 60 * 1000);
  try {
    const res = await calendar.events.list({
      calendarId: 'primary',
      timeMin: now.toISOString(),
      timeMax: end.toISOString(),
      maxResults: 10,
      singleEvents: true,
      orderBy: 'startTime',
    });
    return res.data.items.filter(event => event.summary.includes(FOCUS_LABEL));
  } catch (err) {
    console.error(`Failed to fetch calendar for ${userId}:`, err);
    return [];
  }
}

async function setSlackFocusMode(userId, isFocus) {
  try {
    if (isFocus) {
      // Set status to Focus Mode, snooze notifications for 1 hour
      await slackClient.users.profile.set({
        user: userId,
        profile: JSON.stringify({
          status_text: 'Focus Mode: Do Not Disturb',
          status_emoji: ':focus:',
          status_expiration: Math.floor(Date.now() / 1000) + 3600,
        }),
      });
      await slackClient.dnd.setSnooze({ num_minutes: 60 });
      console.log(`Set ${userId} to Focus Mode`);
    } else {
      // Clear status, end snooze
      await slackClient.users.profile.set({
        user: userId,
        profile: JSON.stringify({
          status_text: '',
          status_emoji: '',
          status_expiration: 0,
        }),
      });
      await slackClient.dnd.endSnooze();
      console.log(`Cleared Focus Mode for ${userId}`);
    }
  } catch (err) {
    console.error(`Failed to update Slack for ${userId}:`, err);
  }
}

async function checkFocusMode() {
  // Get all active users in Slack channel
  try {
    const usersResp = await slackClient.conversations.members({ channel: process.env.SLACK_CHANNEL_ID });
    const users = usersResp.members;
    for (const userId of users) {
      const focusBlocks = await getFocusBlocks(userId);
      const hasActiveFocus = focusBlocks.some(block => {
        const start = new Date(block.start.dateTime);
        const end = new Date(block.end.dateTime);
        return start <= new Date() && end >= new Date();
      });
      await setSlackFocusMode(userId, hasActiveFocus);
    }
  } catch (err) {
    console.error('Failed to check focus mode:', err);
  }
}

// Run every 15 minutes
cron.schedule(CHECK_INTERVAL, checkFocusMode);
// Initial run
checkFocusMode();

import os
import json
import requests
from datetime import datetime, timedelta
from dotenv import load_dotenv
import logging

load_dotenv()

GITHUB_TOKEN = os.getenv(\"GITHUB_TOKEN\")
SLACK_TOKEN = os.getenv(\"SLACK_TOKEN\")
STANDUP_REPO = os.getenv(\"STANDUP_REPO\")  # e.g., \"org/standups\"
SLACK_CHANNEL = os.getenv(\"SLACK_CHANNEL\")

logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(levelname)s - %(message)s\")
logger = logging.getLogger(__name__)

GITHUB_HEADERS = {\"Authorization\": f\"token {GITHUB_TOKEN}\", \"Accept\": \"application/vnd.github.v3+json\"}
SLACK_HEADERS = {\"Authorization\": f\"Bearer {SLACK_TOKEN}\", \"Content-type\": \"application/json\"}

STANDUP_TEMPLATE = \"\"\"
## Yesterday
- 

## Today
- 

## Blockers
- 
\"\"\"

def check_standup_compliance():
    \"\"\"Check if all engineers have submitted standup updates by 09:30 UTC.\"\"\"
    # Get all open standup issues from today
    today = datetime.utcnow().date().isoformat()
    issues_url = f\"https://api.github.com/repos/{STANDUP_REPO}/issues\"
    params = {\"state\": \"open\", \"labels\": \"standup\", \"since\": f\"{today}T00:00:00Z\", \"per_page\": 100}
    try:
        resp = requests.get(issues_url, headers=GITHUB_HEADERS, params=params)
        resp.raise_for_status()
        issues = resp.json()
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to fetch standup issues: {e}\")
        return []

    # Get all engineers in org
    engineers_url = f\"https://api.github.com/orgs/{STANDUP_REPO.split('/')[0]}/members\"
    try:
        eng_resp = requests.get(engineers_url, headers=GITHUB_HEADERS, params={\"per_page\": 100})
        eng_resp.raise_for_status()
        engineers = eng_resp.json()
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to fetch engineers: {e}\")
        return []

    submitted = [issue[\"user\"][\"login\"] for issue in issues]
    missing = [eng[\"login\"] for eng in engineers if eng[\"login\"] not in submitted]

    # Post reminder to Slack for missing engineers
    if missing:
        message = f\"⚠️ Standup missing for: {', '.join(missing)}. Submit by 10:00 UTC to avoid toil flag.\"
        try:
            slack_resp = requests.post(
                \"https://slack.com/api/chat.postMessage\",
                headers=SLACK_HEADERS,
                json={\"channel\": SLACK_CHANNEL, \"text\": message}
            )
            slack_resp.raise_for_status()
        except requests.exceptions.RequestException as e:
            logger.error(f\"Failed to post Slack reminder: {e}\")

    return missing

def aggregate_standups():
    \"\"\"Aggregate all standup updates and post to Slack.\"\"\"
    today = datetime.utcnow().date().isoformat()
    issues_url = f\"https://api.github.com/repos/{STANDUP_REPO}/issues\"
    params = {\"state\": \"open\", \"labels\": \"standup\", \"since\": f\"{today}T00:00:00Z\", \"per_page\": 100}
    try:
        resp = requests.get(issues_url, headers=GITHUB_HEADERS, params=params)
        resp.raise_for_status()
        issues = resp.json()
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to fetch standups: {e}\")
        return

    if not issues:
        logger.info(\"No standups to aggregate\")
        return

    aggregated = f\"*Daily Standup Aggregation: {today}*\n\n\"
    for issue in issues:
        user = issue[\"user\"][\"login\"]
        body = issue[\"body\"]
        aggregated += f\"*@{user}*\n{body}\n\n\"

    # Calculate time saved vs synchronous standup: 15 mins per engineer
    time_saved = len(issues) * 15
    aggregated += f\"\n*Total time saved: {time_saved} minutes (vs synchronous standup)*\"

    try:
        slack_resp = requests.post(
            \"https://slack.com/api/chat.postMessage\",
            headers=SLACK_HEADERS,
            json={\"channel\": SLACK_CHANNEL, \"text\": aggregated}
        )
        slack_resp.raise_for_status()
    except requests.exceptions.RequestException as e:
        logger.error(f\"Failed to post aggregated standup: {e}\")

if __name__ == \"__main__\":
    missing = check_standup_compliance()
    if not missing:
        aggregate_standups()
    else:
        logger.warning(f\"Missing standups from {len(missing)} engineers\")

// Jira API snippet to check toil hours for a user
const axios = require('axios');
const JIRA_TOKEN = process.env.JIRA_TOKEN;
const JIRA_URL = process.env.JIRA_URL;

async function getToilHours(userKey, sprintId) {
  const response = await axios.get(
    `${JIRA_URL}/rest/api/3/search`,
    {
      headers: { Authorization: `Bearer ${JIRA_TOKEN}` },
      params: {
        jql: `assignee=${userKey} AND sprint=${sprintId} AND labels=toil`,
        fields: 'timeoriginalestimate,timespent'
      }
    }
  );
  return response.data.issues.reduce((total, issue) => {
    return total + (issue.fields.timespent || 0) / 3600; // Convert seconds to hours
  }, 0);
}

// Google Calendar API snippet to list focus blocks
const { google } = require('googleapis');
const calendar = google.calendar({ version: 'v3', auth: /* auth client */ });

async function listFocusBlocks(userId) {
  const res = await calendar.events.list({
    calendarId: 'primary',
    timeMin: new Date().toISOString(),
    timeMax: new Date(Date.now() + 86400000).toISOString(),
    q: 'Focus Block', // Search for events with \"Focus Block\" in title
    maxResults: 10,
  });
  return res.data.items;
}

// Google Workspace API snippet to decline Wednesday meetings
const { google } = require('googleapis');
const calendar = google.calendar({ version: 'v3', auth: /* auth client */ });

async function declineWednesdayMeetings(userId) {
  const wednesday = new Date();
  wednesday.setDate(wednesday.getDate() + (3 - wednesday.getDay())); // Next Wednesday
  const start = new Date(wednesday.setHours(0,0,0,0)).toISOString();
  const end = new Date(wednesday.setHours(23,59,59,999)).toISOString();

  const res = await calendar.events.list({
    calendarId: 'primary',
    timeMin: start,
    timeMax: end,
  });

  for (const event of res.data.items) {
    if (!event.summary.includes('on-call-handoff')) {
      await calendar.events.patch({
        calendarId: 'primary',
        eventId: event.id,
        resource: {
          attendees: event.attendees.map(att => ({
            ...att,
            responseStatus: 'declined',
            comment: 'No-meeting Wednesday policy: please reschedule.'
          }))
        }
      });
    }
  }
}

2026-toolkit/
├── toil-audit/
│   ├── requirements.txt
│   ├── .env.example
│   └── audit.py
├── slack-focus-enforcer/
│   ├── package.json
│   ├── .env.example
│   ├── google-tokens.json.example
│   └── index.js
├── async-standup/
│   ├── requirements.txt
│   ├── .env.example
│   └── standup.py
├── jira-toil-budget/
│   ├── package.json
│   └── budget.js
├── calendar-sync/
│   ├── package.json
│   └── sync.js
└── README.md