plotly-dashboard-skill
npx machina-cli add skill fmschulz/omics-skills/plotly-dashboard-skill --openclawFiles (1)
SKILL.md
1.5 KB
Plotly Dashboard Skill
Create interactive dashboards with a single source of truth for UI and figure styling.
Instructions
- Capture audience, questions, and data constraints.
- Pick a layout pattern and component library.
- Define a theme and Plotly figure template.
- Build the layout skeleton before callbacks.
- Implement callbacks with clear inputs/outputs.
- Optimize slow callbacks with caching or pre-aggregation.
Quick Reference
| Task | Action |
|---|---|
| UI style guide | See STYLE_GUIDE.md |
| Figure template | See FIGURE_STYLE.md |
| Palettes | See PALETTES.md |
| App architecture | See DASH_ARCHITECTURE.md |
| Performance | See 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
- Step 1: Capture audience, decisions, data sources, and update cadence.
- Step 2: Pick a layout pattern and define a theme + Plotly figure template.
- 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