dashboard-builder
affaan-m/everything-claude-code
Build operational dashboards that answer real questions, not vanity boards.
What is dashboard-builder?
Creates monitoring dashboards for Grafana, SigNoz, and similar platforms focused on answering operator questions: is it healthy, where's the bottleneck, what changed, what action to take. Use when turning metrics into a working dashboard instead of displaying every available metric.
- Start from operator questions rather than visual layout
- Organize panels around health, latency, throughput, saturation, and service-specific risks
- Study target platform schema and existing dashboards before building
- Build minimum useful board with overview, performance, resources, and service-specific sections
- Remove vanity panels that don't answer real operational questions
- Ensure valid JSON, clear grouping, titles, units, meaningful thresholds, and sensible defaults
How to install dashboard-builder
npx skills add https://github.com/affaan-m/everything-claude-code --skill dashboard-builderHow to use dashboard-builder
- 1.Define the operating questions your dashboard must answer (health, latency, throughput, saturation, service risks)
- 2.Study the target platform's schema by inspecting existing dashboards for JSON structure and query language
- 3.Build the minimum useful board with four sections: overview, performance, resources, and service-specific panels
- 4.Add titles, units, and meaningful thresholds to each panel
- 5.Configure variables for common filters and set sensible default time range and refresh rates
- 6.Review and remove any panels that don't answer a real operational question
Use cases
- Build a Kafka monitoring dashboard with broker count, under-replicated partitions, consumer lag, and disk pressure
- Create a Grafana dashboard for Elasticsearch with cluster health, shard allocation, search latency, and JVM metrics
- Make a SigNoz dashboard for an API gateway with request rate, latency percentiles, error rate, and upstream health
- Turn a metrics list into an operational dashboard with proper structure and filtering variables
- Monitor service health and performance with panels grouped by availability, throughput, and resource utilization
- Site reliability engineers (SREs) building operational dashboards
- DevOps engineers creating monitoring solutions for production systems
- Backend engineers setting up service-specific monitoring
- Platform operators needing to diagnose issues quickly
dashboard-builder FAQ
No. Every panel should answer a real operator question. If a metric doesn't help answer 'is it healthy?', 'where's the bottleneck?', 'what changed?', or 'what action to take?', remove it.
Organize around operator questions: health/availability, latency/performance, throughput/volume, saturation/resources, and service-specific risks. A recommended layout is overview, performance, resources, then service-specific sections.
Start by studying existing dashboards for your platform to understand the JSON structure and query language. Then define the operating questions specific to that service before designing any visual layout.
A valuable panel has a clear title, proper units, meaningful thresholds or status colors, and answers a specific operational question. Vanity panels show metrics just because they exist without actionable insight.
It works with Grafana, SigNoz, and similar monitoring platforms that use JSON-based dashboard definitions and support variables and threshold styling.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: dashboard-builder description: Build monitoring dashboards that answer real operator questions for Grafana, SigNoz, and similar platforms. Use when turning metrics into a working dashboard instead of a vanity board. metadata: origin: ECC direct-port adaptation version: "1.0.0"
Dashboard Builder
Use this when the task is to build a dashboard people can operate from.
The goal is not "show every metric." The goal is to answer:
- is it healthy?
- where is the bottleneck?
- what changed?
- what action should someone take?
When to Use
- "Build a Kafka monitoring dashboard"
- "Create a Grafana dashboard for Elasticsearch"
- "Make a SigNoz dashboard for this service"
- "Turn this metrics list into a real operational dashboard"
Guardrails
- do not start from visual layout; start from operator questions
- do not include every available metric just because it exists
- do not mix health, throughput, and resource panels without structure
- do not ship panels without titles, units, and sane thresholds
Workflow
1. Define the operating questions
Organize around:
- health / availability
- latency / performance
- throughput / volume
- saturation / resources
- service-specific risk
2. Study the target platform schema
Inspect existing dashboards first:
- JSON structure
- query language
- variables
- threshold styling
- section layout
3. Build the minimum useful board
Recommended structure:
- overview
- performance
- resources
- service-specific section
4. Cut vanity panels
Every panel should answer a real question. If it does not, remove it.
Example Panel Sets
Elasticsearch
- cluster health
- shard allocation
- search latency
- indexing rate
- JVM heap / GC
Kafka
- broker count
- under-replicated partitions
- messages in / out
- consumer lag
- disk and network pressure
API gateway / ingress
- request rate
- p50 / p95 / p99 latency
- error rate
- upstream health
- active connections
Quality Checklist
- valid dashboard JSON
- clear section grouping
- titles and units are present
- thresholds/status colors are meaningful
- variables exist for common filters
- default time range and refresh are sensible
- no vanity panels with no operator value
Related Skills
research-opsbackend-patternsterminal-ops
Related skills
More from affaan-m/everything-claude-code and the wider catalog.

security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.

golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.

coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.

frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.

backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.

golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.