home / skills / jeremylongshore / claude-code-plugins-plus-skills / analyzing-database-indexes

This skill analyzes database indexes to design, optimize, and validate indexing strategies that boost query performance and reliability.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill analyzing-database-indexes

Review the files below or copy the command above to add this skill to your agents.

Files (5)
SKILL.md
4.8 KB
---
name: analyzing-database-indexes
description: |
  Process use when you need to work with database indexing.
  This skill provides index design and optimization with comprehensive guidance and automation.
  Trigger with phrases like "create indexes", "optimize indexes",
  or "improve query performance".
  
allowed-tools: Read, Write, Edit, Grep, Glob, Bash(psql:*), Bash(mysql:*), Bash(mongosh:*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---
# Database Index Advisor

This skill provides automated assistance for database index advisor tasks.

## Prerequisites

Before using this skill, ensure:
- Required credentials and permissions for the operations
- Understanding of the system architecture and dependencies
- Backup of critical data before making structural changes
- Access to relevant documentation and configuration files
- Monitoring tools configured for observability
- Development or staging environment available for testing

## Instructions

### Step 1: Assess Current State
1. Review current configuration, setup, and baseline metrics
2. Identify specific requirements, goals, and constraints
3. Document existing patterns, issues, and pain points
4. Analyze dependencies and integration points
5. Validate all prerequisites are met before proceeding

### Step 2: Design Solution
1. Define optimal approach based on best practices
2. Create detailed implementation plan with clear steps
3. Identify potential risks and mitigation strategies
4. Document expected outcomes and success criteria
5. Review plan with team or stakeholders if needed

### Step 3: Implement Changes
1. Execute implementation in non-production environment first
2. Verify changes work as expected with thorough testing
3. Monitor for any issues, errors, or performance impacts
4. Document all changes, decisions, and configurations
5. Prepare rollback plan and recovery procedures

### Step 4: Validate Implementation
1. Run comprehensive tests to verify all functionality
2. Compare performance metrics against baseline
3. Confirm no unintended side effects or regressions
4. Update all relevant documentation
5. Obtain approval before production deployment

### Step 5: Deploy to Production
1. Schedule deployment during appropriate maintenance window
2. Execute implementation with real-time monitoring
3. Watch closely for any issues or anomalies
4. Verify successful deployment and functionality
5. Document completion, metrics, and lessons learned

## Output

This skill produces:

**Implementation Artifacts**: Scripts, configuration files, code, and automation tools

**Documentation**: Comprehensive documentation of changes, procedures, and architecture

**Test Results**: Validation reports, test coverage, and quality metrics

**Monitoring Configuration**: Dashboards, alerts, metrics, and observability setup

**Runbooks**: Operational procedures for maintenance, troubleshooting, and incident response

## Error Handling

**Permission and Access Issues**:
- Verify credentials and permissions for all operations
- Request elevated access if required for specific tasks
- Document all permission requirements for automation
- Use separate service accounts for privileged operations
- Implement least-privilege access principles

**Connection and Network Failures**:
- Check network connectivity, firewalls, and security groups
- Verify service endpoints, DNS resolution, and routing
- Test connections using diagnostic and troubleshooting tools
- Review network policies, ACLs, and security configurations
- Implement retry logic with exponential backoff

**Resource Constraints**:
- Monitor resource usage (CPU, memory, disk, network)
- Implement throttling, rate limiting, or queue mechanisms
- Schedule resource-intensive tasks during low-traffic periods
- Scale infrastructure resources if consistently hitting limits
- Optimize queries, code, or configurations for efficiency

**Configuration and Syntax Errors**:
- Validate all configuration syntax before applying changes
- Test configurations thoroughly in non-production first
- Implement automated configuration validation checks
- Maintain version control for all configuration files
- Keep previous working configuration for quick rollback

## Resources

**Configuration Templates**: `{baseDir}/templates/database-index-advisor/`

**Documentation and Guides**: `{baseDir}/docs/database-index-advisor/`

**Example Scripts and Code**: `{baseDir}/examples/database-index-advisor/`

**Troubleshooting Guide**: `{baseDir}/docs/database-index-advisor-troubleshooting.md`

**Best Practices**: `{baseDir}/docs/database-index-advisor-best-practices.md`

**Monitoring Setup**: `{baseDir}/monitoring/database-index-advisor-dashboard.json`

## Overview

This skill provides automated assistance for the described functionality.

## Examples

Example usage patterns will be demonstrated in context.

Overview

This skill automates database index design and optimization to improve query performance and reduce resource usage. It guides you through assessment, design, testing, and safe production deployment while producing scripts, documentation, and monitoring artifacts. Use it to get prioritized index recommendations, implementation plans, and runbooks for operational maintenance.

How this skill works

The skill inspects schema, query patterns, and runtime metrics to identify missing, redundant, or suboptimal indexes. It generates concrete index definitions, change scripts, and a step-by-step implementation plan that includes testing and rollback procedures. It also produces monitoring configurations and runbooks so performance impacts can be observed and managed after deployment.

When to use it

  • When slow queries or high CPU/disk I/O indicate indexing issues
  • Before major schema changes or application feature launches
  • During capacity planning or performance tuning cycles
  • When consolidating databases or refactoring data models
  • To automate index creation and rollback in CI/CD pipelines

Best practices

  • Always run recommendations in a staging environment before production
  • Capture baseline metrics (latency, CPU, I/O) to compare post-change results
  • Prefer targeted, narrow indexes over broad ones to limit write overhead
  • Document all index changes, reasoning, and rollback steps
  • Schedule heavy index builds during low-traffic windows and enable monitoring

Example use cases

  • Analyze slow-reporting queries and create composite indexes to reduce scan time
  • Remove redundant or duplicate indexes to cut storage and write amplification
  • Automate index builds and rollbacks as part of database migration pipelines
  • Generate monitoring dashboards and alerts for newly added indexes
  • Create runbooks for on-call teams describing how to revert index changes

FAQ

What inputs does the skill need to produce recommendations?

Provide schema definitions, representative query logs or explain plans, and recent performance metrics (CPU, I/O, query latency). Credentials and permission to read metadata are required; write permission is needed only to apply changes.

Can the skill apply index changes directly to production?

The skill produces safe, reviewed change scripts and a deployment plan. Applying changes to production is permitted only after testing and approval; it is recommended to use the provided rollbacks and maintenance windows.