| name | mermaid-mindmap |
| description | **MERMAID MINDMAP EXPERT** — Specialized skill for creating tech-focused Mermaid mindmaps for knowledge organization and system planning. USE FOR: technology stack planning; software architecture brainstorming; feature breakdown structures; technical decision trees; system component hierarchies; learning path visualization; troubleshooting guides; project planning; technical concept mapping; knowledge base organization. CREATES: hierarchical mindmaps with proper indentation; styled mindmaps with custom shapes and icons; interactive mindmaps with clickable elements; complex multi-level technical taxonomies; visual knowledge structures. TECH FOCUS: Organizes complex technical information into digestible visual hierarchies, emphasizing relationships between technologies, components, and concepts. |
Mermaid Mindmap Skill
Tech-focused mindmaps for knowledge organization and system planning
Purpose
This skill specializes in creating Mermaid mindmaps that organize complex technical information into clear, hierarchical visual structures. Perfect for planning technology stacks, breaking down system architectures, and creating visual knowledge bases for technical concepts.
Core Capabilities
Mindmap Types Supported
- Technology Stack Planning: Framework selection, tool evaluation
- System Architecture: Component hierarchies, service dependencies
- Feature Breakdown: Epic → Story → Task decomposition
- Learning Paths: Skill progression, certification tracks
- Troubleshooting Guides: Problem → Solution hierarchies
- Project Planning: Technical roadmaps, milestone organization
- Knowledge Management: Concept relationships, documentation structure
- Decision Trees: Technical choice evaluation
Mermaid Mindmap Syntax Mastery
Basic Structure
mindmap
root((Technology Stack))
Frontend
React
Next.js
Hooks
State Management
Redux
Zustand
Vue
Nuxt.js
Composition API
Backend
Node.js
Express
Fastify
Python
FastAPI
Django
Database
SQL
PostgreSQL
MySQL
NoSQL
MongoDB
Redis
Shape Variations
mindmap
root((Central Concept))
[Square Node]
(Rounded Square)
((Circle Node))
))Bang Node((
)Cloud Node(
{{Hexagon Node}}
Default Shape Node
Advanced Features with Icons & Styling
mindmap
root((DevOps Workflow))
Development
::icon(fa fa-code)
Git Workflow
Code Review
Testing
Unit Tests
Integration Tests
CI/CD
::icon(fa fa-cogs)
Build Pipeline
Docker
GitHub Actions
Deployment
Staging
Production
Monitoring
::icon(fa fa-chart-line)
Metrics
Prometheus
Grafana
Logging
ELK Stack
Fluentd
Tech-Specific Patterns
Full-Stack Application Architecture
mindmap
root((E-commerce Platform))
Frontend
User Interface
React Components
Product Catalog
Shopping Cart
Checkout Flow
State Management
Redux Toolkit
React Query
Mobile App
React Native
Expo CLI
Backend Services
API Gateway
Kong
Rate Limiting
Authentication
Microservices
User Service
Registration
Authentication
Profile Management
Product Service
CRUD Operations
Search & Filter
Inventory Management
Order Service
Cart Management
Payment Processing
Order Tracking
Data Layer
Databases
PostgreSQL
User Data
Order History
MongoDB
Product Catalog
Session Data
Redis
Caching
Session Store
Message Queue
RabbitMQ
Event Processing
Infrastructure
Cloud Platform
AWS/Azure/GCP
Container Orchestration
Kubernetes
Docker Swarm
Monitoring
Prometheus
Grafana
ELK Stack
Learning Path: Becoming a DevOps Engineer
mindmap
root((DevOps Engineer Path))
Foundation Skills
Operating Systems
Linux Administration
Command Line
File Systems
Process Management
Windows Server
PowerShell
Active Directory
Networking
TCP/IP
DNS
Load Balancers
Firewalls
Programming
Scripting
Bash
PowerShell
Python
Version Control
Git
GitHub/GitLab
Core DevOps Tools
Infrastructure as Code
Terraform
Ansible
CloudFormation
Containerization
Docker
Images & Containers
Docker Compose
Kubernetes
Pods & Services
Ingress Controllers
Helm Charts
CI/CD Pipelines
Jenkins
GitHub Actions
GitLab CI
Azure DevOps
Cloud Platforms
AWS
EC2, S3, RDS
Lambda
CloudWatch
Azure
Virtual Machines
App Service
Monitor
GCP
Compute Engine
Cloud Functions
Stackdriver
Monitoring & Security
Observability
Prometheus
Grafana
ELK Stack
Security
SSL/TLS
Secrets Management
Compliance
Technology Decision Framework
mindmap
root{{Database Selection}}
Requirements Analysis
Data Structure
Relational
ACID Properties
Complex Queries
Joins Required
Document-based
Flexible Schema
Nested Objects
Rapid Development
Key-Value
Simple Lookups
High Performance
Caching Layer
Scale Requirements
Read vs Write Heavy
Concurrency Needs
Storage Size
Geographic Distribution
Technology Options
SQL Databases
PostgreSQL
Advanced Features
JSON Support
Full-text Search
MySQL
Proven Stability
Wide Adoption
Good Performance
SQLite
Embedded Use
Zero Configuration
Local Development
NoSQL Options
MongoDB
Document Store
Horizontal Scaling
Rich Query Language
Redis
In-Memory
Data Structures
Pub/Sub Messaging
DynamoDB
Serverless
Auto-scaling
AWS Native
Evaluation Criteria
Performance
Query Speed
Write Throughput
Read Latency
Operational
Backup & Recovery
Monitoring Tools
Maintenance Overhead
Cost Factors
Licensing
Infrastructure
Development Time
Troubleshooting Guide: Application Performance
mindmap
root))Performance Issues((
Symptoms
Slow Response Time
Database Queries
Missing Indexes
N+1 Problems
Large Result Sets
API Bottlenecks
Synchronous Processing
External API Calls
Memory Leaks
High Resource Usage
CPU Intensive
Inefficient Algorithms
Infinite Loops
Heavy Computation
Memory Issues
Memory Leaks
Large Object Graphs
Insufficient Cleanup
Diagnostic Tools
Application Monitoring
APM Tools
New Relic
Datadog
AppInsights
Profiling
CPU Profilers
Memory Profilers
Database Profilers
Infrastructure Monitoring
System Metrics
CPU Usage
Memory Usage
Disk I/O
Network Analysis
Latency Monitoring
Throughput Analysis
Error Rates
Solutions
Code Optimization
Algorithm Improvements
Caching Strategies
Redis
Memcached
Application Cache
Async Processing
Message Queues
Background Jobs
Event-driven Architecture
Infrastructure Scaling
Horizontal Scaling
Load Balancers
Auto-scaling Groups
Microservices
Vertical Scaling
Increase Resources
Optimize Hardware
SSD Storage
Project Planning: Microservices Migration
mindmap
root((Microservices Migration))
Assessment Phase
Current Architecture
Monolith Analysis
Code Dependencies
Database Schema
Performance Bottlenecks
Business Domains
User Management
Product Catalog
Order Processing
Payment Handling
Migration Strategy
Strangler Fig Pattern
Database Decomposition
API Gateway Implementation
Technical Preparation
Infrastructure Setup
Container Platform
Kubernetes Cluster
Docker Registry
Networking Setup
Observability Stack
Distributed Tracing
Centralized Logging
Metrics Collection
Development Tools
Service Templates
CI/CD Pipelines
Testing Frameworks
Contract Testing
End-to-End Testing
Implementation Phases
Phase 1: Extract User Service
Authentication/Authorization
User Profile Management
Database Migration
Phase 2: Product Service
Catalog Management
Search Functionality
Inventory Tracking
Phase 3: Order Service
Shopping Cart
Order Processing
Payment Integration
Post-Migration
Performance Optimization
Service Communication
Database Queries
Caching Strategies
Operational Excellence
Monitoring Setup
Alert Configuration
Documentation Update
Cloud Migration Planning
mindmap
root{{Cloud Migration Strategy}}
Assessment
Current State Analysis
Application Inventory
Legacy Systems
Dependencies
Performance Metrics
Infrastructure Audit
Hardware Age
Capacity Utilization
Security Posture
Business Requirements
Cost Optimization
Scalability Needs
Compliance Requirements
Disaster Recovery
Migration Approaches
Lift and Shift
Fast Migration
Minimal Changes
Infrastructure as a Service
Re-platforming
Optimize for Cloud
Managed Services
Performance Improvements
Re-architecting
Cloud-Native Design
Microservices
Serverless Functions
Cloud Strategy
Multi-Cloud
Risk Mitigation
Best-of-Breed Services
Avoid Vendor Lock-in
Single Cloud Provider
Deeper Integration
Cost Optimization
Simplified Management
Hybrid Approach
On-premises + Cloud
Gradual Migration
Regulatory Compliance
Implementation
Pilot Projects
Low-Risk Applications
Learning Opportunities
Proof of Concept
Production Migration
Phased Approach
Rollback Plans
Performance Validation
Optimization
Cost Management
Security Hardening
Performance Tuning
Best Practices
Structure & Organization
- Start with a clear central concept
- Use logical hierarchical grouping
- Maintain consistent indentation
- Balance depth vs breadth for readability
Visual Design
- Choose appropriate shapes for different concepts
- Use icons to enhance understanding (FontAwesome)
- Apply consistent styling within domains
- Consider color coding for categories
Technical Accuracy
- Reflect real-world relationships accurately
- Include relevant technical details
- Show both horizontal and vertical dependencies
- Consider operational aspects like monitoring and security
Content Strategy
- Focus on actionable information
- Include decision criteria where relevant
- Show alternative paths and options
- Link to detailed documentation
Integration Guidelines
Documentation
- Use in technical specifications
- Include in architecture decision records
- Add to onboarding materials
- Create visual table of contents
Planning & Strategy
- Include in project kickoff meetings
- Use for technology selection processes
- Add to quarterly planning sessions
- Create visual roadmaps
Knowledge Management
- Build technical competency maps
- Create troubleshooting decision trees
- Organize learning resources
- Map system dependencies
Validation & Refinement
- Syntax Validation: Ensure proper Mermaid formatting
- Logical Review: Verify hierarchical relationships make sense
- Completeness Check: Ensure all relevant concepts are included
- Accessibility: Test with screen readers and assistive technology
- Maintenance: Keep content current with technology changes
"Mindmaps transform complex technical landscapes into navigable territories"
