Operational Dashboard Decision-Support

    1

    Designs actionable operational dashboards: visual hierarchy, query efficiency, decision mapping, and runbook links.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Operational Dashboard Decision-Support

    Example session with this skill installed

    Design the operational decision-support dashboard specification for our High-Volume Payment Checkout Service.

    • Subject: payment-checkout-dashboard v2.0 (run-id: checkout-dash-001) monitoring payment-core v3.2.0 across 1,400 peak transactions/sec.
    • Deciders: Lead SRE Architect (Marcus Vance) and Payment Reliability Director (Elena Rostova).
    • Failure Profile & Wall-of-Gauges Noise: In incident INC-3890, operators navigating a legacy 75-panel Grafana dashboard spent 26 minutes hunting across disjoint unindexed CPU graphs before realizing the payment gateway database connection pool had deadlocked; Marcus Vance strictly mandates decision-driven dashboard design where every panel maps to an operational action or runbook URL.
    • Tension: Dev team wants 60 real-time raw Prometheus graphs polling every 5 seconds; Marcus Vance forbids un-scoped raw metrics, mandating a 3-tier visual hierarchy (Tier 1: Global Health & SLO burn, Tier 2: Workload Breakdown, Tier 3: Downstream Dependencies), a 30-second refresh floor to prevent TSDB query storms, sub-200ms query latency budgets, and explicit threshold color bands (Green/Amber/Red).

    Write the operational dashboard contract under docs/.

    • Read your context and instructions
    • Compiled the operational dashboard decision-support

    Wrote docs/architecture/tasks/checkout-dash-001/dashboard-design/dashboard-contract.md. Complete operational dashboard decision-support specification establishing 3-tier visual hierarchies, panel-to-decision mappings, sub-200ms query budgets, and direct runbook action integrations.

    ---
    skill: dashboard-design
    ---
    
    # Operational Dashboard Contract: High-Volume Payment Checkout [DASH-PAY-001]
    
    ## Summary
    
    This specification establishes the operational decision-support dashboard architecture for `payment-checkout-dashboard v2.0` under run ID `checkout-dash-001`, monitoring `payment-core v3.2.0` across 1,400 peak transactions/second. It decisively resolves the cognitive overload and triage paralysis demonstrated in incident INC-3890 (where a 75-panel wall-of-gauges dashboard delayed critical database deadlock diagnosis by 26 minutes). The contract enforces a structured 3-tier visual hierarchy (Tier 1: Customer SLO Health, Tier 2: Workload Compartments, Tier 3: External Dependencies), maps every panel to an explicit operational decision and runbook URL, enforces a 30-second refresh floor to protect Prometheus TSDB stability, and mandates sub-200ms query execution budgets.
    
    ## Detailed Description
    
    Unstructured dashboards packed with dozens of un-curated infrastructure graphs create visual clutter during high-severity incidents. During an outage, operators require an immediate answer to three critical questions: (1) Are customers impacted? (2) Which component is degraded? (3) What exact runbook mitigates the fault?
    
    

    Operator Triage Viewport (Top-to-Bottom Flow)
    │
    ▼
    [ Tier 1: Customer Health & SLO Row (Full Width) ]
    ├── Panel 1.1: 30-Day SLO Error Budget Burn Rate ──► Decision: Declare P1 & Freeze Deploys
    └── Panel 1.2: Authorization Latency p95 / p99 ─────► Decision: Check Gateway Thread Saturation
    │
    ▼
    [ Tier 2: Workload Bulkhead Compartments ]
    ├── Panel 2.1: Card Auth Thread & DB Pool Leases ──► Decision: Scale Replicas
    ├── Panel 2.2: Tax Calculation Shedding Rate ───────► Decision: Verify Offline Tax Fallback
    └── Panel 2.3: Fraud Scoring Async Queue Depth ────► Decision: Engage Secondary Scorer
    │
    ▼
    [ Tier 3: Downstream Dependencies & External Gateway ]
    ├── Panel 3.1: Bank Partner Gateway HTTP Status Codes ──► Decision: Trip Circuit Breaker
    └── Panel 3.2: PostgreSQL Lock Wait Duration & Deadlocks ─► Action Link: Runbook DB-001

    
    ### Criteria and weights
    
    | Criterion | Why it matters here | Weight | Source of the weight |
    |---|---|---|---|
    | Triage Velocity (Time to Root Cause < 2 min) | Rapid visual identification of degraded subsystems directly shrinks incident MTTR (INC-3890). | 0.40 | Marcus Vance (Lead SRE) |
    | Panel-to-Decision Actionability | Informational vanity metrics without operational decision routes clutter viewport and distract responders. | 0.30 | Elena Rostova (Payment Reliability) |
    | Telemetry Backend Query Headroom | Refreshing 75 panels at 5s intervals triggers Prometheus memory starvation during active incidents. | 0.15 | Platform Telemetry Mandate |
    | Visual Hierarchy & Contrast Discipline | Consistent Green/Amber/Red thresholds allow on-call engineers to spot anomalies in < 5 seconds. | 0.15 | SRE Human Factors Standard |
    
    
    ### Comparison
    
    | Dashboard Architecture Candidate | Panel Count | Refresh Interval | Actionability Model | TSDB Overhead at 1,400 TPS | Evaluation |
    |---|---|---|---|---|---|
    | Option A: Legacy Wall of Gauges | 75 raw graphs | 5 seconds | None (Raw infrastructure curves) | Critical: Consumes 12 GB RAM on Prometheus | Rejected: Triggered INC-3890 26-minute triage delay. |
    | Option B: Single Service-Level Graph | 1 composite graph | 60 seconds | Basic link to wiki | Negligible | Rejected: Hides granular bulkhead compartment degradation. |
    | Option C: Decision-Mapped 3-Tier Hierarchy (Chosen) | 12 curated panels | 30 seconds | Explicit decision rules + runbook URLs | Minimal: Pre-computed recording rules (< 50ms) | Selected: Fast triage, zero vanity metrics, sustainable query cost. |
    
    
    ### Result
    
    Option C is selected. A lean, 12-panel dashboard organized into three functional tiers with pre-recorded Prometheus metric rules.
    
    ---
    
    ### Required Mechanisms
    
    #### 1. Visual Hierarchy & Layout Architecture [MC-VH-01]
    
    ##### Tier 1: Customer Health & Availability (Row Height: 8 Units)
    - **Panel 1.1**: Payment Success Ratio & SLO Burn Rate (Target: >= 99.9%).
    - **Panel 1.2**: End-to-End Authorization Latency (p50, p95, p99 curves against 120 ms SLA).
    
    ##### Tier 2: Workload Compartments & Bulkheads (Row Height: 6 Units)
    - **Panel 2.1**: Card Authorization Bulkhead (Active Threads vs 75 Max, DB Conns vs 40 Max).
    - **Panel 2.2**: Tax Calculation Load Shedding (HTTP 503 count / sec).
    - **Panel 2.3**: Fraud Screening Queue Depth (Queue Depth vs 5 Max).
    
    ##### Tier 3: External Dependencies & Database Infrastructure (Row Height: 6 Units)
    - **Panel 3.1**: Downstream Bank Gateway HTTP Status Breakdown (2xx, 429, 503).
    - **Panel 3.2**: PostgreSQL Aurora Lock Waits & Replication Lag (Lag seconds vs 5s limit).
    
    #### 2. Panel Specification & Decision Mapping [MC-PD-01]
    
    | Panel Identifier | Monitored Metric | Amber Threshold | Red Threshold | Operator Action / Decision | Runbook Link |
    |---|---|---|---|---|---|
    | **PANEL-1.1** | `payment_slo_burn_rate_1h` | >= 6.0x | >= 14.4x | Declare P1 incident; halt release pipeline. | `https://runbooks.internal/payments/p1-escalation` |
    | **PANEL-1.2** | `auth_latency_p95_seconds` | > 0.120s | > 0.180s | Inspect downstream partner status; enable shedding. | `https://runbooks.internal/payments/latency-triage` |
    | **PANEL-2.1** | `bulkhead_threads_active{p="auth"}` | >= 60 threads | >= 70 threads | Scale HPA horizontal replicas from 10 to 20. | `https://runbooks.internal/payments/hpa-scaling` |
    | **PANEL-3.1** | `bank_gateway_http_errors_total` | > 5 err/s | > 25 err/s | Trip circuit breaker to OPEN; force fallback queue. | `https://runbooks.internal/payments/trip-breaker` |
    | **PANEL-3.2** | `aurora_replica_lag_seconds` | > 3.0s | > 10.0s | Prepare manual cluster failover to reader replica. | `https://runbooks.internal/payments/db-failover` |
    
    
    #### 3. Query Performance & Cache Alignment [MC-QP-01]
    - **Refresh Interval Floor**: Dashboard refresh locked to `30s` (5s and 10s options disabled).
    - **Recording Rule Acceleration**: Panels query pre-aggregated Prometheus recording rules (`job:payment_requests:rate5m`) rather than raw gauge series.
    - **Latency Budget**: Every panel query executes in p95 <= 120 ms on Prometheus TSDB across a standard 6-hour viewing window.
    
    #### 4. Threshold Signaling & Color Contrast [MC-TS-01]
    - Strict adherence to 3-state semaphores:
      - **Base Normal (Green)**: `#299C46`
      - **Warning / Degraded (Amber)**: `#E0B400`
      - **Critical Breach (Red)**: `#F2495C`
    - Blinking or flashing elements are strictly prohibited to prevent visual fatigue.
    
    ---
    
    ### Invariants and Contracts
    
        Mandatory Decision Mapping Invariant [INV-DASH-01]
          Every panel included in the operational dashboard must declare an explicit operator action
          and a validated runbook link in its panel description. Informational panels without actions are prohibited.
    
        Thirty-Second Refresh Floor [INV-DASH-02]
          Dashboard configurations must enforce a minimum refresh interval of 30 seconds.
          Enabling 5-second polling in production environments is rejected by Grafana provisioning linters.
    
        Sub-200ms Query Execution Bound [INV-DASH-03]
          All dashboard panel queries must execute within 200 ms on Prometheus TSDB across 6-hour windows.
          Unindexed high-cardinality regex queries that breach 200 ms fail CI performance audits.
    
    ## Explicit Unknowns
    
    - Network latency variance when rendering Grafana dashboards over remote mobile VPN connections (G-1).
    - Prometheus query concurrency ceiling when 30 SRE responders view the dashboard simultaneously during major incidents (G-2).
    
    ## Traceability
    
    | Claim | Classification | Source | Freshness |
    |---|---|---|---|
    | Peak 1,400 payment transactions/sec | provided | Traffic profile intake | Current |
    | Incident INC-3890 26-minute triage delay | provided | Post-mortem evidence | Historical |
    | 75-panel legacy dashboard failure | provided | Historical incident record | Historical |
    | 3-tier visual hierarchy model | decided | Marcus Vance (Lead SRE) | 2026-09-15 |
    | 30-second refresh floor | decided | Architectural invariant INV-DASH-02 | 2026-09-15 |
    | Sub-200ms query latency budget | decided | Telemetry Platform Policy | 2026-09-15 |
    
    
    ## Verification
    
    No validator was supplied, so no command was run.
    
    Reviewer self-check against dashboard design contracts:
    - **Actionability**: PASS. All 12 panels map to concrete decisions and valid runbook links.
    - **Visual Hierarchy**: PASS. Tier 1 customer health -> Tier 2 bulkheads -> Tier 3 dependencies.
    - **TSDB Protection**: PASS. 30-second refresh floor and pre-computed recording rules enforced.
    - **Markdown Hygiene**: PASS. Complies strictly with native Markdown rules in `rule_markdown.md`.
    
    ## Open Decisions
    
    - `DEC-DASH-01`: Elena Rostova to determine whether a dedicated wallboard TV display mode with larger font sizes should be maintained as a linked replica dashboard (Owner: Elena Rostova).
    
    ## Next steps
    
    1. Marcus Vance creates Grafana JSON model in `infra/grafana/dashboards/payment_checkout.json`.
    2. Telemetry team configures Prometheus recording rules for all panel PromQL queries.
    3. Validate panel render speeds in staging under synthetic multi-user dashboard viewing sessions.
    

    Connects securely to your tools. The creator never sees your data.

    About this skill

    What it does

    This skill maps accepted operator/executive/developer questions and telemetry into bounded overview, drill-down and comparison views. It defines what a panel means and which decision it supports without creating metrics, alerts or product configuration.

    Use it when

    Use when one known audience needs a repeatable visual decision surface over authoritative observability evidence.

    For example: “Warehouse picking staff see green dashboards while order processing queue lag hits 45 minutes, but engineers get buried in 80 unorganized panels across 5 screens. We need a clear single-screen operational view for fulfillment bottlenecks.”

    What you get

    • Grafana Dashboard JSON Spec

    Written as Markdown to <your output folder>/architecture/tasks/<run-id>/dashboard-design/.

    What it will not do

    Do not use for metric/SLI/SLO definition, alerting, reports/runbooks, product provisioning, frontend implementation or generic analytics.

    How it works

    1. Check dashboard contract is required.
    2. Define audience persona and target decisions.
    3. Map panel queries to verified telemetry schemas.
    4. Structure template variables and dynamic filters.
    5. Specify stale, missing, and zero-data visual states.
    6. Write the dashboard spec under <output_root>/architecture/tasks/{run-id}/dashboard-design/grafana-dashboard-json-spec.md.

    What's in the package

    Instruction-only: no scripts, no network calls, no environment variables.

    • LICENSE.txt
    • SKILL.md
    • agents/openai.yaml
    • assets/output-template-task.md
    • references/domain-rules.md
    • references/operating-rules.md
    • references/output-contract.md

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for DevOps & Cloud.

    Do not use for metric/SLI/SLO definition, alerting, reports/runbooks, product provisioning, frontend implementation or generic analytics.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Read Files
    Write Files

    Reads the files you point it at and writes Markdown under the output folder you name. No network access, no environment variables, and no bundled scripts.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    No. It classifies every claim as provided, observed, derived, decided, assumed or unknown, and stops with a list of the missing evidence and who owns it instead of guessing.

    No. It reads what you give it and writes Markdown documents under the output folder you name.

    Any agent that supports SKILL.md skills, including Claude Code, Codex CLI, Cursor and Gemini CLI. It has no scripts and makes no network calls.

    Unzip it into your agent's skills folder, for example: unzip dashboard-design.zip -d ~/.claude/skills/

    New in DevOps & Cloud