Get the FREE Ultimate OpenClaw Setup Guide →

plotly-dashboard-skill

npx machina-cli add skill fmschulz/omics-skills/plotly-dashboard-skill --openclaw
Files (1)
SKILL.md
1.5 KB

Plotly Dashboard Skill

Create interactive dashboards with a single source of truth for UI and figure styling.

Instructions

  1. Capture audience, questions, and data constraints.
  2. Pick a layout pattern and component library.
  3. Define a theme and Plotly figure template.
  4. Build the layout skeleton before callbacks.
  5. Implement callbacks with clear inputs/outputs.
  6. Optimize slow callbacks with caching or pre-aggregation.

Quick Reference

TaskAction
UI style guideSee STYLE_GUIDE.md
Figure templateSee FIGURE_STYLE.md
PalettesSee PALETTES.md
App architectureSee DASH_ARCHITECTURE.md
PerformanceSee PERFORMANCE.md

Input Requirements

  • Audience and key decisions
  • Data sources and update cadence
  • Required filters and views
  • Deployment constraints

Output

  • Dash app scaffold (layout + callbacks)
  • Consistent theming and figure templates
  • README with usage notes

Quality Gates

  • Layout communicates hierarchy and intent
  • Callbacks are small and focused
  • p95 interaction latency acceptable
  • Styling is consistent across charts

Examples

Example 1: Layout-first workflow

Header + filters + KPI row + primary trends + breakdown table

Troubleshooting

Issue: Slow callbacks Solution: Cache expensive steps or pre-aggregate data.

Source

git clone https://github.com/fmschulz/omics-skills/blob/main/skills/plotly-dashboard-skill/SKILL.mdView on GitHub

Overview

Creates interactive dashboards with a single source of truth for UI and figure styling. Emphasizes consistent theming, clean layouts, and fast, focused callbacks to deliver production-ready apps.

How This Skill Works

Start by capturing audience needs, data constraints, and decisions. Then choose a layout pattern and a component library, define a theme and a Plotly figure template, and build the layout skeleton before coding callbacks. Implement callbacks with clear inputs and outputs, and optimize slow paths with caching or pre-aggregation.

When to Use It

  • You're building a layout-first dashboard where the UI communicates hierarchy (layout-first workflow).
  • You need consistent theming and a shared figure template across charts.
  • You have slow callbacks and need caching or pre-aggregation to speed up interactivity.
  • You're delivering a production-ready app scaffold with a robust layout and callback structure.
  • You're aligning audience, data sources, filters, and deployment constraints early in the project.

Quick Start

  1. Step 1: Capture audience, decisions, data sources, and update cadence.
  2. Step 2: Pick a layout pattern and define a theme + Plotly figure template.
  3. Step 3: Build the layout skeleton, wire up callbacks with clear inputs/outputs, and optimize slow paths.

Best Practices

  • Capture audience and decision criteria upfront (audience, data constraints, update cadence).
  • Pick a layout pattern and a component library to standardize UI across charts.
  • Define a theme and Plotly figure template to ensure visual consistency.
  • Build the layout skeleton before implementing callbacks to avoid rework.
  • Keep callbacks small and focused; optimize slow paths with caching or pre-aggregation.

Example Use Cases

  • Example 1: Layout-first workflow—Header + filters + KPI row + primary trends + breakdown table.
  • Produce a production-ready Dash scaffold with a clear layout and defined callbacks.
  • Apply consistent theming across charts via a defined theme and Plotly figure templates.
  • Coordinate styling with style references (STYLE_GUIDE.md and FIGURE_STYLE.md) for uniform visuals.
  • Address performance early by caching expensive steps to reduce callback latency.

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers