DynamoDB

kumolo implements the DynamoDB REST API. All operations accept standard AWS SDK v2 requests — point your client at http://localhost:5566. Unlike S3, UsePathStyle is not required; only BaseEndpoint needs to be overridden on the client.

Support levels

Symbol	Meaning
✓	Fully implemented — the feature behaves like real AWS
◐	Partial support — the operation works but has known limitations; see the note for details
—	Not yet implemented

Operation support

Operations sourced from internal/dynamodb/router.go in the kumolo repository.

Table management

Operation	Supported
CreateTable	✓
DeleteTable	✓
DescribeTable	✓
ListTables	✓
UpdateTable	✓

Item operations

Operation	Supported
PutItem	✓
GetItem	✓
DeleteItem	✓
UpdateItem	✓

Query & scan

Operation	Supported
Query	✓
Scan	◐

Note

Parallel scan: Segment and TotalSegments are validated but the keyspace is not physically partitioned. All segments return the full dataset. Suitable for testing parallel scan SDK usage but not for workload distribution.

Batch & transactions

Operation	Supported
BatchGetItem	✓
BatchWriteItem	✓
TransactGetItems	✓
TransactWriteItems	✓

TTL

Operation	Supported
UpdateTimeToLive	✓
DescribeTimeToLive	✓

Tagging

Operation	Supported
TagResource	✓
UntagResource	✓
ListTagsOfResource	◐

Note

TagResource and UntagResource accept both table ARNs and index ARNs (GSI/LSI). Tag limits are enforced: 50 tags per resource, key length 1–128 characters, value length 0–256 characters.

ListTagsOfResource pagination is not implemented — NextToken is accepted but ignored and all tags are returned in a single response.

Limits & endpoints

Operation	Supported
DescribeLimits	✓
DescribeEndpoints	✓

Note

DescribeLimits returns fixed capacity unit values (AccountMaxReadCapacityUnits: 80000, AccountMaxWriteCapacityUnits: 80000, TableMaxReadCapacityUnits: 40000, TableMaxWriteCapacityUnits: 40000). DescribeEndpoints returns a single endpoint pointing at localhost:5566.

Streams

Operation	Supported
ListStreams	✓
DescribeStream	✓
GetShardIterator	✓
GetRecords	✓

Note

DynamoDB Streams records INSERT, MODIFY, and REMOVE events for all tables. StreamViewType is honoured (KEYS_ONLY, NEW_IMAGE, OLD_IMAGE, NEW_AND_OLD_IMAGES). Shard iterators expire after 15 minutes of inactivity, matching real AWS behaviour. Stream records are persisted to disk and survive process restarts — unread records remain available after kumolo is restarted.

PartiQL

Operation	Supported
ExecuteStatement	✓
BatchExecuteStatement	✓
ExecuteTransaction	✓

Continuous backups (PITR)

Operation	Supported
DescribeContinuousBackups	◐
UpdateContinuousBackups	◐

Note

Point-in-time recovery (PITR) can be enabled or disabled and the setting is persisted and returned. No actual backups are created and RestoreTableToPointInTime is not available.

Kinesis streaming

Operation	Supported
DescribeKinesisStreamingDestination	◐
EnableKinesisStreamingDestination	◐
DisableKinesisStreamingDestination	◐
UpdateKinesisStreamingDestination	—

Note

Kinesis destination configuration is persisted and returned. No data is forwarded to an actual Kinesis stream.

Global tables

Operation	Supported
CreateGlobalTable	—
DescribeGlobalTable	—
DescribeGlobalTableSettings	—
ListGlobalTables	—
UpdateGlobalTable	—
UpdateGlobalTableSettings	—
DescribeTableReplicaAutoScaling	—
UpdateTableReplicaAutoScaling	—

Backups

Operation	Supported
CreateBackup	—
DeleteBackup	—
DescribeBackup	—
ListBackups	—
RestoreTableFromBackup	—
RestoreTableToPointInTime	—
ExportTableToPointInTime	—
ListExports	—
DescribeExport	—
ImportTable	—
ListImports	—
DescribeImport	—

Resource policy

Operation	Supported
GetResourcePolicy	—
PutResourcePolicy	—
DeleteResourcePolicy	—

Contributor insights

Operation	Supported
DescribeContributorInsights	—
ListContributorInsights	—
UpdateContributorInsights	—

Quick start

Go

import (
    "context"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/credentials"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
)

cfg, err := config.LoadDefaultConfig(context.Background(),
    config.WithRegion("us-east-1"),
    config.WithCredentialsProvider(
        credentials.NewStaticCredentialsProvider("test", "test", ""),
    ),
)
if err != nil {
    panic(err)
}

client := dynamodb.NewFromConfig(cfg, func(o *dynamodb.Options) {
    o.BaseEndpoint = aws.String("http://localhost:5566")
})

if _, err = client.CreateTable(context.Background(), &dynamodb.CreateTableInput{
    TableName:   aws.String("my-table"),
    BillingMode: types.BillingModePayPerRequest,
    AttributeDefinitions: []types.AttributeDefinition{
        {AttributeName: aws.String("pk"), AttributeType: types.ScalarAttributeTypeS},
    },
    KeySchema: []types.KeySchemaElement{
        {AttributeName: aws.String("pk"), KeyType: types.KeyTypeHash},
    },
}); err != nil {
    panic(err)
}

if _, err = client.PutItem(context.Background(), &dynamodb.PutItemInput{
    TableName: aws.String("my-table"),
    Item: map[string]types.AttributeValue{
        "pk":      &types.AttributeValueMemberS{Value: "hello"},
        "message": &types.AttributeValueMemberS{Value: "hello, kumolo"},
    },
}); err != nil {
    panic(err)
}

Python (boto3)

import boto3

dynamodb = boto3.client(
    "dynamodb",
    region_name="us-east-1",
    endpoint_url="http://localhost:5566",
    aws_access_key_id="test",
    aws_secret_access_key="test",
)

dynamodb.create_table(
    TableName="my-table",
    BillingMode="PAY_PER_REQUEST",
    AttributeDefinitions=[
        {"AttributeName": "pk", "AttributeType": "S"},
    ],
    KeySchema=[
        {"AttributeName": "pk", "KeyType": "HASH"},
    ],
)

dynamodb.put_item(
    TableName="my-table",
    Item={
        "pk": {"S": "hello"},
        "message": {"S": "hello, kumolo"},
    },
)

AWS CLI

aws dynamodb create-table \
  --table-name my-table \
  --billing-mode PAY_PER_REQUEST \
  --attribute-definitions AttributeName=pk,AttributeType=S \
  --key-schema AttributeName=pk,KeyType=HASH \
  --endpoint-url http://localhost:5566 \
  --region us-east-1

aws dynamodb put-item \
  --table-name my-table \
  --item '{"pk": {"S": "hello"}, "message": {"S": "hello, kumolo"}}' \
  --endpoint-url http://localhost:5566