data-modeling

Firestore 데이터 모델링과 스키마 설계 패턴을 적용합니다. 새 컬렉션 추가, 관계 설계, 인덱스 최적화, 데이터 마이그레이션 시 사용하세요. NoSQL 특성에 맞는 비정규화 전략을 포함합니다.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026⬇️2downloads

When & Why to Use This Skill

This Claude skill specializes in comprehensive data modeling and schema design, bridging the gap between conceptual domain boundaries and physical database implementation. It provides expert guidance on defining entities, relationships, and NoSQL/SQL patterns to ensure scalable, high-performance data structures that maintain server-side integrity.

Use Cases

  • Initial Schema Architecture: Designing robust entity-relationship models and domain boundaries for new projects using tools like Drizzle ORM or Firestore.
  • NoSQL Optimization: Applying denormalization strategies and index optimization specifically tailored for Firestore and other document-based databases.
  • Scalability Planning: Identifying potential bottlenecks in current data models and restructuring schemas to handle increased load and complexity.
  • Data Migration & Evolution: Planning safe data migrations and schema updates while ensuring high-value mutations maintain a clear audit trail.
namedata-modeling
descriptionData modeling - entities, relationships, schemas. Use when designing data structures.

Data Modeling Guideline

Tech Stack

  • API: tRPC
  • Framework: Next.js (with Turbopack)
  • Database: Neon (Postgres)
  • ORM: Drizzle

Non-Negotiables

  • All authorization must be server-enforced (no client-trust)
  • Platform is source of truth — third-party services sync FROM platform
  • UI must never contradict server-truth
  • High-value mutations must have audit trail (who/when/why/before/after)

Context

Data modeling is conceptual — entities, relationships, domain boundaries. Physical implementation (indexes, migrations, query performance) lives in database.

Consider: what are the real-world entities? How do they relate? What invariants must hold? What will break when requirements change?

Driving Questions

  • If we were designing this from scratch, what would be different?
  • Where will the current model break as the product scales?
  • What implicit assumptions are waiting to cause bugs?
  • Where is complexity hiding that makes the system hard to reason about?
  • What domain boundaries are we violating?