Form 1: State-Repair. Form 2: Wasteful Report.
A Metered Heart beats on a clock. Not on need. Not on change. On a timer.
Two forms, one root cause: a scheduled job substituting for correct design.
Form 1: State-Repair
A state transition fails to complete atomically. Instead of fixing the transition, a background job runs on a delay & reconciles. Users see broken state during the reconciliation window.
GitHub example (2026-04-08): A pull request's upstream repository went private. GitHub attempted a state transition: close the PR, update the branch status, clear the merge status. The transition did not complete atomically. PR status showed 'branch-forced-closed' & 'Merge status cannot be loaded' simultaneously. A Sidekiq background job ran minutes later & completed the reconciliation. Observers saw broken state for the duration of the window.
The Metered Heart: the Sidekiq job ran on a schedule. It did not run because GitHub detected broken state; it ran because the timer fired. A user watching the PR in real time saw a PR that contradicted itself until the next job execution.
Form 2: Wasteful Report
A report or aggregation recomputes from scratch on a fixed interval. No cache check. No idempotency guard. No incremental update. Every execution: a full scan.
Examples: a nightly cron job that recomputes each user's total purchase amount by scanning all orders from the beginning of time. A daily analytics job that regenerates a dashboard from raw event logs. A weekly summary email that queries every row in the activity table.
Each fires whether or not data changed since the last execution. Each scans full history even when only the last 24 hours contain new data. Each substitutes scheduled repetition for incremental design.
The Shared Root
A Metered Heart cannot tell the truth about its own state. It only knows the clock. Form 1: the state repair job runs at T+5 minutes regardless of whether the state is broken at T+0. Form 2: the report job runs at 2 AM regardless of whether any data changed since yesterday.
The clock does not carry information about what needs doing. An event carries that information: 'a state transition just failed,' 'new orders just arrived.' A Metered Heart throws that information away & replaces it with a schedule.
Capital Drain
A Metered Heart drains living capital: engineers on call for broken-state incidents. Erodes social trust: users see inconsistent data & report defects that resolve themselves. Amplifies other MOADs: a state-repair job that scans all records to find broken state often contains MOAD-0001 (O(N²) scan). A report job that recomputes cold may trigger MOAD-0005 (cache stampede). MOAD-0009 compounds other defects.
The Shared Root
Form 1 & Form 2 appear different on the surface: one repairs state, one recomputes data. The root cause connects them.
Fire on Change, Not on Clock
Event-driven design fires when something changes. The state change is the event. The event is the trigger.
Form 1: the atomic transition replaces the repair job.
If a state transition can leave the system in a broken intermediate state, the defect lives in the transition, not in its absence of a repair job. Fix the transition to complete atomically (or transactionally). When the transition completes atomically, broken state never exists. The repair job has nothing to repair.
# DEFECT: non-atomic transition leaves broken state
def close_pr_on_repo_private(pr_id):
pr = PR.get(pr_id)
pr.status = 'branch-forced-closed' # step 1: partial state
pr.save() # visible to users NOW
# ... other steps may fail ...
pr.merge_status = 'not_applicable'
pr.save() # step 2: now consistent
# Sidekiq job reconciles if step 2 fails# FIX: atomic transition; no intermediate state visible
def close_pr_on_repo_private(pr_id):
with db.transaction():
pr = PR.get(pr_id)
pr.status = 'branch-forced-closed'
pr.merge_status = 'not_applicable'
pr.save() # both fields commit atomically; never half-writtenForm 2: the incremental update replaces the full recompute.
A report that recomputes from scratch fires because old data + new data = new result. But the old result + delta = same new result, computed incrementally. The event: new data arrived. The trigger: update the aggregate for the new data only.
# DEFECT: full recompute on schedule
def nightly_totals_job():
for user in all_users():
total = sum(o.amount for o in user.orders) # scan all time
user.total_purchases = total
user.save()
# FIX: event-driven incremental update
def on_order_placed(order):
order.user.total_purchases += order.amount # delta only
order.user.save()The incremental update fires when an order arrives, not at 2 AM. It updates only the affected user. It reads only the new order, not all orders from all time. The nightly job disappears.
Why Form 1 Reveals a Broken Transition
A Form 1 Metered Heart reveals that a state transition was left incomplete. The repair job exists because an engineer noticed broken state & added a reconciliation mechanism rather than fixing the transition. The repair job: a patch over a broken architectural decision.
MOAD-0009 as Amplifier
MOAD-0009 amplifies other MOADs. A state-repair job that scans all records to find broken state: MOAD-0001 (O(N) or O(N²) scan per job run). A report job that recomputes everything cold: MOAD-0005 (cache stampede when the job starts & hits a warm upstream). MOAD-0009 does not just harm by itself; it delivers other MOADs on a schedule.
Diagnose & Redesign
A team runs a nightly cron job at 2 AM. The job scans all orders for all users & recomputes each user's total purchase amount from scratch. The job takes 4 hours. By 6 AM, the dashboard shows fresh totals. Between 2 AM & 6 AM, the dashboard shows yesterday's totals.