e a visible indicator (status message, physical sign) that you are in a Deep Work block.

Code Examples

A. OS-Level Focus Mode Script

This shell script automates context isolation on macOS. It sets Focus modes, updates Slack status, and blocks distracting domains via /etc/hosts.

#!/bin/bash
# focus-mode.sh
# Usage: ./focus-mode.sh [deep-work|admin|break]

MODE=$1
HOSTS_FILE="/etc/hosts"
BACKUP_FILE="/etc/hosts.backup"

# Backup hosts file if not exists
if [ ! -f "$BACKUP_FILE" ]; then
    sudo cp "$HOSTS_FILE" "$BACKUP_FILE"
fi

# Restore original hosts
sudo cp "$BACKUP_FILE" "$HOSTS_FILE"

case $MODE in
    deep-work)
        # Set macOS Focus Mode
        osascript -e 'tell application "System Events" to tell process "Control Center" to click menu bar item "Focus" of menu bar 1'
        
        # Block distractions
        echo "0.0.0.0 twitter.com" | sudo tee -a "$HOSTS_FILE" > /dev/null
        echo "0.0.0.0 reddit.com" | sudo tee -a "$HOSTS_FILE" > /dev/null
        echo "0.0.0.0 news.ycombinator.com" | sudo tee -a "$HOSTS_FILE" > /dev/null
        
        # Update Slack Status
        curl -X POST -H 'Authorization: Bearer $SLACK_TOKEN' \
        -d '{"status_emoji":":coding:","status_text":"Deep Work | Back at 12:00"}' \
        https://slack.com/api/users.profile.set
        
        echo "✅ Deep Work Mode Active"
        ;;
    admin)
        # Allow all, set admin status
        curl -X POST -H 'Authorization: Bearer $SLACK_TOKEN' \
        -d '{"status_emoji":":email:","status_text":"Admin & Support"}' \
        https://slack.com/api/users.profile.set
        echo "✅ Admin Mode Active"
        ;;
    *)
        echo "Usage: $0 [deep-work|admin|break]"
        exit 1
        ;;
esac

B. Automated Support Triage Bot

A Python snippet using a simple keyword matching algorithm to categorize incoming support emails and auto-reply.

import re
import smtplib
from email.message import EmailMessage

def triage_ticket(subject, body):
    score = 0
    category = "general"
    
    # Keyword weighting for bug detection
    bug_keywords = ["error", "crash", "bug", "broken", "500", "404"]
    urgency_keywords = ["urgent", "production", "down", "lost data"]
    
    text = (subject + " " + body).lower()
    
    for kw in bug_keywords:
        if re.search(r'\b' + kw + r'\b', text):
            score += 10
            category = "bug"
            
    for kw in urgency_keywords:
        if re.search(r'\b' + kw + r'\b', text):
            score += 20
            
    # Decision Logic
    if score >= 20:
        # High urgency: Create PagerDuty ticket or SMS alert
        create_alert(subject, body)
        return auto_reply("P1 Incident", "Your report has been escalated to our engineering team immediately.")
    elif category == "bug":
        # Standard bug: Add to GitHub Issues
        create_github_issue(subject, body)
        return auto_reply("Bug Ack", "Thanks! We've logged this. You'll get an update when it's fixed.")
    else:
        # General: Queue for admin block
        queue_for_later(subject, body)
        return auto_reply("Received", "We'll review your message during our next support batch.")

def auto_reply(category, message):
    # Implementation to send email reply
    pass

Architecture Decisions

1. Push vs. Pull Notifications:

   • Decision: Switch all non-critical notifications to Pull.
   • Rationale: Push notifications force context switches. Configure Slack, Email, and Social Media to be checked only during the Admin Block. Use desktop notifications only for PagerDuty/Statuspage alerts.

2. Stateless vs. Stateful Task Management:

   • Decision: Use a Stateful system with context tags.
   • Rationale: A flat list of tasks loses context. Tasks should be tagged with @dev, @marketing, @support. When in Deep Work, only @dev tasks are visible. This reduces cognitive load by filtering irrelevant state.

3. Time Boxing Granularity:

   • Decision: 90-minute blocks minimum.
   • Rationale: Ultradian rhythms suggest human focus peaks in 90-minute cycles. 25-minute Pomodoros are insufficient for complex debugging or architecture work.

Pitfall Guide

1. The Tooling Trap: Spending more time configuring your productivity app than doing the work. Fix: If a tool takes >30 minutes to set up, it's likely over-engineered. Use simple text files or native OS features.
2. Context Bleeding: Checking email "just for a second" during coding. Fix: Enforce hard boundaries. If you check email during Deep Work, you have broken the block. Log the violation and analyze the trigger.
3. Optimizing for Busyness: Feeling productive because you cleared 50 emails but shipped no code. Fix: Measure output by shipped features and revenue, not tasks completed.
4. Ignoring Maintenance Windows: Failing to schedule time for system updates, library upgrades, and tech debt. Fix: Allocate 15% of weekly capacity to maintenance. Unplanned tech debt leads to catastrophic latency later.
5. The "Quick Reply" Fallacy: Believing a 2-minute reply costs only 2 minutes. Fix: Remember the 23-minute refocus tax. Batch replies.
6. No Kill Switch: Continuing to work on a feature or project that isn't gaining traction. Fix: Define clear metrics for success. If a project doesn't meet KPIs by a deadline, kill or pivot. Time spent on dead projects is unrecoverable.
7. Neglecting Recovery: Treating sleep and downtime as optional. Fix: Sleep is the garbage collection for your brain. Chronic sleep deprivation degrades cognitive performance equivalent to being intoxicated. Schedule recovery as non-negotiable blocks.

Production Bundle

Action Checklist

• Audit Current State: Track time spent for 3 days. Categorize by activity and context switches.
• Define Cron Jobs: Write down your daily time blocks. Treat them as immutable schedule entries.
• Implement OS Blocking: Install the focus-mode.sh script or equivalent domain blocker.
• Configure Triage: Set up auto-responders for support and email filters for newsletters.
• Establish SLA: Update your website and social bios with response time expectations.
• Create Context Snapshots: Adopt the habit of writing "Next Step" notes before switching contexts.
• Schedule Review: Block 30 minutes weekly to review metrics and adjust time blocks.

Decision Matrix

Configuration Template

Copy this JSON structure to define your time blocks. Use this with a task runner or scheduler.

{
  "runtime": {
    "timezone": "UTC",
    "blocks": [
      {
        "id": "deep-work",
        "start": "09:00",
        "end": "12:00",
        "type": "maker",
        "permissions": {
          "slack": false,
          "email": false,
          "internet": "restricted"
        },
        "focus_script": "./focus-mode.sh deep-work"
      },
      {
        "id": "admin",
        "start": "13:00",
        "end": "14:00",
        "type": "manager",
        "permissions": {
          "slack": true,
          "email": true,
          "internet": "full"
        },
        "focus_script": "./focus-mode.sh admin"
      },
      {
        "id": "build-ship",
        "start": "14:00",
        "end": "16:00",
        "type": "maker",
        "permissions": {
          "slack": false,
          "email": false,
          "internet": "full"
        }
      }
    ]
  }
}

Quick Start Guide

1. Install the Blocker: Deploy the domain blocking script on your machine. Set it to run automatically at 09:00.
2. Set the Calendar: Create recurring events for your Deep Work and Admin blocks. Mark them as "Busy" and "Focus Time."
3. Automate Triage: Configure your support inbox with the auto-reply template. Set up email filters to archive non-urgent mail.
4. Execute: For the next 5 days, strictly adhere to the blocks. Do not break character. If a distraction arises, log it and handle it in the Admin block.
5. Review: On Day 6, compare your commit velocity and feature cycle time against your baseline. Iterate on block durations.

Time management for indie hackers is not about working harder; it's about reducing the latency between intention and execution. By treating your cognitive runtime as a system to be optimized, you can achieve the throughput of a team while maintaining the agility of a solo developer.