Diagnostics

Measure API error-budget burn from status counts or access logs, project the compliance window, and spot policy-breaking failure rates.

Check a public page for ad-network signatures and ads.txt seller alignment with confidence bands, fetch warnings, and focused follow-ups.

Complete and score the 10-item WHO AUDIT for the past year, see the 0–40 screening zone, and review which item groups contributed.

Score three past-year AUDIT-C responses against published 3+ through 8+ reference lines, with non-diagnostic guidance and local processing.

Measure alert noise from classified CSV rows, compare it with your target, and isolate repeated alert-route groups without uploading data.

Group application logs into stable fingerprints, compare severity and time clusters, and triage recurring patterns without uploading the source.

Test HTTP APIs from your browser with cURL import and authentication while inspecting exposed headers, timing, response text and CORS failures.

Rank suspicious audit events from common log and CloudTrail exports using transparent signals for failures, source shifts, and privilege changes.

Look up an ASN or public IP to compare current routing prefixes and neighbours with registry contacts and optional PeeringDB context.

Audit pasted BGP route paths for policy conflicts and trace each pass, watch or reject verdict before changing production router filters.

Calculate a child’s BMI-for-age percentile from measurements or known BMI and interpret it with WHO or CDC curves, z-scores and P95 checks.

Calculate bandwidth-delay product and per-stream TCP window targets from path rate and RTT, then compare current buffers and stream counts.

Estimate front and rear bicycle tire pressures from measured load and setup with temperature adjustment, tuning ranges and safety limits.

Check a mail host or sender IP across selected DNSBLs, distinguish policy listings from resolver errors, and inspect provider evidence.

Compare adult BMI and waist ratios with three body-fat estimates, derived fat and lean mass plus BSA and method-spread warnings.

Calculate body surface area from height and weight, compare five BSA formulas and review protocol choices for weight basis, caps and dosing.

Draft a tracker-ready bug report with structured reproduction details, triage fields, readiness checks, and local sensitive-data warnings.

Check a hostname's CAA policy through its effective DNS record set and wildcard rules, with issuer findings and public resolver evidence.

Find actionable clues in a failed CI log, map them to pipeline stages, and mask common secret patterns before sharing the evidence.

Measure clicks per second in a timed browser trial, compare pace and consistency, and filter near-duplicate presses when checking switch bounce.

Check CSS structure locally with line-aware errors and review warnings for duplicate declarations, empty rules, and risky at-rules.

Validate CSV or TSV imports against column types and required values, including ranges and uniqueness, with safe pattern checks and row-level findings.

Build a capacity upgrade brief from utilization and compounded growth, then compare threshold runway, lead time and ranked upgrade options.

Plan front and rear cold tire pressure from placard values and trip load with axle-share, temperature-change and equipment-limit checks.

Check past-week depressive symptom frequency with the 20-item CES-D and review reverse scoring, the 16-point line, and private answer review.

Review a certificate inventory CSV locally to rank renewal urgency and flag ownership, manual-process, invalid-date and public-lifetime risks.

Check an exact TLS certificate fingerprint against public CT data and compare hostname coverage, issuer evidence and provider revocation flags.

Compare approved and observed configuration snapshots, classify meaningful drift, and prioritize changed or missing security settings.

Check payment-card test numbers with Luhn and issuer-length rules, review batch verdicts, and keep full PAN handling risks visible.

Check one browser-clock instant in local and UTC forms, capture stable ISO 8601 and Unix values, and spot a nearby date boundary.

Score the four lifetime CAGE questions, check the standard two-Yes cutoff, and see separate safety guidance when Eye-opener is endorsed.

Check a DKIM selector in public DNS and review its record count, key strength and policy tags with clear testing and resolver evidence.

Validate a domain's DMARC policy and check syntax, alignment and external report receivers before making stricter mail enforcement changes.

Audit a domain's public DNS for authority, address and mail-policy gaps while comparing TTL horizons and resolver-visible evidence across common records.

Trace a public hostname through DNS delegation and aliases, compare resolver views, and inspect DNSSEC or negative-cache clues.

Investigate NXDOMAIN or NODATA using recursive resolver evidence plus NSEC or NSEC3 coverage, DNSSEC clues and negative-cache retry timing.

Check DNS glue and delegation for a public zone, compare resolver views, and identify missing NS addresses, aliases, or DS evidence.

Check DNS propagation across public resolvers, compare the intended record set, and identify cache holdouts with TTL and failure evidence.

Look up DNS records for a domain, URL or IP through Google or Cloudflare with response codes, returned TTL evidence and DNSSEC flags.

Test DNS wildcard behavior with random public resolver probes and distinguish broad matches, branch boundaries, mixed views, and cached negatives.

Validate a domain's DNSSEC trust evidence from parent DS through DNSKEY signatures and resolver AD signals with a focused 15-check report.

Build a disaster recovery runbook around RTO and RPO goals, accountable recovery steps and evidence-based readiness gates for owner review.

Check SQL migration risk before release with engine and table context, exposing destructive changes plus lock hazards, rewrites and backfills.

Compare DNS answers with and without an EDNS Client Subnet hint, then inspect answer steering, echoed scope, TTL drift, and privacy clues.

Inspect EDNS OPT responses from public DNS-over-HTTPS resolvers, compare requested and returned options, and keep replay evidence.

Inspect raw email headers locally to trace relay delays and compare recorded SPF, DKIM and DMARC evidence while spotting sender mismatches.

Calculate SLO error-budget burn rate and compare page or ticket thresholds, then estimate runway from the budget that remains.

Calculate SLO error-budget use from observed traffic, compare burn and policy gates, and estimate runway before a release decision.

Calculate Ethernet payload efficiency and goodput from frame size plus VLAN and wire-time overhead, then check whether a target rate fits.

Calculate fiber link loss and receive power from datasheet and route values, then check operating margin plus reserve, reach and overload risk.

Find vessels in a Finnish AIS snapshot by identity or radius and review reported motion, position quality, speed bands and map context.

Analyze firewall deny logs into ranked traffic paths using format-aware parsing, CIDR direction checks and transparent priority scores.

Build a reviewable firewall rule matrix from flow rows with least-privilege findings, deterministic risk cues, and platform handoff guidance.

Review firewall rules for stale use and broad exposure while scoring expiry, ownership and privileged-service evidence into a cleanup queue.

Find full and partial firewall rule shadows in ordered IPv4 policy exports, with precedence-aware evidence and safer cleanup priorities.

Score the GAD-7 for the last two weeks and compare anxiety symptom severity with the separate impact on work, home tasks, and relationships.

Screen past-week depression-related responses in older adults with GDS-15, strict follow-up thresholds, and separate safety cues.

Rank Git diff files by churn and repository risk signals, with transparent scores that guide owner review without claiming merge safety.

Review pediatric growth visits with estimated percentiles, height velocity, BMI flags, and clear prompts to confirm results on official charts.

Review a child's height, weight or BMI percentile path across visits with WHO/CDC references plus band-crossing alerts and trend context.

Screen serial child growth measurements for percentile drift and low height velocity, with age-routed adiposity checks and data-quality flags.

Calculate child height or weight velocity across visits, compare intervals with a clearly labeled screening model, and flag sustained change patterns.

Place a child's height, weight or BMI on age- and sex-specific WHO or CDC curves with z-score, percentile and reference-gate context.

Check a public URL or pasted headers for gzip, Brotli, or identity compression with cache-variation checks and measured byte savings.

Calculate a serial HA failover budget, compare every recovery phase with an RTO and safety reserve, and identify the longest delay.

Check HA peer snapshots for ownership drift, standby readiness, stale synchronization and heartbeat failures with service and priority evidence.

Compare two HTML documents or fragments as parsed DOM trees and review path-level changes with explicit whitespace and attribute rules.

Check pasted or local HTML in document or fragment mode with line-aware findings and strict review signals without executing code in your browser.

Analyze NGINX, Apache, or ALB access logs locally for endpoint P95 and 5xx rates with clear parse-gap evidence and SLA findings.

Identify likely hash formats from pasted values or local text files with confidence labels, cleanup clues and browser-local analysis.

Size or check a heat sink from power, ambient and junction limits using the full thermal-resistance path plus airflow planning factors.

Check a child’s height-for-age percentile and z-score against WHO or CDC references, with measurement-method alignment and uncertainty.

Audit hostname inventories against RFC and Kubernetes syntax, organization regex rules and duplicate policy with browser-local evidence.

Check a public URL’s HTTP headers across redirects and review security, cache behavior, browser state and cross-origin exposure.

Trace a public HTTP redirect chain hop by hop to identify loops and HTTPS downgrades, compare timing and generate a replayable cURL command.

Check IPv4 CIDRs and ranges for exact duplicates, containment, partial overlap, host-bit corrections, and duplicate address coverage.

Estimate IIP3 and OIP3 with IM3 clearance and SFDR for an equal-tone RF test based on gain, noise bandwidth and detection margin.

Compare two equal-size images locally using channel tolerance and transparency rules, then inspect a highlighted diff with exact pixel-change metrics.

Calculate incident MTTx metrics from lifecycle CSV rows, then compare means and tail percentiles with strict acknowledgement and recovery targets.

Turn incident notes into a sorted chronology with phase coverage, evidence gaps and response-cadence checks for a review-ready handoff report.

Check network interface descriptions for endpoint evidence and policy gaps, then prioritize duplicates or length issues before cleanup and change review.

Check JavaScript syntax and selected defect rules by ECMAScript edition and environment without executing or rewriting the source.

Estimate how jumbo frames reduce packet rate and repeated Ethernet overhead for eligible traffic, with path-risk and optional CPU relief checks.

Measure distress frequency over the past four weeks with K10, compare two published band guides, and review the complete response pattern.

Screen past-30-day psychological distress with the six-item K6 total, clear 5 and 13 cutoffs, and non-diagnostic follow-up guidance.

Turn Kubernetes Event text or JSON into a repeat-aware timeline with warning concentration, reason groups, and object hot spots.

Calculate a log sampling rate that fits a daily storage target while reserving critical records and accounting for bursts and index overhead.

Inspect a MAC or EUI address with normalized forms and first-octet flags plus special-use checks and optional vendor assignment evidence.

Inspect a domain's MX route and compare public DNS answers while catching Null MX conflicts, unresolved exchanges, and alias targets.

Check maintenance schedules for time overlap, shared services or owners, blackout conflicts, guard-buffer near misses, and concurrency spikes.

Check Markdown against CommonMark or GFM rules, tune severities and overrides, and review line-level findings without changing the source.

Estimate a child's family target height from biological parent heights, compare three methods, and read the midpoint within a chosen band.

Plan cold motorcycle tire pressures from a manual or profile baseline while accounting for ride load and temperature change within clear safety limits.

Analyze MySQL slow query logs locally to group SQL fingerprints and rank accumulated or tail cost with scan, lock and temp-table findings.

Review NTP or chrony peer evidence for clock offset and uncertainty with configurable gates for stratum, reach, and source selection.

Check a domain’s resolver-visible nameserver set and verify address coverage, SOA presence, and cross-resolver drift before a DNS cutover.

Rank NetFlow or IPFIX rows to find dominant endpoints and services while comparing byte, packet and flow patterns with local processing.

Turn network audit findings into a ranked remediation register with escalation counts, due-state checks, owner gaps, and browser-local reporting.

Estimate useful network throughput and transfer time from link capacity and RTT with TCP window, loss and packet-rate bottleneck checks.

Calculate cascaded RF noise figure and receiver sensitivity from ordered gain and loss stages plus bandwidth, temperature and SNR.

Estimate observability storage from event volume and retention with compression, replica copies and reserve plus optional quota headroom.

Estimate monthly observability ingest cost from measured telemetry and model collector reduction across vendor meters with retention discounts and growth.

Prepare an on-call handover with normalized incident rows, ownership checks, readiness rules, and warnings for risky or incomplete transfers.

Compare one instant across local, UTC, and IANA time zones, check handoff work windows, and prepare calendar-ready UTC event text.

Compare two text-bearing PDFs locally with content-aware page alignment and review page-level changes, movement, and text-extraction gaps.

Decode PHP serialized data into a local typed tree with byte offsets, reference checks, and binary-safe display without object instantiation.

Estimate packet capture storage from traffic rate and duration with snapshot limits, file overhead, compression and capacity reserve checks.

Check a password against predictable patterns and attack scenarios, compare estimated crack times, and keep the candidate in your browser.

Rate how much 15 physical symptoms bothered you over four weeks, then review the 0–30 PHQ-15 total and its symptom-burden band.

Score the nine PHQ-9 symptoms, keep functional impact separate, and flag any Item 9 response for direct follow-up regardless of the total.

Analyze saved ping output for packet loss and unstable round-trip times, then compare sequence gaps and jitter with your own limits.

Turn firewall, scanner, or cloud-rule port rows into a local exposure review that prioritizes risky public listeners and missing ownership.

Normalize mixed TCP and UDP port lists into compact ranges and target strings with IANA bands, duplicate checks and service exposure cues.

Inspect PostgreSQL EXPLAIN plans for costly nodes and row-estimate drift with browser-local parsing of scan, spill and buffer clues.

Complete the 20-item past-month PCL-5, see the 0 to 80 total and DSM-5 cluster counts, and review screening cut points with safety context.

Check a lifetime trauma gate and five past-month PTSD symptoms, then see how the 0–5 PC-PTSD-5 score compares with 3+ and 4+ cut points.

Estimate a child's projected adult height from current stature and parent heights, with an uncertainty range and sensitivity comparisons.

Estimate Prometheus monthly cost from active series and retention, then model cleanup savings and growth with editable managed or self-hosted rates.

Build Prometheus scrape YAML from target rows and labels with timing, grouping, limits and validation cues to review before a live reload.

Review pasted or current-request proxy headers, trace the trusted edge from the right, and flag spoofable client-IP evidence and disclosure clues.

Allocate a QoS parent rate across traffic classes and check reserved bandwidth, best-effort headroom, burst ceilings and priority pressure.

Calculate queueing delay from buffer depth and bottleneck rate, then compare occupancy and target buffer size with optional BDP context.

Size a queue worker pool from busy-period arrivals, measured throughput, backlog drain time, utilization headroom, and worker limits.

Decode a QR image locally, inspect the recovered payload, and flag suspicious links or sensitive OTP and Wi-Fi data before opening.

Validate RSS 2.0 or Atom 1.0 XML locally with format detection and line-aware errors plus empty-feed warnings and clear repair guidance.

Compare public DNS answers across open and filtered profiles to separate policy splits from cache or DNSSEC drift with repeatable evidence.

Check PTR records for an IP or hostname, verify forward-confirmed reverse DNS, and compare expected names or public resolver views.

Build a risk register from pasted rows or CSV with inherent and residual scores, owner-gap priorities, treatment cues, and review dates.

Find the IPv4 or IPv6 route that wins for a destination using longest-prefix lookup, selectable tie-break rules, and CIDR cleanup warnings.

Calculate SLA availability and downtime allowance with planned-maintenance policy, then check budget use, burn rate and breach projection.

Estimate SNMP polling pressure from devices and OIDs with interval and packing effects plus security, MTU and per-poller capacity checks.

Check a domain's SPF record, trace include and redirect dependencies, and flag duplicate policies or lookup-budget risks from public DNS.

Check SQL structure and selected dialect rules for PostgreSQL, MySQL, or SQLite without connecting to a database or executing statements.

Trace SIP/SIPS, XMPP, or LDAP discovery through NAPTR and SRV to terminal addresses with optional public resolver comparison.

Calculate SSD endurance from DWPD or TBW, size the rating for per-drive host writes, and forecast SMART-based wear and replacement timing.

Match a TLS leaf certificate to a candidate issuer with signature verification, CA checks, expiry horizons, and policy-based review guidance.

Check a live TLS host or pasted PEM chain for broken issuer links, hostname and expiry problems, then build a root-aware install bundle.

Check a public hostname across SSL Labs endpoints for weak protocols and trust gaps, then prioritize certificate renewal and TLS fixes.

Check a live TLS listener for certificate expiry and SAN coverage, then verify renewal timing plus the served serial number and fingerprints.

Compare a TLS certificate with a CSR or RSA private key in your browser, using exact SHA-256 SPKI identity checks without uploading secrets.

Check a public TLS host or pasted certificate for OCSP status and responder timing with freshness warnings and independent-verification evidence.

Analyze swim splits and stroke counts into comparable SWOLF trends with lap drift, segment changes, and pace cues for one pool course.

Check public satellite TLE age, orbit class, and optional SatNOGS status before choosing a record for pass planning or fleet review.

Forecast observer-relative satellite passes from TLE data and compare rise times, elevation filters and sky direction in calendar-ready windows.

Check an SSH public key locally, compare modern or legacy fingerprints, and review host-key identity warnings before trusting the key.

Check release notes and commit subjects for the required SemVer bump, then verify whether a planned version covers the strongest change signal.

Estimate snapshot reserve from changed-block churn and retention, then test reduction and headroom against growth, burst load and current capacity.

Group stack traces into repeatable fingerprints, compare frame evidence across common runtimes, and keep sensitive trace text in your browser.

Classify pasted syslog and application logs by RFC severity, measure the error-plus share, and spot emitters that cross your review threshold.

Estimate searchable syslog storage from EPS and event size with retention, compression and index overhead plus stored copies and disk reserve.

Trace a live TLS handshake to review protocol and cipher, certificate identity and trust, plus DNS-to-negotiation timing from one remote probe.

Turn one feature workflow into traceable manual, Gherkin, or automation-ready test cases with risk coverage and focused review cues.

Trace every visible CNAME hop for a public hostname and compare resolver views before verifying the terminal DNS answer and provider suffix.

Parse traceroute, tracert or MTR output locally and compare hop delays with no-reply or downstream-loss patterns before escalating a route issue.

Check one TypeScript or TSX file with pinned compiler diagnostics, target and strictness choices, and explicit project-context limits.

Check a suspicious URL with Safe Browsing and SURBL plus weighted string clues, then review every source's scope and gaps before choosing a safer next step.

Calculate allowed downtime and budget use from an SLA or SLO target, with burn pace and projected availability under a chosen maintenance policy.

Parse a User-Agent string or header block into a readable browser profile with device, crawler and Client Hints evidence for reliable triage.

Compare switch VLAN evidence with intended trunk and native rules plus database, reserved-VLAN, and VLAN 1 policy before a change.

Estimate practical VPN concurrent-user capacity from tunnel rate and packet overhead with gateway limits, busy-hour demand, and MTU risk checks.

Convert VSWR or return loss into exact RF mismatch values and power splits with support for reflection coefficient, reflected watts and review guidance.

Inspect one local video for container and stream evidence, with bounded file reads plus clear warnings for sampled or missing metadata.

Estimate WAN round-trip latency from route distance and path overhead to compare target headroom, dominant delays and serial application wait.

Check domain registration data through RDAP with WHOIS fallback, then review expiry timing, nameservers and evidence coverage for follow-up.

Extract WWN and NAA values from SAN text and normalize the hex before decoding identifier fields or flagging fragments for operational review.

Detect visible server and application clues at a public URL, including CDN or proxy evidence across redirects and a clear confidence score.

Test an authorized WebSocket endpoint from your browser with bounded traffic and inspect timing, close codes, the selected subprotocol and optional payload previews.

Calculate a child's weight-for-age percentile from WHO or CDC reference data with corrected-age handling and clear screening limits.

Calculate weight-for-length percentile from WHO or CDC references with measurement correction, source comparison and growth-context cautions.

Identify your current browser session, check storage and graphics readiness, and review privacy exposure before sharing a support report.

Check the public IPv4 or IPv6 address visible to your browser, with ASN, network owner, approximate location, and provider coverage.

Check your current viewport and screen resolution, compare responsive breakpoints, and estimate device-pixel capture size from browser readings.

Validate XML against a supplied XSD 1.0 Core schema with namespace-aware findings and blocked external resource resolution in your browser.

Compare two YAML documents as parsed data with schema-aware scalar types and sequence matching, then review path-level changes and ignored paths.