The on-call engineer's
free toolkit.

Turn an SLA target like 99.9% into the exact downtime you're allowed per day, week, month, and year.

See how much error budget an SLO gives you, how much you've burned, and how much is left.

Compute multi-window, multi-burn-rate alert thresholds (the Google SRE workbook pattern) from an SLO.

Calculate end-to-end availability across serial and parallel service dependencies.

Estimate the business cost of an outage from revenue, engineers engaged, and duration.

Compute an Apdex score from satisfied, tolerating, and frustrated request counts.

Generate the classic 'nines' allowed-downtime table for any custom SLO target and window.

Pick safe heartbeat and cron-monitor intervals and grace periods to avoid false alerts.

Compute Mean Time To Resolution (and MTTA) from incident timestamps, with downtime-cost estimates.

Design fair on-call rotations with primary and secondary layers and export them as an ICS calendar.

Find working-hour overlap and ideal handoff times across a distributed, follow-the-sun on-call team.

Quantify pager fatigue from alert volume, actionability, and after-hours pages.

Build and preview a Slack incident-alert message and export the Block Kit JSON.

Format, validate, and pretty-print alert webhook payloads for Opsgenie, Alertmanager, and generic sinks.

Build common PromQL queries from a guided form, with an inline cheat sheet.

Produce a structured, blameless postmortem in Markdown from guided inputs, following the Google SRE format.

Build a SEV0–SEV4 severity matrix from a template and export it to Markdown for Slack or Notion.

Generate customer-facing status updates for each stage: investigating, identified, monitoring, resolved.

Design tiered escalation chains with timeouts and build an incident RACI chart.

Build and test Logstash / Grok patterns against sample log lines with live field extraction.

Reflow collapsed, JSON-escaped, or single-line stack traces into readable multiline output.

Flatten nested JSON log objects to dotted-key or CSV form for grepping and analysis.

Strip or render ANSI escape codes in CI and terminal logs.

Test regular expressions against sample text with live match highlighting and capture groups.

Compute P50–P99.9 latency percentiles and basic stats from a dataset, with a tail-latency warning.

Solve Little's Law for capacity planning: concurrency = throughput × latency.

Simulate token-bucket rate limiting and visualize throttling under a request pattern.

Convert between requests/sec, per-minute, daily, and monthly volumes with a peak-factor adjustment.

Estimate time-series cardinality and rough cost from metric and label dimensions.

Pick a tracing sample rate that balances visibility against span volume and cost.

Expand CIDR notation into network, broadcast, mask, usable range, and host count.

Convert storage units and estimate file transfer time at a given bandwidth.

A searchable reference of common TCP/UDP ports and the services that use them.

Build a ready-to-run curl command from a visual form, with correct escaping.

Searchable HTTP status codes with plain-English causes and fix guidance.

Determine a pod's QoS class from requests and limits, and flag OOM and overcommit risk.

Generate tuned liveness, readiness, and startup probe YAML with worst-case timing math.

Plan DNS cutovers by computing a safe TTL-lowering schedule and worst-case propagation window.

Decode a PEM certificate locally and surface expiry, SANs, and issuer. Nothing leaves your browser.

Encode and decode Base64 text, with URL-safe mode and UTF-8 support.

Decode a JSON Web Token's header and payload and inspect its claims and expiry locally.

Generate SHA-1, SHA-256, SHA-384, and SHA-512 hashes of text in your browser.

Generate v4 (random) and v7 (time-ordered) UUIDs in bulk, ready to copy.

Format, minify, and validate JSON, with sorted keys and error locations.

Compare two blocks of text or config and see a line-by-line diff.

Convert config back and forth between YAML and JSON, all in your browser.

Convert between Unix timestamps and human-readable dates across timezones.

Build and read cron expressions in plain English, with the next run times.

Normalize mixed log timestamp formats (ISO, epoch, RFC) to a single timezone for correlation.