Framework Overview

"What gets observed becomes measurable. What gets measured becomes manageable."

The HEAT Framework transforms invisible effort into observable signals through a lightweight tagging system. Like cormorants foraging beneath the surface, HEAT dives deep to discover patterns traditional time tracking completely misses.

Framework Architecture

Core Components

1. Tagging System (Input Layer)

The foundation of HEAT is lightweight metadata capture:

Work Type Tags

Tag	Purpose	Typical Intensity	Business Value
Feature	New functionality	x2-x4	Innovation work (desired)
Bug	Defect fixing	x3-x6	Quality maintenance
Blocker	Stuck, needs investigation	x5-x10	Friction signal (reduce)
Support	Helping others	x1-x2	Coordination overhead
Config	Environment/tooling	x1-x3	Shadow work (automate)
Research	Exploration	x3-x7	Strategic investment

Intensity Multipliers

Scale	Meaning	Physical Sensation	When to Use
x1	Routine	Easy, autopilot	Task done 100+ times before
x2-x3	Moderate	Normal focus	Standard feature work
x5-x7	Heavy	Deep concentration	Complex problem-solving
x8-x10	High Load	Mentally exhausting	Grinding, stuck, crisis mode

Example:

Task: Fix SQL performance regression
Tags: Blocker, SQL, x8 (spent 4 hours, still no root cause — drained)

Task: Review PR for UI component
Tags: Support, UI, x1 (familiar code, 10-minute review — effortless)

→ Learn more: Observable Signals

2. Intensity Aggregation (Processing Layer)

HEAT sums intensity multipliers, not hours:

Daily Effort Calculation:
├── Task A (10:00 AM): SQL debugging (x8 intensity)
├── Task B (2:00 PM): Feature work (x3 intensity)
├── Task C (4:00 PM): PR review (x1 intensity)
└── Total Daily Intensity: 12 units

Heatmap Color:
├── < 5 units: 🟦 Blue (Cool - light day)
├── 5-15 units: 🟩 Green (Normal workload)
├── 15-30 units: 🟨 Amber (Heavy load)
├── 30+ units: 🟥 Red (Burnout risk)
└── This example: 12 units = 🟩 Green (normal)

Key Insight: Two developers can both log "8 hours" but have wildly different effort:

Developer	Hours Logged	Intensity Total	Heatmap Color
Alice	8 hours	6 units (x1 tasks all day)	🟦 Cool
Bob	8 hours	42 units (stuck on x8 blocker)	🟥 Critical

Traditional view: Both worked 8 hours — equal effort. HEAT view: Bob is burning out, Alice is coasting.

3. Pain Streak Algorithm (Pattern Detection)

The Pain Streak is HEAT's most powerful early warning system.

How It Works

typescript

Pain Streak Detection:
├── IF (User logs Tag 'T' on Task 'X' today)
├── AND (User logged same Tag 'T' on same Task 'X' yesterday)
├── THEN Streak_Count += 1
└── Visual: 🔥 Streak: N days

Example:
Monday: Fix payment bug (Blocker, SQL, x7)
Tuesday: Fix payment bug (Blocker, SQL, x8) 🔥 Streak: 2 days
Wednesday: Fix payment bug (Blocker, SQL, x9) 🔥 Streak: 3 days
Thursday: Manager intervention: Pair with senior developer
Friday: Payment bug resolved (final x2 cleanup)

Why It Matters

Scenario	Timesheet Shows	HEAT Reveals	Action Taken
Developer stuck 5 days	"Worked on Feature X"	🔥 Streak: 5 days, x8 intensity	Pair programming assigned
Developer grinding silently	"40 hours logged"	🔥 Streak: 7 days on same blocker	Root cause escalation
Knowledge bottleneck	"Productive week"	Same person, 🔥 Streak on critical module	Cross-training initiated

Business Value: Catches silent failure before resignation notice.

→ Learn more: Pain Streak Algorithm

4. The Three Views (Output Layer)

HEAT generates three perspectives from the same data:

Developer View (Personal Board)

What you see:

Your own heatmap (Am I balanced?)
Your streaks (Am I stuck?)
Tag distribution (What am I actually doing?)

Use case: Self-awareness and planning.

Example:

Your Week:
├── Monday: 12 intensity (🟩 Normal)
├── Tuesday: 28 intensity (🟨 Heavy) — 🔥 Streak: 2 days on API blocker
├── Wednesday: 34 intensity (🟥 Critical) — 🔥 Streak: 3 days
├── Thursday: 8 intensity (🟦 Cool) — Blocker resolved!
└── Friday: 14 intensity (🟩 Normal)

Insight: Tuesday-Wednesday were brutal. Take it easy next week.

Manager View (Team Heatmap)

What you see:

Effort concentration across team
🔥 Burnout risk flags
Bus factor warnings (single person on critical work)
Project filtering (isolate by billing code)

Use case: Proactive intervention.

Example:

Team Heatmap (This Week):
├── Alice: 48 intensity (🟥 Critical) — 🔥 Streak: 4 days on Payment module
├── Bob: 12 intensity (🟩 Normal) — Balanced across Feature + Support
├── Carol: 22 intensity (🟨 Heavy) — No streaks, just heavy load
└── Action: Pair Bob with Alice on Payment module tomorrow

Tag Analysis View (Strategic Trends)

What you see:

Global aggregation (What is the team doing?)
Daily vs Weekly toggle
Drill-down (click tag → see all contributors)

Use case: Identify systemic issues.

Example:

Team Tag Analysis (This Week):
├── Feature: 140 intensity (desired)
├── Blocker: 280 intensity (🔴 Alert: 2× normal)
├── Config: 120 intensity (🟡 Warning: Environment issues?)
├── Support: 45 intensity (normal)
└── Insight: Blocker spike = systemic problem, not individual performance
   Action: Root cause analysis — likely recent deployment broke something

→ Learn more: The Three Views

How HEAT Prevents Burnout

Traditional Approach (Reactive)

Cost: Turnover (50-200% of salary), knowledge loss, team morale hit.

HEAT Approach (Proactive)

Savings: Retention, sustained productivity, team trust.

Integration Architecture

HEAT uses a Sidecar Architecture — it integrates with existing PM systems without modifying them:

┌─────────────────────────────────────────────────────────────┐
│  EXISTING SYSTEM (Read-Only)                                │
│  └─ Jira / ADO / Easy Projects                              │
│     └─ Source for Task IDs and Titles                       │
├─────────────────────────────────────────────────────────────┤
│  HEAT COLLECTOR (Browser Extension / Overlay)               │
│  └─ Reads active Task ID from DOM                           │
│  └─ Provides lightweight tagging UI (30 sec)                │
│  └─ Handles streak logic and local caching                  │
├─────────────────────────────────────────────────────────────┤
│  HEAT DASHBOARD (Web Application)                           │
│  └─ Developer View: Personal effort board                   │
│  └─ Manager View: Team heatmaps + alerts                    │
│  └─ Tag Analysis: Global trends                             │
└─────────────────────────────────────────────────────────────┘

Key Benefit: If Jira goes down, HEAT remains active — developers continue tagging against cached tasks.

→ Learn more: Integration Architecture

What HEAT Measures vs. What It Doesn't

HEAT Measures	HEAT Does NOT Measure
Cognitive load intensity	Exact hours worked
Effort concentration patterns	Individual productivity scores
Burnout risk signals	Performance ratings
Knowledge distribution	Billable vs non-billable time
Context switching fragmentation	Keystroke analytics
Team health observables	Individual surveillance metrics

Philosophy: HEAT is a team health telemetry layer, not a surveillance tool.

Industry Alignment

HEAT follows proven patterns:

Framework	What They Track	HEAT Equivalent
Google SRE Toil	Toil vs Engineering ratio (<50% target)	Support + Config vs Feature ratio
Spotify Squad Health	Team health via traffic-light signals	Heatmap intensity thresholds
DORA Metrics	Outcomes, not inputs	Patterns, not hours
Microsoft DevDiv	Context switching cost research	Context Switching Score

"All these frameworks exist parallel to timesheets because hours don't reveal effort. HEAT follows the same proven principle."

Using the Framework

Daily Workflow (Developer)

Morning: Preview tasks, estimate intensity (30 sec)
End of day: Update intensity based on experience (30 sec)
Friday: Review personal heatmap (5 min)

Weekly Workflow (Manager)

Monday: Review team heatmap from last week (15 min)
Mid-week: Check for 🔥 streak alerts, intervene if needed (5 min)
Sprint planning: Use heatmap data to inform capacity estimates

Monthly Workflow (Leadership)

Tag Analysis: Review global trends (What is the team doing?)
Bus Factor Report: Identify knowledge concentration risks
KTLO Ratio: Measure Feature vs Support+Config (innovation capacity)

Real-World Example

Scenario: Mid-size engineering team (25 developers)

Before HEAT

Manager's view:
├── "Team is working hard" (based on late-night Slack messages)
├── "Alice seems stressed" (anecdotal observation)
├── "Bob quit last month" (surprise — no early warning)
└── Action: Reactive firefighting

After HEAT

Manager's dashboard:
├── Alice: 🔥 Streak: 5 days on Payment module, 42 intensity (🟥 Critical)
├── Carol: 🔥 Streak: 3 days on Auth service, 28 intensity (🟨 Heavy)
├── Dave: 38 intensity (🟥 Critical) — No streak, but overloaded
├── Bus Factor Alert: Payment module = Alice only (knowledge silo)
└── Action:
    1. Pair Bob (low load) with Alice on Payment (immediate)
    2. Assign Carol's Auth blocker to senior developer
    3. Redistribute Dave's upcoming tasks to rest of team
    4. Schedule Payment module knowledge transfer session

Outcome:

Alice's streak ends Day 6 (resolved with help)
Carol's blocker resolved Day 4
Dave's load normalized
No resignations
Payment module now has 2 people who understand it (Bus Factor: 2)

Next Steps

👁️ Observable Signals — What to track and where to find it

🔥 Pain Streak Algorithm — Deep dive on burnout detection

📊 The Three Views — Developer, Manager, Tag Analysis dashboards

🏗️ Integration Architecture — How HEAT integrates with existing systems

"Traditional tools track time. HEAT tracks reality." 🔥

Framework Overview ​

Framework Architecture ​

Core Components ​

1. Tagging System (Input Layer) ​

Work Type Tags ​

Intensity Multipliers ​

2. Intensity Aggregation (Processing Layer) ​

3. Pain Streak Algorithm (Pattern Detection) ​

How It Works ​

Why It Matters ​

4. The Three Views (Output Layer) ​

Developer View (Personal Board) ​

Manager View (Team Heatmap) ​

Tag Analysis View (Strategic Trends) ​

How HEAT Prevents Burnout ​

Traditional Approach (Reactive) ​

HEAT Approach (Proactive) ​

Integration Architecture ​

What HEAT Measures vs. What It Doesn't ​

Industry Alignment ​

Using the Framework ​

Daily Workflow (Developer) ​

Weekly Workflow (Manager) ​

Monthly Workflow (Leadership) ​

Real-World Example ​

Before HEAT ​

After HEAT ​

Next Steps ​

Framework Overview

Framework Architecture

Core Components

1. Tagging System (Input Layer)

Work Type Tags

Intensity Multipliers

2. Intensity Aggregation (Processing Layer)

3. Pain Streak Algorithm (Pattern Detection)

How It Works

Why It Matters

4. The Three Views (Output Layer)

Developer View (Personal Board)

Manager View (Team Heatmap)

Tag Analysis View (Strategic Trends)

How HEAT Prevents Burnout

Traditional Approach (Reactive)

HEAT Approach (Proactive)

Integration Architecture

What HEAT Measures vs. What It Doesn't

Industry Alignment

Using the Framework

Daily Workflow (Developer)

Weekly Workflow (Manager)

Monthly Workflow (Leadership)

Real-World Example

Before HEAT

After HEAT

Next Steps