Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    DynamoDB Single Table Designer

    1

    Design high-performance DynamoDB Single Table architectures with overloaded keys and GSI optimization.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    DynamoDB Single Table Designer

    DynamoDB Single Table Designer

    Example session with this skill installed

    I need a Single Table Design for a task management app. Users have projects, and projects have many tasks. I need to get all tasks for a project and all projects for a user.

    • Read your context and instructions
    • Compiled the dynamodb single table

    I have mapped the access patterns for your task management application and designed a Single Table schema that supports both user-centric and project-centric lookups.

    DynamoDB Single Table Design

    Access PatternTargetKey Condition Expression
    Get User ProfileBase TablePK = USER#<UserId> AND SK = METADATA
    Get All User ProjectsBase TablePK = USER#<UserId> AND begins_with(SK, "PROJ#")
    Get Project MetadataBase TablePK = PROJ#<ProjectId> AND SK = METADATA
    Get All Tasks for ProjectBase TablePK = PROJ#<ProjectId> AND begins_with(SK, "TASK#")
    Get Task by IDBase TablePK = PROJ#<ProjectId> AND SK = TASK#<TaskId>
    Get User by Project (Reverse)GSI1GSI1PK = PROJ#<ProjectId> AND GSI1SK = USER#<UserId>

    Key Overloading Schema

    Table: TaskManagerTable
    PK: Partition Key (String)
    SK: Sort Key (String)
    GSI1PK: Global Secondary Index 1 Partition Key (String)
    GSI1SK: Global Secondary Index 1 Sort Key (String)
    
    Example Item (Task):
    {
      "PK": "PROJ#p123",
      "SK": "TASK#t456",
      "GSI1PK": "USER#u789",
      "GSI1SK": "TASK#t456",
      "Title": "Fix Login Bug",
      "Status": "OPEN"
    }
    

    Next steps

    1. Implement these prefixes in your application's data access layer.
    2. Configure GSI1 in your Infrastructure as Code (CDK/Terraform) to enable the reverse lookup patterns.
    3. Verify the begins_with queries against your expected result set sizes to monitor pagination needs.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Relational modeling in DynamoDB often leads to fragmented queries and high latency. This skill forces a Single Table Design approach to minimize round trips and maintain high throughput for enterprise-scale NoSQL workloads.

    What it does

    • Map access patterns by documenting every read and write requirement before defining the schema.
    • Implement key overloading using generic PK and SK naming conventions like USER#<id> and METADATA.
    • Architect GSI structures for complex reverse lookups and secondary one-to-many relationships.
    • Generate query cheat sheets providing specific DynamoDB query expressions for each modeled pattern.

    How it works

    1. Requirements gathering to identify every data entity and its relationship cardinality.
    2. Schema mapping to place multiple entity types into a single table structure using prefixed keys.
    3. Index optimization to create Global Secondary Indexes that solve for patterns not covered by the primary keys.
    4. Validation against provided architectural references to ensure the design scales.

    Frameworks & tools

    Built for Amazon DynamoDB and AWS SDK environments. Optimized for developers using Infrastructure as Code tools like AWS CDK, Terraform, or SAM to provision NoSQL resources.

    Why this beats prompting it yourself

    Generic LLM prompts often fallback to relational "one table per entity" anti-patterns or fail to handle sort key prefixes correctly. This skill enforces strict Single Table Design principles, ensuring your GSI strategies actually reduce RCUs rather than inflating costs.

    Use cases

    • Migrating a relational e-commerce schema to a high-performance DynamoDB table.
    • Designing a multi-tenant SaaS backend with strictly isolated data partitions.
    • Modeling social graph relationships like followers and likes within a single NoSQL table.
    • Optimizing existing DynamoDB tables that are suffering from excessive scan operations.

    Known limitations

    Does not perform cost estimation or provision live AWS resources. Restricted to the active project workspace for all file operations.

    Limited to architectural design and schema mapping. Does not estimate monthly AWS costs or perform live database migrations. Workspace restricted.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    Requires

    File System Read/Write (strictly scoped to current project workspace `./`).
    Zero global installation or elevated privileges required.

    Permissions

    Read Files

    Target Use Cases: - Model DynamoDB single-table design for multi-tenant SaaS. - Design overloaded PK/SK keys and GSIs in DynamoDB. - Map entity access patterns to Amazon DynamoDB single table.

    Listed3 days ago

    What's inside

    Frequently Asked Questions

    This skill eliminates the "one table per entity" anti-pattern by enforcing Single Table Design principles, allowing you to model complex relationships and multiple entity types within a single table to minimize latency and RCU costs.

    The skill generates a comprehensive schema map with overloaded PK/SK structures and a detailed query cheat sheet, providing the specific DynamoDB expressions needed to implement your access patterns in code.

    Yes, it is specifically designed to architect Global Secondary Indexes (GSIs) for reverse lookups and complex one-to-many relationships that the primary partition keys cannot handle alone.

    While the skill provides the logical schema and key structures, it is optimized for you to easily port these designs into IaC tools like AWS CDK, Terraform, or SAM for resource provisioning.

    It is highly effective for migrations; by inputting your current relational schema and access patterns, the skill will re-map those entities into a consolidated NoSQL structure optimized for scale.

    New in Data & Databases