Skip to content
Skills Library
Programming · Building & coding

database-designer

/database-designer

Database design with schema analysis, index optimization, and migration generation for PostgreSQL, MySQL, MongoDB, and DynamoDB. Use when designing schemas, optimizing queries, planning migrations, or analyzing database performance.

Licence
MIT
Last repository change
23.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
16
Scripts
3
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 3 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: index_optimizer.py, migration_generator.py, schema_analyzer.py

What it does and when to use it

Database design with schema analysis, index optimization, and migration generation for PostgreSQL, MySQL, MongoDB, and DynamoDB. Use when designing schemas, optimizing queries, planning migrations, or analyzing database performance.

Original author description

Database design with schema analysis, index optimization, and migration generation for PostgreSQL, MySQL, MongoDB, and DynamoDB. Use when designing schemas, optimizing queries, planning migrations, or analyzing database performance.

How it works

  1. Core Capabilities
  2. When to Use
  3. Clarify First
  4. References
  5. Scope & Limitations
  6. Integration Points
Original SKILL.md headings · 66 lines, 761 words
SKILL.md preview
---
name: database-designer
description: >
  Database design with schema analysis, index optimization, and migration generation for
  PostgreSQL, MySQL, MongoDB, and DynamoDB. Use when designing schemas, optimizing queries,
  planning migrations, or analyzing database performance.
license: MIT + Commons Clause
metadata:
  version: 1.1.0
  author: borghei
  category: engineering
  domain: databases
  tier: POWERFUL
  updated: 2026-06-17
  tags:
    - database
    - schema-design
    - indexing
    - migrations
    - postgresql
    - mongodb
---
# Database Designer

The agent analyzes SQL schemas for normalization compliance, recommends optimal indexes based on query patterns, and generates safe migration scripts with rollback procedures. It produces Mermaid ERDs, detects redundant indexes, and implements zero-downtime expand-contract migration patterns for PostgreSQL and MySQL.

## Core Capabilities

- **Schema analysis** — detect normalization violations (1NF-BCNF), missing constraints, naming issues, and data-type problems from DDL or JSON.
- **ERD generation** — produce valid Mermaid entity-relationship diagrams from declared relationships.
- **Index optimization** — recommend indexes from query patterns, order composite columns by selectivity, detect redundant/overlapping indexes, and find covering-index opportunities.
- **Migration generation** — forward + rollback SQL between schema versions, with validation queries.
- **Zero-downtime migrations** — expand-contract pattern with safe backfill for tables with 10M+ rows.
- **Database selection guidance** — match workload requirements to PostgreSQL, MySQL, MongoDB, or DynamoDB.

## When to Use

- Designing or reviewing a new schema for normalization and constraints.
- Optimizing queries by recommending or pruning indexes.
- Planning a safe (optionally zero-downtime) migration between schema versions.
- Analyzing database performance and relationship structure (ERD).
- Choosing the right database technology for a workload.

## Clarify First

Before designing or migrating, settle the inputs below. When one is missing or vague and would change the result, ask about it; when it wouldn't, use a sensible default and say which one you used.

- **Task:** schema analysis/ERD, index optimization, or migration generation (selects `schema_analyzer.py` vs `index_optimizer.py` vs `migration_generator.py`).
- **Engine:** PostgreSQL, MySQL, MongoDB, or DynamoDB (drives the DDL dialect and selection guidance).
- **Schema input & query patterns:** the DDL/JSON schema and the queries to optimize for (the input the tools analyze; index recommendations depend on the query patterns).

Ask about the two or three inputs that matter most for this request, not the whole list. If the user wants a result straight away, produce it and state your assumptions at the top.

## References

Load the reference that matches the task — keep this file lean and pull detail on demand:

- **[references/workflows-and-tools.md](references/workflows-and-tools.md)** — the Quick Start, three core workflows (analyze/optimize, safe migration, index optimization), and the full CLI reference (flags, usage, output formats) for `schema_analyzer.py`, `index_optimizer.py`, and `migration_generator.py`. Read when running the tools end-to-end.
- **[references/patterns-and-troubleshooting.md](references/patterns-and-troubleshooting.md)** — index-type selection table, anti-patterns, the troubleshooting table for tool output, and the success-criteria quality bar. Read when picking an index type, avoiding mistakes, debugging output, or checking your work.
- **[references/database_selection_decision_tree.md](references/database_selection_decision_tree.md)** — systematic database-technology selection based on requirements, data patterns, and operational constraints. Read when choosing between SQL and NoSQL engines.
- **[references/index_strategy_patterns.md](references/index_strategy_patterns.md)** — proven patterns for index design, optimization strategies, and pitfalls to avoid. Read when designing an indexing strategy in depth.
- **[references/normalization_guide.md](references/normalization_guide.md)** — normal forms (1NF-BCNF), decomposition to eliminate anomalies, and integrity trade-offs. Read when normalizing or deliberately denormalizing a schema.

## Scope & Limitations

**Covers:**
- Schema design analysis for SQL databases (PostgreSQL, MySQL) including normalization, constraints, naming, and data types
- Index optimization with selectivity estimation, composite index ordering, covering indexes, and redundancy detection
- Migration generation with forward/rollback scripts, zero-downtime patterns, and validation queries
- ERD generation in Mermaid format from DDL or JSON schema definitions

**Does NOT cover:**
- Runtime query performance monitoring or live database profiling (see `performance-profiler` skill)
- NoSQL-specific schema design for MongoDB, DynamoDB, or Cassandra (conceptual guidance only in the reference sections)
- Database administration tasks such as backup/restore, replication setup, or user/role management
- Application-level ORM configuration, connection pool tuning, or driver-specific optimizations (see `database-schema-designer` for ORM-adjacent patterns)

## Integration Points

| Skill | Integration | Data Flow |
|-------|-------------|-----------|
| `migration-architect` | Migration strategy and execution planning for large-scale schema changes | Database Designer generates migration SQL; Migration Architect orchestrates multi-service deployment order and rollback coordination |
| `database-schema-designer` | Complementary schema design with focus on application-layer patterns | Database Designer provides normalization analysis; Schema Designer applies ORM mapping and application modeling conventions |
| `performance-profiler` | Runtime validation of index and schema optimization recommendations | Database Designer outputs recommended indexes; Performance Profiler measures actual query plan improvements via EXPLAIN ANALYZE |
| `api-design-reviewer` | Alignment between database schema and API resource contracts | Database Designer defines table structures; API Design Reviewer validates that endpoint schemas match underlying data models |
| `ci-cd-pipeline-builder` | Automated migration execution in deployment pipelines | Database Designer generates migration scripts; CI/CD Pipeline Builder integrates them into deployment stages with validation gates |
| `observability-designer` | Database performance monitoring and alerting post-optimization | Database Designer identifies query patterns; Observability Designer configures slow query alerts and index usage dashboards |
Files in this package (16)
  • README.md 12 KB
  • SKILL.md 7 KB
  • index_optimizer.py 38 KB
  • migration_generator.py 49 KB
  • schema_analyzer.py 41 KB
  • assets/sample_query_patterns.json 9 KB
  • assets/sample_schema.json 9 KB
  • assets/sample_schema.sql 8 KB
  • expected_outputs/index_optimization_sample.txt 3 KB
  • expected_outputs/migration_sample.txt 4 KB
  • expected_outputs/schema_analysis_sample.txt 7 KB
  • references/database_selection_decision_tree.md 16 KB
  • references/index_strategy_patterns.md 12 KB
  • references/normalization_guide.md 10 KB
  • references/patterns-and-troubleshooting.md 4 KB
  • references/workflows-and-tools.md 7 KB

Versions

RepositoryScoreLicence
This page · borghei/Claude-Skills90MIT
DnsQueen/orcinus-skills100MIT
alirezarezvani/claude-skills100MIT
420company/artemis100MIT
shining319/claude-code-single-person-workflow100MIT

Database snapshot: 13.11.2026 · package version 75db0cc1abf7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90database-engineer
    Database architecture design, schema optimization, query performance tuning, and data migration. Handles PostgreSQL, MySQL, MongoDB, Redis. Use when user asks to design database, optimize queries, create migrations, or improve database performance. Do NOT use for frontend or application logic.
  • 100database-design
    Database schema design, optimization, and migration patterns for PostgreSQL, MySQL, and NoSQL databases. Use for designing schemas, writing migrations, or optimizing queries.
  • 90database-design
    Use when designing database schemas, reviewing data models, planning migrations, optimizing slow queries, or establishing database patterns. Covers relational (PostgreSQL, MySQL, SQLite), document (MongoDB), and ORM-integrated (Prisma, Drizzle, TypeORM) projects.
  • 95database-expert
    Advanced database design and administration for PostgreSQL, MongoDB, and Redis. Use when designing schemas, optimizing queries, managing database performance, or implementing data patterns.
  • 90database-review
    Read-only database review for PostgreSQL, MySQL/MariaDB, Redis, DynamoDB, RDS/Aurora and SQLite. Use for "review my database", "slow queries", "missing indexes", "unused indexes", "Postgres review", "MySQL review", "Redis review", "DynamoDB review", "is this migration safe",…
  • 90database-craft
    Database engineering standards for PostgreSQL, MySQL, MongoDB, Supabase and Firebase/Firestore — schema/index design, security, and the per-engine gotchas an agent gets wrong. Loaded on top of backend-craft when a ticket touches the database. Use when designing schema, queries,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.