nosql-patterns

Select NoSQL databases and design schemas for access patterns.

5|1|Updated Jun 17, 2026
One-click install
npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill nosql-patterns-roanbrasil
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: nosql-patterns
Source: https://github.com/roanbrasil/engineer-grade-agent-skills/tree/main/skills/nosql-patterns
Command: npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill nosql-patterns-roanbrasil

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Engineering teams frequently make costly mistakes when choosing a NoSQL database, designing schemas that don't align with access patterns, and falling into common anti-patterns that cause severe performance degradation, unexpected costs, and lengthy rework cycles as scale increases.

Core Features & Use Cases

  • NoSQL Database Selection: Clear decision trees and trade-off analysis to choose between document, key-value, wide-column, graph, and time-series stores based on access patterns, throughput needs, and consistency requirements.
  • Schema Design Patterns: Production-ready, idiomatic patterns for MongoDB (embed vs reference, aggregation pipelines, indexes, change streams), DynamoDB (single-table design, GSIs/LSIs, optimistic locking), Cassandra (partition/clustering keys, denormalization, TTLs), and Redis (caching, distributed locks, rate limiting, leaderboards).
  • Anti-Pattern Mitigation: Curated lists of common mistakes for each NoSQL database type, with explicit fixes to prevent issues like unbounded arrays, hot partitions, tombstone accumulation, and full table scans.
  • Use Case Example: A team building a high-throughput IoT sensor data pipeline can use this skill to select Cassandra, design time-bucketed partition keys to avoid large partitions, and configure TTLs to automatically expire old sensor data without tombstone buildup.

Quick Start

Use the nosql-patterns skill to evaluate the optimal NoSQL database for your new real-time order tracking system and design a schema that supports your required access patterns while avoiding common performance pitfalls.

Frequently Asked Questions about nosql-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I choose the right NoSQL database for my application's access patterns?

Choosing the right NoSQL database requires analyzing your throughput, consistency, and access pattern needs. Use decision trees to evaluate document, key-value, wide-column, graph, and time-series stores to ensure your selection aligns with production scale requirements.

What are the most common NoSQL anti-patterns that cause performance degradation?

Common NoSQL anti-patterns include unbounded arrays, hot partitions, tombstone accumulation, and full table scans. Mitigating these requires access-pattern-driven schema design and applying specific database optimizations like proper indexing and partition key selection.

How do I design a DynamoDB single-table schema for high-throughput data?

Designing a DynamoDB single-table schema involves structuring partition and sort keys to support multiple access patterns simultaneously. You must carefully plan GSIs, LSIs, and optimistic locking to avoid hot partitions and expensive full table scans.

MongoDB vs Cassandra: which NoSQL schema design is best for time-series IoT data?

For time-series IoT data, Cassandra wide-column data modeling is generally preferred over MongoDB document modeling. Cassandra allows you to design time-bucketed partition keys and configure TTLs to automatically expire old sensor data while preventing large partitions and tombstone buildup.

Can I use Redis for distributed locking and rate limiting alongside my primary database?

Yes, Redis caching patterns specifically support distributed locks, rate limiting, and leaderboards. Integrating Redis as a complementary key-value store provides high-speed in-memory data access while your primary database handles persistent storage.

When should I not use a NoSQL database for schema modeling?

You should not use NoSQL schema modeling if your application requires complex multi-record transactions or extensive join operations across highly relational data. NoSQL databases optimize for specific access patterns and scalability rather than strict relational consistency.