Simple by Design, Powerful by Default

Databases like AWS DynamoDB force developers to work with low-level, verbose APIs. A simple operation, like creating a new user with a unique email address, requires hundreds of lines of code to manually validate inputs, marshal objects into attribute maps, construct transaction items, and handle complex error conditions.

This is what that looks like with the raw AWS SDK for Go:

**Raw DynamoDB (Go):**

func (c *DynamoDBClient) CreateUser(ctx context.Context, displayName, email string) (*User, error) {
    if displayName == "" { // Manual validation
        return nil, fmt.Errorf("display name cannot be empty")
    }
    if email == "" {
        return nil, fmt.Errorf("email cannot be empty")
    }
    if !emailRegex.MatchString(email) {
        return nil, fmt.Errorf("invalid email format")
    }

    user := &User{
        ID:          uuid.New(),
        DisplayName: displayName,
        Email:       email,
    }

    // Manually marshal the object to a DynamoDB attribute map
    userAV, err := attributevalue.MarshalMap(user)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal user: %w", err)
    }
    userAV["PK"] = &types.AttributeValueMemberS{
        Value: fmt.Sprintf("USER#%s", user.ID.String()),
    }
    userAV["SK"] = &types.AttributeValueMemberS{
        Value: "METADATA",
    }

    // Manually create a second record for the email lookup/uniqueness check
    emailAV := maps.Clone(userAV)
    emailAV["PK"] = &types.AttributeValueMemberS{
        Value: fmt.Sprintf("EMAIL#%s", email),
    }
    emailAV["SK"] = &types.AttributeValueMemberS{
        Value: "METADATA",
    }

    // Manually construct a transaction to write both records
    _, err = c.client.TransactWriteItems(ctx, &dynamodb.TransactWriteItemsInput{
        TransactItems: []types.TransactWriteItem{
            {
                Put: &types.Put{
                    TableName: aws.String(c.table),
                    Item:      userAV,
                },
            },
            {
                Put: &types.Put{
                    TableName:           aws.String(c.table),
                    Item:                emailAV,
                    ConditionExpression: aws.String("attribute_not_exists(PK)"), // Uniqueness check
                },
            },
        },
    })

    // Manually parse complex error responses
    if err != nil {
        var txErr *types.TransactionCanceledException
        if errors.As(err, &txErr) {
            for _, reason := range txErr.CancellationReasons {
                if reason.Code != nil && *reason.Code == "ConditionalCheckFailed" {
                    return nil, fmt.Errorf("email %s is already in use", email)
                }
            }
        }
        return nil, fmt.Errorf("failed to create user: %w", err)
    }

    return user, nil
}

‍

With StatelyDB, the same operation is a single, intuitive line of code. Our schema-aware client handles validation, ID generation, and transactional writes automatically.

**StatelyDB (Go):**

user, err := client.Put(ctx, &schema.User{
    DisplayName: "Stately Support",
    Email:       "support@stately.cloud",
})
// ... handle error

This radical simplicity allows your developers to be productive from day one, onboard new team members faster, and focus their talent on building your product, not managing the database.