HIIT Timer Setup: Tabata, EMOM and AMRAP in the Browser

Every gym app wants an account before it will count to twenty for you. A HIIT timer is a countdown that repeats and makes a noise — no login required. This is how to run the three interval formats that cover almost every session (Tabata, EMOM, AMRAP) from a browser tab, and why 20-second intervals are the one case where most online timers quietly fall apart.

#TL;DR

• Tabata is 20 s work, 10 s rest, 8 rounds — four minutes total.
• EMOM starts a new round every 60 seconds; leftover time is your rest.
• AMRAP is one long countdown; a plain browser timer handles it perfectly.
• Sub-minute repeats need deadline math, not a setInterval tick counter.
• Keep the tab visible: hidden tabs get throttled and alarms fire late.

#What do Tabata, EMOM and AMRAP actually mean?

These three names describe when the clock matters, not what movement you do. Learn the shapes once and every workout you read becomes parseable.

#What is the Tabata protocol?

The protocol is named after Izumi Tabata, whose group published the original 1996 trial in Medicine & Science in Sports & Exercise. Subjects rode a cycle ergometer for 20 seconds at a load around 170% of VO2max, rested 10 seconds, and repeated for seven to eight bouts — roughly four minutes of work. Compared with a group doing 60 minutes of moderate cycling, the interval group improved both aerobic and anaerobic capacity.

Two details get dropped when "Tabata" becomes a class name on a gym schedule:

• The intensity was supramaximal, not "work hard". A later study, Defining the number of bouts and oxygen uptake during the "Tabata protocol", found that the eight-bout figure only holds at that load — lower intensities let you go far past eight.
• The original subjects were trained athletes on a fixed-load ergometer, not people doing burpees in a living room.

Timing-wise, though, the shape is exact and easy to automate: 20 / 10 × 8.

#What does EMOM mean in a workout?

EMOM is "every minute on the minute". You start a prescribed set of reps at the top of each minute; whatever time is left over is your rest. Finish 10 kettlebell swings in 35 seconds and you get 25 seconds back. Take 55 seconds and you get five. The self-regulating rest is the whole point — as fatigue accumulates, the rest shrinks, and the workout tells you honestly when to stop.

#What does AMRAP mean in a workout?

AMRAP is "as many rounds and/or reps as possible" inside a fixed window, which is how CrossFit's own terminology page defines it. There is exactly one clock event: the end. A 12-minute AMRAP needs a 12-minute countdown and a loud buzzer, nothing more.

For a general picture of where these sit among interval prescriptions, ACSM's Health & Fitness Journal overview of HIIT describes typical work bouts running from about 15 seconds to 4 minutes, with recovery equal to or slightly longer than the work interval, bracketed by a 5–10 minute warm-up and cool-down.

#How to set up a HIIT timer in your browser

iKit's Stopwatch & Timer is a single page with three modes and a t query parameter. Each protocol maps onto a different mode, and the mapping is not obvious until you have done it once.

#How to run an AMRAP timer online

This is the easy one. Put the window in the URL:

https://timer.ikit.app/?t=12m
https://timer.ikit.app/?t=20m
https://timer.ikit.app/?t=7:30

The parser accepts 12m, 90s, 1h, colon form like 7:30, and combinations like 1h 10m. The page opens in countdown mode with the duration already on the display; the space bar starts and pauses it, R resets. Bookmark the URL for whichever AMRAP length your gym programs most often and it becomes a one-click warm-up.

#How to run an EMOM timer without an app

EMOM is a counting-up problem, not a counting-down one. Open the stopwatch:

https://timer.ikit.app/?stopwatch

Start a round each time the display crosses a whole minute, and press L to drop a lap marker as you finish. At the end you have a lap list showing exactly how long each round took — which is the data you actually want from an EMOM, because the trend across rounds is your fatigue curve.

If you would rather be told when to start than watch for it, a repeating 1-minute countdown works too, but you have to restart it manually each round. Pomodoro mode looks like a fit — it has work, rest and a round count — but its inputs are whole minutes with a minimum of 1, so the shortest interval it can produce is a 1-minute block. That is fine for 1 / 1 × 10 style intervals and useless for Tabata.

#Why Tabata 20/10 breaks most browser timers

A 20-second work period and a 10-second rest period are both shorter than the granularity most timer UIs expose. Enter 20 in a field labelled "minutes" and you get a twenty-minute countdown, which is a very different afternoon.

You have three honest options:

• Load 20 seconds and restart eight times. https://timer.ikit.app/?t=20s opens a 20-second countdown; ?t=10s gives you the rest. Two pinned tabs, alternate between them. Crude, but it works and it beeps.
• Use one 4-minute countdown as a cap and let a coach or a playlist mark the intervals. ?t=4m covers the whole protocol.
• Run 15 lines of JavaScript. If you're the sort of person who reads a tools blog, this is probably the option you want — and it's the one that teaches you why generic interval apps drift.

#How to build a Tabata timer in JavaScript that doesn't drift

The naive version is a setInterval that decrements a counter every second. It is wrong for the same reason every naive timer is wrong: the callback is not guaranteed to fire on time, and errors accumulate.

#Deadline math instead of tick counting

Never count ticks. Compute the absolute moment each phase ends, then ask the clock how far away it is. If a frame is late, the next phase still lands where it should.

const PLAN = [];
for (let i = 0; i < 8; i++) {
  PLAN.push({ phase: "work", ms: 20_000 });
  PLAN.push({ phase: "rest", ms: 10_000 });
}

function run(plan, onPhase, onTick) {
  const t0 = performance.now();
  let elapsed = 0;
  const marks = plan.map((p) => (elapsed += p.ms));

  let index = -1;
  function frame(now) {
    const t = now - t0;
    let i = marks.findIndex((m) => t < m);
    if (i === -1) return onPhase(null, 0);
    if (i !== index) onPhase(plan[i].phase, i);
    index = i;
    onTick(marks[i] - t);
    requestAnimationFrame(frame);
  }
  requestAnimationFrame(frame);
}

marks holds cumulative deadlines: 20 000, 30 000, 50 000, 60 000 and so on up to 240 000 ms. Whatever the browser does to your frame rate, phase 12 still starts at 190 000 ms.

#Why does setTimeout run late in a background tab?

Because browsers deliberately throttle timers in hidden tabs to save battery. MDN's setTimeout reference documents the clamping rules: nested timeouts get a minimum delay, and background tabs are clamped much harder — typically to once per second, and in some conditions far less often than that.

Two consequences for a workout timer:

• requestAnimationFrame stops entirely in a hidden tab. Your display freezes.
• Any design that counts elapsed time by adding up callbacks will finish late by however long the tab was hidden.

Deadline math survives both, because when the tab comes back the first frame reads the real clock and jumps straight to the correct phase. That difference is the whole subject of our write-up on background tab throttling.

#How do I keep my phone screen on during a workout?

Ask for a screen wake lock. Per MDN, the Screen Wake Lock API has been Baseline since March 2025, and it needs a secure context:

let lock = null;

async function keepAwake() {
  try {
    lock = await navigator.wakeLock.request("screen");
  } catch (err) {
    // Denied: low battery or power-save mode.
  }
}

document.addEventListener("visibilitychange", () => {
  if (lock && document.visibilityState === "visible") {
    keepAwake();
  }
});

The re-request on visibilitychange is not optional. The platform releases the lock whenever the document stops being visible, so without that listener your screen stays on until the first time you glance at a notification, then never again.

#Interval cheat sheet: work, rest, rounds

Three formats, one table. Total time assumes no warm-up.

And how each one maps onto the browser tool:

#How should I scale the work-to-rest ratio?

The ratio encodes which energy system you are taxing. Tabata's 2:1 work-to-rest is aggressive; most people meeting HIIT for the first time do better inverting it.

• 1:2 (20/40) — repeatable, technique stays clean, good for beginners.
• 1:1 (30/30) — the default for circuit classes.
• 2:1 (20/10) — the Tabata ratio; only honest if the work period is genuinely maximal.
• EMOM — ratio is emergent. Your rest is whatever you earn.

None of this is medical advice, and interval work at true maximal intensity is not the place to start if you haven't trained in a while. ACSM's guidance on progression is worth reading before you write yourself a program.

#Do I need a different timer for stretching and cool-down?

Not really, but a second tab helps. A fixed-length cool-down is a countdown — ?t=5m — and if you want a date-anchored version (a class that starts at 18:30, a challenge that ends on the 30th), that's what iKit's Countdown Timer is for.

#Common HIIT timer mistakes

#The muted tab

Browsers block audio until a page has received a user gesture, and phones respect the hardware mute switch. Press Start once with the volume up before you're mid-plank. If you want to know exactly how a browser synthesises those beeps, we took the alarm apart in our Web Audio API write-up.

#Counting rounds in your head

At round six of eight, at 170% of anything, you cannot count. Either use a timer that displays the round number, or lay out eight objects and move one each round. Sounds primitive; works every time.

#Trusting a phone that's about to sleep

If you're using a phone as the gym clock and the page doesn't hold a wake lock, the screen dims mid-round and the timer keeps running invisibly. Prop up a laptop or tablet instead, and generate a QR code for your preset URL with iKit's QR Code Generator so the phone can hand the workout to whichever screen is bigger. 💪

#Programming Tabata as a warm-up

Four minutes looks short on paper, which is exactly why people schedule it as an opener. It isn't one. If the intensity is right, it's the session.

#References

• Effects of moderate-intensity endurance and high-intensity intermittent training on anaerobic capacity and VO2max — the 1996 Tabata et al. study; source for the 20/10 timing, 170% VO2max load, and seven-to-eight bout count.
• Defining the number of bouts and oxygen uptake during the "Tabata protocol" performed at different intensities — used for the point that the eight-bout figure depends on the original intensity.
• High-Intensity Interval Training: Efficient, Effective, and a Fun Way to Exercise — ACSM Health & Fitness Journal; typical work-bout durations, recovery ratios and warm-up guidance.
• CrossFit Terms Explained — primary source for the AMRAP definition and surrounding vocabulary.
• Screen Wake Lock API — MDN; Baseline status (March 2025), secure-context requirement, and the re-acquire-on-visibilitychange pattern.
• setTimeout() global function — MDN; timer clamping and background-tab throttling behaviour.

#Related on iKit

• Why setInterval drifts and how to build a timer that doesn't — the deadline-math pattern used in the Tabata engine above, explained from first principles.
• Why background tabs pause your JavaScript timer — what actually happens to your interval clock when you switch apps mid-round.
• Building a browser alarm sound with the Web Audio API — how the beep between work and rest is synthesised, and why autoplay policy blocks it.
• Reminders that survive a tab switch, using the Notification API — getting a round-transition alert through when the tab isn't in front.
• The Pomodoro technique, 25/5, and where the numbers came from — the same work/rest engine at a hundred times the interval length.
• Pomodoro vs timeboxing vs flowtime — choosing an interval structure for focus work rather than for burpees.
• Online stopwatch with lap times — the lap list is the EMOM tool; this covers how to read it.
• Five-minute timer presets you can put in a URL — the ?t= parameter in depth, including bookmark keywords.
• Kitchen timer online: twelve recipe presets in one URL — the same preset trick applied to running several countdowns side by side.