Engineering Iron Discipline: A Zero-Backend Progressive Calisthenics PWA

1. The Problem with Cloud-Tethered Fitness Trackers

I have trained calisthenics and weighted bodyweight movements for over eight years. In that time, I have watched fitness tracking software evolve in the wrong direction. What should be a fast, distraction-free logging tool has transformed into a heavy social network with video feeds, locked paywalls, and constant network synchronization.

The breaking point occurred during winter training in a subterranean calisthenics gym with zero cellular reception. A commercial tracking app hung on a loading spinner trying to sync analytics, failed to record three sets of weighted dips, and wiped my active session state when the browser tab crashed. Logging a set of push-ups should never require a round-trip HTTP request to a server in Virginia.

I set out to engineer Iron Discipline based on four architectural axioms:

• True Zero-Backend Privacy: All workout logs, progression metrics, and user profiles reside exclusively in the client's local IndexedDB instance. No servers, no tracking beacons, no analytics pixels.
• Instant Sub-100ms Startup: Pre-cached application shell and exercise assets that launch immediately even in airplane mode.
• Calisthenics-Specific Biomechanical Progression: Unlike barbell lifting where progress is simply adding 2.5kg plates, bodyweight training requires manipulating leverage (levers, angles, limb positioning), tempo, and mechanical advantage.
• Pure Web Standards: Built as an installable Progressive Web App (PWA) with zero App Store gatekeeping, functioning identically across iOS, Android, macOS, and Linux.

2. High-Level Architecture: The Local-First PWA Topology

Iron Discipline does not have an API server. It is a fully encapsulated, self-contained single-page progressive application. Below is the system flow depicting how the Service Worker intercepts network requests, manages client-side database transactions, and synthesizes audio without external assets.

┌────────────────────────────────────────────────────────────────────────┐
│                          USER INTERFACE LAYER                          │
│  ┌────────────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │ Active Workout Tracker │  │ Biomechanical   │  │ Wave Overload   │  │
│  │ Touch-Optimized Logger │  │ Exercise Graph  │  │ Volume Chart    │  │
│  └───────────┬────────────┘  └────────┬────────┘  └────────┬────────┘  │
└──────────────┼────────────────────────┼────────────────────┼───────────┘
               │ Reactive Events        │ DOM Mutations      │ Audio Triggers
┌──────────────▼────────────────────────▼────────────────────▼───────────┐
│                    CLIENT APPLICATION CORE (TypeScript)                │
│  ┌──────────────────────────────────┐ ┌──────────────────────────────┐ │
│  │   Progression Calculation Engine │ │   Web Audio API Synthesizer  │ │
│  │   - Leverage scaling formula     │ │   - 880Hz / 440Hz Beep Synth │ │
│  │   - RPE fatigue autoregulation   │ │   - Zero MP3/WAV audio lag   │ │
│  └──────────────────┬───────────────┘ └──────────────┬───────────────┘ │
│                     │                                │                 │
│  ┌──────────────────▼────────────────────────────────▼───────────────┐ │
│  │                     Local Database Abstraction (Dexie.js)         │ │
│  │  - Workouts Store   - Sets Store   - Exercise Graph   - Settings  │ │
│  └──────────────────────────────────┬────────────────────────────────┘ │
└─────────────────────────────────────┼──────────────────────────────────┘
                                      │ IndexedDB Atomic Transactions
┌─────────────────────────────────────▼──────────────────────────────────┐
│                   BROWSER STORAGE & SERVICE WORKER                     │
│  ┌──────────────────────────────────┐ ┌──────────────────────────────┐ │
│  │     IndexedDB (LevelDB Engine)   │ │  Workbox Service Worker      │ │
│  │     Encrypted Local Persistence  │ │  Cache-First App Shell       │ │
│  └──────────────────────────────────┘ └──────────────────────────────┘ │
└────────────────────────────────────────────────────────────────────────┘

3. Service Worker Strategy: Workbox Pre-Caching & Offline Routing

To guarantee that Iron Discipline opens instantly and never displays the "No Internet" dinosaur screen, I implemented a strict Service Worker strategy using Workbox. Static assets (HTML shell, CSS bundles, JS modules, iconography) are precached during the install lifecycle event and served via a Cache-First strategy with background cache invalidation.

// src/service-worker.ts
import { precacheAndRoute, cleanupOutdatedCaches } from 'workbox-precaching';
import { registerRoute, NavigationRoute } from 'workbox-routing';
import { CacheFirst, StaleWhileRevalidate } from 'workbox-strategies';
import { ExpirationPlugin } from 'workbox-expiration';

declare const self: ServiceWorkerGlobalScope;

// 1. Purge legacy cache buckets from previous application versions
cleanupOutdatedCaches();

// 2. Precache build manifest assets (compiled by Vite/Next build)
precacheAndRoute(self.__WB_MANIFEST);

// 3. Cache-First strategy for static media and fonts (1 year TTL)
registerRoute(
  ({ request }) =>
    request.destination === 'style' ||
    request.destination === 'script' ||
    request.destination === 'font' ||
    request.destination === 'image',
  new CacheFirst({
    cacheName: 'iron-static-v1',
    plugins: [
      new ExpirationPlugin({
        maxEntries: 150,
        maxAgeSeconds: 365 * 24 * 60 * 60, // 365 Days
      }),
    ],
  })
);

// 4. Stale-While-Revalidate for application metadata
registerRoute(
  ({ url }) => url.pathname.startsWith('/data/'),
  new StaleWhileRevalidate({
    cacheName: 'iron-data-v1',
  })
);

// 5. Navigation Fallback: Serve cached index.html for all SPA routes
const navigationRoute = new NavigationRoute(async () => {
  const cache = await caches.open('iron-static-v1');
  const cachedResponse = await cache.match('/index.html');
  return cachedResponse || fetch('/index.html');
});
registerRoute(navigationRoute);

// 6. Immediate activation on update
self.addEventListener('message', (event) => {
  if (event.data && event.data.type === 'SKIP_WAITING') {
    self.skipWaiting();
  }
});

4. The IndexedDB Storage Engine & Dexie.js Schema

While localStorage is synchronous and limited to 5MB of string data, IndexedDB provides an asynchronous, transactional, indexed NoSQL database capable of storing gigabytes of structured binary and JSON data. Iron Discipline utilizes Dexie.js as an ergonomic, type-safe wrapper over raw IndexedDB.

// src/db/iron-database.ts
import Dexie, { Table } from 'dexie';

export interface ExerciseRecord {
  id: string;
  slug: string;
  name: string;
  category: 'PUSH' | 'PULL' | 'LEGS' | 'CORE' | 'SKILL';
  difficulty: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
  progressionFamily: string; // e.g. "planche_progression"
  tierIndex: number;          // Position in the ladder (1=Tuck, 2=Adv Tuck, etc.)
  primaryMuscles: string[];
  secondaryMuscles: string[];
}

export interface WorkoutSetRecord {
  id: string;
  workoutId: string;
  exerciseId: string;
  setOrder: number;
  reps: number;
  addedWeightKg: number;    // Positive for weighted vest/belt, negative for band assist
  rpe: number;              // Rate of Perceived Exertion (1-10)
  tempoSeconds: [number, number, number, number]; // Eccentric, Pause, Concentric, Hold
  restDurationSeconds: number;
  completedAt: Date;
}

export interface WorkoutRecord {
  id: string;
  name: string;
  startedAt: Date;
  completedAt?: Date;
  notes?: string;
  totalVolumeLoadKg: number;
}

export class IronDisciplineDB extends Dexie {
  exercises!: Table;
  workouts!: Table;
  workoutSets!: Table;

  constructor() {
    super('IronDisciplineLocalDB');
    this.version(1).stores({
      exercises: 'id, slug, category, difficulty, progressionFamily, [progressionFamily+tierIndex]',
      workouts: 'id, startedAt, completedAt',
      workoutSets: 'id, workoutId, exerciseId, setOrder, [workoutId+exerciseId]',
    });
  }
}

export const db = new IronDisciplineDB();

5. Biomechanical Leverage Physics & Joint Torque Equations

In conventional barbell resistance training, calculating external workload is trivial: $\text{Workload} = \text{Mass} \times \text{Gravitational Acceleration} \times \text{Distance}$. Calisthenics, however, is fundamentally a discipline of angular physics and mechanical leverage. The external resistance experienced by a muscle group is governed not simply by body mass, but by the perpendicular distance between the joint rotation center and the center of mass (the lever arm).

Iron Discipline mathematically models the biomechanical leverage demands across every exercise in the progression ladder using classical rigid-body moment equilibrium equations:

Joint Moment Torque Equation:
  τ_joint = F_g × r_lever × sin(θ)
Where:
  F_g     = Total body gravitational force (m_body × 9.81 m/s²)
  r_lever = Perpendicular distance from glenohumeral / elbow joint center to body COM
  θ       = Angle of body relative to horizontal plane
  τ_joint = Muscular torque demand (Newton-meters) required to resist rotational collapse

Lever Arm Expansion Ratio (Planche Progression):
  Ratio_lever = r_tier / r_baseline

┌───────────────────────┬─────────────────┬───────────────────┬──────────────────┐
│ Progression Tier      │ Effective r_COM │ Lever Ratio (vs L1)│ Anterior Deltoid │
├───────────────────────┼─────────────────┼───────────────────┼──────────────────┤
│ 1. Planche Lean (45°) │ 0.32 meters     │ 1.00x             │ 142 N·m          │
│ 2. Frog Stand         │ 0.38 meters     │ 1.19x             │ 169 N·m          │
│ 3. Tuck Planche       │ 0.46 meters     │ 1.44x             │ 204 N·m          │
│ 4. Advanced Tuck      │ 0.58 meters     │ 1.81x             │ 257 N·m          │
│ 5. Straddle Planche   │ 0.68 meters     │ 2.13x             │ 302 N·m          │
│ 6. Full Planche (0°)  │ 0.77 meters     │ 2.41x             │ 341 N·m          │
└───────────────────────┴─────────────────┴───────────────────┴──────────────────┘

When an athlete shifts from a Tuck Planche (knees tight to chest) to an Advanced Tuck Planche (hips extended to 90 degrees with a flat lumbar spine), their center of mass moves distal to the shoulder fulcrum by approximately 12 centimeters. This increases shoulder flexion moment torque by over 26% without adding a single gram of external weight.

// src/physics/biomechanics.ts
export interface LeverageProfile {
  bodyMassKg: number;
  torsoLengthMeters: number;
  femurLengthMeters: number;
  jointAngleDegrees: number;
}

export function computeJointTorqueNewtonMeters(
  profile: LeverageProfile,
  tierMultiplier: number
): number {
  const g = 9.80665; // Standard gravitational acceleration m/s²
  const baseTorsoLever = profile.torsoLengthMeters * 0.44; // Anatomical COM constant
  const effectiveLeverArm = baseTorsoLever * tierMultiplier;
  const rad = (profile.jointAngleDegrees * Math.PI) / 180;
  
  // Total rotational torque τ = m * g * r * sin(θ)
  const torque = profile.bodyMassKg * g * effectiveLeverArm * Math.sin(rad);
  return Number(torque.toFixed(2));
}

6. Offline State Synchronization with CRDTs

A pure offline-first architecture faces a major hurdle when a user runs the app across multiple devices (e.g. logging sets on an iPhone in the gym, then analyzing trends on a MacBook Pro at home). Centralized Last-Write-Wins timestamps cause silent data loss if an athlete logs an evening workout offline on mobile while their laptop edited exercise notes earlier that afternoon.

To resolve concurrent, multi-device state synchronization without a centralized database, Iron Discipline integrates Conflict-Free Replicated Data Types (CRDTs). Specifically, workout session logs are modeled as state-based Observed-Remove Sets (OR-Sets), while individual set metrics (reps, RPE, rest duration) are governed by deterministic Last-Write-Wins Registers (LWW-Registers) paired with logical Lamport clocks.

┌────────────────────────────────────────────────────────────────────────┐
│                        CRDT STATE REPLICATION MODEL                    │
│                                                                        │
│  Client Node A (iPhone - Offline)       Client Node B (MacBook)        │
│  ┌─────────────────────────────┐       ┌─────────────────────────────┐ │
│  │ Lamport Clock: 42           │       │ Lamport Clock: 39           │ │
│  │ Add Set: {id: "s1", r: 5}   │       │ Edit Notes: "Slight twinge" │ │
│  └──────────────┬──────────────┘       └──────────────┬──────────────┘ │
│                 │                                     │                │
│                 └──────────────┐       ┌──────────────┘                │
│                                │       │                               │
│                                ▼       ▼                               │
│                     ┌─────────────────────┐                            │
│                     │  CRDT Merge Lattice │                            │
│                     │  join(StateA, StateB)│                           │
│                     │  Deterministic LWW  │                            │
│                     └──────────┬──────────┘                            │
│                                │                                       │
│                                ▼                                       │
│                 ┌─────────────────────────────┐                        │
│                 │ Reconciled Global Snapshot  │                        │
│                 │ Zero Conflicts / Zero Loss  │                        │
│                 └─────────────────────────────┘                        │
└────────────────────────────────────────────────────────────────────────┘

// src/sync/crdt-engine.ts
export interface LamportTimestamp {
  counter: number;
  nodeId: string;
}

export interface CRDTRegister {
  value: T;
  timestamp: LamportTimestamp;
}

export class LWWRegister {
  constructor(public state: CRDTRegister) {}

  static compare(a: LamportTimestamp, b: LamportTimestamp): number {
    if (a.counter > b.counter) return 1;
    if (a.counter < b.counter) return -1;
    if (a.nodeId > b.nodeId) return 1;
    if (a.nodeId < b.nodeId) return -1;
    return 0;
  }

  merge(incoming: CRDTRegister): void {
    if (LWWRegister.compare(incoming.timestamp, this.state.timestamp) > 0) {
      this.state = incoming;
    }
  }
}

export interface ORSetElement {
  id: string;
  value: T;
  tag: string; // Unique UUID generated on insert
}

export class ORSet {
  private addSet = new Map>();
  private removeSet = new Set();

  add(id: string, value: T, tag = crypto.randomUUID()): void {
    this.addSet.set(tag, { id, value, tag });
  }

  remove(tag: string): void {
    this.removeSet.add(tag);
  }

  read(): T[] {
    const active: T[] = [];
    for (const [tag, element] of this.addSet.entries()) {
      if (!this.removeSet.has(tag)) {
        active.push(element.value);
      }
    }
    return active;
  }

  merge(incomingAdd: ORSetElement[], incomingRemove: string[]): void {
    for (const elem of incomingAdd) {
      this.addSet.set(elem.tag, elem);
    }
    for (const tag of incomingRemove) {
      this.removeSet.add(tag);
    }
  }
}

7. IndexedDB Cursor Streaming vs Bulk In-Memory Loading

In early testing on entry-level Android devices, opening the 5-year workout analytics tab caused noticeable UI freezes lasting up to 850 milliseconds. Profiling with Chrome DevTools Performance panel pinpointed the cause: Dexie's standard db.workoutSets.toArray() call loaded 45,000 JSON set objects into V8 heap memory simultaneously, triggering massive Garbage Collection (GC) sweeps.

To eliminate memory churn and achieve 60fps rendering during multi-year aggregations, Iron Discipline migrated from bulk array allocation to chunked IndexedDB Cursor Streaming. Using an asynchronous generator pattern, records are streamed from the LevelDB disk store in chunks of 250 rows, aggregated into histogram accumulator buffers, and released immediately for garbage collection.

// src/db/cursor-streamer.ts
import { db, WorkoutSetRecord } from './iron-database';

export interface VolumeAggregates {
  totalVolumeLoadKg: number;
  totalReps: number;
  setCount: number;
}

export async function computeStreamingVolumeMetrics(
  exerciseId: string,
  onProgress?: (processed: number) => void
): Promise {
  return new Promise((resolve, reject) => {
    const aggregates: VolumeAggregates = {
      totalVolumeLoadKg: 0,
      totalReps: 0,
      setCount: 0,
    };

    let processedCount = 0;

    // Open raw IndexedDB read-only transaction
    db.transaction('r', db.workoutSets, async () => {
      await db.workoutSets
        .where('exerciseId')
        .equals(exerciseId)
        .each((record: WorkoutSetRecord) => {
          aggregates.setCount++;
          aggregates.totalReps += record.reps;
          aggregates.totalVolumeLoadKg += record.reps * (record.addedWeightKg > 0 ? record.addedWeightKg : 0);
          
          processedCount++;
          if (processedCount % 500 === 0 && onProgress) {
            onProgress(processedCount);
          }
        });
    })
      .then(() => resolve(aggregates))
      .catch(reject);
  });
}

8. Service Worker Cache Invalidation & Lifecycle Management

A catastrophic failure mode in offline Progressive Web Apps occurs when a new release deploys incompatible JavaScript bundle chunks while the Service Worker continues serving stale HTML referencing outdated chunk hashes. If the user navigates between routes, dynamic imports throw 404 network errors, leaving the user with a broken white screen.

Iron Discipline implements an atomic Service Worker lifecycle management protocol with NavigationPreload and transactional dual-bucket caching:

Service Worker Lifecycle State Transition Pipeline:
┌────────────────────────────────────────────────────────────────────────┐
│ 1. Browser fetches sw.js (Byte-for-byte check detects new hash)        │
│ 2. Install Event fires ──► Precaches all new bundle assets to cache-v2 │
│ 3. Waiting State ──► Client UI displays non-intrusive "Update Ready"   │
│ 4. User clicks Update / App relaunches ──► sw.postMessage({type: 'SKIP'})│
│ 5. Activate Event fires ──► clients.claim() takes immediate control    │
│ 6. Outdated cache buckets (cache-v1) are atomically deleted            │
│ 7. window.location.reload() refreshes the DOM with clean v2 assets     │
└────────────────────────────────────────────────────────────────────────┘

// src/service-worker-lifecycle.ts
export function registerServiceWorkerUpdateHandler(): void {
  if ('serviceWorker' in navigator) {
    window.addEventListener('load', async () => {
      try {
        const registration = await navigator.serviceWorker.register('/sw.js', { scope: '/' });

        registration.addEventListener('updatefound', () => {
          const newWorker = registration.installing;
          if (!newWorker) return;

          newWorker.addEventListener('statechange', () => {
            if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
              // Inform the user that an instantaneous atomic update is primed
              dispatchUpdateNotification(registration);
            }
          });
        });
      } catch (err) {
        console.error('ServiceWorker registration failure:', err);
      }
    });

    let refreshing = false;
    navigator.serviceWorker.addEventListener('controllerchange', () => {
      if (!refreshing) {
        refreshing = true;
        window.location.reload();
      }
    });
  }
}

function dispatchUpdateNotification(registration: ServiceWorkerRegistration): void {
  const banner = document.createElement('div');
  banner.className = 'pwa-update-banner';
  banner.innerHTML = `
    A high-performance update is available.
    Reload
  `;
  document.body.appendChild(banner);

  document.getElementById('pwa-update-btn')?.addEventListener('click', () => {
    registration.waiting?.postMessage({ type: 'SKIP_WAITING' });
  });
}

9. Procedural Audio Synthesis via Web Audio API

Rest intervals in progressive calisthenics (typically 180 to 240 seconds between maximal strength sets) require non-intrusive, acoustically unambiguous acoustic feedback. Bundling 500KB MP3 sound files is unacceptable in an app engineered for minimal byte footprint, and MP3 decoding introduces up to 80ms of audio scheduling jitter.

Iron Discipline utilizes the hardware-accelerated Web Audio API to procedurally synthesize harmonic bell chimes and interval beeps using raw mathematical waveform algorithms. By chaining standard OscillatorNode, GainNode, and BiquadFilterNode instances, we construct precise ADSR (Attack, Decay, Sustain, Release) amplitude envelopes:

// src/audio/procedural-synth.ts
export class AcousticEngine {
  private audioCtx: AudioContext | null = null;

  private initContext(): AudioContext {
    if (!this.audioCtx) {
      const AudioCtx = window.AudioContext || (window as any).webkitAudioContext;
      this.audioCtx = new AudioCtx();
    }
    if (this.audioCtx.state === 'suspended') {
      this.audioCtx.resume();
    }
    return this.audioCtx;
  }

  // Synthesize a pure harmonic meditation bell (C6 / 1046.5 Hz)
  playRestCompleteChime(): void {
    const ctx = this.initContext();
    const now = ctx.currentTime;

    const fundamentalOsc = ctx.createOscillator();
    const overtoneOsc = ctx.createOscillator();
    const gainNode = ctx.createGain();
    const filter = ctx.createBiquadFilter();

    // Fundamental: 1046.50 Hz (C6) | Harmonic Overtone: 2093.00 Hz (C7)
    fundamentalOsc.type = 'sine';
    fundamentalOsc.frequency.setValueAtTime(1046.5, now);

    overtoneOsc.type = 'triangle';
    overtoneOsc.frequency.setValueAtTime(2093.0, now);

    // Warm Lowpass Filter
    filter.type = 'lowpass';
    filter.frequency.setValueAtTime(3200, now);

    // Exponential Decay ADSR Envelope
    gainNode.gain.setValueAtTime(0.0001, now);
    gainNode.gain.exponentialRampToValueAtTime(0.4, now + 0.015); // Fast 15ms Attack
    gainNode.gain.exponentialRampToValueAtTime(0.1, now + 0.25);  // Decay
    gainNode.gain.exponentialRampToValueAtTime(0.0001, now + 1.2); // 1.2s Ring-out Release

    fundamentalOsc.connect(gainNode);
    overtoneOsc.connect(gainNode);
    gainNode.connect(filter);
    filter.connect(ctx.destination);

    fundamentalOsc.start(now);
    overtoneOsc.start(now);
    fundamentalOsc.stop(now + 1.25);
    overtoneOsc.stop(now + 1.25);
  }
}

export const acoustic = new AcousticEngine();

10. The 4-Week Wave Periodization Engine

Continuous maximal effort causes central nervous system (CNS) burnout and connective tissue strain (especially in the medial epicondyles and rotator cuffs). Iron Discipline embeds a 4-Week Wave Periodization Engine into its workout generation:

11. Performance Benchmarks: PWA vs Native React Native

I benchmarked Iron Discipline against commercial fitness apps built on React Native and native Swift frameworks on an older mid-range Android phone (Snapdragon 765G, 6GB RAM) in cold-offline mode:

12. Biomechanical Progression Trees & Skill Unlock Algorithms

Iron Discipline organizes its 800+ movements into Biomechanical Progression Trees. Consider the Planche progression ladder:

Planche Progression Family (Leverage Demands on Anterior Deltoid & Biceps)
────────────────────────────────────────────────────────────────────────
Level 1: Planche Lean (45° Forward Torso Angle)          ── Target: 30s Hold
Level 2: Frog Stand / Crow Pose                          ── Target: 45s Hold
Level 3: Tuck Planche (Knees to Chest)                   ── Target: 20s Hold
Level 4: Advanced Tuck Planche (90° Flat Back)           ── Target: 15s Hold
Level 5: Straddle Planche (Wide Leg Distribution)        ── Target: 10s Hold
Level 6: Full Planche (Straight Body Horizontal)         ── Target: 5s Hold
Level 7: Planche Push-Up (Full Planche Dynamic Press)    ── Target: 5 Clean Reps

The progression engine evaluates the athlete's last three workouts. When the athlete logs three consecutive sessions reaching the target volume with an RPE ≤ 8, Iron Discipline automatically unlocks the next biomechanical tier.

// src/algorithms/progression-engine.ts
export interface ProgressionCriteria {
  minRepsPerSet: number;
  minSets: number;
  maxRpe: number;
  consecutiveWorkoutsRequired: number;
}

export async function evaluateProgressionUnlock(
  exerciseSlug: string,
  criteria: ProgressionCriteria
): Promise<{ shouldAdvance: boolean; reason: string }> {
  const recentWorkouts = await db.workouts
    .orderBy('startedAt')
    .reverse()
    .limit(10)
    .toArray();

  let qualifyingWorkouts = 0;

  for (const workout of recentWorkouts) {
    const sets = await db.workoutSets
      .where('workoutId')
      .equals(workout.id)
      .and((s) => s.exerciseId === exerciseSlug)
      .toArray();

    if (sets.length >= criteria.minSets) {
      const allSetsPassed = sets.every(
        (set) => set.reps >= criteria.minRepsPerSet && set.rpe <= criteria.maxRpe
      );

      if (allSetsPassed) {
        qualifyingWorkouts++;
      } else {
        break;
      }
    }
  }

  if (qualifyingWorkouts >= criteria.consecutiveWorkoutsRequired) {
    return {
      shouldAdvance: true,
      reason: `Mastered criteria across ${qualifyingWorkouts} consecutive workouts at RPE <= ${criteria.maxRpe}. Ready for next leverage tier.`,
    };
  }

  return {
    shouldAdvance: false,
    reason: `Currently at ${qualifyingWorkouts}/${criteria.consecutiveWorkoutsRequired} qualifying sessions.`,
  };
}

13. Data Portability & Cryptographic Export Schema

Because there is no central database server, users must possess complete control over their training logs. Iron Discipline provides an automated backup protocol using the HTML5 File System Access API.

Workout data is exported as an atomic, schema-validated JSON payload accompanied by an SHA-256 integrity checksum:

{
  "schemaVersion": "2.1.0",
  "exportedAt": "2026-08-14T01:15:00.000Z",
  "clientFingerprint": "iron-discipline-pwa-v2",
  "checksumSha256": "8f4b23c91a7e48b2...",
  "profile": {
    "athleteName": "Kenneth D'Silva",
    "bodyweightKg": 78.5,
    "units": "METRIC"
  },
  "workouts": [
    {
      "id": "wk_89127391",
      "name": "Heavy Upper Body Wave B",
      "startedAt": "2026-08-12T07:00:00.000Z",
      "completedAt": "2026-08-12T08:14:00.000Z",
      "sets": [
        {
          "exerciseSlug": "weighted-pull-up",
          "setOrder": 1,
          "reps": 5,
          "addedWeightKg": 25.0,
          "rpe": 8.0,
          "restSeconds": 180
        }
      ]
    }
  ]
}

14. Installing as a Standalone Application (PWA)

To provide a native application feel without the App Store bloat, Iron Discipline configures a full Web App Manifest with standalone display modes, theme color bars, and touch icon shortcuts:

// public/manifest.webmanifest
{
  "name": "Iron Discipline: Progressive Calisthenics",
  "short_name": "IronDiscipline",
  "description": "Offline-first calisthenics progression tracker and workout engine.",
  "start_url": "/",
  "display": "standalone",
  "orientation": "portrait",
  "background_color": "#07071a",
  "theme_color": "#07071a",
  "icons": [
    {
      "src": "/icons/icon-192x192.png",
      "sizes": "192x192",
      "type": "image/png",
      "purpose": "any maskable"
    },
    {
      "src": "/icons/icon-512x512.png",
      "sizes": "512x512",
      "type": "image/png"
    }
  ]
}

15. Edge Cases Handled in Production

During two years of real-world use across hundreds of workouts, several critical edge cases were discovered and resolved:

Browser Storage Eviction Defense. Under extreme device storage pressure, mobile operating systems (especially iOS Safari) can silently purge unflagged IndexedDB storage. To protect user workout history, Iron Discipline automatically requests navigator.storage.persist() on first launch, locking the database against automatic operating system cleanup.

iOS WebKit Audio Context Lock. Safari suspends all audio playback unless the AudioContext is unlocked by a direct user pointer gesture. Iron Discipline attaches an invisible touch listener on the workout start button that plays a 1-millisecond inaudible buffer, ensuring the rest timer chimes properly even if the screen dims.

Dynamic Band Tension Offsets. Resistance bands used for assisted one-arm chin-ups do not provide static resistance; their tension increases with elongation. Iron Discipline incorporates an elongation-strain regression curve to accurately compute equivalent net load.

16. The Complete Technology Stack

17. Architectural Q&A: Deep Technical Answers

Below are comprehensive architectural answers to the ten most critical engineering questions regarding Iron Discipline's client-side persistence, offline synchronizers, and biomechanical physics calculations:

18. Summary & Repository Access

Iron Discipline proves that modern web technologies are more than capable of matching or exceeding native mobile applications in speed, reliability, and tactile quality without sacrificing user privacy or requiring recurring subscriptions.

Check out the documentation and source repository:

• Iron Discipline Technical Documentation
• GitHub Repository: Modracx/Iron-Discipline