Back to the library

Alert triage — acknowledge

Variant: Acknowledge

An alert fires, pulses rust, and is acknowledged — and the dot stays rust. That is the piece: acknowledging means someone owns the problem, not that the problem is gone, so the badge drops from a filled Firing chip to the same rust as a hairline and never borrows the success colour; olive Healthy returns only when the metric under the name actually recovers. The ring runs on its own 800ms sub-clock, an exact eighth of the loop, and the gate that silences it only opens and shuts on ring boundaries. The press lands a quarter into a fresh ring, so you watch that ring finish after the tap and no new one follow it — an acknowledgement stops future pages, it does not snatch back the one already sent. The fire itself is a hard cut, olive to rust on one frame, because a service is never half-down; recovery is the only eased colour change. The press is 80ms down and 120ms back, and the badge swaps at the bottom of the dip. Reach for it on incident consoles and on-call apps, anywhere “I have seen this” and “this is fixed” are currently the same green.

statusalerterrorcontrolloop

The source

A complete HTML document. Paste it into an empty .html file and it plays — no stylesheet, script, font, or image to fetch.

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Triage — acknowledge silences, it does not resolve</title>
    <style>
      :root {
        /* Neutrals — fixed, never remixed. */
        --ivory: #faf9f5;
        --paper: #ffffff;
        --oat: #e3dacc;
        --slate: #141413;

        /* Knobs — the remix API. A knob exists iff declared here and used below. */
        --hue: 38.8;
        --lift: 0;
        --chroma: 1;
        --round: 1;
        --speed: 1;

        /* Accents — derived from the knobs with the family's offsets baked in,
           so one hue roll moves them together. Defaults reproduce the original hex. */
        --clay: oklch(calc(0.6724 + var(--lift)) calc(0.1308 * var(--chroma)) var(--hue));
        --clay-d: oklch(calc(0.5797 + var(--lift)) calc(0.127 * var(--chroma)) var(--hue));
        --olive: oklch(
          calc(0.6118 + var(--lift)) calc(0.0713 * var(--chroma)) calc(var(--hue) + 88.3)
        );
        --rust: oklch(
          calc(0.5408 + var(--lift)) calc(0.1357 * var(--chroma)) calc(var(--hue) - 10.3)
        );

        /* Clock — 6.4s, so 1% is 64ms and an eighth is one 800ms ring.
           Fires at 12.5%, acked at 39.5% — a quarter into the ring born at
           37.5% — quiet from 50% when that ring lands, healthy again at 81%. */
        --cycle: 6.4s;
        --t: calc(var(--cycle) / var(--speed));

        --ease-out: cubic-bezier(0.23, 1, 0.32, 1);

        --_muted: color-mix(in srgb, var(--slate) 54%, transparent);
        --_rust-tint: color-mix(in srgb, var(--rust) 10%, var(--paper));
        --_olive-tint: color-mix(in srgb, var(--olive) 16%, var(--paper));
        --_olive-ink: color-mix(in srgb, var(--olive) 70%, var(--slate));
      }

      * {
        box-sizing: border-box;
        margin: 0;
        padding: 0;
      }

      body {
        min-height: 100vh;
        display: grid;
        place-items: center;
        background: var(--ivory);
        font-family:
          system-ui,
          -apple-system,
          'Segoe UI',
          Roboto,
          sans-serif;
        color: var(--slate);
      }

      .card {
        width: min(320px, 88vw);
        background: var(--paper);
        border: 1px solid var(--oat);
        border-radius: calc(14px * var(--round));
        overflow: hidden;
      }

      .head {
        display: flex;
        justify-content: space-between;
        padding: 10px 14px;
        font-size: 11.5px;
        color: var(--_muted);
        border-bottom: 1px solid var(--oat);
      }

      .row {
        display: grid;
        grid-template-columns: 22px 1fr auto;
        align-items: center;
        gap: 10px;
        padding: clamp(12px, 4vw, 16px) 14px;
      }

      .sig {
        position: relative;
        display: grid;
        place-items: center;
        width: 22px;
        height: 22px;
      }

      .dot,
      .ring {
        grid-area: 1 / 1;
        width: 10px;
        height: 10px;
        border-radius: 50%;
      }

      /* A fire is a cut, not a fade: the dot is olive on one frame and rust on
         the next, because there was never a moment the service was half-down.
         The return to olive is the only eased change — recovery is observed
         over a few samples, so 192ms of blend is not a lie. */
      .dot {
        background: var(--olive);
        animation: dot var(--t) infinite;
      }

      @keyframes dot {
        0%,
        12.49% {
          background: var(--olive);
        }
        12.5%,
        81% {
          background: var(--rust);
          animation-timing-function: ease;
        }
        84%,
        100% {
          background: var(--olive);
        }
      }

      /* The ring runs on its own 800ms sub-clock, an exact eighth of the
         loop, and the gate only opens and closes on ring boundaries. So the
         ring that is in flight when you press is allowed to finish — the
         acknowledgement stops new pages being born, it does not snatch back
         the one already sent — and the silence that follows is total. */
      .gate {
        grid-area: 1 / 1;
        display: grid;
        place-items: center;
        animation: gate var(--t) steps(1, end) infinite;
      }

      @keyframes gate {
        0% {
          opacity: 0;
        }
        12.5% {
          opacity: 1;
        }
        50%,
        100% {
          opacity: 0;
        }
      }

      .ring {
        background: var(--rust);
        animation: ring calc(var(--t) / 8) var(--ease-out) infinite;
      }

      @keyframes ring {
        0% {
          transform: scale(1);
          opacity: 0.55;
        }
        100% {
          transform: scale(2.6);
          opacity: 0;
        }
      }

      .txt {
        display: grid;
        gap: 3px;
        min-width: 0;
      }

      .name {
        font-size: 13px;
        font-weight: 600;
        letter-spacing: -0.01em;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      }

      .stack {
        display: grid;
      }

      .stack > * {
        grid-area: 1 / 1;
      }

      .sub {
        font-size: 11.5px;
        color: var(--_muted);
        min-width: 0;
      }

      .sub span {
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      }

      .badge {
        justify-items: end;
      }

      .badge span {
        font-size: 11.5px;
        font-weight: 600;
        line-height: 1;
        padding: 5px 8px;
        border-radius: 999px;
        white-space: nowrap;
      }

      /* Three readings of one alert, in falling volume: Firing is a filled
         rust chip, Acked is the same rust as a hairline — still a problem,
         just one somebody owns — and Healthy is olive. Acknowledging never
         borrows the success colour; that is the whole lesson of the piece. */
      .b-ok {
        color: var(--_olive-ink);
        background: var(--_olive-tint);
        animation: b-ok var(--t) infinite;
      }

      .b-fire {
        color: var(--rust);
        background: var(--_rust-tint);
        opacity: 0;
        animation: b-fire var(--t) infinite;
      }

      .b-ack {
        color: var(--rust);
        box-shadow: inset 0 0 0 1px var(--rust);
        opacity: 0;
        animation: b-ack var(--t) infinite;
      }

      @keyframes b-ok {
        0%,
        12.49% {
          opacity: 1;
        }
        12.5%,
        81.5% {
          opacity: 0;
          animation-timing-function: ease;
        }
        83%,
        100% {
          opacity: 1;
        }
      }

      @keyframes b-fire {
        0%,
        12.49% {
          opacity: 0;
        }
        12.5%,
        39.5% {
          opacity: 1;
          animation-timing-function: ease;
        }
        40%,
        100% {
          opacity: 0;
        }
      }

      @keyframes b-ack {
        0%,
        40% {
          opacity: 0;
          animation-timing-function: ease;
        }
        41%,
        81% {
          opacity: 1;
          animation-timing-function: ease;
        }
        81.5%,
        100% {
          opacity: 0;
        }
      }

      .s-ok {
        animation: b-ok var(--t) infinite;
      }

      .s-base {
        opacity: 0;
        animation: s-base var(--t) infinite;
      }

      .s-ack {
        opacity: 0;
        animation: s-ack var(--t) infinite;
      }

      @keyframes s-base {
        0%,
        12.49% {
          opacity: 0;
        }
        12.5%,
        39.5% {
          opacity: 1;
          animation-timing-function: ease;
        }
        40%,
        100% {
          opacity: 0;
        }
      }

      @keyframes s-ack {
        0%,
        40% {
          opacity: 0;
          animation-timing-function: ease;
        }
        41%,
        81% {
          opacity: 1;
          animation-timing-function: ease;
        }
        81.5%,
        100% {
          opacity: 0;
        }
      }

      .foot {
        padding: 0 14px 14px;
      }

      .ack {
        display: block;
        width: 100%;
        height: 34px;
        font: inherit;
        font-size: 12.5px;
        font-weight: 600;
        color: var(--slate);
        background: var(--paper);
        border: 1px solid var(--oat);
        border-radius: calc(9px * var(--round));
        opacity: 0.4;
        animation:
          ack-live var(--t) infinite,
          ack-press var(--t) infinite;
      }

      /* Only actionable while firing. It wakes on the fire frame and goes
         back to sleep on the press, so there is never a live button for an
         alert that no longer needs one. */
      @keyframes ack-live {
        0%,
        12.5% {
          opacity: 0.4;
          animation-timing-function: ease;
        }
        14.5%,
        39.5% {
          opacity: 1;
          animation-timing-function: ease;
        }
        41.5%,
        100% {
          opacity: 0.4;
        }
      }

      /* 80ms down, 120ms up — the family's one press. The badge swaps at the bottom of the dip, so the
         answer arrives as the finger does rather than after it lifts. */
      @keyframes ack-press {
        0%,
        38.25% {
          transform: scale(1);
          animation-timing-function: var(--ease-out);
        }
        39.5% {
          transform: scale(0.97);
          animation-timing-function: var(--ease-out);
        }
        41.4%,
        100% {
          transform: scale(1);
        }
      }

      @media (prefers-reduced-motion: reduce) {
        /* The ring stops travelling and becomes a held halo that breathes in
           opacity only, and the press dip goes. Every clock doubles together,
           so the gate still opens and shuts on a ring boundary. */
        .ring {
          animation-name: ring-calm;
        }

        @keyframes ring-calm {
          0% {
            transform: scale(2);
            opacity: 0.3;
          }
          100% {
            transform: scale(2);
            opacity: 0;
          }
        }

        .ack {
          animation-name: ack-live;
        }

        .dot,
        .gate,
        .b-ok,
        .b-fire,
        .b-ack,
        .s-ok,
        .s-base,
        .s-ack,
        .ack {
          animation-duration: calc(var(--t) * 2);
        }

        .ring {
          animation-duration: calc(var(--t) * 2 / 8);
        }
      }
    </style>
  </head>
  <body>
    <div
      class="card"
      role="img"
      aria-label="An alert fires and its dot pulses rust; pressing Acknowledge lets the last pulse finish and stops new ones, and the badge changes from Firing to an outlined Acked while the dot stays rust; later the service recovers and the badge returns to an olive Healthy"
    >
      <div class="head"><span>Alerts</span><span>On call · you</span></div>
      <div class="row">
        <span class="sig">
          <span class="gate"><span class="ring"></span></span>
          <span class="dot"></span>
        </span>
        <span class="txt">
          <span class="name">Checkout latency</span>
          <span class="sub stack">
            <span class="s-ok">p95 140ms · eu-west</span>
            <span class="s-base">p95 812ms · eu-west</span>
            <span class="s-ack">Acked · paging stopped</span>
          </span>
        </span>
        <span class="badge stack">
          <span class="b-ok">Healthy</span>
          <span class="b-fire">Firing</span>
          <span class="b-ack">Acked</span>
        </span>
      </div>
      <div class="foot"><button class="ack" tabindex="-1">Acknowledge</button></div>
    </div>
  </body>
</html>

The variant family

Same idea, one axis moved. Compare them side by side before you commit.